Shader Forge Chinese Help Manual

Reprinted from: http://blog.csdn.net/bb245922917/article/details/52311028

Main

This is the node that all your other nodes will eventually link to. It holds multiple inputs serving different purposes.
The following animated images show all the inputs and their behavior over time. Most inputs will animate back and forth between 0 and 1 (black and white).

   
Diffuse
This is the main color of the shader. The diffuse color will receive or attenuate light, and be masked by shadows, depending on the normal angle of the exiting light.

  
Diffuse Power (Diffuse Power)
This is the exponential of the light normal angle attenuation. Additional metallic appearance can be obtained when using values ​​greater than 1. Note that it is quite power hungry whenever enabled.

  
Specular
This is the color of the shader's specular highlights. Higher values ​​are brighter and blacks are not affected by the shader at all.

  
Gloss
This is the index of specular highlights. The higher the value, the higher the glossiness, and it becomes dull as the value approaches 0. Note that if you uncheck Gloss Remap, you should avoid using gloss values ​​below 1.

  
Normal
This is the tangent space normal direction, where you can connect a normal map or a custom normal vector.

  
Emission
This is a light that is always added to the shader regardless of lighting conditions.

  
Transmission
This option controls how much light can pass through when the light source is behind the currently rendered surface. This is useful for thin materials such as cloth or vegetation.

  
Light Wrapping
This is a method of controlling the angular falloff offset of the outgoing light normal, which can be used to achieve a similar effect to subsurface scattering. Most useful for smoothing objects. Entering a reddish value will cause the red channel to "wrap around" the object more than the other channels, so that it appears as if light is passing into the mesh and carrying red wavelengths out, similar to how you mask skin.

  
Diffuse Ambient Light
This option adds light to the shader, affected by diffuse reflections. Specular Ambient Light can be used in conjunction with cubemaps (normal direction using Image Based Lighting (IBL)) or ambient lights etc.

  
Specular Ambient Light
This option adds light to the shader, affected by specular reflections. Can be used with cubemaps (view reflection directions using Image Based Lighting (IBL)) etc.

  
Diffuse Ambient Occlusion
This option suppresses indirect diffuse light such as light probes, indirect light and diffuse ambient light

  
Specular Ambient Occlusion
This option suppresses indirect specular rays such as reflection probes and specular ambient light

  
Custom Lighting
This input is active when the shader is set to unlit and can be Lets you define custom lighting behavior. Here you place nodes according to the light.

  
Opacity Opacity
controls the transparency of the final pixel. Note that partial transparency is often difficult to get right, especially when using deferred rendering.

  
Opacity Clip
Opacity Clip is a way to control whether the current pixel/fragment should be drawn. Always use hard clipping for objects that need transparency, but don't use hard clipping for partial transparency, because Opacity Clips can be sorted easily, but Opacity can't.

  
Refraction Refraction
is the screen space UV offset used to refract background pixels. Make sure to set the Opacity to a value below 1 before use so that the refraction effect is visible.

  
Outline Width
This option will add a stroke to the shader, rendering as an offset mesh with inverse normals. Note that hard edges will damage the stroke.

  
Outline Color
This option controls the color of the stroke.

  
Vertex Offset
This option can be used to animate shaders over time, or to change the shape of an object under different conditions. You just plug in the XYZ coordinates of the desired offset for each vertex.

  
DX11 Displacement
This option works very similarly to Vertex Offset, but works with DX11 Tessellation. (Note that DirectX is Windows only, requires a DX11 GPU and must be enabled in the Unity settings)

  
DX11 Tessellation
This option controls how many tessellations you want to split the triangle into. (Note that DirectX is Windows only, requires a DX11 GPU and must be enabled in Unity settings)

Add (additive) A + LMB
Sum of output [A] + [B]
Subtract (subtraction) S +
difference of LMB output [A] - [B]
Multiply (multiplication) M +
product of LMB output [A] * [B]
Divide (division) D + LMB
output [A] / [B] quotient
Power (power) E + LMB
output [Val] ^ [Exp] power
Sqrt (square root)

output the square root of its input
Log (logarithm)

output the logarithm of its input. You can toggle the logarithmic base
Min (minimum value)
output in the drop down menu the minimum value of [A] and [B]
Max (maximum value)
output of [A] and [B] the maximum value of
Abs (absolute value)
output its input the absolute value of . It essentially turns negative values ​​into positive values
​​Sign (positive and negative zero values)
output the sign of its input.
When value is greater than 0, output 1 when
value is equal to 0, output 0 when value is less than 0 , output
-1 when value is less
than 0 integer



Floor (rounding)
on ​​output rounds its input down to the nearest integer
Trunc (rounding)
on ​​output rounds its input to zero to the nearest integer. It essentially removes the decimals, leaving the integer
Step (A <= B) (compare (A <= B))
if [A] is less than or equal to [B], output 1, otherwise output 0
If (condition) I + LMB

When [A] is greater than [B], output [A>B] When input
[A] is equal to [B], output [A=B] When input
[A] is less than [B], output [A<B] Input
Frac ( Take decimals)
outputs the fractional part of its input. It essentially removes the integer part, leaving only the fractional part. If the input is 4.32, it will output 0.32. This node is useful when used with the Time node to bring a sawtooth wave over time
Fmod (modulo)

outputs the remainder of dividing [A] by [B]
Clamp (range)

outputs the value of its main input, Not less than [Min] and not greater than [Max]
Clamp (Simple)

Same as Clamp (Range), but uses digital inputs for min and max instead of node interface
Clamp 0-1 (Range). 0-1)
Output its input value, not less than 0 and not more than 1
Lerp (linear interpolation) L + LMB
Lerp (linear interpolation) is used to mix two values ​​or colors.
If [T] is 0, output A will be output
If [T] is 0.5, then input [A] and [B] will be mixed in half
If [T] is 1, output B will be output
if [T] is both Any value in between, a linear blend of the two will be entered.
Lerp (Simple)

Same as Lerp (Linear Interpolation), but uses digital inputs for [A] and [B] instead of the node interface
Posterize is
based on pairs of values ​​going through [Steps] Values ​​are rounded to the nearest integer. A [Steps] value of 5 will create 5 segments in the range 0 to 1
Blend (blended) B + LMB
Blends [A] and [B]
Remap (remapping) using the specified method to remap
values ​​from one range to another a range. As Remap (Simple), but using inputs instead of numerical constants
Remap (Simple) (Remap (Simple)) R + LMB Remaps
values ​​from one range to another. For example, if a node expects values ​​from -1 to 1, but you want it to output values ​​from 2 to 5, you can type -1 and 1 on the first line and 2 and 5 on the second line
Noise
Generate a pseudorandom point from a two-component input (eg UV coordinates)
One Minus (1 minus) O + LMB
output 1 minus its input. When used with a color input, inverts the color
Negate (inverted)
Output its main input multiplied by -1. Essentially make positive values ​​negative and negative values ​​positive
Exp (Exponential)

When Exp (Exponential) is selected: Output e raised to the power of its input When Exp 2 (Exponential 2) is
selected : Output 2 raised to the power of its input
Value (value) 1 + LMB

numeric value, also known as "Vector 1". Attribute versions are also available. Values ​​can be used with the Append node to create a vector with multiple components. Values ​​can also be multiplied by vectors/colors. For example, multiplying the vector (3,1,0) by 0.5 will output the vector (1.5,0.5,0)
Vector 2 (Vector 2 ) 2 + LMB

A vector with two components/values. Usually used with UV coordinates. Adding Vector 2 to UV coordinates transforms the UV coordinates. Multiplying UV coordinates with Vector 2 scales the UV
Vector 3 (vector 3) 3 + LMB vector

with three components/values. Usually used as color, position or direction
Vector 4 (Vector4) 4 + LMB

A vector with four components/values. Typically used as a color with an alpha channel, or as a location with some extra data in the fourth channel. There are two parameters in the viewer for exposure. Color and Vector 4 parameters
Texture 2D T + LMB
Contains a reference to a texture, and will sample the texture (if connected) at a specific UV coordinate using a specific MIP level. If the [Tex] input is connected by a Texture Asset node, it will no longer be a parameter in the inspector. The output [RGB] and a separate channel
Texture Asset
contains references to textures. For multiple sampling of a single texture – only connectable to the [Tex] input of the Texture 2D (2D texture) node. This will also be reflected in the material's inspector, so the user only needs to assign a texture
Value (Property)

numeric value; same as Value, but expose
Vector 4 (Property ) in the material inspector .

_
_

A vector with four components/values, same as Vector 4, but exposed as a shader in the material
inspector Cubemap

contains a reference to the cube and will use a specific MIP level in a specific direction It samples (if connected). Output [RGB] and individual channel
Sliders

allow you to easily adjust a value between a minimum and maximum value.
Also expose Dot Product to the viewer

Output the dot product between [A] and [B]. For two normalized vectors, it essentially outputs the distance between the two vector points. If they point in the same direction, output 1; if they are perpendicular to each other, output 0; if they point in the opposite direction, output -1.
Drop-down selections:
Standard – Regular Dot Product
Positive – make all negative values ​​0
Negative – make all positive values ​​0
Absolute – make all negative values ​​positive
Normalize – on 0 to 1 (instead of -1 to 1) The in-range output

of the following figure shows the behavior of the different modes when using two normalization vectors.
The included angle can be obtained on the X-axis, and the output value can be obtained on the Y-axis:

Cross Product

Outputs the cross product of [A] and [B]. It essentially outputs a vector normal to the two input vectors
Reflect

outputs a reflection vector of the incident vector [I] as if reflecting/bounced on a surface with a normal [N]
Normalize N+ The LMB

outputs a normalized version of the input vector. Essentially set the vector length to 1 and keep the same direction
Append (append) Q + LMB
output a single vector from multiple input values/vectors. For example, if [A] is Vector 2 and [B] is Value (Vector 1), then the node will output Vector 3 (Vector 3), where [A] is in the red and green channels, and [B]
Component Mask in blue channel C + LMB
Component masks can be used to reorder or extract channels of a vector
Desaturate
outputs a desaturated version of Input [Col]. [Des] Determines the degree of desaturation. A value of 1 means full desaturation, a value of 0.5 means half desaturation, and a value of 0 means no desaturation The sum of each component of the
Channel Blend
output mask multiplied by the corresponding color input. Useful for tri-plane blending
Normal Blend

merges two normal directions where the base normal is disturbed by the detail normal
Distance
Outputs the distance between the two input points [A] and [B]
Length (Length)
Outputs the length/magnitude of its input vector.
Transform (Transform)

transforms a vector from one space to another. You can switch between world/local/tangent/view. Built-in vectors are in world space. The direction of the normal input is in tangent space.
Vector Projection

Output Projection of Vector [A] to Vector [B]
Vector Rejection

Output from Vector [B] Rejected Vector [A]
Panner P + LMB

Output Input [UV ] coordinates, press [Dist] distance, translate/offset the
Rotator in the direction/velocity specified by the U parameter and the V parameter
Output and input [UV] coordinates, rotate around the pivot point [Piv] by [Ang] radians. If [Ang] is not connected or connected to a time node, [Spd] will control the rotation speed
Parallax (parallax)

output input [UV] coordinates with parallax offset derived from [Hei] input, depth is [Dep], reference height is [Ref].
[Ref] A height of 0 means its parallax effect is that the heightmap appears to protrude from the grid
[Ref] A height of 1 means that its parallax effect is that the heightmap appears to go down into the mesh
UV Coordinates U + LMB

Outputs the specified UV coordinates for this part of the geometry. The drop down selection allows you to select UV Channel 0 or UV Channel 1.
Note that a lightmap mesh uses UV1 Object Position for its lightmap UVs to
output the world position of the object's pivot point
Screen Position
outputs the screen position of the current part of the mesh, which can be used when mapping in screen space as UV coordinates. In the drop down box, "Normalized" will place {0,0} in the center of the screen and {1,1} in the upper right. Tiled will also center {0,0}, but will scale on the X axis according to the aspect ratio
World Position
Outputs the position of the current part of the mesh in world space
Vertex Color (vertex color) V + LMB
output vertex color. If you have ambient occlusion baked in vertex color, or want to tint meshes with spray color, or use vertex color for other objects, then this is the node you need
Fresnel
outputs the dot product between the surface normal and the view direction. If you want to use a custom normal, [Nrm] is used. Disturbed normals are used by default. [Exp] Change the exponent of the output. The higher the value, the thinner the fresnel.
Normal Direction
Outputs the direction of mesh normals in world space. The Perturbed checkbox makes it use the normal after applying the Main node's Normal input, such as a normal map.
Bitangent Direction Outputs the direction of the mesh's bitangents
in world space
Tangent Direction
Outputs the direction of the mesh's tangents in world space
View Direction
Outputs the current part from the geometry in world space Direction to Camera
View Reflection
Outputs the direction of the view, as if it were bounced off of the surface normal. This can be used as an input for a perfectly reflective cubemap
Light Color
Inputs the color of the light currently being rendered
Light Attenuation
Outputs a light attenuation. This node contains both light falloff and shadows
Ambient Light
outputs the ambient light of the scene where the shader is to be rendered
Light Direction
outputs the direction of the light currently being rendered
Half Direction
outputs the half direction. This is the direction halfway between the view and the ray vector, usually in the blinn-phong specular model using
Light Position
to output the position of the current ray being rendered.
[Pnt] Output 1 if the current ray to be rendered is a point ray, otherwise 0
Time
Output time at different rates.
[t/20] Output time at 1/20x rate
[t] Output current time
[t*2] Output time at 2x rate
[t*3] Output time at 3x rate
View Position
output view/ The current position of the camera (note that when using a perspective camera, the view position is "behind" the screen)
Projection Parameters
outputs four projection parameters.
[Sign] is -1, if the current rendering is using the flip projection matrix, otherwise 1
[Near] is the near plane distance
of the current camera [Far] is the far plane distance of the current camera
[1/Far] is the reciprocal of the far plane distance
Screen Parameters
outputs four screen parameters.
[pxW] is the screen width
in pixels [pxH] is the screen height in pixels
[1+1/W] is 1 plus the reciprocal of the pixel width
[1+1/H] is 1 plus the reciprocal of the pixel height
Scene Color

contains the texture of the scene rendering before rendering this object. By default its UVs are in screen space, allowing each pixel to represent the color behind the object. This can be used for more advanced blending/transparency effects, or as one of the manual methods of refraction when UVs change
Scene Depth

The depth of the camera to the scene behind the current pixel. You need to turn off depth buffer writing in the blend settings, and you need to use a camera that renders the depth texture
Depth Blend

which outputs a value between 0 and 1 based on the distance input, depending on how close this pixel is to the background geometry. Useful for fading of water edges or softening of geometry where light axes intersect. Note: You need to turn off depth buffer writing in your blend settings, and you need to use the camera that renders the depth texture
Depth

is the distance from the camera's near plane to the object
Pi (π, Pi)
outputs the value of π, the circumference of the circle is the same as The ratio of diameters (approximately 3.141593)
Tau (τ, Tau)
outputs the value of τ, the ratio of the circumference of the circle to the radius (approximately 6.283185)
Phi (Golden ratio) (φ, Phi (Golden Ratio))
outputs the value of φ , the golden ratio (approximately 1.618034)
Root 2 (√2)
outputs the arithmetic square root of 2 (approximately 1.414214)
e (Euler's Constant) (e, Euler's Constant)
outputs the Euler's constant e (approximately 2.718282)
Sin (sine)

outputs the sine of its input
Cos (cosine)

outputs the cosine of its input
Tan (tangent)

outputs the tangent of its input
ArcSin (arc sine)

outputs the arc sine of its input in radians
ArcCos (arc cosine)

outputs its input in radians
ArcTan (arc tangent) outputs

the arc tangent of its input in radians
ArcTan2 (bivariate arc tangent)
outputs the arc tangent of its two inputs in radians.
ArcTan2 outputs a specific angle Code (code) between –π and π
Nodes used to execute custom code inside the shader.
In the example on the left, the nodes work similarly to linear interpolation, bending the Relay
output towards [mid] before reaching [end]