specular func

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()

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

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

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

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)

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

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