
Monday, October 31, 2011
subSurface

Tuesday, August 30, 2011
Procedural Primitives 2
Depois de brigar um pouco com o c++ consegui "traduzir" mais um exemplo de procedural
primitives que vi em python para a linguagem c++ , dessa vez usando um exemplo de como gerar esferas dispostas aleatoriamente ao redor de uma esfera maior .
/*
* RibBox.h
* classExerc
*
* Created by chrysl666 on 8/27/11.
* Copyright 2011 none. All rights reserved.
*
*/
#ifndef RIBBOX_H
#define RIBBOX_H
#include
#include
int const VECTOR_SIZE = 3;
class RibBox
{
public:
//constructor
RibBox();
//variaveis
std::string parFromMaya ;// sent by renderman
std::string details ;// got from splited[0]
std::string number ;// got from splited[1]
std::string width ;// got from splited[2]
std::string radius ;// got from splited[3]
double point[VECTOR_SIZE];// ponto aleatorio
double normPoint[VECTOR_SIZE];// ponto apos normalizado
double scalePnt[VECTOR_SIZE];// ponto apos scalado
//funcoes
void setRibBox(); // insert commands at render stream
void getRibBoxPar(); // get par from renderman
void Tokenize(const std::string& ,
std::vector
const std::string& ); //tokenize
void randomPoint(double rangeMin, double rangeMax );
std::string formatTuple(std::string theTuple);
void scalePoint();
void normalize();
double randWidth(std::string max);
};
#endif
cpp:
/*
* RibBox.cpp
* classExerc
*
* Created by chrysl666 on 8/27/11.
* Copyright 2011 none. All rights reserved.
*
*/
#include
#include
#include
#include
#include
#include "RibBox.h"
RibBox::RibBox()
{
// construtor da classe
//incializa o array point
for(int i=0;i<3;i++)
{
point[i]=0;
}
}
void RibBox::Tokenize(const std::string& str,
std::vector
const std::string& delimiters = " ")
{
// tokenize function para separar as informacoes em strings
// pula o delimitadores no inicio
std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
// acha o primeiro nao delimitador
std::string::size_type pos = str.find_first_of(delimiters, lastPos);
while (std::string::npos != pos || std::string::npos != lastPos)
{
// achou um token , add no vetor.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// pula delimitadores. Note o "nao_de"
lastPos = str.find_first_not_of(delimiters, pos);
// procura proximo "nao-delimitador"
pos = str.find_first_of(delimiters, lastPos);
}
}
void RibBox::getRibBoxPar()
{
//parsing comandos vindos dos renderman
std::vector
std::getline(std::cin,parFromMaya);
Tokenize(parFromMaya ,tokens);
details = tokens[0];
number = tokens[1];
width = tokens[2];
radius = tokens[3];
}
void RibBox::setRibBox()
{
//formatacao dos comandos de saida para o stream
std::cout<<"AttributeBegin\n";
std::cout<<"Points \"P\" [";
for (int i=0; i< (atoi(number.c_str())); i++)
{
randomPoint(-1, 1);
normalize();
scalePoint();
std::cout<
}
std::cout<<"]\n";
std::cout<<"\"width\" [";
for (int i=0; i< (atoi(number.c_str())); i++)
{
std::cout<<randWidth(width)<<" ";
}
std::cout<<"] \n";
std::cout<<"\"Cs\" [";
for (int i=0; i< (atoi(number.c_str())); i++)
{
std::cout<<randWidth("1")<<" "<<randWidth("1")<<" "<<randWidth("1")<<" " ;
}
std::cout<<"]\n";
std::cout<<"AttributeEnd\n";
std::cout<<"\377"<
}
void RibBox::randomPoint(double rangeMin, double rangeMax )
{
//cria um valor aleatorio entre rangeMin e rangeMax para o arrayPoint
double step = rangeMax - rangeMin ;
for (int i=0; i<VECTOR_SIZE; i++)
{
point[i] = (step * static_cast <double> (rand ()) / static_cast <double> (RAND_MAX) -1);
}
}
void RibBox::normalize()
{
double mag = sqrt(point[0] * point[0] + point[1] * point[1] + point[2] * point[2]);
for (int i=0; i<VECTOR_SIZE; i++)
{
normPoint[i] = point[i]/mag;
}
}
void RibBox::scalePoint()
{
int radiusInt = atoi(radius.c_str());
for (int i=0; i<VECTOR_SIZE; i++)
{
scalePnt[i] = normPoint[i] * radiusInt;
}
}
double RibBox::randWidth(std::string max)
{
double maxInt = atof(max.c_str());
return (maxInt * static_cast <double> (rand ()) / static_cast <double> (RAND_MAX));
}
e o main.cpp :
#include
#include
#include
#include
#include "RibBox.h"
int main (int argc, char * const argv[])
{
RibBox ribBoxObj;
while(1)
{
ribBoxObj.getRibBoxPar();
ribBoxObj.setRibBox();
}
}
e o comando de insercao no maya :
RiProcedural -pn "/Users/chrysl666/Desktop/devBook/classExerc02/build/Debug/classExerc02" -p "1000000 0.05 10" -b -1e38 1e38 -1e38 1e38 -1e38 1e38;
Monday, August 29, 2011
procedural primitives
#include iostream
#include string
#include vector
#include algorithm
#include "RibBox.h"
int main (int argc, char * const argv[])
{
RibBox ribBoxObj;
while(1)
{
ribBoxObj.getRibBoxPar();
ribBoxObj.setRibBox();
}
}
header:
/*
* RibBox.h
* classExerc
*
* Created by chrysl666 on 8/27/11.
* Copyright 2011 none. All rights reserved.
*
*/
#ifndef RIBBOX_H
#define RIBBOX_H
#include
#include
class RibBox
{
public:
//constructor
RibBox();
//variaveis
std::string parFromMaya ; //sent by renderman
std::string details; // got from splited[0]
std::string scaleSize ;// got from splited[1]
//funcoes
void setRibBox(); // insert commands at render stream
void getRibBoxPar(); // get par from renderman
void Tokenize(const std::string& ,
std::vector
const std::string& ); //tokenize
};
#endif
implementacao da classe:
/*
* RibBox.cpp
* classExerc
*
* Created by chrysl666 on 8/27/11.
* Copyright 2011 none. All rights reserved.
*
*/
#include
#include
#include
#include "RibBox.h"
RibBox::RibBox()
{
}
// tokenize function // precisa ser implementado antes de ser usado
void RibBox::Tokenize(const std::string& str,
std::vector
const std::string& delimiters = " ")
{
// pula o delimitadores no inicio
std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
// acha o primeiro nao delimitador
std::string::size_type pos = str.find_first_of(delimiters, lastPos);
while (std::string::npos != pos || std::string::npos != lastPos)
{
// achou um token , add no vetor.
tokens.push_back(str.substr(lastPos, pos - lastPos));
// pula delimitadores. Note o "nao_de"
lastPos = str.find_first_not_of(delimiters, pos);
// procura proximo "nao-delimitador"
pos = str.find_first_of(delimiters, lastPos);
}
}
void RibBox::getRibBoxPar()
{
std::vector
std::getline(std::cin,parFromMaya);
Tokenize(parFromMaya ,tokens);
details = tokens[0];
scaleSize = tokens[1];
}
void RibBox::setRibBox()
{
std::cout<<"AttributeBegin\n";
std::cout<<"Scale "<
std::cout<< "Sphere [3 -3 3 360]\n";
std::cout<<"AttributeEnd\n";
std::cout<<"\377"<
}
bem . depois de compilar voce vai ter um programa chamado "classExerc"
que recebe uma parametro float qualquer que representa o tamanho da esfera que voce quer criar. .. mas pro render chamar esse programa eh preciso definiar algumas coisas no maya
no meu caso eu criei um box no {0,0,0} do grid do maya e adicionei alguns attributos
do 3delight .. um Geometry , com a opcao OutPutGeometry desligado .. para esse cubo nao
ser exportado para o render . esse cubo so serve como proxy para inserir os comando que eu preciso para chamar o programa ... o segundo atributo que eu inseri foi o Mel Script - PreGeoMel -- e adicionei o seguinte comando na caixa de dialogo
RiProcedural -pn "/Users/chrysl666/Desktop/devBook/classExerc/build/Debug/classExerc" -p "0.3" -b -1e38 1e38 -1e38 1e38 -1e38 1e38;
isso diz ao render " rode o programa procedural classExerc e envie o parametro 0.3 para o stream de saida .. e reserve um espaco de bound de box de tamanho "1e38" para o objeto que o programa vai criar !
bem .. eh isso .. ao render voce vai ter uma sphere de tamanho 0.3 na tela . ao invez de um cubo.
bem .. sei que o exemplo como disse eh bem simples .. mas espero que tenha ajudado a entender como esse mecanismo funciona usando OOP .. vou tentar criar alguns exemplos mais legais no proximo post : ) .
Friday, August 26, 2011
Fiz um teste de raytracing ( reflex e refrax ) para um trabalho . onde tinha que produzir alguns blocos de gelo ... como no final o shader nao foi usado . resolvi postar o teste .. o shader eh um simples archshader que ja vem com o 3delight .. bem util por sinal . um pouco lento porcausa dos samples .. quem sabe um dia eu tente programar um mais leve so pra essa finalidade de fazer gelo :P ... no momento ele me serviu bem .. pena que meu shader nao foi usado no final .. mas valeu a experiencia : ) ..
Wednesday, August 10, 2011
3delight e photons
Sunday, September 06, 2009
Pagina de Odio do Mental Ray ?
Tuesday, August 04, 2009
3Delight !!

Tuesday, July 10, 2007
Raytracing e environment()
com blur , no manual do renderman vem um exemplo muito legal de como
usar o raytracing de outra forma , atraves da funcao environment().
environment() costuma ser usado para adicionar uma reflexao atraves
de um bitmap . mas o renderman aceita uma palavra reservada "raytracing"
com essa funcao .. repassar uma palavra reservada
para a funcao environment() forca o renderman a usar raytracing .
environment() tbm tem opcoes de samples, dir , maxdist , e no lugar de
angulo uma variacao para "blur" . nos meus testes environment() com raytracing
deu resultados mais rapidos e com melhor qualidade com um menor
numero de samples ..
segue um shader de teste :
/*----------------------------------------------------------------------------------------*/
surface envRayReflex (
float Kr = 1;
float samples = 1;
float blur = 0 ;
float maxdist = 1;
)
{
color Crefl ;
string envmap = "raytrace"; /* cria uma string para guardar a palavra reservada */
if (N.I <0){
normal Nn = normalize(N);
vector In = normalize(I);
vector reflDir = reflect(In,Nn);
Crefl = environment(envmap,reflDir,"samples",samples,"blur",blur,"maxdist",maxdist);
} else { /* pintar de preto onde nao tiver nada para fazer raytracing */
Crefl = 0;
}
Ci = Kr * Crefl;
Oi = 1;
}
/*-----------------------------------------------------------------------------------------*/
abaixo segue um exemplo com o mesmo setup do render anterior (64SAMPLES, 0.18
BLUR , MAXDIST 110)
a qualidade do blur 'e bem melhor com um render mais rapido
ainda nao sei exatamente porque fica tao mais rapido
ja que por debaixo dos panos pelo que eu entendi . o renderman
faz um gather() do mesmo modo .. bem ..

Raytracing e gather()
a sintaxe da funcao gather:
gather ( string category, point P, vector dir, float angle, float samples, ... ) {statements} [else {statements}]
a funcao gather envia um cone de raios(samples) a partir do ponto P para a direcao "dir"em um determinado angulo "angle" . O angulo dado em radianos 'e medido a partir de "dir" .quanto maior o cone mais blur nos dados ou cores capturados , a qualidade desse blur 'e calculado pelo valor de samples . Quando um raio atinge uma surface ele captura informacoes diversas que podem ser escolhidas entre as variaveis globais do renderman ou uma informacao customizada do shader, a cada looping ele acumula as informacoes sobre as superficies. Uma media total das informacoes desses loopings 'e feita fora do looping , e adicionado no resultado final do seu shader , como voce pode ver existem dois blocos de statements , o primeiro blocovai ser executado quando o raio atingir uma surface e o codigo no bloco do "else" vai ser executado quando nao for atingida nenhuma superficie , o parametro "maxdist" limita os raios em uma certa distancia excluindo objetos fora desse campo .. muito bom para
dar uma optimizada no desempenho do raytracing
abaixo segue o codigo usando gather() :
/*----------------------------------------------------------------------------------*/
surface gatherReflex(
float samples = 1;
)
{
/* inicia as variaveis para a cptura de informacoessbre a superficie e a cor do reflexo */
color hitColor = 0;
Ci = 0;
/* verifica o angulo da surface em relacao ao observador */
if(Nn.-In >= 0)
{
vector ReflexDir = reflect(In, Nn); /* acha a direcao do reflexo */
/* inicia o gathering com as informacoes adquiridas , "surface:ci" vai ser a informacao capturado pelo raio ao bater em uma surface e adicionada na variavel hitcolor */
hitColor)
}
/* calcula a media das cores pelo raios atingidos assinalado em Ci */
Ci /= numhits;
Oi = 1;}
/*-------------------------------------------------------------------------------------*/
Monday, July 09, 2007
trace() + etc..
o shader ainda nao me parece tao legal e tbm nao sei c a soma final das funcoes
esta feito do modo mais certo mas foi uma tentativa de juntar as funcoes
ai vai o shader :
surface mySurfReflex(
float Kspecular = .5 ;
float Kdifusse = .5 ;
float Kambiente = 1 ;
float Kroughness = .1;
float KReflex = 1 ;
color ambiente_color = 0 ;
color diffuse_color = .8 ;
color specular_color = .5 ;
)
{
/* cria variaveis para captura de informacoes sobre a superficie */
normal Nf;
vector V;
Nf = faceforward( normalize(N), I );
normal Nn = normalize(N);
vector In = normalize(I);
color Temp_reflex_color = 0 ;
/* inicializa os calculos difuse ambiente e especular e acha a direcao e cor da reflexao */
color Temp_ambiente_color = ambiente_color * Kambiente * ambient();
color Temp_diffuse_color = diffuse_color * Kdifusse * diffuse(Nf);
color Temp_specular_color = specular_color * Kspecular * specular(Nf,-In,Kroughness);
/* verifica o angulo entre a superficie e o observador */
if (Nn.-In >= 0) {
/* acha a direcao do reflexo entre a surface e o observador */
vector DirecaoReflex = reflect(Nn,In);
/*captura a cor do reflexo naquele ponto usando a funcao trace */
Temp_reflex_color = KReflex * trace(P, DirecaoReflex);
}
/* adiciona todas as informacoes achadas na cor final do shader*/
Oi = Os;
Ci = (Temp_ambiente_color + Temp_diffuse_color) + (Temp_specular_color + Temp_reflex_color);
/* premultiplica a cor final com a opacidade */
Ci *= Oi;
}
e uma imagem do shader aplicado :
Raytracing e a funcao Trace
uma coisa interessante da funcao shader 'e que quando voce assinala essa funcao dentro de uma variavel float ela vai retornar a distancia do ponto atingido ao inves da cor
para a funcao trace funcionar no seu RFM ou RAT voce precisar ligar o "RAYTRACING" no seu render globals
segue um exemplo de um shader com trace
uma simples bola com reflexo aplicado :
surface TraceReflex( ) {
/* captura as informacoes necessarias para o calculo da superficie */
normal NormalSurface = normalize(N);
vector Observador = normalize(I);
color TempColorReflex = 0;
/* verifica o angulo entre a superficie e o observador */
if (NormalSurface.Observador < 0) {
/* acha a direcao do reflexo entre a surface e o observador */
vector DirecaoReflex = reflect(NormalSurface,Observador);
/* captura a cor do reflexo naquele ponto usando a funcao trace */
TempColorReflex = trace(P, DirecaoReflex);
}
/* assinala a cor capturada pela funcao trace na cor final do objeto */
Ci = Os * TempColorReflex;
Oi = Os;
}
um exemplo do render :

Thursday, January 05, 2006
specular func
N = normal
I = observador
com essas informacoes vamos comecar a usar algumas funcoes que ja vimos para preparar as variaveis para o specular.
Logo de cara um faceforward com um normalize para conseguir a normal com comprimento de no maximo 1 aprontada para o observador ..
faceforward(normalize(N),I) ;
agora vamos guardar isso em uma variavel para usar depois
normal Nf = faceforward(normalize(N),I) ;
agora vamo descobrir o vetor em uma surface apontada para o observador com valor no maximo ate 1.0 .
-normalize(I) ;
essa funcao pegou o comprimento do vetor I que `e apontada pra surface . e inverteu colocando o sinal negativo na frente e com a funcao normalize convertemos ele pra um valor entre 0 e 1
vamos guardar esse vetor em outra variavel para usar depois
vector V = -normalize(I);
agora vamo criar um valor qualquer pro roughness
float roughness = 0.2 ;
agora `e so adicionar isso na funcao specular
specular(Nf,V,roughness);
pronto temos a funcao pronta pra usar . apenas somando o specular com o resto das contribuicoes ambiente
e diffuse e assinale a Ci .
surface
meushaderV2( color verde = (0.0 , 1.0 , 0.0 ) ; float roughness = 0.2 ; )
{
normal Nf = faceforward(normalize(N),I);
vector V = -normalize(I) ;
Oi = Os ;
Ci = Os * verde *( ambient()+ diffuse(Nf)+ specular(Nf,V,roughness) );
}
salve seu shader como meushaderV2.sl
copile e teste !!
um exemplo do shader no RFM
T+ e boa sorte !
Wednesday, January 04, 2006
Ambient() diffuse()
no shader . adicionando iluminacao ambient, diffuse e specular
essas funcoes sao :
ambient()
diffuse()
specular()
algumas dessas funcoes precisam receber informacoes sobre a geometria para o calculo
,a funcao ambient() é a mais simples em geral usada sem argumentos adicionais, mas
ja a diffuse() precisa de uma normal com comprimento maximo de 1 apontada para a direcao contraria
do Observador . confuso ne ! . eu tbm acho ! mas seguindo a relacao de funcoes e variaveis globais vc
vai descobrir que N = normal de um objeto, I = vetor do observador, e que a funcao normalize(), converte
o comprimento de um vetor em um valor entre 0 e 1 e finalmente a funcao faceforward() inverte a direcao
da normal para aprontar na direcao contraria do observador no Ponto de vista do shader .
entao no final fica assim
faceforward(normalize(N),I) ;
essa pequena funcao vai retornar um a normal do ponto a ser calculado com comprimento de no maximo 1 apontada para o observador
vamos guardar isso em uma variavel do tipo normals .
normal Nf = faceforward(normalize(N),I) ;
bem agora que achamos a informacao que precisamos . é so adicionar isso como um argumento
na funcao diffuse() .
diffuse(Nf)
aplicando tudo isso em um shader :
surface
meushader( color verde = (0.0 , 1.0 , 0.0 ) ; )
{
normal Nf = faceforward(normalize(N),I);
Oi = Os ;
Ci = Os * verde *(ambient()+ diffuse(Nf));
}
copile e teste !!
t+
Transparencia no MaisSimplesDoMundo.slo
surfaceMaisSimplesDoMundo( color vermelho = (1.0 , 0.0 , 0.0 ) ; )
{
Oi = Os ;
Ci = Os*vermelho ;
}
eu adicionei novas variaveis no shader Oi e Os.
Oi é a transparencia final do shader e Os é a transparencia default .. entao assinalei
uma a outra ,para o controle ser centralizado , multipliquei isso pela cor , e liguei tudo a Ci
. em geral a cor final é uma multiplicacao entre a cor e a transparencia .
salve copile e teste .
t+
Tuesday, January 03, 2006
Usando custom Shaders no RFM
utilizar shaders copilados pro renderman direto no maya, o unico problema
desse node é que ele nao tem as conexoes de input e output, com isso
conexoes entre shaders/nodes nao sao permitidas . a unica conexao permitida
é via RendermanShaderSG. Nas propiedades desse shader existem somente as opcoes de
Cor(Cs), Opacity (Os) , e um campo chamado "Shader" para adicionar o seu custom shader

clike sobre a pastinha ao lado do campo Shader e carregue o shader copilado MaisSimplesDoMundo.slo.
Apos carregar nosso shader MaisSimplesDoMundo.slo a interface do RenderManShader
ganha uma nova propiedade "vermelho(Ci)"
....................t+
copilando o Shader MaisSimplesDoMundo.sl
Primeiro digite no Notepad o shader MaisSimplesDoMundo e salve em uma pasta de sua preferencia, com o nome MaisSimplesDoMundo.sl , no meu caso eu salvei o meu shader na pasta
c:\temp
agora usando a barra de start do windows . execute a opcao RUN ( executar) e digite no campo
da ferramenta
CMD
isso vai abrir a janela do DOS
entre na pasta onde vc salvou o shader
cd c:\temp
antes de copilar os shader é preciso configurar as variaveis de ambiente do RFM para ele poder achar os programas necessarios a compilacao
digite no DOS :
set RMANTREE=C:\Program Files\Pixar\RenderManForMaya7.0-1.0\rmantree
e c sua versao de windows for em portugues é possivel que o path seja diferente :
set RMANTREE=C:\arquivos de programas\Pixar\RenderManForMaya7.0-1.0\rmantree
agora precisamos informar ao windows onde c encontra o copilador "shader.exe", em geral esse programa c instala na pasta /bin da instalacao do RFM
digite o comando no DOS :
set PATH = c:\Program Files\Pixar\RenderManForMaya7.0-1.0\bin
c o seu windows for em portugues :
set PATH=C:\arquivos de programas\Pixar\RenderManForMaya7.0-1.0\bin
pronto apos configurar o RFM podemos copilar nosso shader
digite no DOS :
shader MaisSimplesDoMundo.sl
c tudo for certo vc vai receber uma resposta como essa :
MaisSimplesDoMundo: compiled.
e um novo arquivo apareceu na sua pasta temp :
MaisSimplesDoMundo.slo
o formato .slo é o shader copilado . pronto para ser usado dentro do RFM
Monday, January 02, 2006
crie o seu primeiro shader para Renderman ( uma visao geral sobre RSL)
Bem pra comecar `e preciso entender a anatomia do shader no ponto de vista do renderman:

O Renderman pinta os objetos dando pequenas pinceladas de cor ponto a ponto sobre o objeto . para isso ele precisa de informacoes sobre a geometria , luz , e o ponto de observacao da camera e etc . essas informacoes sao predefinidas no renderman , sao as chamadas Variaveis Globais do Renderman
Abaixo uma pequena (micro) lista de algumas variaveis :
Os surface Opacity = transparencia original da surface
Cs Surface Color = cor original da surface
Oi Surface Opacity Incident = a transparencia da surface em direcao a camera
Ci Surface Color Incident = a cor da surface em direcao a camera
P Surface Position = um ponto qualquer na surface
N Shading Normal = direcao da Normal de uma surface
I Incident Vector = direcao do observador
E Vantage (eye)point = a posicao do observador
L Light Vector = direcao da Luz
Antes de sair programando `e preciso falar sobre as variaveis " Os,Cs,Oi,Ci ", o renderman considera que a surface tem uma cor default e uma opacidade default, essas cores originais em geral sao variaveis que sao definidas dentro do corpo do arquivo .RIB .
A Cor incidente e a Opacidade Incidente sao as cores e a transparencia final do objeto , resumindo , o renderman sempre vai colorir e definir a transparencia do seu objeto pela cor que vc definir na variavel Ci e Oi , mesmo que Cs e Os sejam cores diferentes.
Abaixo o shader de renderman MaisSimplesDoMundo :
surface
MaisSimplesDoMundo( color vermelho = (1.0 , 0.0 , 0.0 ) ; )
{
Ci = vermelho ;
}
Render feito no Maya usando
o Shader MaisSimplesDoMundo:

RAT ?!! RFM ??RIB ??RSL ??
o RenderMan ProServer `e um renderizador da pixar que trabalha com arquivos .Rib e shaders feitos na linguagem RSL.
o Arquivo .Rib (rendermanBitStream) `e um tipo de arquivo ASCII que descreve cenas produzidas em um programade animacao ou modelagem ,e o RSL (rendermanShadingLanguage) `e uma linguagem similar ao C++ que descreve os Shaders de cada objeto nos arquivos RIB.
renderizar um arquivo Rib e utilizar RSL nao `e restrito apenas para quem `e dono de uma licensa de Renderman Pro Server , a Pixar a muitos anos atras durante o desenvolvimento desse tipo de arquivoe linguagem , resolveu liberar essas definicoes para outros desenvolvedores . com isso existem no mercado outros tipos de produtos de render que utilizam RIB e RSL , portanto para vc aprender nao `e necessario ter um Renderman . pode ser qualquer Renderizador RenderMan Compativel ;
abaixo alguns renderizadores compativeis com RIb e RSL :
Air
Aqsis
o RAT !!(RenderMan Artist Tool) :
como o Renderman `e render muito flexivel gracas ao RIB e ao RSL , existem muitas formas de trabalhar com ele, muitos grandes estudios desenvolveram ferramentas que conectam seus softwares de 3d no renderman, mas para aumentar a velocidade de uso, a Pixar desenvolveu suas propias ferramentas de conexao entre o software 3d (MAYA) e o renderman. o pacote RAT `e exatamente isso . o renderizador Renderman + plugin de conexao com o maya + o editor de shaders + gerenciador de render + visualizador de imagens .
nomeados pela Pixar como:
MTOR = plugin de conexao
SLIM = editor de shaders
ALFRED = gerenciador de render em rede
It = visualizador de imagens
esse `e o pacote mais completo da Pixar pra quem quer ir fundo na utilizacao do renderman , cada pequena ferramenta dessa tem um mundo de comandos e opcoes ,sem falar do propio renderman e seus amigos RIB e RSL .
O RFM ( Renderman For Maya ) :
Depois de muitos users low end reclamarem da falta de facilidade em usar o renderman em producoes menores , a Pixar resolveu produzir uma versao do renderman que fosse mais integrado e de facil utilizacao, com isso criaram o RenderMan For maya. Existem algumas diferencas entre os dois produtos , a primeira `e a falta de suporte ao arquivo .RIB , o renderman for maya nao pode criar ou abrir .Rib , a segunda `e que para utilizar shaders no renderman For maya vc nao precisa saber programar em RSL ou usar o editor Slim do RAT , A PIXAR integrou os shaders do Maya para o propio renderman , com isso a maioria dos shaders ,luzes ,etc funciona transparente dentro do RFM . mas como a integracao ainda nao `e total , a Pixar permitiu usar shaders feitos para o RAT dentro do RFM, mas nao permitiu conexoes de shaders maya com Shaders renderman de forma direta (infelizmente) , mas com isso abriu a porta para um mundo novo de criacao de shaders usando a linguagem RSL .
por Hoje `e so pessoal !!

