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