Sei sulla pagina 1di 19

Hemali Tanna 

Rendering and Shading – Final Project 

For the Final Project I chose to shade and render a tree face I have modeled. Reason for choosing this 
project is that my research in the course would help my thesis which involves study of 
anthropomorphism and developing a character of a tree woman, the artistic style being surreal. I also 
wanted to create something different and beautiful looking that exhibited my artistic as well as technical 
skills to present in my demo reel. 

I first developed some concept art for my face to study how I could blend a human side of a face with a 
fantasy tree side. Here are some concept art works.  

From these sketches I observed it helped my tree character if I placed the tree contours and rings to 
confirm with facial contours and lines. Because of these reasons, I made a decision to manually paint 
this area of my model. This required me to UV layout my model, so I can be sure of what I color and 
displacement I am assigning to my model at any particular point. Laying out UVs for this model was 
quite challenging and time consuming considering the twisted and overlapping branches, but completely 
worth the effort.   

I was particular about laying out the uvs of the facial area and the origin of branches (these were aimed 
to look like hair tufts) correctly. I had plans to shade the branches midway to end procedurally as it 
would save me time in the UV layout process. So I let the parts where the branches forked as the uvs 
were laid out from the camera view. This left seams even when I shaded that portion of the branches 
procedurally (my procedural shader also made use of u and v expressions). I solved the problem in a 
unique way which I will explain later. This shows that uv unwrapping would have been necessary even if 
I shaded the model entirely procedurally if I were making use of uv or st co‐ordinates in my shader.   
Here is an image of the initial UV map and a checker pattern test on my model. 

Creating the tree contours through plain programming, according to me would require very superior 
mathematical skills, and many many hours.  In my view it would be justified to spend that time and 
effort if one wanted a colony of tree faces and were satisfied with the changes in the shapes of the 
contours through change of parameters used. For me, this project and tree face is a unique 
individualistic expression of my art, and I like the fact that even though my shader would be replicable in 
terms of network, it would take a fine artist to paint the textures to achieve the result similar to mine. 
There are many studios such as Walt Disney who paint 90 percent of their textures.  
To ensure that I have a base map to where my painted lines should follow I first painted reference lines 
directly on the maya model, using the maya paint 3d tool. You need to create a filename where the 
painted textures are saved. It is done using the assign/Edit Textures button in the tool. Now I have an 
image file which has reference lines and where they fall in my uv layout, which I can use as a reference 
layer in photoshop. 

Reference lines painted with Maya 3d Paint tool 

The painted reference lines automatically saved over the UV map. 

When the uvs were disjointed, even procedural shaders looked disjointed. Look at the example: 

To fix that, I performed a move and sew uv edges on broken pieces not caring about squares of checkers 
all I wanted to get rid of was the seams. I made sure the uvs of the parts I had already painted did not 
move. Here below is the revised uv layout. 

The Tree Shader: 


Here now, I shall explain my compiled shader. 

Even though I built the shader as a whole, it would be easy to understand how it works if we break it 

I will begin by explaining my procedural branch shader. I apply it to the entire tree body, and the painted 
part is overlaid over this procedural shader with an appropriate opacity map, we do it here in Blend 
Node 2. 

The procedural branch shader: The branches outer surface network 

This outer color is built in with a Blend Node1 in the diagram. The mode has two layers. The lower layer 
is the color obtained by tiling a seamless texture map.  

Lower Layer 

The upper layer is a plain brownish golden color chosen from color picker. Now the blend node is linked 
to a transparency, according to which the upper layer blends with the lower layer. Here I use this 
particular image file for driving the transparency. 

Transparency map that drives Blend 1 node. 


The procedural branch shader: The branches opacity network 
I first create a uv black and white ramp and repeat it 100 times in u and v direction to get the 
transparent swirls. I use it with an opacity map to prevent the face and hairl line from getting the 
transparent swirls. 

The ramp used to achieve the transparent swirls. 

Branches when Color surface shader is not double sided 

This is how it looked after adding the opacity map. I then decided I wanted to even shade the back side 
of the branches, the inner surface, so that it is seen through the transparency. This is how it looked after 
making it double sided. 

Branches when Color surface shader is double sided 
So I made the shader double sided using a Maya sampler info node, and a condition node. These are 
very useful Maya node that can be used to generate numerous shading effects. A condition node is used 
like an if – else statement in programming.  

The condition node that is used to make shader double sided 

Shader network when condition node is detached. 

In my shader I link the flipped normals parameter of the sampler info to the first term of the condition 
node. Thus if the normal at the point faces the camera the condition is met. The back side of the surface, 
since the normal would be facing away from the camera the condition won’t be met. So I specified a 
condition that if it faces normal faces the camera shade it using the surface colors derived from the 
BlendNode 1, otherwise use the dark golden brown ramp color. This way when I use transparency on my 
branches, I can even see the back side of the branches that makes it look very interesting and detailed 

Thus let’s remember the condition node 3 has the information of branches color, inside and outside. 

Painted color map for tree face 
Now I made another Blend Node, Blend node 2. In this the lower layer gets color from the condition 
node 3 which I just explained earlier has color information of branches. The top layer has my painted 
color map. I also use a painted map to drive the opacity of Blend Node 2 so the branches area doesn’t 
get the painted color, and rather retains the information from the condition node. 

Diffuse Skin Color Map 

Branches Opacity Map – This opacity map is used to blend the diffuse color map over the procedural 
shader on the model in Blend node 2.  

The blend node 2 drives the color of the final compiled shader that is applied to the tree face. Lets call 
it the treeShader. 

Displacement Map: Used to create bumps and depths in the tree wood surface. This map is 
applied to the final compiled treeShader. 

Here are the results of the bump map. 

Possibility of replacing Painted with procedural 
The entire skin on the face and the branches is rendered using just a single shader, part of which is 
painted and part of which is procedural, which is very unique. The painted part could be replaced by a 
procedural shading method, still retaining the original shader network. Here’s an example where I have 
done just that. I replaced the texture map in my network with a maya node that allows me to import an 
slo file. The slo file I used is compiled so that displacement of surface point P happens according to the 
following noise function:  noise(noise(step * P)) 

Sub Surface Scattering: 
To add life to the skin of the tree face I used sub surface scattering. In my tree shader, I added an extra 
renderman sub surface scatter attribute. These are the values I used for. 

These are my results from the sub surface scattering. I observed more life in the face after the use of sub 
surface scattering. 

Face without sub surface scattering

Face with sub surface scattering 
Falling flowers changing colors: 
The falling flowers in the animation change colors based on the camera facing angle. For this effect I 
used Maya’s sampler info node.  

Here’s the shader network for the procedurally shaded color changing flowers. 

The sampler info node has a parameter within it, called the facing ratio, which basically is determined 
how straight or angled the vector of the camera view is at a specific point.  

When the camera faces the point straight on the facing ratio is 0, and when the camera is hardly facing 
the point, the facing ratio is around 1. Thus the facing ratio can vary from 0 to 1. 

Coincidently when we create a uv ramp, the color values of the ramp also vary from 0 to 1; 0 being 
black, 1 being white.  
The camera can thus interpolate between values 0 to 1 and drive the ramp colors similarly. I then design 
the ramp colors to influence the colors of two crater nodes ( a planet surface like 2d node in maya) 
between pink and yellow. Thus in my scene the flowers change colors from pink to yellow depending on 
the cameras facing angle to the point on the flower.  

Leaf Eye Lash Shader: 

Here a base green color layer is combined with a s=serrated leaf shaped transparency color layer, which 
has no specular reflection, thus giving the eyelashes a serrated leaf shape. The eyeball shader is painted. 

Some experiments with the branches shading: 

This mystic look is created by building the tree shader entirely differently using a layered shader node. 
The different layers are multiplied with each other suing different opacities. 


The one above is achieved by using checkers for transparent, tiled just 4 times in u direction and 80 
times in V direction. 

The above is achieved by using a grid 2d node for transparency. The backside color of the branches 
double sided shader is pink. I was going for ribbons on hair. 

Here I used just plain colors for branches without transparency, to make it resemble like painted wood. 

In the above shader a volume noise is applied for transparency directly to the treeShader.