RenderMonkey

Spherical Harmonics

2011-12-25T14:45:00.001-08:00

Spherical Harmonics com e sem Occ

Spherical Harmonics eh uma tecnica usada muito em games para criar falsa iluminacao ambiente nos objetos , ele dispensa o uso de HDRI para simular a irradiancia sobre o difuse de um shader , apesar da matematica envolvida ser cheio de letras e numeros malucos a aplicacao eh bem simples usando um pouco a ajuda e o programa do paper :

http://graphics.stanford.edu/papers/envmap/

esse paper explica que voce pode pegar todos os valores de "luma"!!! :P atraves de 9 coeficientes processados de um mapa de HDR .. esses coeficientes sao depois multiplicados sobre o diffuse

a formula eh isso aqui :

vector DiffuseColor = vector ( C1 * L22 * (tnorm[0] * tnorm[0] - tnorm[1] * tnorm[1]) +C3 * L20 * tnorm[2] * tnorm[2] +C4 * L00 -C5 * L20 +2.0 * C1 * L2m2 * tnorm[0] * tnorm[1] +2.0 * C1 * L21 * tnorm[0] * tnorm[2]+2.0 * C1 * L2m1 * tnorm[1] * tnorm[2] +2.0 * C2 * L11 * tnorm[0] +2.0 * C2 * L1m1 * tnorm[1] + 2.0 * C2 * L10 * tnorm[2] );

onde cada c1 c2 c3 etc .. sao numeros constantes indicados no paper .. e o L22 L11 etc .. sao coeficientes processados do HDRI ... existe uma tabela de mapas HDRI mais conhecidos para ser usados de exemplo .. o que eu usei eh o mapa Grace cathedral , c for preciso novos coficientes de mapas propios . o paper fornece um codigo em "C" que extrai os coeficientes para voce de um novo mapa , nao testei ainda . mas acho que eh possivel transformar esse codigo em um DSO para o renderman . assim extrair o coeficiente em renderTime c for o caso ... aqui vai a tabela :

um detalhe, como essa eh uma tecnica para produzir luz ambiente . ela nao gera sombra, alguns papers na net demonstram outras formas de usar esse calculo para retirar

o sample de cor pra producao de bleeding e sombras usando raytracing . mas basicamente

eh um looping de gather conferindo onde o raio obteve ou nao colisao , caso nao , ele utiliza o spherical harmonic para produzir o occlsuion , aqui . eu usei um simples occlusion do renderman para produzir isso. detalhe spherical harmonics pode ser usados tbm na composicao .. caso voce tenha um pass de normal ... no video "Nuke master Class de Roy Stelzer" encontrado no propio site da Foundry .. ele demonstra como aplicar isso ..

bem segue o codigo do shader :

surface  spherical(float scalefactor = .2 , samples = 32 , occOnOff = 0.0)

{

// spherical harmonics coeficients

        float C1 = 0.429043;

        float C2 = 0.511664;

        float C3 = 0.743125;

        float C4 = 0.886227;

        float C5 = 0.247708;

// Constants for Old Town Square lighting

        vector L00  = vector( .79,  .44,  0.54);

        vector L1m1 = vector( 0.39,  0.35,  0.60);

        vector L10  = vector( -0.34,  -0.18, -0.27);

        vector L11  = vector(-0.29, -0.06, .01);

        vector L2m2 = vector(-0.11, -0.05, -0.12);

        vector L2m1 = vector( -0.26,  -0.22,  -0.47);

        vector L20  = vector(-0.16, -0.09, -0.15);

        vector L21  = vector(0.56, 0.21, .14);

        vector L22  = vector(.21, -0.05, -0.30);

        vector tnorm = vector(faceforward(normalize(N),I));

        vector DiffuseColor = vector ( C1 * L22 * (tnorm[0] * tnorm[0] - tnorm[1] * tnorm[1]) +

        C3 * L20 * tnorm[2] * tnorm[2] +C4 * L00 -

        C5 * L20 +

        2.0 * C1 * L2m2 * tnorm[0] * tnorm[1] +

        2.0 * C1 * L21  * tnorm[0] * tnorm[2]+

        2.0 * C1 * L2m1 * tnorm[1] * tnorm[2] +

        2.0 * C2 * L11  * tnorm[0] +

        2.0 * C2 * L1m1 * tnorm[1] +  

        2.0 * C2 * L10  * tnorm[2] );

//occlusion

        float average;

        normal  n = normalize(N),

        nf = faceforward(n, I);

        float   hits = 0;

        if(occOnOff != 0.0)

{

                gather("illuminance", P, nf, PI/2, samples, "distribution","cosine")

{

                        hits += 1;

}

                average = hits / samples;

}

        else   

{

                average = 0;

}

        Ci = (color(DiffuseColor * scalefactor)) - average;

        Oi = 1;

}

subSurface

2011-10-31T14:55:00.000-07:00

Fiz um teste de shader de SSS no 3delight .. modelo e texturas nao sao meus ("http://www.ir-ltd.net/infinite-3d-head-scan-released) somente fiz a combinação de dois shader no maya cook torrance com SSS tanto no specular quanto no difusse ! e detalhes com displace ao invez de normal map .. o resultado ficou bem legal . levando em conta o pouco que precisei mexer nos shader pro resultado final ! mas tenho que admitir que o modelo e as texturas sao tao bons que mesmo um maya software tira um render bem aceitavel com esse modelo "D ..

Procedural Primitives 2

2011-08-30T19:33:00.000-07:00

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 .

o codigo praticamente o mesmo

do exemplo anterior . com a diferenca

da adicao de funcoes para sortear posicoes aleatorias e normalizacao dessas posicoes para chegar no formato da esfera maior , segue abaixo o codigo

header:

* RibBox.h

* classExerc

* Created by chrysl666 on 8/27/11.

#ifndef RIBBOX_H

#define RIBBOX_H

#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::vectorstring>& ,

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.

#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::vectorstring>& tokens,

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::vectorstring> tokens; // um vector de string temporario

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<0]<<" "<1]<<" "<2]<<" ";

}

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 "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;

procedural primitives

2011-08-29T12:54:00.000-07:00

O Renderman tem formas simples para adicionar programas dentro do RIB sem ter que literalmente fazer plugin via DSO .. . basicamente voce chama um programa em qualquer

linguagem no meio do processo de render .. e o programa envia chamadas de API ou simples

comandos de RIB via stdout streams( no caso o stdout stream usado eh o prompt do sistema).

o Renderman entende essas chamadas como c elas tivessem vindo do maya ou do RIB.

Voce pode usar qualquer linguagem pra isso .. basta saber usar a saida e entrada padrao de stream da linguagem escolhida.

existem muitos exemplos na internet de como fazer isso usando python , tcl ou "C" ,

mas eu resolvi fazer isso usando um pouco de c++OOP approach : ) ; logico que isso deixa tudo um pouco mais complicado do realmente deveria .. ja que os muitos exemplos que vi em "C" sem OOP eram ridiculos de simples e faceis : ) .. mas como a intencao eh aprender a experiencia valeu : )....meu exemplo tbm eh simples .. fazer uma esfera no meio da tela : ) usando chamadas ao meu programa sem ter essa esfera na cena do maya .. bem segue os codigos

main:

#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.

#ifndef RIBBOX_H

#define RIBBOX_H

#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::vectorstring>& ,

const std::string& ); //tokenize

};

#endif

implementacao da classe:

* RibBox.cpp

* classExerc

* Created by chrysl666 on 8/27/11.

#include

#include "RibBox.h"

RibBox::RibBox()

{

}

// tokenize function // precisa ser implementado antes de ser usado

void RibBox::Tokenize(const std::string& str,

std::vectorstring>& tokens,

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::vectorstring> tokens; // um vector de string temporario

std::getline(std::cin,parFromMaya);

Tokenize(parFromMaya ,tokens);

details = tokens[0];

scaleSize = tokens[1];

}

void RibBox::setRibBox()

{

std::cout<<"AttributeBegin\n";

std::cout<<"Scale "<" "<" "<"\n";

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 : ) .

2011-08-26T05:28:00.000-07:00

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 : ) ..

3delight e photons

2011-08-10T22:15:00.000-07:00

Andei testando um pouco os photons do 3delight .. mas nao gostei muito do processo .. mas acho que eh um problema na minha copia de 3delight ( ou versao ) ... pelo que parece ela nao esta gerando o arquivo de photons pra reutilizacao como deveria . deixando meus renders muito lento pra uso de photons .. mas o engracado eh que testes feitos numa versao de 3DL anterior funcionou muito bem ... bem .. segue a imagem de teste .. uma caverna feita com algumas caixas e mapas de displace . !

Pagina de Odio do Mental Ray ?

2009-09-06T17:02:00.001-07:00

Durante uma pesquiza sobre algumas pessoas . eu achei uma pagina bem interessante .

um blog dedicado a mostrar as cagadas do Mental ray e porque ele eh uma bosta pra producao

de animation feature filmes .. eu nao sou um antimental ray mas achei em interessante o topico .. muita das analises do cara com certeza nunca ia fazer diferenca pra nois pobres mortais que usam mental ray pra pequena producao . mas pra quem tiver curiosidade .. segue ai o link

http://community.livejournal.com/antimentalray/

http://community.livejournal.com/antimentalray/331.html

vale a pena olhar os outros Post no Blog : ) como o que ele fala doBejamin Butao : ) ..

flw

3Delight !!

2009-08-04T07:02:00.000-07:00

Depois de um longo inverno eu finalmente

voltei a mexer com renderman dessa vez usando

o 3delight para estudos ... apesar da diferenca de interface

entre ele e o renderman for maya ou o renderman studio .

estou conseguindo encontrar a maioria dos equivalentes

da interface do renderman ...aqui vai um render teste usando

3delight . com shader de Occ + color Bleeding e sombras raytracing

.. o arquivo de teste foi retirado do pixar curseware e adaptado

para uso no 3delight ...

Raytracing e environment()

2007-07-10T04:42:00.000-07:00

Usar a funcao gather() nao 'e a unica forma de conseguir uma reflexao
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()

2007-07-10T04:14:00.000-07:00

A funcao gather() produz um looping para capturar informacoes via raytracing , ele 'e usado para capturar informacoes do shader que o raio atinge a cada looping .. como ele tem uma emissao de multiplos raios em um certo angulo ele 'e ideal para produzir reflexoes com blur e outros truques com raytracing .

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;

float coneAngulo = 0;

float maxdist = 1
)
{
/* inicia as variaveis para a cptura de informacoessbre a superficie e a cor do reflexo */
color hitColor = 0;

vector In = normalize(I);

normal Nn = normalize(N);

normal Nf = faceforward(Nn, In);

float numhits = 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 */

gather("illuminance", P, ReflexDir,coneAngulo,samples,"maxdist", maxdist, "surface:Ci",
hitColor)

{ Ci += hitColor; /* adiciona a cor capturada em Ci */

numhits += 1; /* conta o numero de raios que atingiram uma surface */

} else { hitColor = 0 ; }

}

/* calcula a media das cores pelo raios atingidos assinalado em Ci */
Ci /= numhits;
Oi = 1;}
/*-------------------------------------------------------------------------------------*/

um teste com samples 64 cone angle 0.18 e distancia 110

trace() + etc..

2007-07-09T04:43:00.000-07:00

segue um shader teste usando a trace() ambient() diffuse() specular()
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

2007-07-09T01:46:00.000-07:00

trace() segundo o manual do renderman :P envia um raio a partir de um ponto em uma determinada direcao,e retorna a cor da superficie em que o raio atingio, que 'e determinada pelo shader da superficie atingida
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 :

specular func

2006-01-05T20:00:00.000-08:00

a funcao specular() retorna a contribuicao do brilho de uma surface. Para usar essa funcao vc tbm precisa informar algumas coisas sobre a geometria da cena . o specular precisa de uma Normal (N) com comprimento maximo de 1.0 e tbm um Vetor com comprimento de no maximo 1.0 definidos no ponto de vista do shader apontado pro observador, e tbm um valor que defina a Roughness da surface , Roughness ou rugosidade `e a medida que define as micro variacoes de altura em uma surface . olhando novamente na lista de variaveis e funcoes vc descobre que

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 !

Ambient() diffuse()

2006-01-04T15:26:00.000-08:00

RSL tem algumas funcoes prontas que calculam a contribuicao da luz
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

2006-01-04T12:23:00.000-08:00

como vc deve ter notado o shader maisSimplesDoMundo.slo apesar de ter um controle de opacidade ele nao funciona .. vamos modificar um pouco o shader para ligar a opacidade:

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+

Usando custom Shaders no RFM

2006-01-03T14:59:00.000-08:00

O RFM vem com novo Node chamado RendermanShader , com ele vc pode
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

2006-01-03T10:10:00.000-08:00

depois de ver um exemplo do Shader MaisSimplesDoMundo .. vamos copilar esse shader e carregar no RFM .. antes de tudo pra isso funcionar vc precisa ter uma Copia de algum renderman compativel . aqui nois vamos usar o RFM .
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

crie o seu primeiro shader para Renderman ( uma visao geral sobre RSL)

2006-01-02T21:25:00.000-08:00

RSL `e uma linguagem similar ao C++ , o que isso quer dizer !?! tenho que aprender C++ ?? bem c vc nao tem nenhum conhecimento basico sobre programacao . seria bom comecar a aprender,tudo bem nao precisa ficar com medo , eu tbm nao sou programador , mas o basico de programacao `e bem facil de aprender e vai ajudar muito nao so com RSL mas tbm com MEL(maya scritp),outra coisa boa`e vc ter um conhecimento basico de 3d na parte de Render e Shader do seu programa favorito, muitas das palavras que usamos em um shader feito RSL tem seu equivalente na interface do seu programa.
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 ??

2006-01-02T20:53:00.000-08:00

o que sao esses nomes? . essas siglas costumam confundir um pouco quem esta comecando a entrar no mundo do renderman( tipo eu ) mas vou tentar explicar de uma forma simples

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 !!