Converting some code shaders to ShaderGraph

A follow-up to the Shader Graph intro, please read that one first if you haven't already! 

In this post I'm converting a few of the shaders I've made in the past into ShaderGraph, (the UnityPackage with all these files will go up soon :) )

Toon Lit

Original Shader (Code) : PasteBin Link 

Since custom lighting is currently not supported by ShaderGraph (if this changes, I'll put up another post for it) the Toon Lit effect has to be faked.

Create a new PBR Shadergraph

Now, the most important part of the toon lit look is the lighting.

This underlined pieces of code are all we need to convert, so how do we do this? 

Lets take it one by one. The first line needs the light direction. There is currently no node for this, so this value needs to be added via script (A very simple script, don't worry!)

We send values to shaders using Shader.SetGlobal___ ,

Since the lighting part is fake, the light direction, and the light intensity need to be included:

Shader.SetGlobalVector("_LightDirectionVec", -transform.forward);
Shader.SetGlobalFloat("_LightIntensity", dirLight.intensity);

Here's the full script : PasteBin Link 

Drop this on your Directional Light, and drag the light into the slot

Now we can get to the graph

Create a Vector3 property with the reference "_LightDirectionVec", and a Vector1 with the reference "_LightIntensity"

Make sure they are not exposed, and give them a value so the preview looks right

Here's the first line of the code, normalize the light direction. Converting code into nodes is a lot of thinking backwards, you plug the value into the function in nodes, instead of typing the fuction with the value inside in code.

So for this add the Property: Light Direction, and plug it into a Normalize node.

For this line, we need a Dot Product node, and plug in a (world)Normal Vector, and the result of the Normalize Light Direction

Next line is a bit more complicated, the SmoothStep node takes 3 inputs. The IN of Smoothstep will be the Dot Product, the 2 Edge inputs are the Offset(Vector1), and a slightly bigger value for smoothness, which is the Offset + Blur(Vector1) value. Convert these Vector1 into properties to control them in the material settings.

Before adding the _ToonTint(Color) value, the _LightIntensity needs to multiplied, it's not in the code, but is needed to fake the lighting.

Just needs a texture now,
Because the lighting is faked, this part goes a bit simpler, just add a Texture Node(convert to property), and a Sampler Texture 2D, then multiply with the lighting ramp result.

PBR Master needs to be set to Specular Workflow, with Specular set to black, and Occlusion set to something like 3. 

There it is, fake toon lighting :)

Full graph image is here, and graph file is attached

Iridescent

A simple, weird one this time, based on the Iridescent Tip 

Looking at the relevant lines, the first two can be done with handy built-in nodes.

(There is also simple noise, and gradient noise to play with, instead of Voronoi)
Fresnel Effect node is great, you can turn the Power into a property if you want for more control

Line 3. is just a texture + sample 2D, as seen before.

Instead of plugging the UV into the Sample Texture, plug in the Fresnel Effect + Noise, then multiply a Color property

Finally, add the Texture, and the iridescent effect with a slider for Brightness

Image of Full Graph 

Snow

Based on the Snow Shader Tip 

This one is a bit more complicated because of vertex manipulation

Here are the relevant lines, both vertex and surface use a Dotproduct of the normal and snowDirection, so lets start with that.

The result of this node is used in all other parts of the shader.

Multiply the Normal with the SnowHeight value, then multiply with the step result to only affect the top area. add this to Position (Object) to add a layer on top of the object, plug this result into Position of the Master Node.

For the non-snowy part, just create a texture + sample 2D like before, and invert the step result using One Minus

The Fresnel Effect node takes up most of the code here. Color the result, then multiply with the step result. Add the snow and non-snow parts together and you're done!

Image of the full graph 


Hope this helped you understand a bit more on how to convert code into graphs, a lot of is just searching the values and functions and finding the right node that way :)


Thanks for reading, and have fun!

Become a patron to

126
Unlock 126 exclusive posts
Be part of the community
Connect via private message