A闪的 BLOG 技术与人文

Shader Graph中的Node函数（上）

Unity中的Shader Graph采用可视化节点方式来编辑Shader文件，这种方式比较直接。唯一不方便的地方在于，没有编码方式调整快。

在内置的Node节点中，提供了不少Function函数包装，方便日常使用，一下来记录下内置的函数包装。

下面的代码示例均使用伪代码

Artistic/Adjustment/Channel Mixer

控制输入 In 的每个通道对输出 Out 的每个通道的贡献量。节点上的滑动条参数用于控制每个输入通道的贡献。切换按钮参数用于控制当前正在编辑哪个输出通道。用于编辑每个输入通道的贡献的滑动条控件介于 -2 和 2 之间。

_ChannelMixer_Red = float3 (OutRedInRed, OutRedInGreen, OutRedInBlue);
_ChannelMixer_Green = float3 (OutGreenInRed, OutGreenInGreen, OutGreenInBlue);
_ChannelMixer_Blue = float3 (OutBlueInRed, OutBlueInGreen, OutBlueInBlue);

void Unity_ChannelMixer_float(float3 In, float3 _ChannelMixer_Red, float3 _ChannelMixer_Green, float3 _ChannelMixer_Blue, out float3 Out)
{
    Out = float3(dot(In, _ChannelMixer_Red), dot(In, _ChannelMixer_Green), dot(In, _ChannelMixer_Blue));
}

Artistic/Adjustment/Contrast

根据输入 Contrast 的大小调整输入 In 的对比度。Contrast 值为 1 将原封不动返回输入值。Contrast 值为 0 将返回输入值的中点。

void Unity_Contrast_float(float3 In, float Contrast, out float3 Out)
{
    float midpoint = pow(0.5, 2.2);
    Out = (In - midpoint) * Contrast + midpoint;
}

Artistic/Adjustment/Hue

使输入 In 的色调偏移输入 Offset 的大小。可使用参数 Range 设置偏移的单位。Offset 以 Degrees 为单位时介于 -180 到 180 范围内。以 Radians 为单位时介于 -Pi 到 Pi 范围内。

Degrees

void Unity_Hue_Degrees_float(float3 In, float Offset, out float3 Out)
{
    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
    float4 P = lerp(float4(In.bg, K.wz), float4(In.gb, K.xy), step(In.b, In.g));
    float4 Q = lerp(float4(P.xyw, In.r), float4(In.r, P.yzx), step(P.x, In.r));
    float D = Q.x - min(Q.w, Q.y);
    float E = 1e-10;
    float3 hsv = float3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);

    float hue = hsv.x + Offset / 360;
    hsv.x = (hue < 0)
            ? hue + 1
            : (hue > 1)
                ? hue - 1
                : hue;

    float4 K2 = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    float3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);
    Out = hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y);
}

Radians

void Unity_Hue_Radians_float(float3 In, float Offset, out float3 Out)
{
    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
    float4 P = lerp(float4(In.bg, K.wz), float4(In.gb, K.xy), step(In.b, In.g));
    float4 Q = lerp(float4(P.xyw, In.r), float4(In.r, P.yzx), step(P.x, In.r));
    float D = Q.x - min(Q.w, Q.y);
    float E = 1e-10;
    float3 hsv = float3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);

    float hue = hsv.x + Offset;
    hsv.x = (hue < 0)
            ? hue + 1
            : (hue > 1)
                ? hue - 1
                : hue;

    // HSV to RGB
    float4 K2 = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    float3 P2 = abs(frac(hsv.xxx + K2.xyz) * 6.0 - K2.www);
    Out = hsv.z * lerp(K2.xxx, saturate(P2 - K2.xxx), hsv.y);
}

Artistic/Adjustment/Invert Colors

基于每个通道反转输入 In 的颜色。此节点假设所有输入值均在 0 - 1 范围内。

float2 _InvertColors_InvertColors = float4(Red, Green, Blue, Alpha);

void Unity_InvertColors_float4(float4 In, float4 InvertColors, out float4 Out)
{
    Out = abs(InvertColors - In);
}

Artistic/Adjustment/Replace Color

将输入 In 中等于输入 From 的值替换为输入 To 的值。输入 Range 可用于在输入 From 周围定义更宽范围的值以便进行替换。输入 Fuzziness 可用于软化选择范围周围的边缘，类似于抗锯齿效果。

void Unity_ReplaceColor_float(float3 In, float3 From, float3 To, float Range, float Fuzziness, out float3 Out)
{
    float Distance = distance(From, In);
    Out = lerp(To, In, saturate((Distance - Range) / max(Fuzziness, e-f)));
}

Artistic/Adjustment/Saturation

根据输入 Saturation 的大小调整输入 In 的饱和度。Saturation 值为 1 将原封不动返回输入值。Saturation 值为 0 将返回完全去饱和的输入。

void Unity_Saturation_float(float3 In, float Saturation, out float3 Out)
{
    float luma = dot(In, float3(0.2126729, 0.7151522, 0.0721750));
    Out =  luma.xxx + Saturation.xxx * (In - luma.xxx);
}

Artistic/Adjustment/White Balance

分别根据输入 Temperature 和 Tint 的大小调整输入 In 的色温和色调。Temperature 具有将值移向黄色或蓝色的效果。Tint 具有移向粉色或绿色的效果。

void Unity_WhiteBalance_float(float3 In, float Temperature, float Tint, out float3 Out)
{
    // Range ~[-1.67;1.67] works best
    float t1 = Temperature * 10 / 6;
    float t2 = Tint * 10 / 6;

    // Get the CIE xy chromaticity of the reference white point.
    // Note: 0.31271 = x value on the D65 white point
    float x = 0.31271 - t1 * (t1 < 0 ?0.1 : 0.05);
    float standardIlluminantY = 2.87 * x - 3 * x * x - 0.27509507;
    float y = standardIlluminantY + t2 * 0.05;

    // Calculate the coefficients in the LMS space.
    float3 w1 = float3(0.949237, 1.03542, 1.08728); // D65 white point

    // CIExyToLMS
    float Y = 1;
    float X = Y * x / y;
    float Z = Y * (1 - x - y) / y;
    float L = 0.7328 * X + 0.4296 * Y - 0.1624 * Z;
    float M = -0.7036 * X + 1.6975 * Y + 0.0061 * Z;
    float S = 0.0030 * X + 0.0136 * Y + 0.9834 * Z;
    float3 w2 = float3(L, M, S);

    float3 balance = float3(w1.x / w2.x, w1.y / w2.y, w1.z / w2.z);

    float3x3 LIN_2_LMS_MAT = {
        3.90405e-1, 5.49941e-1, 8.92632e-3,
        7.08416e-2, 9.63172e-1, 1.35775e-3,
        2.31082e-2, 1.28021e-1, 9.36245e-1
    };

    float3x3 LMS_2_LIN_MAT = {
        2.85847e+0, -1.62879e+0, -2.48910e-2,
        -2.10182e-1,  1.15820e+0,  3.24281e-4,
        -4.18120e-2, -1.18169e-1,  1.06867e+0
    };

    float3 lms = mul(LIN_2_LMS_MAT, In);
    lms *= balance;
    Out = mul(LMS_2_LIN_MAT, lms);
}

Artistic/Blend/Blend

使用 Mode 参数定义的混合模式将输入 Blend 的值混合到输入 Base 上。指混合的强度由输入 Opacity 定义。Opacity 值为 0 将原封不动返回输入 Base。

Burn

void Unity_Blend_Burn_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out =  1.0 - (1.0 - Blend)/Base;
    Out = lerp(Base, Out, Opacity);
}

Darken

void Unity_Blend_Darken_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = min(Blend, Base);
    Out = lerp(Base, Out, Opacity);
}

Difference

void Unity_Blend_Difference_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = abs(Blend - Base);
    Out = lerp(Base, Out, Opacity);
}

Dodge

void Unity_Blend_Dodge_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Base / (1.0 - Blend);
    Out = lerp(Base, Out, Opacity);
}

Divide

void Unity_Blend_Divide_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Base / (Blend + 0.000000000001);
    Out = lerp(Base, Out, Opacity);
}

Exclusion

void Unity_Blend_Exclusion_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Blend + Base - (2.0 * Blend * Base);
    Out = lerp(Base, Out, Opacity);
}

HardLight

void Unity_Blend_HardLight_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    float4 result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend);
    float4 result2 = 2.0 * Base * Blend;
    float4 zeroOrOne = step(Blend, 0.5);
    Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
    Out = lerp(Base, Out, Opacity);
}

HardMix

void Unity_Blend_HardMix_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = step(1 - Base, Blend);
    Out = lerp(Base, Out, Opacity);
}

Lighten

void Unity_Blend_Lighten_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = max(Blend, Base);
    Out = lerp(Base, Out, Opacity);
}

LinearBurn

void Unity_Blend_LinearBurn_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Base + Blend - 1.0;
    Out = lerp(Base, Out, Opacity);
}

LinearDodge

void Unity_Blend_LinearDodge_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Base + Blend;
    Out = lerp(Base, Out, Opacity);
}

LinearLight

void Unity_Blend_LinearLight_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Blend < 0.5 ? max(Base + (2 * Blend) - 1, 0) : min(Base + 2 * (Blend - 0.5), 1);
    Out = lerp(Base, Out, Opacity);
}

LinearLightAddSub

void Unity_Blend_LinearLightAddSub_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Blend + 2.0 * Base - 1.0;
    Out = lerp(Base, Out, Opacity);
}

Multiply

void Unity_Blend_Multiply_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Base * Blend;
    Out = lerp(Base, Out, Opacity);
}

Negation

void Unity_Blend_Negation_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = 1.0 - abs(1.0 - Blend - Base);
    Out = lerp(Base, Out, Opacity);
}

Overlay

void Unity_Blend_Overlay_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    float4 result1 = 1.0 - 2.0 * (1.0 - Base) * (1.0 - Blend);
    float4 result2 = 2.0 * Base * Blend;
    float4 zeroOrOne = step(Base, 0.5);
    Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
    Out = lerp(Base, Out, Opacity);
}

PinLight

void Unity_Blend_PinLight_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    float4 check = step (0.5, Blend);
    float4 result1 = check * max(2.0 * (Base - 0.5), Blend);
    Out = result1 + (1.0 - check) * min(2.0 * Base, Blend);
    Out = lerp(Base, Out, Opacity);
}

Screen

void Unity_Blend_Screen_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = 1.0 - (1.0 - Blend) * (1.0 - Base);
    Out = lerp(Base, Out, Opacity);
}

SoftLight

void Unity_Blend_SoftLight_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    float4 result1 = 2.0 * Base * Blend + Base * Base * (1.0 - 2.0 * Blend);
    float4 result2 = sqrt(Base) * (2.0 * Blend - 1.0) + 2.0 * Base * (1.0 - Blend);
    float4 zeroOrOne = step(0.5, Blend);
    Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
    Out = lerp(Base, Out, Opacity);
}

Subtract

void Unity_Blend_Subtract_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = Base - Blend;
    Out = lerp(Base, Out, Opacity);
}

VividLight

void Unity_Blend_VividLight_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    float4 result1 = 1.0 - (1.0 - Blend) / (2.0 * Base);
    float4 result2 = Blend / (2.0 * (1.0 - Base));
    float4 zeroOrOne = step(0.5, Base);
    Out = result2 * zeroOrOne + (1 - zeroOrOne) * result1;
    Out = lerp(Base, Out, Opacity);
}

Overwrite

void Unity_Blend_Overwrite_float4(float4 Base, float4 Blend, float Opacity, out float4 Out)
{
    Out = lerp(Base, Blend, Opacity);
}

Artistic/Filter/Dither

抖动 (Dither) 是特意用于将量化误差随机化的噪声形式。用于防止大尺寸图案，例如图像中的色带。Dither 节点在屏幕空间中应用抖动来确保图案均匀分布。这可通过将另一个节点连接到输入 Screen Position 进行调整。

此节点通常用作主节点 上 Alpha Clip Threshold 的输入，以便为不透明对象提供透明外观。这对于创建看似透明但具有不透明渲染优势（例如写入深度和/或延迟渲染）的对象非常有用。

void Unity_Dither_float4(float4 In, float4 ScreenPosition, out float4 Out)
{
    float2 uv = ScreenPosition.xy * _ScreenParams.xy;
    float DITHER_THRESHOLDS[16] =
    {
        1.0 / 17.0,  9.0 / 17.0,  3.0 / 17.0, 11.0 / 17.0,
        13.0 / 17.0,  5.0 / 17.0, 15.0 / 17.0,  7.0 / 17.0,
        4.0 / 17.0, 12.0 / 17.0,  2.0 / 17.0, 10.0 / 17.0,
        16.0 / 17.0,  8.0 / 17.0, 14.0 / 17.0,  6.0 / 17.0
    };
    uint index = (uint(uv.x) % 4) * 4 + uint(uv.y) % 4;
    Out = In - DITHER_THRESHOLDS[index];
}

Artistic/Mask/Channel Mask

在下拉选单 Channels 中选择的通道上屏蔽输入 In 的值。输出一个与输入矢量长度相同但所选通道设置为 0 的矢量。下拉选单 Channels 中可用的通道将表示输入 In 中存在的通道数量。

void Unity_ChannelMask_RedGreen_float4(float4 In, out float4 Out)
{
    Out = float4(0, 0, In.b, In.a);
}

Artistic/Mask/Color Mask

根据输入 In 中的等于输入 Mask Color 的值创建遮罩。输入 Range 可用于在输入 Mask Color 周围定义更宽范围的值以便创建遮罩。此范围内的颜色将返回 1，否则节点将返回 0。输入 Fuzziness 可用于软化选择范围周围的边缘，类似于抗锯齿效果。

void Unity_ColorMask_float(float3 In, float3 MaskColor, float Range, float Fuzziness, out float4 Out)
{
    float Distance = distance(MaskColor, In);
    Out = saturate(1 - (Distance - Range) / max(Fuzziness, 1e-5));
}

Artistic/Normal/Normal Blend

将输入 A 和 B 定义的两个法线贴图混合到一起，并对结果进行标准化以创建有效的法线贴图。

Default

void Unity_NormalBlend_float(float3 A, float3 B, out float3 Out)
{
    Out = normalize(float3(A.rg + B.rg, A.b * B.b));
}

Reoriented

void Unity_NormalBlend_Reoriented_float(float3 A, float3 B, out float3 Out)
{
    float3 t = A.xyz + float3(0.0, 0.0, 1.0);
    float3 u = B.xyz * float3(-1.0, -1.0, 1.0);
    Out = (t / t.z) * dot(t, u) - u;
}

Artistic/Normal/Normal From Height

根据输入值 Input 定义的高度值以及输入值 Strength 定义的强度来创建法线贴图。

Tangent

void Unity_NormalFromHeight_Tangent_float(float In, float Strength, float3 Position, float3x3 TangentMatrix, out float3 Out)
{
    float3 worldDerivativeX = ddx(Position);
    float3 worldDerivativeY = ddy(Position);

    float3 crossX = cross(TangentMatrix[2].xyz, worldDerivativeX);
    float3 crossY = cross(worldDerivativeY, TangentMatrix[2].xyz);
    float d = dot(worldDerivativeX, crossY);
    float sgn = d < 0.0 ?(-1.f) : 1.f;
    float surface = sgn / max(0.00000000000001192093f, abs(d));

    float dHdx = ddx(In);
    float dHdy = ddy(In);
    float3 surfGrad = surface * (dHdx*crossY + dHdy*crossX);
    Out = normalize(TangentMatrix[2].xyz - (Strength * surfGrad));
    Out = TransformWorldToTangent(Out, TangentMatrix);
}

World

void Unity_NormalFromHeight_World_float(float In, float Strength, float3 Position, float3x3 TangentMatrix, out float3 Out)
{
    float3 worldDerivativeX = ddx(Position);
    float3 worldDerivativeY = ddy(Position);

    float3 crossX = cross(TangentMatrix[2].xyz, worldDerivativeX);
    float3 crossY = cross(worldDerivativeY, TangentMatrix[2].xyz);
    float d = dot(worldDerivativeX, crossY);
    float sgn = d < 0.0 ?(-1.f) : 1.f;
    float surface = sgn / max(0.00000000000001192093f, abs(d));

    float dHdx = ddx(In);
    float dHdy = ddy(In);
    float3 surfGrad = surface * (dHdx*crossY + dHdy*crossX);
    Out = normalize(TangentMatrix[2].xyz - (Strength * surfGrad));
}

Artistic/Normal/Normal From Texture

将输入 Texture 定义的高度贴图转换为法线贴图。UV 值和采样器状态可分别由输入 UV 和 Sampler 定义。如果这些端口未进行任何连接，它们将使用输入中的默认值。请参阅端口绑定以了解更多信息。

可以使用输入 Offset 和 Strength 来定义所创建的法线贴图的强度，其中 Offset 定义法线细节的最大距离，而 Strength 用作结果的乘数。

void Unity_NormalFromTexture_float(Texture texture, SamplerState Sampler, float2 UV, float Offset, float Strength, out float3 Out)
{
    Offset = pow(Offset, 3) * 0.1;
    float2 offsetU = float2(UV.x + Offset, UV.y);
    float2 offsetV = float2(UV.x, UV.y + Offset);
    float normalSample = Texture.Sample(Sampler, UV);
    float uSample = Texture.Sample(Sampler, offsetU);
    float vSample = Texture.Sample(Sampler, offsetV);
    float3 va = float3(1, 0, (uSample - normalSample) * Strength);
    float3 vb = float3(0, 1, (vSample - normalSample) * Strength);
    Out = normalize(cross(va, vb));
}

Artistic/Normal/Normal Reconstruct Z

使用输入 In 中的给定 X 和 Y 值为生成的法线贴图导出正确的 Z 值。

void Unity_NormalReconstructZ_float(float2 In, out float3 Out)
{
    float reconstructZ = sqrt(1.0 - saturate(dot(In.xy, In.xy)));
    float3 normalVector = float3(In.x, In.y, reconstructZ);
    Out = normalize(normalVector);
}

Artistic/Normal/Normal Strength

根据输入 Strength 的大小调整输入 In 定义的法线贴图的强度。Strength 值为 1 将原封不动返回输入值。Strength 值为 0 将返回空白法线贴图。

void Unity_NormalStrength_float(float3 In, float Strength, out float3 Out)
{
    Out = {precision}3(In.rg * Strength, lerp(1, In.b, saturate(Strength)));
}

Artistic/Normal/Normal Unpack

解压缩由输入 In 定义的法线贴图。针对在纹理导入设置 (Texture Import Settings) 中定义为法线贴图 (Normal Map) 的纹理，此节点可以在采样该纹理时对其进行解压缩，就像是默认纹理一样。

请注意，在大多数情况下，此节点是不必要的，因为当使用 Sample Texture 2D 或 Triplanar 节点对法线贴图进行采样时，应该通过将其 Type 参数设置为 Normal 对法线贴图进行这样的采样。

Tangent

void Unity_NormalUnpack_float(float4 In, out float3 Out)
{
    Out = UnpackNormalmapRGorAG(In);
}

Object

void Unity_NormalUnpackRGB_float(float4 In, out float3 Out)
{
    Out = UnpackNormalmapRGB(In);
}

Artistic/Utility/Colorspace Conversion

返回将输入 In 的值从一个颜色空间转换为另一个颜色空间的结果。转换的起始和目标颜色空间由节点上的下拉选单的值定义。

RGB > RGB

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    Out =  In;
}

RGB > Linear

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    float3 linearRGBLo = In / 12.92;;
    float3 linearRGBHi = pow(max(abs((In + 0.055) / 1.055), 1.192092896e-07), float3(2.4, 2.4, 2.4));
    Out = float3(In <= 0.04045) ? linearRGBLo : linearRGBHi;
}

RGB > HSV

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
    float4 P = lerp(float4(In.bg, K.wz), float4(In.gb, K.xy), step(In.b, In.g));
    float4 Q = lerp(float4(P.xyw, In.r), float4(In.r, P.yzx), step(P.x, In.r));
    float D = Q.x - min(Q.w, Q.y);
    float  E = 1e-10;
    Out = float3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);
}

Linear > RGB

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    float3 sRGBLo = In * 12.92;
    float3 sRGBHi = (pow(max(abs(In), 1.192092896e-07), float3(1.0 / 2.4, 1.0 / 2.4, 1.0 / 2.4)) * 1.055) - 0.055;
    Out = float3(In <= 0.0031308) ? sRGBLo : sRGBHi;
}

Linear > Linear

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    Out = In;
}

Linear > HSV

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    float3 sRGBLo = In * 12.92;
    float3 sRGBHi = (pow(max(abs(In), 1.192092896e-07), float3(1.0 / 2.4, 1.0 / 2.4, 1.0 / 2.4)) * 1.055) - 0.055;
    float3 Linear = float3(In <= 0.0031308) ? sRGBLo : sRGBHi;
    float4 K = float4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
    float4 P = lerp(float4(Linear.bg, K.wz), float4(Linear.gb, K.xy), step(Linear.b, Linear.g));
    float4 Q = lerp(float4(P.xyw, Linear.r), float4(Linear.r, P.yzx), step(P.x, Linear.r));
    float D = Q.x - min(Q.w, Q.y);
    float  E = 1e-10;
    Out = float3(abs(Q.z + (Q.w - Q.y)/(6.0 * D + E)), D / (Q.x + E), Q.x);
}

HSV > RGB

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    float3 P = abs(frac(In.xxx + K.xyz) * 6.0 - K.www);
    Out = In.z * lerp(K.xxx, saturate(P - K.xxx), In.y);
}

HSV > Linear

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
    float3 P = abs(frac(In.xxx + K.xyz) * 6.0 - K.www);
    float3 RGB = In.z * lerp(K.xxx, saturate(P - K.xxx), In.y);
    float3 linearRGBLo = RGB / 12.92;
    float3 linearRGBHi = pow(max(abs((RGB + 0.055) / 1.055), 1.192092896e-07), float3(2.4, 2.4, 2.4));
    Out = float3(RGB <= 0.04045) ? linearRGBLo : linearRGBHi;
}

HSV > HSV

void Unity_ColorspaceConversion_RGB_RGB_float(float3 In, out float3 Out)
{
    Out = In;
}

Channel/Combine

从四个输入 R、G、B 和 A 创建新矢量。输出 RGBA 是由输入 R、G、B 和 A 组成的矢量 4。输出 RGB 是由输入 R、G 和 B 组成的矢量 3。输出 RG 是由输入 R 和 G 组成的矢量 2。

void Unity_Combine_float(float R, float G, float B, float A, out float4 RGBA, out float3 RGB, out float2 RG)
{
    RGBA = float4(R, G, B, A);
    RGB = float3(R, G, B);
    RG = float2(R, G);
}

Channel/Flip

翻转节点参数选择的输入 In 的各个通道。正值变为负值，反之亦然。

float2 _Flip_Flip = float4(Red, Green, Blue, Alpha);

void Unity_Flip_float4(float4 In, float4 Flip, out float4 Out)
{
    Out = (Flip * -2 + 1) * In;
}

Channel/Split

将输入矢量 In 分成四个 Float 输出：R、G、B 和 A。这些输出矢量由输入 In 的各个通道定义：分别是红色、绿色、蓝色和 Alpha。如果输入矢量 In 的维度小于 4（矢量 4），则输入中不存在的输出值将为 0。

float _Split_R = In[0];
float _Split_G = In[1];
float _Split_B = 0;
float _Split_A = 0;

Channel/Swizzle

通过将输入矢量的元素重新排序来创建新的矢量。这就是所谓的重排 (swizzling)。

要指定输入元素应如何重排，请在输入掩码中输入格式字符串。 例如，要是使输入元素反向排序，请使用字符串 “wzyx” 或 “abgr”。

输入掩码的长度决定了输出矢量的维度。错误 “Invalid Mask” 表示输入掩码值包含了一个或多个输入矢量中不存在的通道。

例如，要使用输入矢量的 x、y 和 z 元素输出 vector3，请使用输入掩码“xyz”或“rgb”。

float4 _Swizzle_Out = In.wzyx;

Input/Basice/Boolean

在 Shader Graph 中定义一个常量布尔值，尽管位于着色器内部，但它被视为一个常量浮点值，即 0 或 1，类似于 Shaderlab 的 Toggle 属性。可通过节点的上下文菜单转换为布尔值类型的属性。

float _Boolean = 1;

Input/Basice/Color

使用 Color 字段在着色器中定义一个常量矢量 4 值。可通过节点的上下文菜单转换为 Color 属性类型。生成属性时，也会考虑 Mode 参数的值。

注意：在 10.0 之前的版本中，Shader Graph 假定来自 Color 节点的 HDR 颜色位于伽马空间。版本 10.0 更正了此行为，现在，Shader Graph 在线性空间中解释 HDR 颜色。使用旧版本创建的 HDR Color 节点仍保持旧行为，但可以使用 Graph Inspector 将其升级。要在新的 HDR Color 节点上模仿旧行为，可以使用 Colorspace Conversion 节点将 HDR 颜色从 RGB 转换为 Linear。

float4 _Color = IsGammaSpace() ? float4(1, 2, 3, 4) : float4(SRGBToLinear(float3(1, 2, 3)), 4);

Input/Basice/Constant

在着色器中定义一个 Float 数学常量值。

PI

float _Constant_PI = 3.1415926;

TAU

float _Constant_TAU = 6.28318530;

PHI

float _Constant_PHI = 1.618034;

E

float _Constant_E = 2.718282;

SQRT2

float _Constant_SQRT2 = 1.414214;

Input/Basice/Integer

使用 Integer 字段在着色器中定义一个常量 Float 值。可在 Mode 设置为 Integer 的情况下通过节点的上下文菜单转换为 Float 类型的属性。

float _Integer = 1;

Input/Basice/Slider

使用 Slider 字段在着色器中定义一个常量 Float 值。可在 Mode 设置为 Slider 的情况下通过节点的上下文菜单转换为 Float 类型的属性。

float _Slider_Out = 1.0;

Input/Basice/Time

允许访问着色器中的各种 Time 参数。

float Time_Time = _Time.y;
float Time_SineTime = _SinTime.w;
float Time_CosineTime = _CosTime.w;
float Time_DeltaTime = unity_DeltaTime.x;
float Time_SmoothDelta = unity_DeltaTime.z;

Input/Basice/Float

在着色器中定义一个 Float 值。如果未使用边连接端口 X，此节点定义一个常量 Float。

float _Vector1_Out = X;

Input/Basice/Vector 2

在着色器中定义矢量 2 值。如果未使用边连接端口 X 和 Y，此节点定义一个常量矢量 2，否则此节点可用于组合各种 Float 值。

float2 _Vector2_Out = float2(X, Y);

Input/Basice/Vector 3

在着色器中定义矢量 3 值。如果未使用边连接端口 X、Y 和 Z，此节点定义一个常量矢量 3，否则此节点可用于组合各种 Float 值。

float3 _Vector3_Out = float3(X, Y, Z);

Input/Basice/Vector 4

在着色器中定义矢量 4 值。如果未使用边连接端口 X、Y、Z 和 W，此节点定义一个常量矢量 4，否则此节点可用于组合各种 Float 值。

float4 _Vector4_Out = float4(X, Y, Z, W);

Input/Geometry/Bitangent Vector

允许访问网格顶点或片元的副切线矢量 (Bitangent Vector)，具体取决于节点所属图形部分的有效着色器阶段。可使用 Space 下拉选单参数选择输出值的坐标空间。

Input/Geometry/Normal Vector

允许访问网格顶点或片元的法线矢量。可使用 Space 下拉选单参数选择输出值的坐标空间。

Input/Geometry/Position

允许访问网格顶点或片元的位置，具体取决于节点所属图形部分的有效着色器阶段。可使用 Space 下拉选单参数选择输出值的坐标空间。

Input/Geometry/Screen Position

允许访问网格顶点或片元的屏幕位置。可使用 Mode 下拉选单参数选择输出值的模式。

Default

返回屏幕位置。此模式将屏幕位置除以裁剪空间位置 W 分量。

Raw

返回屏幕位置。此模式不会将屏幕位置除以裁剪空间位置 W 分量。这对投影很有用。

Center

返回屏幕位置偏移，因此位置 float2(0,0) 位于屏幕的中心。

Tiled

返回屏幕位置偏移，因此位置 float2(0,0) 位于屏幕的中心，并使用 frac 平铺。

Input/Geometry/Tangent Vector

允许访问网格顶点或片元的切线矢量。可使用 Space 下拉选单参数选择输出值的坐标空间。

Input/Geometry/UV

允许访问网格顶点或片元的 UV 坐标。可使用 Channel 下拉选单参数选择输出值的坐标通道。

Input/Geometry/Vertex Color

允许访问网格顶点或片元的顶点颜色值。

Input/Geometry/View Direction

允许访问网格顶点或片元的视图方向矢量。这是从顶点或片元到摄像机的矢量。可使用 Space 下拉选单参数选择输出值的坐标空间。

Input/Gradient/Blackbody

对模拟黑体辐射的渐变进行采样。 此节点中的计算基于 Mitchell Charity 收集的数据。 此节点输出线性 RGB 空间的颜色，并使用一个 D65 白点和一个 CIE 1964 10 度的颜色空间执行转换。

void Unity_Blackbody_float(float Temperature, out float3 Out)
{
    float3 color = float3(255.0, 255.0, 255.0);
    color.x = 56100000. * pow(Temperature,(-3.0 / 2.0)) + 148.0;
    color.y = 100.04 * log(Temperature) - 623.6;
    if (Temperature > 6500.0) color.y = 35200000.0 * pow(Temperature,(-3.0 / 2.0)) + 184.0;
    color.z = 194.18 * log(Temperature) - 1448.6;
    color = clamp(color, 0.0, 255.0)/255.0;
    if (Temperature < 1000.0) color *= Temperature/1000.0;
    Out = color;
}

Input/Gradient/Gradient

定义用于 Shader Graph 中的常量渐变 (Gradient)，但这在着色器内部定义为结构。要对渐变采样，必须将其与 Sample Gradient 节点结合使用。使用单个 Gradient 节点时，可使用不同的 Time 参数对渐变进行多次采样。

Gradient Unity_Gradient_float()
{
    Gradient g;
    g.type = 1;
    g.colorsLength = 4;
    g.alphasLength = 4;
    g.colors[0] = 0.1;
    g.colors[1] = 0.2;
    g.colors[2] = 0.3;
    g.colors[3] = 0.4;
    g.colors[4] = 0;
    g.colors[5] = 0;
    g.colors[6] = 0;
    g.colors[7] = 0;
    g.alphas[0] = 0.1;
    g.alphas[1] = 0.2;
    g.alphas[2] = 0.3;
    g.alphas[3] = 0.4;
    g.alphas[4] = 0;
    g.alphas[5] = 0;
    g.alphas[6] = 0;
    g.alphas[7] = 0;
    return g;
}

Gradient _Gradient = Unity_Gradient_float();

Input/Gradient/Sample Gradient

根据给定的 Time 输入对渐变进行采样。返回矢量 4 颜色值以便在着色器中使用。

void Unity_SampleGradient_float(float4 Gradient, float Time, out float4 Out)
{
    float3 color = Gradient.colors[0].rgb;
    [unroll]
    for (int c = 1; c < 8; c++)
    {
        float colorPos = saturate((Time - Gradient.colors[c-1].w) / (Gradient.colors[c].w - Gradient.colors[c-1].w)) * step(c, Gradient.colorsLength-1);
        color = lerp(color, Gradient.colors[c].rgb, lerp(colorPos, step(0.01, colorPos), Gradient.type));
    }
# ifndef UNITY_COLORSPACE_GAMMA
    color = SRGBToLinear(color);
# endif
    float alpha = Gradient.alphas[0].x;
    [unroll]
    for (int a = 1; a < 8; a++)
    {
        float alphaPos = saturate((Time - Gradient.alphas[a-1].y) / (Gradient.alphas[a].y - Gradient.alphas[a-1].y)) * step(a, Gradient.alphasLength-1);
        alpha = lerp(alpha, Gradient.alphas[a].x, lerp(alphaPos, step(0.01, alphaPos), Gradient.type));
    }
    Out = float4(color, alpha);
}

Input/High Definition Render Pipeline/Diffusion Profile

扩散配置文件节点 (Diffusion Profile Node) 允许在 Shader Graph 中采样扩散配置文件资源。

该节点的输出是一个表示扩散配置文件的浮点值。着色器可以使用该值查找该值表示的扩散配置文件资源的设置。

如果修改输出值，则着色器将无法再使用该值来查找扩散配置文件资源的设置。您可以使用此行为在 Shader Graph 中启用和禁用扩散配置文件。要禁用某个扩散配置文件，请将输出乘以 0。要启用某个扩散配置文件，请将输出乘以 1。这使您可以在 Shader Graph 的不同部分中使用多个扩散配置文件。请注意，高清渲染管线 (HDRP) 不支持扩散配置文件之间的混合。这是因为 HDRP 只能评估每个像素的一个扩散配置文件。

Input/High Definition Render Pipeline/Exposure

曝光节点 (Exposure Node) 允许从当前帧或上一帧获取摄像机的曝光值。

Input/High Definition Render Pipeline/HD Scene Color

高清场景颜色节点 (HD Scene Color Node) 的功能与场景颜色节点 (Scene Color Node) 相同，但允许访问颜色缓冲区的 Mip。

可以使用 Exposure 属性指定是否要在应用了曝光的情况下输出摄像机颜色。默认情况下会禁用此属性以避免双重曝光。

该节点用于对颜色缓冲区进行采样的采样器处于三线性钳位模式 (trilinear clamp mode)。因此，采样器可以在 Mipmap 之间进行平滑插值。

Input/Lighting/Ambient

提供对场景环境光颜色值的访问。当环境光源设置为“渐变端口颜色/Sky”时，返回值“Sky Color”。当环境光源设置为“颜色端口颜色/天空”时，返回值“环境光颜色”。无论当前环境光源如何，端口赤道和地面始终返回赤道颜色和地面颜色的值。

注意：此节点的值仅在进入播放模式或保存当前场景/项目时更新。 注意：此节点的行为未全局定义。着色器图形不定义节点的功能。相反，每个渲染管道定义要为此节点执行的HLSL代码。 不同的渲染管道可能会产生不同的结果。如果要在一个渲染管道中构建要在两个渲染管道中使用的着色器，请在生成之前尝试在两个管道中检查该着色器。节点可能在一个渲染管道中定义，而在另一个渲染管道中未定义。如果此节点未定义，则返回0（黑色）。

float3 _Ambient_ColorSky = SHADERGRAPH_AMBIENT_SKY;
float3 _Ambient_Equator = SHADERGRAPH_AMBIENT_EQUATOR;
float3 _Ambient_Ground = SHADERGRAPH_AMBIENT_GROUND;

Input/Lighting/Baked GI

提供对顶点或片段位置处烘焙GI值的访问。光探测器采样需要位置和正常输入，并且光照贴图为所有可能的光照贴图采样情况协调静态UV和动态UV。 注意：此节点的行为未全局定义。着色器图形不定义节点的功能。相反，每个渲染管道定义要为此节点执行的HLSL代码。 不同的渲染管道可能会产生不同的结果。如果要在一个渲染管道中构建要在两个渲染管道中使用的着色器，请在生成之前尝试在两个管道中检查该着色器。节点可能在一个渲染管道中定义，而在另一个渲染管道中未定义。如果此节点未定义，则返回0（黑色）。

void Unity_BakedGI_float(float3 Position, float3 Normal, float2 StaticUV, float2 DynamicUV, out float Out)
{
    Out = SHADERGRAPH_BAKED_GI(Position, Normal, StaticUV, DynamicUV, false);
}

Input/Lighting/Reflection Probe

提供对距离对象最近的反射探测器的访问。需要法线和视图方向才能对探头进行采样。通过使用LOD输入在不同的细节级别进行采样，可以实现模糊效果。 注意：此节点的行为未全局定义。着色器图形不定义节点的功能。相反，每个渲染管道定义要为此节点执行的HLSL代码。 不同的渲染管道可能会产生不同的结果。如果要在一个渲染管道中构建要在两个渲染管道中使用的着色器，请在生成之前尝试在两个管道中检查该着色器。节点可能在一个渲染管道中定义，而在另一个渲染管道中未定义。如果此节点未定义，则返回0（黑色）。

void Unity_ReflectionProbe_float(float3 ViewDir, float3 Normal, float LOD, out float3 Out)
{
    Out = SHADERGRAPH_REFLECTION_PROBE(ViewDir, Normal, LOD);
}

Input/Matrix/Matrix 2x2

在着色器中定义一个常量矩阵 2x2 值。

float2x2 _Matrix2x2 = float2x2(1, 0, 0, 1);

Input/Matrix/Matrix 3x3

在着色器中定义一个常量矩阵 3x3 值。

float3x3 _Matrix3x3 = float3x3(1, 0, 0, 0, 1, 0, 0, 0, 1);

Input/Matrix/Matrix 4x4

在着色器中定义一个常量矩阵 4x4 值。

float4x4 _Matrix4x4 = float4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1);

Input/Matrix/Transformation Matrix

在着色器中定义通用变换矩阵的常量矩阵 4x4 值。可从下拉选单参数中选择变换矩阵。

Model

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_M;

InverseModel

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_I_M;

View

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_V;

InverseView

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_I_V;

Projection

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_P;

InverseProjection

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_I_P;

ViewProjection

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_VP;

InverseViewProjection

float4x4 _TransformationMatrix_Out = UNITY_MATRIX_I_VP;

Input/Mesh Deformation/Compute Deformation

此节点用于将计算变形的顶点数据传递给顶点着色器，并且仅适用于DOTS Hybrid Renderer。您必须在 _DeformedMeshData 缓冲区中提供 DeformedVertexData。该节点使用 _ComputeMeshIndex 属性来计算与当前网格关联的 DeformedVertexData 在 _DeformedMeshData 缓冲区中的位置。要输出数据，必须同时安装 DOTS Hybrid Renderer 和 DOTS Animation 包，或者使用自定义解决方案。

Input/Mesh Deformation/Linear Blend Skinning

此节点用于应用线性混合顶点蒙皮，并且仅适用于 DOTS Hybrid Renderer。您必须在 _SkinMatrices 缓冲器提供蒙皮矩阵。该节点使用 _SkinMatrixIndex 属性来计算与当前网格关联的矩阵在 _SkinMatrices 缓冲区中的位置。

Input/PBR/Dielectric Specular

返回物理材质的介电镜面反射 (Dielectric Specular) F0 值。可使用节点上的 Material 下拉选单参数选择要使用的材质。

Common 材质类型定义了 0.034 到 0.048 的 sRGB 值范围。可使用 Range 参数选择这一范围内的值。此材质类型应当用于诸如塑料和织物之类的各种材质。

您可以使用 Custom 材料类型来定义自己的物理材质值。在这种情况下，输出值由其折射率定义。此值可由 IOR 参数设置。

Common

float _DielectricSpecular_Range = 0.5;
float _DielectricSpecular_Out = lerp(0.034, 0.048, _DielectricSpecular_Range);

RustedMetal

float _DielectricSpecular_Out = 0.030;

Water

float _DielectricSpecular_Out = 0.020;

Ice

float _DielectricSpecular_Out = 0.018;

Glass

float _DielectricSpecular_Out = 0.040;

Custom

float _DielectricSpecular_IOR = 1;
float _DielectricSpecular_Out = pow(_Node_IOR - 1, 2) / pow(_DielectricSpecular_IOR + 1, 2);

Input/PBR/Metal Reflectance

返回物理材质的金属反射 (Metal Reflectance) 值。可使用节点上的 Material 下拉选单参数选择要使用的材质。

在 PBR 主节点上使用 Specular Workflow 时，应将此值提供给 Specular 端口。使用 Metallic Workflow 时，应将此值提供给 Albedo 端口。

Iron

float3 _MetalReflectance_Out = float3(0.560, 0.570, 0.580);

Silver

float3 _MetalReflectance_Out = float3(0.972, 0.960, 0.915);

Aluminium

float3 _MetalReflectance_Out = float3(0.913, 0.921, 0.925);

Gold

float3 _MetalReflectance_Out = float3(1.000, 0.766, 0.336);

Copper

float3 _MetalReflectance_Out = float3(0.955, 0.637, 0.538);

Chromium

float3 _MetalReflectance_Out = float3(0.550, 0.556, 0.554);

Nickel

float3 _MetalReflectance_Out = float3(0.660, 0.609, 0.526);

Titanium

float3 _MetalReflectance_Out = float3(0.542, 0.497, 0.449);

Cobalt

float3 _MetalReflectance_Out = float3(0.662, 0.655, 0.634);

Platinum

float3 _MetalReflectance_Out = float3(0.672, 0.637, 0.585);

Input/Scene/Camera

允许访问当前用于渲染的摄像机 (Camera) 的各种参数。这包含摄像机游戏对象的值，例如 Position 和 Direction，以及各种投影参数。

float3 _Camera_Position = _WorldSpaceCameraPos;
float3 _Camera_Direction = -1 * mul(UNITY_MATRIX_M, transpose(mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V)) [2].xyz);
float _Camera_Orthographic = unity_OrthoParams.w;
float _Camera_NearPlane = _ProjectionParams.y;
float _Camera_FarPlane = _ProjectionParams.z;
float _Camera_ZBufferSign = _ProjectionParams.x;
float _Camera_Width = unity_OrthoParams.x;
float _Camera_Height = unity_OrthoParams.y;

Input/Scene/Fog

允许访问场景的 Fog 参数。

注意：此节点的行为未在全局范围内定义。Shader Graph 未定义此节点的函数。但每个渲染管线都为此节点定义了要执行的 HLSL 代码。

不同的渲染管线可能会产生不同的结果。如果要在一个渲染管线中构建希望在两个渲染管线中使用的着色器，请在实际应用之前尝试在这两个管线中对其进行检查。节点可能在一个渲染管线中已定义，而在另一个渲染管线中未定义。如果此节点未定义，则会返回 0（黑色）。

void Unity_Fog_float(float3 Position, out float4 Color, out float Density)
{
    SHADERGRAPH_FOG(Position, Color, Density);
}

Input/Scene/Object

允许访问当前渲染对象的各种参数。

注意：可以根据渲染管线定义位置端口的行为。不同的渲染管线可能会产生不同的结果。如果要在一个渲染管线中构建希望在两个渲染管线中使用的着色器，请在实际应用之前尝试在这两个管线中对其进行检查。

float3 _Object_Position = SHADERGRAPH_OBJECT_POSITION;
float3 _Object_Scale = float3(length(float3(UNITY_MATRIX_M[0].x, UNITY_MATRIX_M[1].x, UNITY_MATRIX_M[2].x)),
length(float3(UNITY_MATRIX_M[0].y, UNITY_MATRIX_M[1].y, UNITY_MATRIX_M[2].y)),
length(float3(UNITY_MATRIX_M[0].z, UNITY_MATRIX_M[1].z, UNITY_MATRIX_M[2].z)));

Input/Scene/Scene Color

允许使用输入 UV（应该是标准化的屏幕坐标）访问当前摄像机的颜色缓冲区。

注意：此节点的行为未在全局范围内定义。此节点执行的 HLSL 代码是根据渲染管线定义的，不同的渲染管线可能会产生不同的结果。希望支持此节点的自定义渲染管线也需要显式定义其行为。如果未定义，此节点将返回 0（黑色）。

注意：在通用渲染管线中，此节点返回 Camera Opaque Texture 的值。请参阅通用渲染管线以了解此功能的更多文档信息。此纹理的内容仅适用于透明对象。将主节点的 Material Options 面板上的 Surface Type 下拉选单设置为 Transparent 可以从此节点接收正确的值。

注意：此节点只能在片元着色器阶段中使用。

void Unity_SceneColor_float(float4 UV, out float3 Out)
{
    Out = SHADERGRAPH_SAMPLE_SCENE_COLOR(UV);
}

Input/Scene/Scene Depth

允许使用输入 UV（应该是标准化的屏幕坐标）访问当前摄像机的深度缓冲区。

注意：若要访问深度缓冲区，需要在活动的渲染管线上启用深度缓冲区。此过程根据渲染管线而不同。建议阅读关于活动渲染管线的文档，了解有关启用深度缓冲区的信息。如果深度缓冲区不可用，则此节点将返回中灰色。

注意：此节点执行的 HLSL 代码是根据渲染管线定义的，不同的渲染管线可能会产生不同的结果。希望支持此节点的自定义渲染管线也需要显式定义其行为。如果未定义，此节点将返回 1（白色）。

注意：此节点只能在片元着色器阶段中使用。

void Unity_SceneDepth_Raw_float(float4 UV, out float Out)
{
    Out = SHADERGRAPH_SAMPLE_SCENE_DEPTH(UV);
}

Input/Scene/Screen

允许访问屏幕的参数。

float _Screen_Width = _ScreenParams.x;
float _Screen_Height = _ScreenParams.y;

Input/Texture/Cubemap Asset

定义要在着色器中使用的常量立方体贴图资源。要对立方体贴图资源采样，必须将其与 Sample Cubemap 节点结合使用。使用单个 Cubemap Asset 节点时，可使用不同的参数对立方体贴图进行两次采样，无需对立方体贴图本身进行两次定义。

Input/Texture/Sample Cubemap

对立方体贴图进行采样并返回矢量 4 颜色值以在着色器中使用。在世界空间中需要一个 Direction (Dir) 输入才能对立方体贴图进行采样。可以使用 LOD 输入在不同的细节级别进行采样，从而获得模糊效果。还可以使用 Sampler 输入来定义一个自定义采样器状态。

如果在包含自定义函数节点或子图形的图形中使用此节点时遇到纹理采样错误，可以通过升级到 10.3 或更高版本来解决这些问题。

如果在包含自定义函数节点或子图形的图形中使用此节点时遇到纹理采样错误，可以通过升级到 10.3 或更高版本来解决这些问题。

float4 _SampleCubemap_Out = SAMPLE_TEXTURECUBE_LOD(Cubemap, Sampler, Dir, LOD);

Input/Texture/Sample Reflected Cubemap

使用反射矢量对立方体贴图进行采样，并返回一个矢量 4 颜色值以在着色器中使用。需要 View Direction (View Dir) 和 Normal 输入才能采样立方体贴图。可以使用 LOD 输入在不同的细节级别进行采样，从而获得模糊效果。还可以使用 Sampler 输入来定义一个自定义采样器状态。

如果在包含自定义函数节点或子图形的图形中使用此节点时遇到纹理采样错误，可以通过升级到 10.3 或更高版本来解决这些问题。

float4 _SampleCubemap_Out = SAMPLE_TEXTURECUBE_LOD(Cubemap, Sampler, reflect(-ViewDir, Normal), LOD);

Input/Texture/Sample Texture 2D

对 2D 纹理进行采样并返回矢量 4 颜色值以在着色器中使用。可使用 UV 输入覆盖 UV 坐标，并使用 Sampler 输入自定义采样器状态。

要使用 Sample Texture 2D 节点对法线贴图进行采样，请将 Type 下拉选单参数设置为 Normal。

注意：此节点只能在片元着色器阶段中使用。要在顶点着色器阶段中对 2D 纹理进行采样，请改用 Sample Texture 2D LOD 节点。

Default

float4 _SampleTexture2D_RGBA = SAMPLE_TEXTURE2D(Texture, Sampler, UV);
float _SampleTexture2D_R = _SampleTexture2D_RGBA.r;
float _SampleTexture2D_G = _SampleTexture2D_RGBA.g;
float _SampleTexture2D_B = _SampleTexture2D_RGBA.b;
float _SampleTexture2D_A = _SampleTexture2D_RGBA.a;

Normal

float4 _SampleTexture2D_RGBA = SAMPLE_TEXTURE2D(Texture, Sampler, UV);
_SampleTexture2D_RGBA.rgb = UnpackNormalRGorAG(_SampleTexture2D_RGBA);
float _SampleTexture2D_R = _SampleTexture2D_RGBA.r;
float _SampleTexture2D_G = _SampleTexture2D_RGBA.g;
float _SampleTexture2D_B = _SampleTexture2D_RGBA.b;
float _SampleTexture2D_A = _SampleTexture2D_RGBA.a;

Input/Texture/Sample Texture 2D Array

对 2D 纹理数组进行采样并返回矢量 4 颜色值以在着色器中使用。可使用 UV 输入覆盖 UV 坐标，并使用 Sampler 输入自定义采样器状态。使用 Index 输入指定要采样的数组的索引。

如果在包含自定义函数节点或子图形的图形中使用此节点时遇到纹理采样错误，可以通过升级到 10.3 或更高版本来解决这些问题。

注意：此节点只能在片元着色器阶段中使用。

float4 _SampleTexture2DArray_RGBA = SAMPLE_TEXTURE2D_ARRAY(Texture, Sampler, UV, Index);
float _SampleTexture2DArray_R = _SampleTexture2DArray_RGBA.r;
float _SampleTexture2DArray_G = _SampleTexture2DArray_RGBA.g;
float _SampleTexture2DArray_B = _SampleTexture2DArray_RGBA.b;
float _SampleTexture2DArray_A = _SampleTexture2DArray_RGBA.a;

Input/Texture/Sample Texture 2D LOD

对 2D 纹理进行采样并返回矢量 4 颜色值以在着色器中使用。可使用 UV 输入覆盖 UV 坐标，并使用 Sampler 输入自定义采样器状态。使用 LOD 输入调整样本的细节级别。

要使用 Sample Texture 2D LOD 节点对法线贴图进行采样，请将 Type 下拉选单参数设置为 Normal。

此节点对于在顶点着色器阶段中对纹理进行采样非常有用，因为该着色器阶段中的 Sample Texture 2D 节点不可用。

在不支持此操作的平台上，将返回不透明黑色。

Default

float4 _SampleTexture2DLOD_RGBA = SAMPLE_TEXTURE2D_LOD(Texture, Sampler, UV, LOD);
float _SampleTexture2DLOD_R = _SampleTexture2DLOD_RGBA.r;
float _SampleTexture2DLOD_G = _SampleTexture2DLOD_RGBA.g;
float _SampleTexture2DLOD_B = _SampleTexture2DLOD_RGBA.b;
float _SampleTexture2DLOD_A = _SampleTexture2DLOD_RGBA.a;

Normal

float4 _SampleTexture2DLOD_RGBA = SAMPLE_TEXTURE2D_LOD(Texture, Sampler, UV, LOD);
_SampleTexture2DLOD_RGBA.rgb = UnpackNormalRGorAG(_SampleTexture2DLOD_RGBA);
float _SampleTexture2DLOD_R = _SampleTexture2DLOD_RGBA.r;
float _SampleTexture2DLOD_G = _SampleTexture2DLOD_RGBA.g;
float _SampleTexture2DLOD_B = _SampleTexture2DLOD_RGBA.b;
float _SampleTexture2DLOD_A = _SampleTexture2DLOD_RGBA.a;

Input/Texture/Sample Texture 3D

对 3D 纹理进行采样并返回矢量 4 颜色值以在着色器中使用。可使用 UV 输入覆盖 UV 坐标，并使用 Sampler 输入自定义采样器状态。

如果在包含自定义函数节点或子图形的图形中使用此节点时遇到纹理采样错误，可以通过升级到 10.3 或更高版本来解决这些问题。

float4 _SampleTexture3D_Out = SAMPLE_TEXTURE3D(Texture, Sampler, UV);

Input/Texture/Sample Virtual Texture

对虚拟纹理进行采样，并返回矢量 4 （最多达四个）颜色值以在着色器中使用。可以使用 UV 输入来覆盖 UV 坐标。Sample Virtual Texture 节点将一个 UV 坐标作为输入，并使用该 UV 坐标对 Virtual Texture 中的所有纹理进行采样。

如果要使用 Sample Virtual Texture 节点对法线贴图进行采样，请导航到要作为法线贴图进行采样的每个图层，打开 Layer Type 下拉选单，然后选择 Normal。

默认情况下，此节点只能在片元着色器阶段中使用。有关如何使用此节点或如何配置以在顶点着色器阶段使用的更多信息，请参见Using Streaming Virtual Texturing in Shader Graph。

如果在项目中禁用虚拟纹理 (Virtual Texturing)，则此节点的工作方式与 Sample 2D Texture 节点相同，并对每个纹理执行标准的 2D 采样。

您必须将 Sample Virtual Texture 节点连接到要编译的 Shader Graph 资源的 Virtual Texture 属性。如果未将节点连接到属性，则会出现错误，指示该节点需要连接。

float4 SampleVirtualTexture(float2 uv, VTPropertyWithTextureType vtProperty, out float4 Layer0)
{
    VtInputParameters vtParams;
    vtParams.uv = uv;
    vtParams.lodOrOffset = 0.0f;
    vtParams.dx = 0.0f;
    vtParams.dy = 0.0f;
    vtParams.addressMode = VtAddressMode_Wrap;
    vtParams.filterMode = VtFilter_Anisotropic;
    vtParams.levelMode = VtLevel_Automatic;
    vtParams.uvMode = VtUvSpace_Regular;
    vtParams.sampleQuality = VtSampleQuality_High;
    #if defined(SHADER_STAGE_RAY_TRACING)
    if (vtParams.levelMode == VtLevel_Automatic || vtParams.levelMode == VtLevel_Bias)
    {
        vtParams.levelMode = VtLevel_Lod;
        vtParams.lodOrOffset = 0.0f;
    }
    #endif
    StackInfo info = PrepareVT(vtProperty.vtProperty, vtParams);
    Layer0 = SampleVTLayerWithTextureType(vtProperty, vtParams, info, 0);
    return GetResolveOutput(info);
}