SoPoIxNx

Using Mental Ray to Implement The Skin Diffusion of GPU Gems 3

2010-11-20T16:35:00.000-08:00

(File of this head is from ICT's website)

I have implemented this method by using Lighting/Shading → Batch Bake from Mental Ray for Maya to bake light maps of each frame. And I wrote script to produce Gauss Blur maps of each light maps of each frame. Then for each frame, I wrote a mental ray node to combine
those maps with the magic values from Skin Diffusion method of GPU Gems 3. But the performance of this way is very poor. Because if any parameter of light has changed, it is need to
bake those light maps again, and will waste time.

So I started to find another way to implement this method and more efficiency. After I referred the sample code of light map of Mental Ray for Maya, I had wrote a light map node for Mantal Ray for Maya. Through this way, it could produse the light map and those Gauss Blur maps and then combine these maps with the magic value automatically while rendering.

I downloaded the face data from ICT's website. This file is provided for Hybrid Normal Map method, so it provide R-channel, G-channel and B-channel normal maps. But I had used only the G-channel normal map for this blog.

The specular of each pictures below is also using the method from the chap.14 of GPU Gems 3.

Just using the G-channel normal map as this face's normal. The shadow is sharp.

Using the Skin Diffusion method of chap.14 of GPU Gems 3. It is more redness of the skin and the shadow is more soft.

If it just render the diffuse part with white color and without using color texure, White Diffuse 2 is more redness of the skin than White Diffure 1.

(White Diffure 1)

(White Diffure 2)

Now, I start to describe what I have done step by step.

Step1. I wrote a mental ray node and used Lighting/Shading → Batch Bake to bake a stretch map. (Please refer the Figure 14-21 of GPU Gems 3)

Step2. Using my light map node to produee the light map and using this light map to make other Gauss Blur maps.

The operation of my light map node is like mib_lightmap_write of Mental Ray for Maya. But beside bake the light map(Texture), I used this light map and the stretch map(Sretch Map) to produce those Gauss Blur maps(Texture 2 ~ 6). Here the Stch Scale is a weight of the stretch map and Input is Diffuse with white color. Note: It is need to use 6 maps and those maps will be wrote by one light map and five Gauss Blur maps. But it will be combined with those magic values to render final image, so, initially, these maps can not be used with workless data.

Step3. Step2 will produce one light map and five Gauss Blur maps.

Step4. I had written a mental ray node to combine these maps with the magic value in Chap.14 of GPU Gems 3.

The final network of shading nodes will have the form below.

Assigning this network to that face and rendering, it will produce the image like the below.

Export Polygon from Maya to PBRT

2010-10-28T21:33:00.000-07:00

I haven't update this blog in almost one year.....It's time to write something down XD.

Recently, I start to read this book → Physically Based Rendering, 2/e : From Theory To Implementation. And I want to test something by Maya, so I start to study Maya API.
This is my first program by using Maya API. It's very simple and just exports the polygon objects from Maya to the format of PBRT's geometry. And I have refered to a Maya API example, say polyRawExporter, to write this exporter.

(We can downlad the source code of PBRT in this website : http://www.pbrt.org/)

I chose a scene file provided by PBRT's source code, say metal.pbrt. Rendering this file and it will generate a image as below. (I think this file format likes the *.rib of RenderMan :) )

Since I want to replace the teapot by some polygon objects that I modeled in Maya.

I wrote a plug-in to export those objects to the format of PBRT's geometry.

In metal.pbrt, replacing the teapot by what I had export. And that will generate the image below.

鯉魚山親山步道

2009-11-01T02:04:00.000-08:00

今天睡到下午才起床～想說上午下過一場雨，不知道鯉魚山親山步道會不會有什麼新奇好玩的東西出現，就跑去逛了一下，也當作是週末的運動囉！

從大湖街走到底的入口進去，可以看到刻著"清景大湖"的石頭～

沿著旁邊的階梯走上去，可以看到這樣的景色～感覺心曠神怡:)

再沿著階梯走下去....有著小溪一條(記得是叫"大溝溪")

人可以在溪兩旁的石頭上面走，感覺很有趣內！

再往裏面走～

小橋流水

旁邊有一條路是往鯉魚山

有下過雨果然有差～水明顯的比較大！

上次有帶幾個同學這裡泡腳

～～～忍～～～

十幾年前來這裡時，是沒有這座橋的喔！
是有一次颱風把這段路給沖走了，才又加蓋這座橋的！

這是竹節蟲嗎？
在這裡只要留意小地方，可是處處有驚奇的呢！

圓覺瀑布

沾滿水珠的蜘蛛網

親山又親水的步道

往鯉魚山的階梯

往上走還有橋喔～
這在我小時候來的時候是沒有的，也是後來修建的！

幾乎每次來都會看到的－－－－人面蜘蛛　(可愛內～～>/////<)

鯉魚山上面還有小人國喔！不知道這裡在半夜會不會很熱鬧　XD

山上所看到的台北盆地～但今天的天氣狀況不好....

山上的小涼亭

內湖真是個好山好水的地方呢！

立體相機

2009-10-26T01:33:00.000-07:00

在現在這間公司，除了3D動畫的技術&知識外，我想另一個不小的收穫就是stereo的部份吧！(當然最大的收穫還是~認識很多非常nice的同事！！)

某次RD meeting時，我們的頭頭--Drake--帶了台朋友借他的stereo相機(富士的FinePix REAL3D)，當下就有幾個同事把玩了起來。

想說在離職前，也寫一篇跟stereo攀的上邊的東西，當作個小小的紀念囉~

立體影像的原理很簡單。從早期用的紅藍眼鏡(讓左右眼分別接收不同色系的影像來達到立體的效果)，到現在一般戲院戲院用的偏光眼鏡(讓左右眼分別接收不同頻率的影像來達到立體成像)，都是一樣的目的---左右眼分別接收不同的影像。

但是要把畫面做的協調好看，又不會讓觀眾看到頭暈看到吐，可是非常需要技術&經驗的累積~不過....不再這篇討論的範圍 ~XD

這篇只是單純的想秀一下用那台stereo相機拍出來的效果。

這是拍出來的左眼影像：

這是拍出來的右眼影像：

這是麻煩同事--柏納--幫我用Nuke合出來的影像，戴上紅藍眼鏡就可以看出stereo效果。(新版的Nuke已經可以做出用紅藍眼鏡就能看出立體效果的功能，很有趣吶~)

當然，還是用偏光眼鏡看到的stereo效果會比較好~但現在一般螢幕只能看紅藍的......

PTT內湖鄉民中秋烤肉版聚[趴兔](20091004)

2009-10-04T22:10:00.000-07:00

內湖人團○
千里共嬋娟

眼尖的版友在玻璃上發現趴了隻青蛙(kero~kero~~)

座位表

可愛又有趣的名牌

專業內！！

忘了開閃光...整個黑掉 @@

又是忘了開閃光...orz

最右邊那位的表情...
good job！ XD

我們第六組的幾位正妹~

以下幾張是去每組偷拍的

我們第六組的David和S.H.E.(我亂取的啦 XD)

↖煞气a粉腸↘

粉腸跟David烤的香腸超讚的呢！！！
在內湖開一間鐵定會賺~

讓自己也入鏡一下 XD

PTT內湖鄉民中秋烤肉版聚(20091004)

2009-10-04T06:17:00.000-07:00

20090908在墾丁被吉普車玩

2009-09-27T19:40:00.000-07:00

(6)在GLSL中，利用sobel描輪廓線

2009-09-27T00:34:00.000-07:00

這是一張今年９月初跟朋友去墾丁玩的時候的照片。sobel就是一個把一張灰階的圖片，描出其輪廓線的演算法。

以下就來用GLSL實做一下sobel。

這裡只有用到fragment shader！

流程很簡單，就是先用OpenGL API做出2D貼圖，再用GLSL將其轉成灰階，再將其用sobel瞄出輪廓線。

先來看一下要set shader的function:(也就只是把之前的例子的vertex shader的部分去掉而已)

void setShaders() {



    char *vs = NULL,*fs = NULL,*fs2 = NULL;



    f = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);



    fs = textFileRead("sobel.frag");



    const char * ff = fs;



    glShaderSourceARB(f, 1, &ff,NULL);



    free(fs);



    glCompileShaderARB(f);



    p = glCreateProgramObjectARB();



    glAttachObjectARB(p,f);



    glLinkProgramARB(p);



    glUseProgramObjectARB(p);



}

再來是先看怎麼在fragment shader中，將其轉成灰階:

uniform sampler2D tex;
float intensity(vec4 color){
    return 0.299*color.r + 0.587*color.g + 0.114*color.b;
}
void main(){
    vec4 a, p;
    p.s=gl_TexCoord[0].s;
    p.t=gl_TexCoord[0].t;
    a=texture2D(tex,p.st);
    float i = intensity(a);
    gl_FragColor = vec4(i, i, i, 1);
}

結果如下:

最後來看怎麼在fragment shader中，將其利用sobel瞄出輪廓:

uniform sampler2D tex;

float intensity(vec4 color){   
    return 0.299*color.r + 0.587*color.g + 0.114*color.b;
}

float sobel(vec4 a1,vec4 a2,vec4 a3,vec4 a4,vec4 a5,vec4 a6,vec4 a7,vec4 a8,vec4 a9)
{   
    float X,Y;  
    vec3 y=vec3(a6.r-a4.r, a3.r-a1.r, a9.r-a7.r);  
    vec3 z=vec3(a2.r-a8.r, a3.r-a9.r, a1.r-a7.r);   
    X=2*y.x+y.y+y.z;    
    Y=2*z.x+z.y+z.z;   
    return (float)sqrt(X*X+Y*Y);
}

void main(){     
    vec4 a1,a2,a3,a4,a5,a6,a7,a8,a9;    
    vec4 p1,p2,p3,p4,p5,p6,p7,p8,p9;    
    vec2 c=vec2(1, 1);
    
    p5.s=gl_TexCoord[0].s;    
    p5.t=gl_TexCoord[0].t;

    a5=texture2D(tex,p5.st);    
    float i = intensity(a5);        
 
    p1.s=p5.s-c.s/(256);   
    p1.t=p5.t-c.t/(256);

    p2.s=p5.s;   
    p2.t=p5.t-c.t/(256);
    p3.s=p5.s+c.s/(256);   
    p3.t=p5.t-c.t/(256);
    p4.s=p5.s-c.s/(256);   
    p4.t=p5.t;
    p6.s=p5.s+c.s/(256);   
    p6.t=p5.t;
    p7.s=p5.s-c.s/(256);   
    p7.t=p5.t+c.t/(256);
    p8.s=p5.s;   
    p8.t=p5.t-c.t/(256);
    p9.s=p5.s+c.s/(256);   
    p9.t=p5.t+c.t/(256);

    a5=texture2D(tex,p5.st);   
    a1=texture2D(tex,p1.st);   
    a2=texture2D(tex,p2.st);   
    a3=texture2D(tex,p3.st);   
    a4=texture2D(tex,p4.st);   
    a6=texture2D(tex,p6.st);   
    a7=texture2D(tex,p7.st);   
    a8=texture2D(tex,p8.st);   
    a9=texture2D(tex,p9.st);

    float j=sobel(a1,a2,a3,a4,a5,a6,a7,a8,a9);   
    gl_FragColor = vec4(j, j, j, 1); 
}

結果如下圖:

(5)多重貼圖{multi-texture}

2009-09-26T22:25:00.000-07:00

上次聽同事(ypcat)分享他去siggraph的收穫後，才知道OpenGL 3.2已經變成shader base programmig了，也就是不再用以往的glBegin() & glEnd()之類的來建構出geometry primitive，而是會將其寫在vertex buffer object裡。

感覺挺酷的!!

不過這篇還是用老舊的方式，也就是使用glBegin() & glEnd()來建構出geometry primitive。

是改自從這個網站 http://www.lighthouse3d.com/ 下載來的project；而使用貼圖所用到的function，是從OpenGL超級手冊的範例中拿來用的。
-------------------------------------------------------------------------------------------------

目的是要將下面這兩張圖:

經由GLSL合併成下圖的樣子:

先來看一下要怎麼透過OpenGL API，傳遞貼圖給GLSL:

glBegin(GL_POLYGON); 
    //
   /*下面這綠色這兩行，作用是同時將GL_TEXTURE0和GL_TEXTURE1，assign給vertex*/
   glMultiTexCoord3fARB(GL_TEXTURE0_ARB, 0.0, 1.0, 0.0);
   glMultiTexCoord3fARB(GL_TEXTURE1_ARB, 0.0, 1.0, 0.0);
   glVertex3f(1*size,1*size,1*size);




   //
   glMultiTexCoord3fARB(GL_TEXTURE0_ARB, 0.0, 0.0, 0.0);
   glMultiTexCoord3fARB(GL_TEXTURE1_ARB, 0.0, 0.0, 0.0);
   glVertex3f(1*size,-1*size,1*size);

   // 
    glMultiTexCoord3fARB(GL_TEXTURE0_ARB, 1.0, 0.0, 0.0); 
    glMultiTexCoord3fARB(GL_TEXTURE1_ARB, 1.0, 0.0, 0.0);
   glVertex3f(-1*size,-1*size,1*size);
 
　　//


 
    glMultiTexCoord3fARB(GL_TEXTURE0_ARB, 1.0, 1.0, 0.0); 
    glMultiTexCoord3fARB(GL_TEXTURE1_ARB, 1.0, 1.0, 0.0); 
    glVertex3f(-1*size,1*size,1*size); 
glEnd();

而texture的資訊，是透過下面的OpenGL API function，assign給GLSL的uniform variable。

void renderScene(void) {
   glClear(GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
   glUseProgram(p);
   //tex1 & tex2 是在 fragment shader中宣告的uniform variable
   //透過loc1 & loc2 來將讀取到的texture資訊，分別assign給tex1 & tex2
   loc1 = glGetUniformLocation(p, "tex1");
   loc2 = glGetUniformLocation(p, "tex2");

   //下面這段，就是先讀取texture資訊，再透過loc1&loc2分別assign給tex1 & tex2
   //其中TextureLoad是從openGL超級手冊的範例拿來用的function
   //(懶的解釋每個fuction的用途 XD)
   glActiveTexture(GL_TEXTURE0_ARB);
   text1=TextureLoad("crate.bmp", GL_FALSE, GL_LINEAR, GL_LINEAR, GL_REPEAT);
   glBindTexture(GL_TEXTURE_2D, text1);
   glEnable(GL_TEXTURE_2D);
   glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
   glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_REPLACE);
   glUniform1i(loc1, 0);
    glDisable(GL_TEXTURE_2D);

   glActiveTexture(GL_TEXTURE1_ARB);
   text2 = TextureLoad("GodTaiwan.bmp", GL_FALSE, GL_LINEAR, GL_LINEAR, GL_CLAMP);
   glBindTexture(GL_TEXTURE_2D, text2);
   glEnable(GL_TEXTURE_2D);
   glTexEnvf (GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_EXT);
   glTexEnvf (GL_TEXTURE_ENV, GL_COMBINE_RGB_EXT, GL_INCR);
   glUniform1i(loc2, 1);
    glLoadIdentity();
   gluLookAt(5.0,0.0,0.0,
             0.0,0.0,0.0,
             0.0f,1.0f,0.0f);
   glLightfv(GL_LIGHT0, GL_POSITION, lpos);
   glRotatef(a,0,1,1);
   drawBox(1);
   a+=0.1;
   glutSwapBuffers();
}

最後，來看一下Vertex & Fragment shader裡是怎麼寫的吧~

Vertex Shader:

void main(void)
{
//用來使用貼圖的內建array
gl_TexCoord[0] = gl_MultiTexCoord0;
gl_TexCoord[1] = gl_MultiTexCoord1;
gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
}

Fragment Shader

//用來讀取從外部傳入的texture的資訊的變數
uniform sampler2D tex1;
uniform sampler2D tex2;
void main (void)
{
//這....看也知道吧 XD........不然就咕狗囉
vec4 texval1 = texture2D(tex1, vec2(gl_TexCoord[0]));
vec4 texval2 = texture2D(tex2, vec2(gl_TexCoord[1]));
gl_FragColor = 0.5*(1.0*texval1 + 1.0*texval2);
}

//用來讀取從外部傳入的texture的資訊的變數

uniform sampler2D tex1;

uniform sampler2D tex2;

void main (void)

{

//這....看也知道吧 XD........不然就咕狗囉

vec4 texval1 = texture2D(tex1, vec2(gl_TexCoord[0]));

vec4 texval2 = texture2D(tex2, vec2(gl_TexCoord[1]));

gl_FragColor = 0.5*(1.0*texval1 + 1.0*texval2);

}

(4)簡單的光照

2009-09-25T23:11:00.000-07:00

最近看到很有感觸的一句話：

人最可怕的不是過去，而是不肯改變自己！

共勉之～

－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－

這是改寫自ShaderDesigner的一個名叫'dimple'的範例(如下)：

改出來的結果如下圖：茶壺的上方及右邊個有一個光源打向茶壺~

改出來的Vertex & Fragment shader分別如下：

Vertex Shader:



//光源的方向
varying vec3 LightDir;
varying vec3 LightDir2;

//視角的方向
varying vec3 EyeDir;

varying vec3 Normal;



//uniform vec3 LightPosition;

//uniform float Scale;



void main(void)

{



float Scale = 3.0;

//讀取每個vertex的位置
vec4 pos = gl_ModelViewMatrix * gl_Vertex;

gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;

//指定視角的方向
vec3 eyeDir = vec3(pos);

gl_TexCoord[0] = gl_MultiTexCoord0;


//宣告一個不為０的向量，用來計算出與每個vertex的normal垂直的平面的base
        //用g或是g2都可以，但結果會有些許不同，因為計算出來的base會有所不同
vec3 g = vec3(1.414, 2.78, 3.14);

vec3 g2 = vec3(0,1,0);


//vertex的法向量
vec3 n = normalize(gl_NormalMatrix * gl_Normal);

//t與n垂直
vec3 t = normalize(cross(g, n));

//b與n以及t垂直，故b,t構成與n垂直的平面的base
vec3 b = cross(n, t);



vec3 v, v2;

//指定兩個光源的位置，一個從上方，一個從右邊
vec3 newLitPos = vec3(0,1,0);
vec3 newLitPos2 = vec3(1,0,0);

//用v和v2，分別來紀錄兩個方向的光源，對每個vertex的貢獻度(亮度)
v.x = dot(newLitPos, t);
v.y = dot(newLitPos, b);
v.z = dot(newLitPos, n);


v2.x = dot(newLitPos2, t);
v2.y = dot(newLitPos2, b);
v2.z = dot(newLitPos2, n);


 //再將normalize後的v和v2設給光源方向
LightDir = normalize(v);
LightDir2 = normalize(v2);


EyeDir = normalize(eyeDir);


}

Fragment Shader:



varying vec3 LightDir;
varying vec3 LightDir2;
varying vec3 EyeDir;
varying vec3 Normal;

const vec3 color = vec3(0.7, 0.6, 0.18);


const float SpecularFactor = 0.75;

void main (void)
{
float Density = 16.0;

float Size = 0.0;

 //initialize 光的顏色
   vec3 litColor=0.0;

vec2 c = Density * (gl_TexCoord[0].xy);
 vec2 p = fract(c) - vec2(0.5);
float d = (p.x * p.x) + (p.y * p.y);
if (d >= Size)
     p = vec2(0.0);

//指定一個與螢幕方向垂直的向量
vec3 normDelta = vec3(0, 0, 1.0);

 //計算從螢幕看出去，兩個光源方向對物體的貢獻度，並乘上顏色
litColor = color * max(0.0, dot(normDelta, LightDir));
litColor = litColor +  color * max(0.0, dot(normDelta, LightDir2));

//計算反射光的方向
float t = 2.0 * dot(LightDir, normDelta);
float t2 = 2.0 * dot(LightDir2, normDelta);
vec3 reflectDir = (1.0*(t)) * normDelta;
vec3 reflectDir2 = (1.0*(t2)) * normDelta;
reflectDir = LightDir - reflectDir;
reflectDir2 = LightDir2 - reflectDir2;

 //計算兩個光源，相對於視角的specular強度
float spec = max(dot(EyeDir, reflectDir), 0.0);
 float spec2 = max(dot(EyeDir, reflectDir2), 0.0);

spec = spec * spec+spec2*spec2;
spec *= SpecularFactor;

litColor = min(litColor + spec, vec3(1.0));
gl_FragColor = vec4(litColor, 1.0);
}

補充說明一下~~宣告為varying的變數，簡單來說，是Vertex和Fragment shader共享的變數。而宣告為uniform的變數，是可以從shader外部assign值給它的變數。

　

墾丁浮潛&香蕉船

2009-09-09T18:42:00.000-07:00

特別要感謝一下耿摯和乃芯用心的規劃這次行程，很讚很棒！！！
還要感激當司機的敏恩和耿摯，很辛苦吶~
也要感激當財務大臣的欣怡(不知道有沒有打錯名字 @@)，真是個精明幹練的女強人！
最後是很感激很開心可以跟這麼棒的一群人出去玩 :)

(3)第一個GLSL程式 part[下]

2009-08-31T01:28:00.000-07:00

先來分享一首老歌~Bon Jovi的All About Loving You~
覺得這MV老歸老，但是屌到掉渣!

------------------------------------------------------------------------------------------

上一篇的Hello World解壓縮後，其主程式(ogl3.cpp)裡用OpenGL API來設置GLSL的function如下: (有解釋錯誤的地方，請不吝指教 @@)

void setShaders() {
    char *vs = NULL,*fs = NULL;

    /*GLuint glCreateShader(GLenum shaderTypr)
        顧名思義，就是建立存放shader的變數囉*/
    v = glCreateShader(GL_VERTEX_SHADER);
    f = glCreateShader(GL_FRAGMENT_SHADER);

    /*讀取vertex shader 和 fragment shader的內容*/
    vs = textFileRead("minimal.vert");
    fs = textFileRead("minimal.frag");

    const char * vv = vs;
    const char * ff = fs;

    /*void glShaderSource(GLuint shader,
                                            GLsizei count,
                                            const GLchar **string,
                                            const GLint *length)
        ◎將shader的source code設成string(array of strings)的內容，而在string
            這個string array中有幾個string是由count 決定.
        ◎如果length = NULL，則每個string的結尾為null，否則其皆為指定string
            中每個元素的長度
        ◎每個在length 這個array中的元素，皆為其所對應的string的長度，若其
            值小於0，則說明所對應的string的結尾為null*/
    glShaderSource(v, 1, &vv,NULL);
    glShaderSource(f, 1, &ff,NULL);

    free(vs);
    free(fs);

    /*void glCompileShader(GLuint shader)
        shader為所要compile的shader object*/
    glCompileShader(v);
    glCompileShader(f);

    printShaderInfoLog(v);
    printShaderInfoLog(f);
  
    /*GLuint glCreateProgram(void)
       ◎glCreateProgram建置一個空的program object及傳回一個non-zero
           value來reference用
       ◎其所建置的program object可用來給shader object attach*/
    p = glCreateProgram();

    glAttachShader(p,v);
    glAttachShader(p,f);

    /*void glLinkProgram(GLuint program)
        ◎如shader object為GL_VERTEX_SHADER且已attach在program上，
            則此function在programmable vertex processer上是可執行的
        ◎program是程序容器，在此function執行後，可以任意修改shader的
            原代碼，對shader重新compile不會影響整個程序，除非重新連接程序*/
    glLinkProgram(p);

    printProgramInfoLog(p);

    /*void UseProgram(GLuint program)
       用來加載並使用連接好的程序*/
    glUseProgram(p);
}

接著來小小介紹一下vertex shader和fragment shader吧~

對於要顯示出來的物件(ex:teapot, cube, sphere...etx)，GPU會對其頂點(vertex)進行處理，並將之轉換成螢幕空間幾何體(screen-space geometry)，該幾何體透過光柵化(rasterization)過程依次被劃分為畫素片段(pixel-sized fragment)。每一片段與螢幕上的一個畫素位置相關。最後，這些片段被處理並組合到由畫素組成的影像中。

而vertex shader和fragment shader，分別為GPU越來處理vertex以及pixel-sized fragment所用的code。

最後來看看這個範例的vertex shader和fragment shader裡寫了些什麼吧~

Vertex Shader:


// minimal vertex shader
// http://www.lighthouse3d.com/
void main(){ 
    // the following three lines provide the same result
    /*
    #更新gl_Position的內容，就是在告知GPU某個頂點轉換到螢幕座標系上的結
       果
   #讀取gl_Vertex就可以取得頂點的位置
   #glModelViewProjectionMatrix是內建變數，它可以取得經由C/C++呼叫
     glLoadMatrixf等矩陣操作函式所設定的矩陣內容
    */
    gl_Position = gl_ModelViewProjectionMatrix * gl_Vertex;
    /*gl_ProjectionMatrix*gl_ModelViewMatrix=gl_ModelViewProjectionMatrix*/ 
    //gl_Position=gl_ProjectionMatrix*gl_ModelViewMatrix*gl_Vertex;
    /*上面兩個等號右邊的東西，可以用一個內建function:ftransform();來取代*/    
    //gl_Position = ftransform();
}

Fragment Shader:


// minimal fragment shader
// http://www.lighthouse3d.com/
void main(){
     /*gl_FragColor代表物件在畫面上所要顯示的顏色*/  
     gl_FragColor = vec4(0.4,0.4,0.8,1.0);
}

(2)第一個GLSL程式 part[上]

2009-08-29T23:31:00.000-07:00

這兩天在玩一個小遊戲--->死亡打字機

是去一個大學同學的租屋處play時，他向我和另一個同學介紹的，當下就向他copy回家玩 XD

對於一般線上遊戲興趣缺缺的我，卻很喜歡玩這種有趣的3D小遊戲

這遊戲對於像我這種英打不快的人而言，真是個有趣又可以練打字的遊戲

由上面的畫面可以看到---要key下顯示在每個殭屍前的英文字，才可以打死殭屍。打不死他們就換自己死了~ XD
而且....不像上圖每個殭屍前只有兩個英文字母這麼簡單，有些還是問答題，要key入正確的答案才能過關!

相信每天過一關....全破後，我就會有神一般的英打速度(握拳!)

--------------分隔線--------------

這裡用的OpenGL版本是2.0，編輯器是用Visual Studio.Net 2005

除了安裝設定好OpenGL，還要下載OpenGL Extension Wrangler Library (GLEW)，並做好相關設定。

可以去這裡下載GLEW: http://glew.sourceforge.net/

但是基本上現在顯卡的driver安裝好後，以上所需要用到的檔案(*.h , *.lib...etc)都可以在driver的安裝路徑中找到。
(這年頭不支援GPU的顯卡應該也賣不出去吧)

但還有一點要注意的，就是要在Visual Studio的專案->屬性，做如下圖的設定:

接下來....去下面這個網站download 他的 Hello World 範例來play一下:
http://www.lighthouse3d.com/opengl/glsl/index.php?intro

(這也是個很棒的GLSL教學網站喔)

解壓縮那個Hello World後，可以看到裡面有一個minimal.frag和一個minimal.vert，分別為fragment shader和vertex shader。

開啟project並執行後可以看到如下圖結果:

至於程式怎麼運作的以及什麼是vertex shader 和 fragment shader就留到下一篇再介紹囉~

(1)一些GLSL的editor

2009-08-26T18:32:00.000-07:00

最近心血來潮，想說把以前從網路上整理的GLSL資料拿來看，發現整個忘的差不多了.....orz

想想，是該整理一些心得出來的時候了，是自己曾經會的東西，不想就這樣讓它隨風而逝，總該留點痕跡下來阿阿阿～

這篇就小小介紹一下GLSL以及有哪些編輯器囉!

什麼是GPU shader呢？簡單來說就是像RenderMan shader一樣，不一樣的是，RenderMan shader吃的是CPU的資源，而GPU shader吃的是GPU的資源。比較有名可以支援GPU shader的shading language有Cg、HLSL(DirectX的High Level Shading Language)以及GLSL(OpenGL Shading Language)。或許是因為跟OpenGL比較熟的緣故，個人比較喜歡GLSL～XD

下面列出三項網路上抓的到的GLSL editor：

(1)QShaderEditor....這似乎只有出Linux版的

(2)RenderMonkey( http://developer.amd.com/gpu/rendermonkey/Pages/default.aspx )

(3)ShaderDesigner( http://www.typhoonlabs.com/ )

Houdini9.5之後，也可以在裡面寫GLSL shader來即時顯示。圖中的Torus為toon、Sphere為diffuse、Cube為隨便套的GLSL shader。說不定哪一天連Maya裡都可以用GLSL了 XD

但個人還是比較傾向用一般的程式編輯器，從在C/C++裡使用OpenGL API到GLSL都自己來～是覺得什麼都自己寫會比較紮實比較有成就感:)

(16)用volume簡單實作水面下的效果

2009-08-20T01:11:00.000-07:00

先扯點題外話....
看到那些八八水災的報導，對災民的處境雖不能感同身受，但也會有想要下去幫點忙的衝動。最近也在想....如果這些水量是降落在台北，想必也會是一場浩劫

◢▆▅▄▃天佑╰(〒皿〒)╯台灣▃▄▅▇◣

----------------------題外話分隔線----------------------

這次是試著實作水面下的效果。上一次做跟水底有關的效果，大概是5,6年前的事了，那時是用3ds max照著書上的範例來做，連RenderMan這個詞都沒聽過。這次要用RenderMan來做，一開始有點傷腦筋，不過把Finding Nemo開來看個幾次之後，也有了點fu，就測試出如上面影片的樣子的東西囉。這篇就是大致上介紹一下上面的影片是如何做出來的，也是我第一次用到RenderMan的volume來做東西。

首先是建置一個這樣的場景：一顆sphere中包著兩片平行的plane，然後camera從這兩片平行的plane裡看過去。如下圖

這裡會用到3個ensemble，分別是水面的、水中的、水底的。這裡先介紹水中的(下圖左:Ensemble_volume)，和水面的(下圖右:Ensemble_ocean_surf)。要注意的地方是，在Ensemble的Atmosphere上，接上smoke這個volume shader。將Ensemble_volume和Ensemble_ocean_surf分別attach在場景中的sphere和上方的plane上。Ensemble_volume的Surface接一個constant當作底色；將這兩個Ensemble接上smoke這個node的功用是~smoke這個volume shader會對這兩個Ensemble發生作用。

上面那個smoke 如下圖。這裡小小介紹幾個欄位：
Color : 就是color ，沒辦法更白話了
Density：volume的濃度
Sampling Increment：volume的顆粒大小
至於這裡Pattern接的SLBox，本來是想要給它一點動態的變化，但是發現好像不明顯 @@，所以也就不特別介紹了~後面會在介紹Color接的SLBox是做什麼用的。

接著是水面波紋的介紹。可以看到Ensemble_ocean_surf上分別在Surface和Displacement上接了Delux和Simple。其中displacement是接一個SLBox，如下圖

SL code內容如下：簡單來說，就是用一層波紋較大片(f)的再疊上一層波紋叫細密(f2)的pattern，然後餵進時間變數(v1)，來做出動態效果。
/******************************************************/
/* float */
float hump = 0, hump2 = 0;
float j, f = 12, f2=200, amplitude = 1;

point p= transform("object", P);

for(j = 0; j ＜3 ; j+=1)
　hump += abs(noise(p * f+2*v1) - 0.75) * amplitude;
　f *= 2;
　amplitude *= 0.5;
　}

for(j = 0; j ＜3; j+=1)
　hump2 += abs(noise(p * f+2*v1) - 0.75) * amplitude;
　f *= 2;
　amplitude *= 0.5;
　}

result = 1.75*(hump)+0.4*hump2;
/******************************************************/

接下來先介紹一個result會隨景深(Z軸)越深而漸漸變小的SLBox(type為float)。這裡將其命名為Z_d

SL code 如下：zmax和zmin分別為最大值的景深和最小值(camera前)的景深，視場景大小而定
/******************************************************/
/* float */
point pp = transform("camera",P);
point py = transform("world",P);
float zr = (zcomp(pp)-zmin) / (zmax-zmin); zr = clamp(zr,0,1);
result = zr*zr;//乘兩次的用意是...加重落差
/******************************************************/

然後來看看用在做水波全反射用的SL code。乘上v4的用意是，讓水面的眼色會隨著景深越深而越來越黑。除此之外，也將Ensemble_ocean_surf上的Delux的opacity接上前述的Z_d，好讓其透明度隨著景深降低。

/******************************************************/
normal n = normalize(N);
normal i = normalize(I);

result = (v1+v5)*v3*v4;

//視角與法向量內積的值小於某個值後，即將其改成較亮的顏色，
//來摹擬全反射。
if(abs(n.i)<0.3)
　result = v4*(v2*v3);
/******************************************************/

同理，在smoke的color上，接上的SLBox，其SL code就只是簡單的color*Z_d(顏色*景深)。

至於水底........就找張還ok的貼圖，乘上Z_d，再加點顏色的動態擾動以及一點displacement即可~

(15)實作一個結冰的動態

2009-08-15T22:27:00.000-07:00

最近在ptt上面發現一個很溫暖的地方→內湖版！
不只家在內湖，從幼稚園到高中，我都是在內湖度過的，覺得這是個生活機能好，有美麗環境，居民又熱心的地方～

所以就想在這篇的影片上，表示一下我對這可愛的地方的喜愛～

內湖Good!!

--------------------------------拉哩拉咂分隔線-----------------------------------

在RenderMan上是可以讓一張texture動態的出現，以下就小小的實作一下囉！(其實基本上，使用RenderMan可以做出很多動態的效果)

這裡要做出的效果是....一個金屬要結冰，但不是整顆同時結，而是從邊邊角角的部位開始漸層的往內擴散~

◎先準備一張像雪的texture~
下面那張是來自這個材質的好站：
http://www.davegh.com/blade/davegh.htm
站長是一個國外專業的繪製材質藝術家(但好像很久沒更新了)

◎在ImageFile裡使用那張texture，並將其接到一個type為float的Spline上，調整一下curve，使其白色的部份變的較為突出。

◎在Delux裡，接上一個type為color的SLBox(這裡是接在v4上)。在這裡的作用是....在這個SLBox裡寫的code所產生的效果(結冰)，可以動態的將Diffuse、Specular、Reflection...等，慢慢蓋掉。

◎這裡就是上述那個SLBox的內容:
v2: [expr $time/5]->此為一個tcl語法，即v2的值為所經過的時間的五倍慢
v3: 連接一個float noise node
v4: 連接上面那個Spline node

◎此為寫在SL code裡的code，小小的解說一下:
/*********************************************************************************/
//宣告兩個type為color的變數，其中finalColor為最後呈現的顏色
color C = 1;
color finalColor=0;

//pp來物件座標的點的值
point pp = transform("object", P);

/*hump為控制結冰的範圍的值，3.2和1.4為測試出來的值，3.2為pp到物件中心點的距離的上界。當v2(時間)為0時，也就是還沒開始結冰。當時間過越久，也就是v2的值越大，hump的值就越小，3.2-hump的值就越大；也就是說...結冰的範圍就越大*/
float hump = 3.20-1.4*(noise(10*s,10*t))*v2;
float rp;

/*當物件表面的點，到物件中心的距離(length(pp))，大於hump的話，就將其做結冰的效果，否則就不作用，維持原本物件表面的樣子*/
if(length(pp)>hump)
{
//用smootstep這個function做出漸層的效果
rp = 1.4*smoothstep(hump, 3.2, length(pp));
finalColor = v4*C*v3*rp;
}
else
{
finalColor = 0;
}

result = finalColor;

/******************************************************************************/

上面的影片中，還有加displacement，也是從這個SLBox node接出去做出來的囉~

(14)在RMS中使用RIBArchive

2009-07-10T04:29:00.000-07:00

最近突然有一種體悟....就是當有一個....我認為xxoo的人，說我很ooxx時，在有那種

"你明明也xxoo，憑什麼批評我的ooxx?!"

的想法前，應該事先要對自己坦承:我就是一個ooxx的人~
還是坦然點會過的比較舒服

-------------嘰哩呱啦吱吱咂咂--------------

這篇只是小小介紹如何在RMS中使用RibArchive的功能。跟RMS的Ensemble跟RAT不同，沒有RIBBox這種東西可以接，因為RMS將其整合進Maya裡(RMS就是為了跟Maya有更好的結合才誕生的)。而且不只RibArchive，很多RenderMan的功能都要透過在Maya裡，新增以及設定一些attribute來達成。

首先...建置一個簡單的場景如下：(cube給它一個紅色的材質球)

然後在Attribute視窗，切換到pCubeShape1的tab，按Attributes->RenderMan->Manage Attributes，會跳出下面這個視窗

在Optional Attributes裡選"Pre Shape MEL"，然後按下Add，即可發現在pCubeShape1最下面出現一個新的attribute：Pre Shape MEL。這個欄位就等同於RAT的RIBBox欄位。

對旁邊那個locator也是相同的作法。然後在這個欄位輸入RiReadArchive "/oox/ooxx/Archive_test.rib";
也就是在RiReadArchive後面接RibArchive的路徑，render後可以看到類似下圖：紅色的teapot是由於有給他一顆材質球，所以它會去讀材質球上的資訊。另一個是只單純讀*.rib裡的geometry資訊。(註:在RMS1.0中，並不能對locator做這樣的動作，而在RMS2.0中，有將這個bug修掉)

可以在文字編輯器裡，先打好所要輸入的code，再複製貼上，不然那欄位那麼小，直接在裏面輸入會搞到眼睛脫窗@@

這裡有順手寫了一個小小的script，先選取object，然後在maya裡執行(環境要為linux)，可選取要被讀取的文字檔，並將此文字檔的內容輸入到Pre Shape MEL裡:

from pymel import *
import pymel as pm

from commands import *

import maya.mel as mel

def getFile():
　zenFile = getoutput('zenity --title="search file" --file-selection --filename=""')
　tmpPath = zenFile.split('failed')
　filePath = tmpPath[1].split('\n')

　fileCont = open(filePath[1], 'r')
　return fileCont.read()

def addArch():
　objShap = pm.ls(sl=1, dag=True, g=True)
　testName = objShap[0]
　mel.eval(' rmanAddAttr '+objShap[0]+' rman__torattr___preShapeScript "" ')

　archCont = getFile()
　print archCont
　setAttr(objShap[0]+".rman__torattr___preShapeScript" , archCont)

addArch()

(13)在RMS中使用Environment Light來做Point-Based Global Illumination

2009-07-08T04:31:00.000-07:00

"為什麼我們要花這麼多時間做準備，以便在未來能做我們想做的事，卻不肯現在就去實現我們的理想？"

節錄自「生命咖啡館」

－－－－－－－－－－－－－－－－－－－－－－－－－－－－

這篇是介紹如何使用RMS的Environment Light中的Point-Based Global Illumination功能，來做approximate occlusion(不負責翻譯:"近似occlusion".....好瞎@@)

首先....就是要先有場景，以及要用來render的camera囉！

然後再新增一個camera，用來bake *.ptc用的，所以要保證render用的camera所看到的範圍，這個新增的camera也都要看的到。這裡是將這個camera重新命名為reference。

打開Render Setting，將Render using切換成RenderMan(也可以直接開啟RenderMan Global)。然後切換到Features這個tab，在其底下的Global Illumination→Environment Light欄位裡，按滑鼠右鍵，選Create RenderManEnvLightShape，可以看到如下視窗。把Shadowing這個欄位切換成是occlusion。

接著在RenderManEnvLightShape的Bake(或是Bake Shadowing)這個欄位裡，按滑鼠右鍵，選Create RenderRadiosity，即可出現如下視窗。
(註：這裡會出現三個選項：Create RenderRadiosity、Create MakeApproxGlobalDiffuse、Create MakeGlobalDiffuse3d，簡述如下：

MakeApproxGlobalDiffuse：會bake出global illumination的*.ptc，並會從這個*.ptc再產生*.bkm(brick map檔，可以想成是經過空間分割的*.ptc)

MakeGlobalDiffuse3d：會bake出有ray-traced的global illumination的*.ptc，並會從這個*.ptc再產生*.bkm

RenderRadiosity：同MakeApproxGlobalDiffuse，但不會產生*.bkm)

然後在rmanRenderRadiosityPass的camera欄位裡，按滑鼠右鍵，選擇要bake *.ptc的camera的名稱(這裡是referenceShape)；在Caching Behavior選Compute，即要計算出*.ptc。

執行render後，可以看到先render出object的color的圖，且是從reference這個camera角度看出去的樣子，也就是說，先透過bake *.ptc用的camera，來bake出object的顏色的資訊到*.ptc裡。

接著會看到真正render出來的approximate occlusion的結果，如下：

而且在project的renderman->untitled->data->0001底下，看到有一個*.ptc檔。

用ptviewer開啟這個*.ptc，再右鍵->Color->_radiosity，可以看到如下結果～將object的color資訊寫進去的*.ptc，且視角是reference看出去的視角。

再在rmanRenderRadiosityPass裡，將Caching Behavior切成Reuse，即可重複使用剛剛生出來的*.ptc的color資訊。再次render，就會直接render出結果，而不會先render出用來bake物件的color pass。

(12)利用python產生rib並使用*.ptc

2009-07-06T04:32:00.000-07:00

～你為什麼在這裡？～

最近在想....該怎麼釐清"依賴"跟"無賴"的感覺。昨天看完了 "生命咖啡館(The WHY ARE YOU HERE CAFE')" 的前面三章，已經很久沒有放慢速度，一字一句的好好看本書了，特別是這種勵志類的書。"我為什麼會在這裡？"，這問題我還沒有個較明確的頭緒～想的到的是"因為我喜歡computer graphic阿"、"因為我喜歡看動畫阿"、"因為我很幸運可以把興趣當職業阿"、"因為我有想要珍惜的人阿"、"因為我宅阿"...etc，但仍是如書上所敘述，我有一份喜歡的職業，也有一些好朋友，生活還算如意～但是內心深處，總還是有種難以言喻的感覺。昨天看完前三章後，感受到這本書有種讓我想一口氣看完的吸引力。但還是闔上了書本，覺得這種書就是要看一部份，然後從生活中累積一些感觸後，再看一部份....慢慢的看完，儘管我真的很想一口氣看完它 XD.

有幾句話真的有被觸動到～

「有的時候，換個角度來看事情，確實會挺有幫助的」

「如果誠實面對自己，我會承認這些年來，我一直在質疑自己的人生，是否還有比我目前所知更深刻的一面」

「有時候你就是不知道自己早已準備好，可以盡情享受生命中的完美時刻」

－－－－－－－－－－－－囉哩八嗦分隔線－－－－－－－－－－－－
RMS2.0新加了PRman for python，顧名思義，就是它有提供module(prman)讓使用者可以在python使用PRman的API。整個手癢想小小測一下，所以就以上一篇網誌當範例來玩一下，然後整理上來囉。以下是玩出來的python code：

import prman

ri=prman.Ri()

def ptc_RIB(ri):
　rendertarget = "ptc_RIB.rib"
　ri.Begin("ptc_RIB.rib") # set rendertarget to ri.RENDER to render pixels
　ri.Display("helloworld.exr", "it", "rgba")
　ri.DisplayChannel("color _ooxx")
　ri.Format(512,512,1)
　ri.Projection(ri.PERSPECTIVE, {ri.FOV: 60}) # standard Ri tokens are available

　ri.Rotate(180, 1,0, 0)
　ri.Rotate(0, 0,1, 0)
　ri.Translate(0, 0.1, -8)
　ri.WorldBegin()

　ri.Attribute( "cull", {"hidden": 0}) # don't cull hidden surfaces
　ri.Attribute( "cull", {"backfacing": 0}) # don't cull backfacing surfaces
　ri.Attribute( "dice", {"rasterorient": 0}) # view-independent dicing !
　ri.Attribute( "visibility", {"int diffuse": 1}) # make objects visible to rays
　ri.Attribute( "visibility", {"int specular": 1}) # make objects visible to rays

#RenderMan Interface會在RIB中的Lights(ex:spot light), Objects(ex:sphere) 和 Archives 上綁
#一個ID，但我們可以自己給他我們想要的ID名稱，來將RI給它的蓋掉。如下紅色部份的寫法
　ri.LightSource("spherelight", {ri.HANDLEID:"sl1", "point from": (-2.8, 2.0, 2.5),
　"float radius": 0.5, "float intensity": 2, "float samples": 64.0, "float falloff": 0.5})

　a="area_illum_tpt.ptc"
　b="_ooxx"

#在給shader的引數設定數值時，跟C/C++不同的是，PRman for python是要寫成如下面的型
#式(綠色部份)
　ri.Surface("bake_direct_irrad", {"string filename": a,"string displaychannels": b})
　ri.Geometry("teapot")
　ri.WorldEnd()
　ri.End()

ptc_RIB(ri)

下面是上面那段code，經由 RenderMan client library產生出來的code(RenderMan client library是把含有RenderMan Interface的code，output成rib語法的東西):

##RenderMan RIB
version 3.04
Display "helloworld.exr" "it" "rgba"
DisplayChannel "color _ooxx"
Format 512 512 1
Projection "perspective" "uniform float fov" [60]
Rotate 180 1 0 0
Rotate 0 0 1 0
Translate 0 0.1 -8
WorldBegin
Attribute "cull" "hidden" [0]
Attribute "cull" "backfacing" [0]
Attribute "dice" "rasterorient" [0]
Attribute "visibility" "int diffuse" [1]
Attribute "visibility" "int specular" [1]
LightSource "spherelight" "sl1" "float falloff" [0.5] "point from" [-2.8 2 2.5] "float samples" [64] "float radius" [0.5] "float intensity" [2]
Surface "bake_direct_irrad" "string filename" ["area_illum_tpt.ptc"] "string displaychannels" ["_ooxx"]
Geometry "teapot"
WorldEnd

render出來的圖(左)以及*.ptc(右)分別如下：

(11)淺談point cloud

2009-07-05T01:04:00.000-07:00

先扯點提外話吧～XD

最近朋友大推我一本書，書名是"生命咖啡館"，裡面問讀者三個神祕的問題：

１.你為什麼在這裡？２.你害怕死亡嗎？３.你實現自我了嗎？

我想....不少人一看到這三個問題，會跟我有一樣的想法--->"就醬阿！科科"

但也就是會想知道除了"就醬阿"之外，這本書能帶給讀者怎樣的省思～
這本書我也才正要開始看～有心得再寫上來囉！

－－－－－－－－－－－正題分隔線－－－－－－－－－－

1 point = 1 micropolygon

什麼是point cloud(*.ptc)檔勒？顧名思義～裏面存的是point(可用ptviewer開來看看)，每個 point 可以有任意的資料，雖然 point 會讓人覺得是一個點，但其實在 *.ptc 裏頭，每一個 point 其實是由 (position, normal, area) 三個組成，亦即它是一個有面積的圓盤(disk)，所以一個最基本的 .ptc 檔，裏頭的每一個 point 至少會有這三個資料，其餘的就看使用的人怎麼去運用（ex, occlusion, irradiance, …）。
(以上是節錄Drake對point cloud檔的介紹～)

接下來開始介紹如何在RenderMan中使用這種檔案，用的範例也是RMS的document所提供的。
在RenderMan中，要產生*.ptc是透過使用一個叫作bake3d()的function，在document中的敘述簡述如下：

bake3d(filename, displaychannels, P, N, "radius", r, "coordsystem", cs,
           "interpolate", 0,
           "direct", d, "onebounce", ob, "occlusion", occ, ... );

綠色標記的部份，是要另外寫入*.ptc的channel，也就是除了(position, normal, area)以外，要寫入*.ptc的資訊。而在RIB檔中，也要有一個跟其名稱對應的DisplayChannel。例如：在bake3d中，有一個"_ooxx", ooxx，其中ooxx為一個type為color的變數，則在RIB中，也要這樣宣告

DisplayChannel "color _ooxx"

才可在*.ptc中寫入一個名為 '_ooxx' 的channel，並將變數color ooxx所存的資訊寫入 '_ooxx'。

至於interpolate這個flag的作用是....先想像有一個四方形的盒子放在桌面上，盒子會有一面跟桌面平貼接觸。當interpolate為0時，除了盒子跟桌子接觸的面的資訊會被寫入*.ptc裡，而桌子跟盒子接觸的面的資訊也會被寫入*.ptc裡；而其值為1時，只會將桌子跟盒子接觸的面的資訊寫入*.ptc裡。所以其值為1是比較省時省空間的。

接下來，來play一下document中的例子吧！

首先，先分別新增一個*.sl和*.rib，這裡檔名分別是ptc_gen.sl與ptc_RIB.rib。先做個小小的實驗～用文字編輯器打開ptc_gen.sl，輸入以下RSL code:

surface
    bake_direct_irrad(string filename = "", displaychannels = "";
                      float interpolate = 1)
    {
        color irrad;
        normal Nn = normalize(N);

        /* Compute direct illumination (ambient and diffuse) */
        //irrad = ambient() + diffuse(Nn);
        irrad = 1;
        /* Store in point cloud file */
        bake3d(filename, displaychannels, P, Nn, "interpolate", interpolate,
               "_ooxx", irrad);

        Ci = irrad * Cs * Os;
        Oi = Os;
    }

注意一下紅色部份：先將 " irrad = ambient() + diffuse() ; " mark起來，另外將irrad的值設為1。

然後打開 ptc_RIB.rib ，輸入：

FrameBegin 0

      Format 400 300 1
      ShadingInterpolation "smooth"
      PixelSamples 4 4

      Display "bake_arealight" "it" "rgba"
      Quantize "rgba" 255 0 255 0.5
　　　#宣告對應bake3d中的 '_ooxx' channel
      DisplayChannel "color _ooxx"

      Projection "perspective" "fov" 25
      Translate 0 -0.5 8
      Rotate -40  1 0 0 
      Rotate 20  0 1 0

      Attribute "trace" "bias" 0.0001

      WorldBegin

        Attribute "cull" "hidden" 0   # don't cull hidden surfaces
        Attribute "cull" "backfacing" 0   # don't cull backfacing surfaces
        Attribute "dice" "rasterorient" 0   # view-independent dicing !
        Attribute "visibility" "int diffuse" 1   # make objects visible to rays
        Attribute "visibility" "int specular" 1   # make objects visible to rays

        LightSource "spherelight" 1 "from" [-2.8 2 0.5] "radius" 0.2
          "intensity" 2 "samples" 64 "falloff" 1

        Sides 1   # to avoid flipping normals in "spherelight"

        # Ground plane
        AttributeBegin
 #產生名稱為area_illum_plane.ptc的point cloud檔
          Surface "bake_direct_irrad" "filename" "area_illum_plane.ptc"
　　　　　　#將shader中，變數irrad的資訊寫入此*.ptc中
            "displaychannels" "_ooxx"
          Scale 3 3 3
          Polygon "P" [ -1 0 1  1 0 1  1 0 -1  -1 0 -1 ]
        AttributeEnd

        Attribute "visibility" "int transmission" 1 # the cyl. casts shadow
        Attribute "shade" "transmissionhitmode" "primitive" 

        # Cylinder with cap
        AttributeBegin
          Surface "bake_direct_irrad" "filename" "area_illum_cyl.ptc"
            "displaychannels" "_ooxx"
          Translate -1 0 0.5
          Rotate -90 1 0 0
          Cylinder 0.5 0 1 360
          Disk 1 0.5 360
        AttributeEnd

      WorldEnd
    FrameEnd

分別用shader和prman去編譯ptc_gen.sl和ptc_RIB.rib後，除了可以看到render出來的obj是一片白，還可以在目錄下發現多了兩個ptc檔:

area_illum_plane.ptc
area_illum_cyl.ptc

用Pixar RenderMan提供的ptviewer開啟area_illum_cyl.ptc，可以看到如下圖～每個point都是全白的cylinder(因為irrad=1)，也就是說～有把irrad是白色的資訊寫入此ptc中:

按右鍵->color可以看到 '_ooxx' 這個channel。選擇Point Radii，可以看到其point的分佈狀況：

將ptc_gen.sl中的 irrad改回 ' irrad = ambient() + diffuse() ;' 再render則可得到下圖：

其area_illum_cyl.ptc如下圖。用滑鼠左鍵反轉一下，可以看到此cylinder底部是空的，是因為interpolate為1的緣故。

而area_illum_plane.ptc如下圖。右鍵->color->white，可以看到中間沒有空洞，整片白的plane。由上一個和此*.ptc可以看到，shadow的資訊被寫入*.ptc裡。

將ptc_gen.sl內容改成：

surface
    bake_illumsurfcolor(string filename = "", displaychannels = "", texturename = "";
                        float interpolate = 1)
    {
        color irrad, tex = 1, illumsurfcolor;
        normal Nn = normalize(N);

        /* Compute direct illumination (ambient and diffuse) */
        irrad = ambient() + diffuse(Nn);

        /* Multiply by surface color */
        if (texturename != "")
            tex = texture(texturename);        
        illumsurfcolor = irrad * tex * Cs;

        /* Store in point cloud file */
        bake3d(filename, displaychannels, P, Nn, "interpolate", interpolate,
               "_illumsurfcolor", illumsurfcolor);

        Ci = illumsurfcolor * Os;
        Oi = Os;
    }

再將ptc_RIB.rib內容改成：

FrameBegin 0

      Format 400 300 1
      ShadingInterpolation "smooth"
      PixelSamples 4 4

      Display "bake_illumsurf" "it" "rgba"
      Quantize "rgba" 255 0 255 0.5
      DisplayChannel "color _illumsurfcolor"

      Projection "perspective" "fov" 25
      Translate 0 -0.5 8
      Rotate -40  1 0 0 
      Rotate 20  0 1 0

      Attribute "trace" "bias" 0.0001

      WorldBegin

        Attribute "cull" "hidden" 0   # don't cull hidden surfaces
        Attribute "cull" "backfacing" 0   # don't cull backfacing surfaces
        Attribute "dice" "rasterorient" 0   # view-independent dicing !
        Attribute "visibility" "int diffuse" 1   # make objects visible to rays
        Attribute "visibility" "int specular" 1   # make objects visible to rays

        LightSource "spherelight" 1 "from" [-2.8 2 0.5] "radius" 0.2
          "intensity" 2 "samples" 64 "falloff" 1

        Sides 1   # to avoid flipping normals in "spherelight"

        # Ground plane
        AttributeBegin
          Surface "bake_illumsurfcolor" "filename" "illumsurf_plane.ptc"
            "displaychannels" "_illumsurfcolor" "texturename" "ooxx.tex"
          Scale 3 3 3
          Polygon "P" [ -1 0 1  1 0 1  1 0 -1  -1 0 -1 ]
          "s" [1 1 0 0]
          "t" [0 1 1 0]
        AttributeEnd

        Attribute "visibility" "int transmission" 1 # the cyl. casts shadow
        Attribute "shade" "transmissionhitmode" "primitive"

        # Cylinder with cap
        AttributeBegin
          Surface "bake_illumsurfcolor" "filename" "illumsurf_cyl.ptc"
            "displaychannels" "_illumsurfcolor" "texturename" "ooxx.tex"
          Translate -1 0 0.5
          Rotate -90 1 0 0
          Cylinder 0.5 1 0 -360   # reversed to get texture right side up
          Disk 1 0.5 360
        AttributeEnd

      WorldEnd
    FrameEnd

其中 'ooxx.tex' 是利用txmake 這個command（txmake ooxx.tif ooxx.tex），將一個ooxx.tif轉成ooxx.tex，也就是RenderMan的材質格式。

render後可得到下圖：

產生的*.ptc，分別為下面兩張圖(右鍵->Focus View可將視角focus在object上)。可以看到texture資訊也被寫入point裡。

最後介紹如何讀取已經bake好的ptc。
可以將已經bake好的ptc，當作是一種3-d的texture，可以用 texture3d() 來讀取。由上一個例子，將ptc_gen改成：

surface
    read_illumsurfcolor(uniform string filename = "")
    {
        color illumsurfcolor = 0;
        normal Nn = normalize(N);
        float ok;
　　　　　
　　　　　//利用texture3d()，將 _illumsurfcolor 的資訊寫入illumsurfcolor 
        ok = texture3d(filename, P, Nn, "_illumsurfcolor", illumsurfcolor);

        Ci = illumsurfcolor * Os;
        Oi = Os;
    }

再將ptc_RIB.rib改成：(注意～這rib跟之前不同，沒有light shader，也不用指定*.tex，因為已經通通被寫入*.ptc裡，直接讀取*.ptc裡的資訊即可)

FrameBegin 0

      Format 400 300 1
      ShadingInterpolation "smooth"
      PixelSamples 4 4

      Display "read_illumsurf" "it" "rgba"
      Quantize "rgba" 255 0 255 0.5

      Projection "perspective" "fov" 25
      Translate 0 -0.5 8
      Rotate -40  1 0 0 
      Rotate 20  0 1 0

      WorldBegin

        # Ground plane
        AttributeBegin
          Surface "read_illumsurfcolor" "filename" "illumsurf_plane.ptc"
          Scale 3 3 3
          Polygon "P" [ -1 0 1  1 0 1  1 0 -1  -1 0 -1 ]
        AttributeEnd

        # Cylinder with cap
        AttributeBegin
          Surface "read_illumsurfcolor" "filename" "illumsurf_cyl.ptc"
          Translate -1 0 0.5
          Rotate -90 1 0 0
          Cylinder 0.5 0 1 360
          Disk 1 0.5 360
        AttributeEnd

      WorldEnd
    FrameEnd

render後即可得到如前一例子的結果。

話說....這網誌已經閒置一個多月了，一來是不知道該寫些什麼，因為之前都在用RAT，而Pixar現在是推RMS；二來是前陣子事情也頗多的說～想想....還是寫些比較技術性的東西會覺得比較有趣～XD

朝下一個10篇邁進吧！(遠目~~~)

(10)利用SLBox出AOV(Arbitrary Output Variables)

2009-05-09T00:32:00.000-07:00

一直很喜歡一首歌－－－華仔的"下次不敢"，也是電影童夢奇緣的主題曲
每隔一段時間聽，都會有不同感受，在進入本篇主題前，先分享一下歌詞囉～

劉德華--下次不敢

歌手：劉德華 | 作曲：Peter Kam
填詞：劉德華 | 編曲：馮翰銘

繞了一圈　又過了一環
犯錯以後才後悔會不會太晚
就算認錯　就算你說下一次　我不敢

＊失去容易　啊　回頭真難
　日子再壞也必需要走完
　啊　在生活中　每一個人
　應該有對自己最誠實的那份勇敢

　朋友啊　雖然哭泣常常讓人太難堪
　其實眼淚也有溫暖
　流過淚的你才能慢慢成長
　有傷心才會懂得有心歡＊

＃啊　抓緊時間　把你感情的帳單
　好好去認認真真　一一的清還
　為身邊每個人　請不要再怠慢
　讓愛火一再點燃　從今我不想
　再聽你說　下一次我不敢＃

REPEAT＊＃＃

－－－－－－－－－－－－本篇開始　XD－－－－－－－－－－－－

承接上一篇....這篇是透過介紹如何利用SLBox來出matte為例，來介紹如何出AOV。

◎接續上一篇....另外再新增一個Ensemble，接一個Delux，然後在Delux裡新增一個Diffuse及SLBox，並將Duffuse的顏色調成黃色。preview可以看到如下圖～～～全白　XD。是因為SLBox的 result=(1,1,1); 將Diffuse蓋掉了。

◎將SLBox改成 result=0;即可看到黃色color的Diffuse效果。

◎接著....來出matte吧。matte的pass在合成時可是非常非常非常重要的！！！
在SLBox裡先新增一個type為color的變數，將其顏色調成紅色。
接著在Primvars輸入
output varying color matte_test;
接著在SL code欄位裡加入
extern color matte_test;
matte_test=v1;

◎在上一篇的SLBox裡，一樣新增一個type為color的變數(v6)，然後跟上一段一樣，
在Primvars輸入
output varying color matte_test;
在SL code欄位裡加入
extern color matte_test;
matte_test=v6;

◎在maya的scene裡，為了方便觀察，建置兩顆交疊的sphere。然後將slim裡的兩個ensemble分別assign給這兩個sphere。

◎接著在RAT的RenderMan Globals裡->Display->Channel，按下New來新增一個pass，並在channel欄位裡打上color matte_test(跟SLBox宣告的pass變數名稱一樣)。

◎然後在Secondary裡，按New，然後在Name欄位裡將名稱改成matteTest(所render出的pass檔按名稱)

◎按下在下方的Channels旁的Add，在選單中選擇剛剛在Display->Channel輸入的color matte_test。(這裡也再加選float a的話，matte_test這個pass裡會有alpha channel)

◎在Primary的Display Server，將it改成tiff，也就是將檔案render成*.tiff。

◎按下render後，即可在project下的rmanpix裡看到render的圖以及拆出來的pass。

◎用shake開啟(或其他合成軟體)，即可看到拆出的pass的物件顏色，為剛剛在SLBox裡assign給matte_test的顏色。

◎如果是用RMS的話，只用在RenderMan Globals的Passes tab裡，output -> Create Output -> Custom，然後輸入color matte_test，即可出pass。

如果想在*.sl裡，寫RSL來出aov的話，是用如下寫法：
surface ooxx(output varying color matte_test = 0;
)
{
matte_test = color(1,0,0);
}
（呃....有程式基礎的，應該看的出這段想表答什麼吧）

呼～不知不覺也累積到10篇了，但也自以為有系統的將RenderMan以及slim的network做了點初步的介紹。覺得達成一個整數後，就會失去動力....XD　疏漏之處....還希望有人指正囉～也謝謝賞識這些小小筆記的人！　^_____^
接下來....會想寫點實際的應用吧～不過還沒想好也還沒去想要怎麼有系統的寫....(劣根性阿....orz)

(9)簡單介紹SLBox

2009-05-08T22:43:00.000-07:00

前一篇介紹了點RenderMan Shading Language，是在介紹這slim裡的SLBox鋪點路。SLBox是slim裡可以寫RSL code的地方，基本上跟寫RenderMan Shading Language是一樣的，只是SLBox是將最後RSL呈現的結果用一個叫作"result"的內建變數包起來，下面就來簡單介紹一下如何使用type為color的SLBox囉！

◎照先前介紹的方式，先在slim裡新增一個Ensemble，再接一個Delux，並在Delux裡新增一個v1。

◎從Colors -> Utility -> SLBox來新增一個type為color的SLBox。

◎可以從底下的SL code欄位裡，看到預設的result為(1,1,1)，也就是全白。

◎將其接到Delux的v1上，可以看到Delux的preview也是全白。

◎在Parameter欄位，可以從下拉的選單中，看到有幾種type的變數。選擇所需要的type後，按下旁邊的+號，即可新增此種type的變數。

◎先在Parameter選擇color，按下＋號；再選擇float，然後再按一次＋號，即可新增兩個type分別為color和float的變數(v1和v2)。

◎新增一個Imagefile node，將其接到SLBox的v1上。

◎在SLBox裡，將　result=(1,1,1);　改成　result=v1;

◎preview即可看到Imagefile裡的貼圖。

◎接著按下v2旁的方塊->float->Pattern->Noise。可以將v2連到一個type為float的Noise node。

◎將noise的frequence調成8，然後在SL code裡改成　result=v1*v2;　preview即可看到noise對剛才的貼圖產生了作用。

◎如果希望這個shader會隨著燈光而有明暗變化以及反射的話，就先新增兩個type為color的變數。在變數名稱上點兩下，即可更改變數名稱。這裡是分別改成diff與spec。然後從shading component新增一個Diffuse和Specular，分別將其接到SLBox的diff以及spec上。

◎把SL code改成　result=v1*v2*diff;　即可看到除了剛才的noise外，也有了和diffuse一樣的明暗變化。

◎再把變數spec加上去，即可做出如specular的反射效果。

如果不知道什麼時候要用乘的，什麼時候要用加的.....只能說先K點計算機圖學會比較有概念。

(8)簡單介紹RenderMan Shading Language

2009-04-30T22:56:00.000-07:00

也該寫點有關RenderMan Shading Language的東西了，不過這篇只是單純介紹如何操作*.sl。如同C++的檔案副檔名為cpp，RenderMan Shading Language的副檔名為sl。以artist的觀點，這篇可以說跟slim沒很大的關係，跳過這篇，一樣可以在slim上拉shader；以 programmer的觀點，會覺得關係可大了，畢竟slim裡的node，其核心都是SL code。所以如果要玩SL code的人，好歹也要修過Data Structure或是Numerical Analysis等較進階的程式課程。(深深覺得....除非是天資過人，萬中選一的高手，不然如果光是K完一本初階的C語言之類的，就出去跟人家說會寫程式，還蠻牽強的　XD)SL code語法跟C語言很像，也是結構式語言，一樣用//和/*....*/來做註解，只是宣告的資料型態不盡相同，例如SL有float、color、point、normal等，但是沒有int和double。

這篇是對surface shader和displacement shader各舉一個例子來介紹。參考資料為：
㊣http://www.fundza.com/
㊣The RenderMan Companion (Steve Upstill)
使用工具為prman

◎可以先新增一個空的資料夾，把會用到的檔案集中到此處。這裡是在G槽下新增一個名為ooxx的folder。

◎先小小介紹一下surface shader和displacement shader較常用到的內建變數(較詳細的介紹，還是要看這個比較好：http://www.fundza.com/rman_shaders/surface/sl_surface1.html　以及　http://www.fundza.com/rman_shaders/displacement/ds_displacement1.html)

###################################################################
Ci：object表面顯現的顏色 (output)
Oi：object表面顯現的透明度 (output)
Cs：object原始的顏色 (input)
Os：object原始的透明度 (input)
N：object表面的法向量(三維向量)
s, t：object表面的貼圖座標(可以想成國中學的(x,y)直角座標)，其範圍皆為0到1，也就是說(0.5, 0.5)會落在座標的中間
P：object表面的point的值(三維向量)
###################################################################

◎開啟一個空的記事本，key入以下內容：
surface　/*宣告surface shader function，所宣告的function名稱為noise_test1*/
noise_test1(float Kfb = 1,
amp = 0.8, /* amplitude of the noise */
freq = 9; /* frequency of the noise */
color top = (1,0,0) /* 方片上方的顏色 */,
lower = (1,1,0)/* 方片下方的顏色 */)
{
// Noise values range from 0 to 1.
float ns =noise(s * freq, t * freq);

// Offset the true value of 't'. The 'amp' parameter will allow
// the artist to strengthen or weaken the visual effect.
float tt = t + ns * amp;

/* 將上方的顏色和下方的顏色，沿著tt做混合(mix)，並將其assign給一個type為color的變數surfcolor */
color surfcolor = mix(top, lower, tt);
Oi = Os;

/* object表現的顏色=透明度*object底色*混合後的顏色*Kfb (此處的Kfb是控制object顯示出來的亮度)*/
Ci = Oi * Cs * surfcolor * Kfb;
}

然後另存為SurfaceShaderTest.sl。開啟命令提示字元，在G:\ooxx底下輸入shader SurfaceShaderTest.sl (要記得設好prman的環境變數)，按下Enter後可以看到這樣的訊息：noise_test1: compiled，表示已經在ooxx這個資料夾底下產生了一個noise_test1.slo檔。用prman的shader來編譯*.sl所產生的檔案，其副檔名為slo，也就是在使用在rib中的shader名稱，同時也是選告surface shader時的function名稱。

◎然後開啟一個空的記事本，貼上以下內容：
Hider "hidden"
LightSource "distantlight" 1
Projection "perspective"
Translate 0 0 1.5
Rotate 40 -1 1 0
FrameBegin 2
Display "test2.jpg" "framebuffer" "rgba"
WorldBegin
Rotate 10 0 0 1
Surface "G:/ooxx/noise_test1"
Polygon "P" [0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 0.5 -0.5 0.5 ]
Rotate 90 0 1 0
Polygon "P" [0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 0.5 -0.5 0.5 ]
Rotate 90 0 1 0
Polygon "P" [0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 0.5 -0.5 0.5 ]
Rotate 90 0 1 0
Polygon "P" [0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 0.5 -0.5 0.5 ]
Rotate 90 1 0 0
Polygon "P" [0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 0.5 -0.5 0.5 ]
Rotate 180 1 0 0
Polygon "P" [0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 0.5 -0.5 0.5 ]
WorldEnd
FrameEnd

紅色註記的部份，即為剛剛產生的*.slo的完整路徑。將其另存為Simple_Cube.rib(這個*.rib只是產生一個cube而已)。如果將Surface "G:/ooxx/noise_test1" 改成
Surface "G:/ooxx/noise_test1" "top" [0.878 0.996 0.474] "lower" [0.580 0.690 0.988]
即可將top, lower原本的值，改成中括號內的數值，依此類推。slim的node上的參數也是由此而來。注意~只有宣告為引數的變數可以這樣使用~

◎然後在命令提示字元裡，key入prman Simple_Cube.rib。

即可看到下圖

◎再開啟一個空的記事本，key入：
displacement ripple1/*宣告一個名稱為ripple1的displacement shader*/
(float Km = 0.004,
numripples = 8,
a = 0.3,
b = 0.25)
{
float sdist = s - a,
tdist = t - b,
//計算object表面每一點(s,t)到(a,b)的距離(dist)
dist = sqrt(sdist * sdist + tdist * tdist),

//將dist餵給sin，以在object表面做sin波。
hump = sin(dist * 2 * PI * numripples);

//將N做normalize，然後assign給一個type為normal(三維向量)的變數n。
normal n = normalize(N);

//將object表面的點，延n做位移(displacement)
P = P - n * hump * Km;
//P位移過後，再重新計算每個P的法向量，然後assign給N
N = calculatenormal(P);
}

將其另存為DisplacementShaderTest.sl。一樣用shader這個command來compile這個*.sl，可以得到一個ripple1.slo。

◎將上面那個*.rib，用紅色註記的部份，換成Displacement "G:/ooxx/ripple1"，然後用prman去render即可看到如下結果

(7)spot light shader的簡單應用

2009-04-27T18:02:00.000-07:00

最近有朋友跟我說我這RenderMan的心得整理的還不錯，聽到後還挺開心的說～XD，真是感謝大家的鼓勵！也有非程式背景的朋友說，希望我在這上面來點程式的教學，嗯....想了一想，一來是自己才疏學淺又懶...orz，二來是覺得非程式背景的人，與其對程式一知半解，想寫的時候不知道如何下手，那把每個node的特性搞清楚還來的較簡單又有意義～例如像上一篇的noise，有些人只會認為是一種亂數的擾動，卻不知道它其實不是亂數，而且是一種uniform continuous的函數(請參考這個很棒的網站-> http://www.fundza.com/rman_shaders/noise/index.html)。也有人問說....那數學需不需要很強，坦白說，還真不知道該怎麼回答這問題，儘管我是唸應用數學出身的，只能說基本的舉陣計算，向量分析要懂一點　@@

推薦一本個人覺得很棒的向量分析，中文的哦！

http://www.tsanghai.com.tw/product_info.php?products_id=653&osCsid=35f70993779eee363847f195d32c8018

個人覺得寫的簡單清晰，對基本的微分幾何也有詳細的介紹，又不像一堆專業知識的書籍，厚到可以拿來砸人～XD，而且預備知識只需要基本的微分和積分就好了。

--------------------------以上是本篇的廢話，進入正題　XD---------------------------

一般在lighting的時候，大部份都是用spot light比較多，一來是好控制，二來是相較point light而言，計算量少很多(記得一個point light的計算量是spot light的6倍)。不過也是要視實際遇到的情形來做考量。

◎先建置一個簡單的場景，記得要打一個maya的spot light。

◎在graph layout裡，Lights-> Spot，來新增一個spot light的node。

◎給sphere一個紅色的diffuse，然後render可以看到如下圖。有光線，但是沒有shadow。

◎點下spot light裡的shadow旁的小方塊，如圖示，給它一個ShadowMap來產生陰影。一般lighting在做shadow的時候，只需要用到ShadowMap這個node就夠了。

◎render之後，即可看到陰影。

◎將maya的spot light的屬性的Penumbra Angle調成10。

◎可得如下結果。對照前一張render的結果，可以看到光線有擴散出去的感覺～像現在這個spot light的Cone Angle是40，Penumbra Angle是10的話，那它擴散的範圍就是spot light照到的範圍的10/40=1/4。

◎ShadowMap裡較常用到的attribute有：Map Resolution、Samples、Blur、Bias。

◎這是Map Resolution為512時的圖

◎這是Map Resolution為1024時的圖，相較於上一張圖，shadow的alias有少很多，也就是resolution的值越大，alias越小。

◎將Blur調成0.02

◎可以看到如下圖，shadow有了blur的效果(這裡調成0.02這個值，其實有點太大)

◎將Samples的值調成64的話，可以看到如下圖的結果，相較於上圖，一粒一粒的感覺明顯改善。

◎將Bias調成0.002(在小場景，這個參數只要調一點點，就會有很大的影響)

◎可以看到如下圖。有時候在一些場景裡做lighting時，會發生shadow跟物件沒接在一起的詭異情形，Bias就可以對shadow做一些位移個的效果，來將shadow和object接在一起。當然也可以用來做出一些特別的效果。

◎上圖中可以看到polygon sphere看起來有點菱菱角角，除了用maya的smooth功能外，這裡順便介紹RAT的subdivision的使用(注意..這跟maya的smooth是用不一樣的演算法)：RenerMan->Pixar Subdivs-> Mesh as Subdivs。

◎再render後即可看到一粒平滑的sphere。

ｐｓ：這裡要感謝一位好同事好朋友~Vence，很多lighting的細節與概念等，都是向他討教來的～　XD

(6)一些 float pattern的介紹

2009-04-24T19:29:00.000-07:00

話說前幾天去一個學長那邊play，算是第一次比較有玩到RenderMan Studio(RMS)，跟RendereMan Artist Tools(RAT)在本質上有很大的不同，光是globals的介面就搞得有點暈頭轉向...orz...還在慢慢研究中~XD。不過，在slim拉RenderMan Network的概念倒是沒差多少，等比較有心得再和RAT做個比較整理上來囉~

這篇主要是介紹一點pattern的應用。其實pattern就是一種programming texture，也可以搭配其他手繪的texture做出一些有趣的效果~以下就簡單介紹一下float type的noise、facingforward、spline以及spline如何跟texture做搭配。

◎在graph layout上，Floats->Patterns->noise，來新增一個float type的noise node。noise可以應用在簡單的處理一些不是那麼平滑的反射，像人臉的反射、桌面的反射...等，都帶了那麼點不平順，就可以用noise來處理~

◎將frequency調到8，可得如下圖。frequency也就是它擾動頻率的程度，值越大，其detail越細。

◎將其接到第1篇小小筆記的Diffuse的intensity上，由於intensity就是亮度，這個動作就是在Diffuse的intensity上做noise，所以可以看到在Diffuse上產生了擾動的效果。

◎這是FacingForward。顧名思義，就是計算物件法向量與視線的內積，值越大的部位越亮。可以應用在一些圓弧形的東西上，來做一些類似拋光的效果。

◎將其接到Diffuse的intensity上，可得如下的效果。

◎將FacingForward的invert打開，也就是將其值倒反過來，可得下圖。

◎Diffuse就變成這樣。

◎這是Spline node的預設值。

◎將其Spline的curve隨便拉一下，可以看到類似下圖的效果。

◎再將其接到Diffuse的intensity上，可以得到如下圖。

◎最後，來小小玩一下Spline和texture的結合吧。先將Diffuse的intensity換成internal value。

◎新增一個color 的ImageFile，沿用之前的青蛙圖，將ImageFile接到spline的Pattern上。

◎預設可得下圖：一隻灰階的青蛙~

◎調整一下spline curve看看。可以看到類似下圖~有一些顏色被濾掉(壓掉)了。這也是spline好用的地方，可以用來濾掉等於某些值的顏色。

以上當然是處理一些比較簡單的情況，但一些比較複雜的情形，還是免不了要在SLBox裡寫點SL code囉，以後再介紹~ XD

Light shader example

2009-04-23T23:08:00.000-07:00

這是自己摸索Help裡面的一些教學，所做出來的東西，
如果有什麼疏漏的地方，請多指教~

Step1:
建置如下圖之場景

然後從Houdini的Help裡，找到如下圖的code

Step2:
利用上圖的上面的code，建立一個surface shader

並指定給其中一個sphere，算圖後可得如下圖之結果

Step3:
開啟New Operator Type，將Network Type設為 Light Shader Operator

然後輸入step1下面的code

Step4:
在Network視窗，切換到shop，按下tab鍵→選擇剛剛建立的Light shader名稱

將此node拖曳到場景中的pointlight上，會跳出如下視窗，
選擇第一個"Create spare paramter on pointlight1 for Light Shader SHOP"

Step5:
按下New Operator Type的Apply鍵→算圖，即可得如下結果

displacement shader example

2009-04-23T22:03:00.000-07:00

這是用下列連結中的其中一個範例
stud.fh-wedel.de/~wk/Handouts/houdini_zip/vex.pdf

Step1:
一樣，設置一個簡單的場景

Step2:
指定一個材質給sphere

然後開啟New Operator Type，在Network Type選擇displacement shader operator

輸入如圖的Code，按下Test Compile

Step3:
在Network視窗，切換到shop模式，進入basic surface，然後在suboutput1 node2的 input上，連接剛剛在New Operator Type上輸入的名稱
如圖

Step4:
算圖，即可得出如下圖之結果

Hiroshige Fishscales Shader Tutorial

2009-04-23T20:41:00.000-07:00

現在介紹surface shader
一樣是用網路上的另一個範例，目的在做出像魚麟的效果，連結如下
http://tutorials.vizyacky.com/vizy_tutorials_student/ChipCollier_fishscales_tutorial/ChipCollier_fishscales_tutorial.php

Step1:
先設置一個簡單的場景

Step2:
一樣，File -> New Operator Type ...，
除了Network Type設為Surface Shader Operator，其餘設定都仿照上一個教學，如圖，按下 Accept

Step3:
在Network Editor，選擇Material Palette，拉一個Basic Surface材質進去，如圖，再將此材質指定給場景中的Sphere

Step4:
來小試牛刀一下。在Editor Operator Type Properties 視窗裡，Key入
surface
noise_surf(vector clr = {1,0,0}; float frequency = 1;
export vector nml = {0,0,0})
{
Cf = clr * (float(noise(frequency * P)) + 0.5) * diffuse(normalize(N));
nml = normalize(N)*0.5 + 0.5;
}
一樣，按下Test Compile

Step5:
在Network Editor選擇shop標籤

然後進入basic_surface node

Step6:
然後在suboutput1 node的 input上，shift+滑鼠右鍵→選擇剛剛輸入的Operator Label名稱，如圖。一樣，按下Edit Operator Type Properties的Apply

Step7:
算張圖來看看吧。Render→Create Render Node→mentra，
然後Render→Start Render→mentra1，可得下圖

Step8:
來試試教學範例上的code吧。將noise_surf內的code改成
int rep_s=10;
int rep_t=15;

float tt = (t * rep_t) % 1;

vector colorA = {0,0,0};
vector colorB = {0.5,0.7,0.8};
vector colorC = {0.9,1,0.9};

float radS = radians(s * (rep_s * 180));
float tSin = sin(radS);
float tCos = cos(radS);

float apt = abs((tt<=0.5)?tCos:tSin) * 0.5; float bpt = abs((tt<=0.5)?tSin:tCos) * 0.5; float cpt = apt - 0.05; float _tt=0; if(tt < _tt =" tt;" _tt =" (tt-0.5);">
Cf = colorB;
} else {
if( _tt > apt) {
if(_tt
Cf = colorA;
} else {
Cf = colorB;
}
} else {
Cf = colorC;
}
}
(註：要將範例檔中的_s改成s，_t改成t，surfcolor改成Cf)
然後一樣，Test Compile→Apply
再算圖即可得出以下結果:

教學檔上的理論部份就不贅述了，至於上面提到的s,t,Cf等，為內建的變數，有興趣的話，
可以去查查相關資料。

A Generic Ripple - Creating a custom VEX Operator (by Georg Duemlein)

2009-04-23T19:37:00.000-07:00

（這前４篇只是將以前寫在另一個blog的Houdini心得整理過來）

這是網路上抓到的一個教學範例
連結：http://www.preset.de/2007/0824/generic_ripple/rdg-genericRipple.pdf

Step1: File -> New Operator Type ...

Step2:
在Operator Name 輸入 rdg_ripple
Operator Label 輸入 RDG Ripple
(這裡可以自由輸入名稱，為尊重作者，所以用教學檔上的名稱)

Network Type 選擇 Geometry Operator
Install Library to 選擇 Current HIP File Only
Save To Library 則指定自己想儲存的路徑
按下 Accept

Step3:
然後會出現以下視窗

選擇Vex Code標籤
Key入
sop
rdg_ripple( float freqency = 50;
float speed = 0;
float amplitude = 0.1;)
{
vector offset = {0, 0, 0};
float offset_y = 0;
float dist = length(P);
offset_y = sin(dist * freqency + speed) * amplitude;
setcomp(offset, offset_y, 1);
P += offset;
}

按下Test Compile，若是沒有bug，則會出現以下視窗(先不要將此視窗關掉)

Step4:
在Network Editor按下 Tab鍵→Geometry，按下i進入Geometry node，
刪除file1 node，接著再按Tab→Grid，然後將Rows 及 Columns調到50，如圖
(將那兩個數值調高的原因在於可以展現較平順的效果)

Step5:
在grid1的output上，shift+滑鼠右鍵→RDG Ripple，會出現如下圖:

然後按下Operator Type Properties視窗的 Apply
即出現如下圖之結果:

挺有意思的吧

這裡只單純的大概介紹如何使用sop shader，教學檔裡的理論部份也只是簡單的三角函數，就不贅述囉！

簡單介紹pymel以及安裝

2009-04-14T19:52:00.000-07:00

什麼是pymel咧？有在寫mel的應該都知道Maya在8.5版之後，有跟python做結合。但是....結合的不是很好，有很多python的優勢沒有發揮出來，像是對資料的動態處理。所以呢，就有幾位工程師，開始著手改良python與maya的結合~~~pymel就誕生了。話說某天用maya原本的python在寫一個工具，為了要動態的存取stringarray這個type的attribute，try了很久，但是卻一直跳error出來，而我現在的主管就在這時向我介紹了這好物，整個輕鬆解決了那時的問題。先介紹一下一下怎麼安裝，再敘述當時遇到的狀況囉~

可以先去這個連結:
http://www.highend3d.com/maya/downloads/tools/syntax_scripting/Pymel-4844.html
下載pymel的壓縮檔，解壓縮後，會得到一個名稱為pymel的資料夾。如果是Windows的使用者，直接將此資料夾複製到My Document\maya\prefs\script裡，即可使用。

來敘述一下當時遇到的問題吧，先看以下code：
###########################################################
import maya.cmds as mcmds
#宣告一個array, 值為a, b, c
TestStringArray=['a','b','c']
#新增一個transform的node，並將其命名為testnode
mcmds.createNode( 'transform', n='testnode' )
#給testnode新增一個資料型態為stringArray的屬性，其名稱為test_stringArray
mcmds.addAttr('testnode', longName='test_stringArray', dt='stringArray')
#將TestStringArray的值，assign給testnode.test_stringArray
mcmds.setAttr('testnode.test_stringArray', 3, TestStringArray, type='stringArray')
###########################################################
執行的話，會在最後一行發生error，因為它不能先宣告一個array (test_stringArray=['a','b','c'])，然後再把這個array的值set給testnode.test_stringArray。所以得將最後一行改成

mcmds.setAttr('testnode.test_stringArray', 3, 'a', 'b', 'c', type='stringArray')

如果現在要在這個testnode.test_stringArray放100筆資料呢.....總不能這樣寫

mcmds.setAttr('testnode.test_stringArray', 100, 'a1', 'a2', 'a3',...bla bla...,'a100', type='stringArray')

很恐怖吶！！

但是換成用pymel的話，就可以直接用已經宣告好的array來用，如下：

#先import pymel的module
from pymel import *
#將TestStringArray assign給testnode.test_stringArray
setAttr('testnode.test_stringArray', TestStringArray)

酷吧~　而pymel在寫UI時，也有其便利性在，以後有機會在寫上來囉~

(5)RenderMan Globals基本介紹

2009-04-14T01:37:00.000-07:00

前面幾篇，除了比較偏programming的部份，也大概介紹了surface, displacement怎麼使用，也是該介紹像是解析度、gamma值、ray tracing....等怎麼設定。這一切~都在RenderMan Globals裡可以設定，簡單來說，RenderMan Globals裏面的設定，決定了render出來的結果。這裡僅介紹小轉個人比較常用的部份囉~

◎RenderMan -> RenderMan Globals 可以看到如下視窗。Display->Primary：
Display Name: render出來的檔案名稱。
Camera Name:用來render的camera的shape名稱。(注意~要是shape的名稱喔)
Display Resolution:解析度。
Display Server:用來選擇要render出來的檔案格式，如果是it的話，就是會直接顯示於catelog視窗。
Exposure:設定gamma值用的。

至於Secondary以及Channel是在出pass、layer時會用到，以後再介紹。

◎Camera：
Motion Blur:就是Motion Blur，沒辦法更白話了。
Shutter Angle:Motion Blur的程度。

◎Reyes：
Shading Rate:可以想成render出來的精細度，值越小，計算的範圍越小，也就越精細。
Pixel Samples:也是決定render出來的精細度，值越大，每次計算的pixel sample越多，也就越精細。

◎Rays：
Ensemble Ray Tracing:打開的就，就會計算ray tracing。

◎Accel：
Selected Object Only & With Selected Lights:照字面上看，就是只render選取到的object和light。

◎Spool->Frames：
就是render出連續圖檔的相關設定，字面上還挺容易懂的，就懶的打了～

(4)displacement及貼圖的基本運用

2009-04-13T02:19:00.000-07:00

上一篇拉哩拉咂的打了一堆偏programming的東西，也是該來介紹一下如何使用displacement和貼圖了。

什麼是displacement呢，簡單來想，就是會變形的bump。

先開始介紹怎麼使用貼圖吧～

◎這裡也是接續第1篇小小筆記的檔案。在graph layout上按滑鼠右鍵-> Colors-> Maps-> ImageFile 來新增一個ImageFile，顧名思義，這就是一個貼圖用的node。其實這裡也可以選Floats-> Maps-> ImageFile，會產生一個灰階的ImageFile，因為displacement用灰階的就可以了。為什麼這裡要用彩色(color)的呢，等一下會說明。

◎在ImageFile的File選項，按下資料夾的圖示，選擇所要使用的貼圖檔案路徑(通常只能為 *.tif)。然後按下另一個圖示，選"Convert Textures"，將剛剛指定的*.tif轉成Pixar RenderMan的貼圖檔案格式(*.tex)。

◎將此ImageFile接到Simple的Displacement，當作要產生displacement的紋路。這裡來解釋一下為什麼要選用color的ImageFile，因為如果把這node接到diffuse的color的話，就可以把這當作彩色的底色囉。

◎這裡是用一張青蛙的圖(kero~kero)。按下"Toggle preview render setting"，然後將"Object Shape"選為Plane，就可以將preview的模式改成plane。

◎S Filtering & T Filtering:是延texture的座標軸(s,t)做blur。例如把兩個值都調成8的話，就可以看見一隻糊的青蛙。

◎在manifold的地方，接一個ST的node，就可以對這個ImageFile，延(s,t)做一些手腳。

◎例如...把ST node的repeat的參數都調成2的話，就可以看到2x2=4隻青蛙。其餘的參數....就自己paly吧~

◎把上述的動作回歸到預設值。在Simple裡preview一下，可以看到如下圖。這裡是將Kb設為0.2，Displacement bound設為1。注意：Displacement bound的值要大於Kb的值。

◎在場景中新增一個plane，隨便打點燈。建議新增的物件最好要是polygon，比起nurbs，較不會有接縫不連續的問題。

◎將Diffuse以及Specular的color都調成50度的灰，render即可看到如下結果。

◎看一下如果Displacement bound的值小於於Kb的值會怎麼樣。

◎就會看到出來的結果會有破洞

Houdini強者:Jacys的blog

2009-04-10T08:48:00.000-07:00

http://tw.myblog.yahoo.com/chiao-pi 他是我的一個好朋友~特效神人Jacys~Maya跟Houdini都很厲害喔!!

(3)結合C和RenderMan API來輸出*.rib

2009-04-08T01:03:00.000-07:00

這裡要先介紹一個很不錯的免費RenderMan:Pixie，可以去他的官方網站：http://www.renderpixie.com/ 下載。

很多人以為RenderMan＝Pixar，事實上～RenderMan只是一套規格，符合這套規格的都可以稱做RenderMan。

這裡用的程式編輯器是Visual Studio.Net 2005。安裝好Pixie後，除了把lib, include, dll...等，copy到Visual Studio.Net 2005對應的目錄下，還要在工具列上的專案→屬性→連結器→輸入→其他相依性，輸入ri.lib sdr.lib。然後，開啟Visual Studio 2005→檔案→新增→專案，選擇"Win32主控台應用程式"按下確定，在彈出視窗左邊的選擇應用程式設定→其他選項→空專案。這裡小轉是將project名稱命名為"RenderMan_Cube"。

然後在原始檔案新增一個C++檔案，key入下面的code(參考資料為"The RenderMan Companion [Steve Upstill]")：

#include <ri.h>
#include <stdio.h>
#define NFRAMES 10 /* number of frame in the animation */
#define NCUBES 5 /* # of minicubes on a side of the color cube */
#define FRAMEROT 5.0 /* # of degrees to rotate cube between frames */

#define L -0.5
#define R 0.5
#define D -0.5
#define U 0.5
#define F 0.5
#define N -0.5

void UnitCube()
{
   static RtPoint Cube[6][4]={
       {{L,D,F}, {R,D,F}, {R,D,N}, {L,D,N}},
       {{L,D,F}, {L,U,F}, {L,U,N}, {L,D,N}},
       {{R,U,N}, {L,U,N}, {L,U,F}, {R,U,F}},
       {{R,U,N}, {R,U,F}, {R,D,F}, {R,D,N}},
       {{R,D,F}, {R,U,F}, {L,U,F}, {L,D,F}},
       {{L,U,N}, {R,U,N}, {R,D,N}, {L,D,N}}
   };
   int i;

   for(i=0;i<6;i++)
       RiPolygon(4, RI_P, (RtPointer)Cube[i],RI_NULL);
}

void ColorCube(int n, float s)
{
   int x, y, z;
   RtColor color;//宣告顏色變數
   RtObjectHandle cube;//選告物件變數

   if(n<=0)
       return;

   cube = RiObjectBegin();
   UnitCube();

   RiObjectEnd();

   RiAttributeBegin();
   RiTranslate(-0.5, -0.5, -0.5);
   RiScale(1.0/n, 1.0/n, 1.0/n);//縮放

   for(x=0; x<n; x++)
   for(y=0; y<n; y++)
   for(z=0; z<n; z++)
   {
       color[0]=((float)x+1)/((float)n);
       color[1]=((float)y+1)/((float)n);
       color[2]=((float)z+1)/((float)n);

       RiColor(color);//指定個別cube的顏色
       RiTransformBegin();//將transform的code"包"起來
       RiTranslate(x+0.5, y+0.5, z+0.5);
       RiScale(s, s, s);
       RiObjectInstance(cube);
       RiTransformEnd();
   }
   RiAttributeEnd();
}

void main()
{
   int frame;
   float scale;
   char filename[20];

   RiBegin(RI_NULL); /*Start the renderer*/
   RiLightSource("distantlight", RI_NULL);//指定light shader明成還有其參數

   /*Viewing transformation*/
   RiProjection("perspective", RI_NULL);//就是perspective,沒辦法更白話了 XD
   RiTranslate(0.0, 0.0, 1.5);//位移
   RiRotate(40.0, -1.0, 1.0, 0.0);//旋轉

   for(frame=1; frame<=NFRAMES; frame++)
   {
       sprintf(filename, "anim%d.jpg", frame);
       RiFrameBegin(frame);
       RiDisplay(filename, "framebuffer", "rgb", RI_NULL);
       RiWorldBegin();
       scale=(float)(NFRAMES-(frame-1))/(float)NFRAMES;
       RiRotate(FRAMEROT*frame, 0.0, 0.0, 1.0);//以z軸為中心旋轉
       RiSurface("matte",RI_NULL);//指定surface shader名稱還有其參數
       ColorCube(NCUBES, scale);
       RiWorldEnd();
       RiFrameEnd();
   }
   RiEnd();
}

有用過OpenGL的話，應該整個覺得很熟悉(話說小轉第一次用RenderMan API時，覺得根本就是OpenGL吧)。RenderMan的function名稱都是"Ri"開頭，變數名稱為"Rt"開頭。用紅色mark起來的那兩行程式碼，會在下面介紹其功用。

執行後可以看到10個buffer(因為code中的frame數=10)，有5x5x5個cube在旋轉，且邊旋轉邊縮小(下兩張圖為示意)：

◎如果將RiDisplay(filename, "framebuffer", "rgb", RI_NULL);中的"framebuffer"改成"file"來執行，則會在project底下產生10張*.jpg，且檔案名稱為filename。

◎如果將RiBegin(RI_NULL);的RI_NULL改成一個*.rib的名稱(這裡小轉是用"rotate_cubes.rib")，則會在project底下輸出一個名稱為rotate_cubes的*.rib(如上上圖)。

◎將rotate_cubes.rib複製到Pixie\bin，並在命令提示字元裡，將路徑切換到Pixie\bin底下，輸入 rndr rotate_cubes.rib，則會在這個目錄底下產生如剛才的10張圖檔。

注意：Pixar的RenderMan的render程式為prman，而Pixie的則為rndr。

來看看這個rotate_cubes.rib，用文字編輯器開啟，可以看到如下的code(因為這code落落長，所以只截取部份)：

## Pixie 2.2.5
## Generated Tue Apr 07 23:41:15 2009

LightSource "distantlight" 1
#就是light shader以及其參數囉

Projection "perspective"
Translate 0 0 1.5
Rotate 40 -1 1 0
FrameBegin 1
#第一個frame開始！到下一個FrameEnd前，都是這個frame會render出來的東西

Display "anim1.jpg" "file" "rgb"
#輸出*.jpg，若是將file改成frmaebuffer，則會直接在一個視窗呈現(如第1張圖)

WorldBegin
Rotate 5 0 0 1
Surface "matte"
ObjectBegin 1
Polygon "P" [-0.5 -0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 -0.5 -0.5 -0.5 ]
Polygon "P" [-0.5 -0.5 0.5 -0.5 0.5 0.5 -0.5 0.5 -0.5 -0.5 -0.5 -0.5 ]
Polygon "P" [0.5 0.5 -0.5 -0.5 0.5 -0.5 -0.5 0.5 0.5 0.5 0.5 0.5 ]
Polygon "P" [0.5 0.5 -0.5 0.5 0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 ]
Polygon "P" [0.5 -0.5 0.5 0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 ]
Polygon "P" [-0.5 0.5 -0.5 0.5 0.5 -0.5 0.5 -0.5 -0.5 -0.5 -0.5 -0.5 ]
ObjectEnd
AttributeBegin
Translate -0.5 -0.5 -0.5
Scale 0.2 0.2 0.2
Color [0.2 0.2 0.2]
TransformBegin
Translate 0.5 0.5 0.5
Scale 1 1 1
ObjectInstance 1
TransformEnd
Color [0.2 0.2 0.4]
TransformBegin
Translate 0.5 0.5 1.5
Scale 1 1 1
ObjectInstance 1
TransformEnd
Color [0.2 0.2 0.6]
TransformBegin
Translate 0.5 0.5 2.5
Scale 1 1 1
ObjectInstance 1
TransformEnd

~~~我是code分隔線~~~

AttributeEnd
WorldEnd
FrameEnd
#這是對應上面的FrameBegin

FrameBegin 2
#第二個frame開始！
Display "anim2.jpg" "file" "rgb"
WorldBegin
Rotate 10 0 0 1
Surface "matte"
ObjectBegin 2
Polygon "P" [-0.5 -0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 -0.5 -0.5 -0.5 ]
Polygon "P" [-0.5 -0.5 0.5 -0.5 0.5 0.5 -0.5 0.5 -0.5 -0.5 -0.5 -0.5 ]
Polygon "P" [0.5 0.5 -0.5 -0.5 0.5 -0.5 -0.5 0.5 0.5 0.5 0.5 0.5 ]
Polygon "P" [0.5 0.5 -0.5 0.5 0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 ]
Polygon "P" [0.5 -0.5 0.5 0.5 0.5 0.5 -0.5 0.5 0.5 -0.5 -0.5 0.5 ]
Polygon "P" [-0.5 0.5 -0.5 0.5 0.5 -0.5 0.5 -0.5 -0.5 -0.5 -0.5 -0.5 ]
ObjectEnd
AttributeBegin
Translate -0.5 -0.5 -0.5
Scale 0.2 0.2 0.2
Color [0.2 0.2 0.2]
TransformBegin
Translate 0.5 0.5 0.5

~~~我是code分隔線~~~

其實....看的出來都是很白話的code，就懶的各個做解釋了XD。也很明顯的可以觀察出*.rib和*.cpp的對應關係。

(2)什麼是RIB

2009-04-07T06:17:00.000-07:00

在解釋什麼是rib之前呢，先說明RenderMan在render每個object時，為了使object在render之後，呈現出某些質感；例如金屬、玻璃、木頭...等，分別在各個object上assign各個質感的shader。而RenderMan用來紀錄這些資訊的檔案，就叫做"RenderMan Interface Byte stream file"，簡寫為『RIB』。這樣的檔案，副檔名也為"rib"，RenderMan就是先產生這樣的*.rib，再用丟給render的程式去產生圖檔。(例如Pixar出的RenderMan的render的檔案名稱為prman)

下面來介紹一下用mtor產生的rib吧～

◎為了方便了解，把上一篇的Ensemble、Delux和Simple後面加上"_test".

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

◎新增一個spot light，並將其assign給上一篇檔案scene的spot light.

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

◎在maya的export選項中，選"MTOR_RIBArchive"，然後輸出一個*.rib（這裡用的名稱是"RIB_test"）

　　　　　　　　　　　　　　　　　　　　　　　　　　　

◎用文字編輯器開啟剛剛輸出的"RIB_test.rib"，可以看到以下內容：
（有學過OpenGL的人，應該會覺得這種東西很親切，因為什麼東西都是'Begin'和'End'成對出現）
◎注意～這跟真正丟下去render的*.rib內容不一樣，真正去render的*.rib裡，還會有"WorldBegin"&"WorldEnd"、"FrameBegin"&"FrameEnd"等較完整的資訊。這部份的基本介紹，打算寫在下一篇網誌裡，這裡先只標示出shader跟geometry資訊在什麼地方。rib用來mark註解的符號是"#".
◎至於什麼是surface shader和displacement shader....可以參考一個很棒的網站：http://www.fundza.com/，而是想把這部份跟mtor的SLBox寫在同一個網誌裡......(遠目 @@)

##RenderMan RIB-Structure 1.1 Entity
##Creator mtor 7.0.1 (Oct 4 2007 03:05:10)
##For spin
##CreationDate Tue Apr 07 07:27:39 2009

version 3.04
AttributeBegin
IfBegin "!defined(RATFilterLightSource)"
TransformBegin
Attribute "identifier" "string name" ["spotLightShape1"]
Transform [-1 -6.42572e-017 -1.04248e-016 0 0 0.851277 -0.524717 0 1.22461e-016 -0.524717 -0.851277 0 0 12.2471 14.8691 1]
#slim light Spot_test
TransformBegin

#torattr write EmitsPhotons 0
LightSource "rmanshader/Spot_test" "e-___NtZQd400000-spotLightShape1" "float ConeAngle" [ 30.0000128573 ] "float PenumbraAngle" [ 0.0 ]
　　#這是燈光shader以及其相關參數的設定，在maya檔裡，是給燈光一個spot light的shader
TransformEnd
TransformEnd
IfEnd
AttributeBegin
ResourceBegin
Attribute "identifier" "name" ["|nurbsSphere1|nurbsSphereShape1"]
　　#這是geometry資訊的位置，在maya裡是建置一粒nubrs的sphere
ConcatTransform [1 0 0 0 0 1 0 0 0 0 1 0 0.102705 0 0.225856 1]
ShadingInterpolation "smooth"
IfBegin "!defined(RATFilterLightSource)"
IfEnd
TransformBegin
#slim ensemble Ensemble_test
Attribute "sides" "int doubleshaded" [0]
Attribute "visibility" "string transmission" ["opaque"]
Scale 1 1 1
Attribute "shade" "float volumeintersectionpriority" [0]
Opacity [1 1 1]
Color [0 .25 1]
Attribute "trace" "int samplemotion" [0] "int displacements" [0]
IfBegin "!defined(user:RATFilterSurface)"
#slim shadingmodel_aov Delux_test
TransformBegin
Surface "rmanshader/Delux_test"
#這裡surface shader資訊，在maya檔裡，是配置給sphere的名稱是Delux_test
TransformEnd
IfEnd
IfBegin "!defined(user:RATFilterDisplacement)"
#slim displacement Simple_test
TransformBegin
Displacement "rmanshader/Simple_test"
　　#這裡diaplacement shader資訊，在maya檔裡，是配置給sphere的名稱是Simple_test
TransformEnd
IfEnd
TransformEnd
NuPatch 11 4 [-0.25 -0.25 -0.125
0 0.125 0.25 0.375 0.5 0.625 0.75 0.875 1 1.125 1.25 1.25] 0 1 7 4 [0 0 0 0 0.25 0.5 0.75 1 1 1 1] 0 1 "Pw" [4.58348e-016 -4.77621 -1.20915e-015 1 4.58348e-016 -4.77621 -1.20915e-015 1
4.58348e-016 -4.77621 -1.20915e-015 1 4.58348e-016 -4.77621 -1.20915e-015 1 4.58348e-016 -4.77621 -1.20915e-015 1
4.58348e-016 -4.77621 -1.20915e-015 1 4.58348e-016 -4.77621 -1.20915e-015 1 4.58348e-016 -4.77621 -1.20915e-015 1
4.58348e-016 -4.77621 -1.20915e-015 1 4.58348e-016 -4.77621 -1.20915e-015 1 4.58348e-016 -4.77621 -1.20915e-015 1
0.954845 -4.77621 -0.954845 1 1.35036 -4.77621 -2.9713e-016 1 0.954845 -4.77621 0.954845 1
5.50029e-016 -4.77621 1.35036 1 -0.954845 -4.77621 0.954845 1 -1.35036 -4.77621 2.7316e-016 1
-0.954845 -4.77621 -0.954845 1 -8.84009e-016 -4.77621 -1.35036 1 0.954845 -4.77621 -0.954845 1
1.35036 -4.77621 -2.9713e-016 1 0.954845 -4.77621 0.954845 1 2.9442 -3.7427 -2.9442 1
4.16373 -3.7427 5.01798e-016 1 2.9442 -3.7427 2.9442 1 9.50604e-016 -3.7427 4.16373 1
-2.9442 -3.7427 2.9442 1 -4.16373 -3.7427 7.69498e-016 1 -2.9442 -3.7427 -2.9442 1
-1.98041e-015 -3.7427 -4.16373 1 2.9442 -3.7427 -2.9442 1 4.16373 -3.7427 5.01798e-016 1
2.9442 -3.7427 2.9442 1 4.14194 3.12144e-016 -4.14194 1 5.85759 5.85233e-017 1.38563e-015 1
4.14194 -1.95098e-016 4.14194 1 9.80036e-016 -3.00151e-016 5.85759 1 -4.14194 -1.95098e-016 4.14194 1
-5.85759 5.85233e-017 1.04766e-015 1 -4.14194 3.12144e-016 -4.14194 1 -2.42878e-015 4.17197e-016 -5.85759 1
4.14194 3.12144e-016 -4.14194 1 5.85759 5.85233e-017 1.38563e-015 1 4.14194 -1.95098e-016 4.14194 1
2.9442 3.7427 -2.9442 1 4.16373 3.7427 1.46808e-015 1 2.9442 3.7427 2.9442 1
4.42665e-016 3.7427 4.16373 1 -2.9442 3.7427 2.9442 1 -4.16373 3.7427 7.19908e-016 1
-2.9442 3.7427 -2.9442 1 -1.47247e-015 3.7427 -4.16373 1 2.9442 3.7427 -2.9442 1
4.16373 3.7427 1.46808e-015 1 2.9442 3.7427 2.9442 1 0.954845 4.77621 -0.954845 1
1.35036 4.77621 9.3599e-016 1 0.954845 4.77621 0.954845 1 -9.81727e-017 4.77621 1.35036 1
-0.954845 4.77621 0.954845 1 -1.35036 4.77621 2.09875e-016 1 -0.954845 4.77621 -0.954845 1
-2.35807e-016 4.77621 -1.35036 1 0.954845 4.77621 -0.954845 1 1.35036 4.77621 9.3599e-016 1
0.954845 4.77621 0.954845 1 8.31046e-016 4.77621 -8.02387e-017 1 8.31046e-016 4.77621 -8.02387e-017 1
8.31046e-016 4.77621 -8.02387e-017 1 8.31046e-016 4.77621 -8.02387e-017 1 8.31046e-016 4.77621 -8.02387e-017 1
8.31046e-016 4.77621 -8.02387e-017 1 8.31046e-016 4.77621 -8.02387e-017 1 8.31046e-016 4.77621 -8.02387e-017 1
8.31046e-016 4.77621 -8.02387e-017 1 8.31046e-016 4.77621 -8.02387e-017 1 8.31046e-016 4.77621 -8.02387e-017 1]
ResourceEnd
AttributeEnd
AttributeEnd

20090405陽明山採海芋

2009-04-06T19:38:00.000-07:00

20090404的高中同學會

2009-04-05T22:19:00.000-07:00

小紅帽跟Dan的離職歡送會

2009-04-01T23:33:00.001-07:00

左起：YC, Jin, Ray, Jin的男友(不知道該怎麼稱呼), 要離職的小紅帽

我跟也是要離職的Dan Mass，他有個帥氣著中文名字:馬一丹～

Vic抓著嘴炮馬的頭，右邊是威廉

我跟前陣子出車禍的寒風～(好險只是皮外傷@@)

nobirdm跟naomi姊姊

超能吃的人妻～阿滿姊，吃飯前她在轉魔術方塊，說沒轉好不給她吃飯
不過她還是順利完成了　XD

我跟寒風還有YC的pose一致耶，改天來組團好了　XD

(1)Slim基本操作

2009-03-29T03:42:00.000-07:00

最近心情有點小混亂～想說藉著整理一些RenderMan的心得，也好好整理自己的思緒囉～

這篇主要是藉著在Slim使用Diffuse和Specular，來小小介紹一下RenderMan Network的操作

◎這是從Maya的tool bar:RenderMan->Slim 開啟Slim的畫面，預設會有一個untitled的palette。
中間的Graph Layout是就拉RenderMan Network的地方。

◎一般標準的作法是：在Graph Layout裡，按滑鼠右鍵->Other->Archiver->Ensemble 新增一個Ensemble。

◎可以從slim裏面看到Ensemble有許多的屬性；如Surface、Displacement...等。可想而知，Ensemble 就是把一堆屬性統整成一個shader的node。比較常用到的是Surface、Displacement和Light。(注意：Displacement不等於Bump)
◎接著按下Surface旁的圖示->AdditiveFx->Delux。用Delux 的好處是，它可以將Diffuse、Specular、Incandescence(自發光)...等，整合起來。簡單來說～可以將Diffuse想成是物件的底色，而Specular是物件受光後，反射出的顏色。(細節還是要找一本computer graphic相關的書籍來play一下會比較了解)。除此之外，Delux還可以用來出AOV。
◎在Displacement旁的圖示，照上面的方法，新增一個simple。(在這篇文裡，這只是新增好玩的，不會用到，想傳達的是～一般Displacement都是先接simple)

◎然後新增Diffuse和Specular：一樣在Graph Layout裡按右鍵->Shading Components->Diffuse 來新增一個Diffuse的node。也是用同樣方法來加入一個Specular的node。
◎在Delux裡，按下shading components旁的"+"號，來新增兩個shading components：v1和v2。預設是Diffuse。

◎然後，用滑鼠中鍵將Diffuse拖曳到Delux上(如上圖)

◎在彈出的選項中，選v1。(其實選v2也是一樣的，只是個人比較喜歡Diffuse的順序在Specular之前　XD)
◎相同的方式，將Specular接到v2上。

◎為了能明顯的觀察Diffuse以及Specular的作用，這裡是打算將兩者的color分別設成blue和red。
◎在Diffuse裡，按下顏色的方塊，在彈出的視窗中，將顏色調成藍色。

◎同樣的方法，將Specular的顏色設成紅色。

◎在場景中，隨便建一顆sphere，隨便打一個spot light。先select這顆sphere，再在Ensemble上按右鍵->Attach 將Ensemble這個shader配置到sphere上。

◎在Maya的tool bar上：RenderMan->Render ，可得到下圖：

◎一顆藍色的球的反射光是紅色～Done!

#這是開始整理RenderMan的第1篇文～接下來會小小介紹什麼是RenderMan Interface Byte stream(*.rib)和shading language(*.sl)，以及如何在C++中使用RenderMan API來產生*.rib以及render#