shadergraph performance worries: it generates shader with branches?

Unity Engine
, , ,
1

aren’t branches slow on gpu?
surprised to find this jewel at the end of the fragment

return all(isfinite(surf.Diffuse_7)) ? half4(surf.Diffuse_7.x, surf.Diffuse_7.y, surf.Diffuse_7.z, 1.0) : float4(1.0f, 0.0f, 1.0f, 1.0f);

this is the full thing

Shader "Custom Function"
{
    Properties
    {
        [NoScaleOffset]_BaseMap("BaseMap", 2D) = "white" {}
        [NoScaleOffset]_NormalMap("NormalMap", 2D) = "white" {}
        [HDR]_SpecColor("SpecColor", Color) = (1.135301, 1.135301, 1.135301, 0)
        _Smoothness("Smoothness", Float) = 0.5
        [HDR]Color_F5CA356F("SSS", Color) = (0.7264151, 0.3387442, 0.1473389, 0)
    }

    HLSLINCLUDE
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Common.hlsl"
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Packing.hlsl"
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/NormalSurfaceGradient.hlsl"
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/UnityInstancing.hlsl"
    #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/EntityLighting.hlsl"
    #include "Packages/com.unity.shadergraph/ShaderGraphLibrary/ShaderVariables.hlsl"
    #include "Packages/com.unity.shadergraph/ShaderGraphLibrary/ShaderVariablesFunctions.hlsl"
    #include "Packages/com.unity.shadergraph/ShaderGraphLibrary/Functions.hlsl"
    #define SHADERGRAPH_PREVIEW 1

    CBUFFER_START(UnityPerMaterial)
    half4 _SpecColor;
    half _Smoothness;
    half4 Color_F5CA356F;
    CBUFFER_END
    TEXTURE2D(_BaseMap); SAMPLER(sampler_BaseMap); half4 _BaseMap_TexelSize;
    TEXTURE2D(_NormalMap); SAMPLER(sampler_NormalMap); half4 _NormalMap_TexelSize;

    struct SurfaceDescriptionInputs
    {
        float3 WorldSpaceNormal;
        float3 WorldSpaceViewDirection;
        float3 WorldSpacePosition;
    };


    // ddb8951f46b5bf7aa9aa154e10897ab5
    #include "Assets/art/shaders/CustomLighting.hlsl"

    struct SurfaceDescription
    {
        half3 Diffuse_7;
    };

    SurfaceDescription PopulateSurfaceData(SurfaceDescriptionInputs IN)
    {
        SurfaceDescription surface = (SurfaceDescription)0;
        half3 _CustomFunction_69DE6333_Diffuse_7;
        half3 _CustomFunction_69DE6333_Specular_8;
        AdditionalLights_half(half3 (0, 0, 0), 0, IN.WorldSpacePosition, IN.WorldSpaceNormal, IN.WorldSpaceViewDirection, _CustomFunction_69DE6333_Diffuse_7, _CustomFunction_69DE6333_Specular_8);
        surface.Diffuse_7 = _CustomFunction_69DE6333_Diffuse_7;
        return surface;
    }

    struct GraphVertexInput
    {
        float4 vertex : POSITION;
        float3 normal : NORMAL;
        UNITY_VERTEX_INPUT_INSTANCE_ID
    };

    GraphVertexInput PopulateVertexData(GraphVertexInput v)
    {
        return v;
    }

    ENDHLSL

    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            HLSLPROGRAM
            #pragma vertex vert
            #pragma fragment frag

            struct GraphVertexOutput
            {
                float4 position : POSITION;
                float3 WorldSpacePosition : TEXCOORD0;
            float3 WorldSpaceNormal : TEXCOORD1;
            float3 WorldSpaceViewDirection : TEXCOORD2;

            };

            GraphVertexOutput vert (GraphVertexInput v)
            {
                v = PopulateVertexData(v);

                GraphVertexOutput o;
                float3 positionWS = TransformObjectToWorld(v.vertex);
                o.position = TransformWorldToHClip(positionWS);
                float3 WorldSpacePosition = mul(UNITY_MATRIX_M,v.vertex).xyz;
            float3 WorldSpaceNormal = normalize(mul(v.normal,(float3x3)UNITY_MATRIX_I_M));
            float3 WorldSpaceViewDirection = _WorldSpaceCameraPos.xyz - mul(GetObjectToWorldMatrix(), float4(v.vertex.xyz, 1.0)).xyz;
                o.WorldSpacePosition = WorldSpacePosition;
                o.WorldSpaceNormal = WorldSpaceNormal;
                o.WorldSpaceViewDirection = WorldSpaceViewDirection;

                return o;
            }

            float4 frag (GraphVertexOutput IN ) : SV_Target
            {
                float3 WorldSpacePosition = IN.WorldSpacePosition;
            float3 WorldSpaceNormal = IN.WorldSpaceNormal;
            float3 WorldSpaceViewDirection = IN.WorldSpaceViewDirection;

                SurfaceDescriptionInputs surfaceInput = (SurfaceDescriptionInputs)0;
                surfaceInput.WorldSpaceNormal = WorldSpaceNormal;
            surfaceInput.WorldSpaceViewDirection = WorldSpaceViewDirection;
            surfaceInput.WorldSpacePosition = WorldSpacePosition;

                SurfaceDescription surf = PopulateSurfaceData(surfaceInput);
                return all(isfinite(surf.Diffuse_7)) ? half4(surf.Diffuse_7.x, surf.Diffuse_7.y, surf.Diffuse_7.z, 1.0) : float4(1.0f, 0.0f, 1.0f, 1.0f);

            }
            ENDHLSL
        }
    }
}

void MainLight_half(float3 WorldPos, out half3 Direction, out half3 Color, out half DistanceAtten, out half ShadowAtten)
{
    #if SHADERGRAPH_PREVIEW
    Direction = half3(0.5, 0.5, 0);
    Color = 1;
    DistanceAtten = 1;
    ShadowAtten = 1;
    #else
    #if SHADOWS_SCREEN
    half4 clipPos = TransformWorldToHClip(WorldPos);
    half4 shadowCoord = ComputeScreenPos(clipPos);
    #else
    half4 shadowCoord = TransformWorldToShadowCoord(WorldPos);
    #endif
    Light mainLight = GetMainLight(shadowCoord);
    Direction = mainLight.direction;
    Color = mainLight.color;
    DistanceAtten = mainLight.distanceAttenuation;
    ShadowAtten = mainLight.shadowAttenuation;
    #endif
}

void DirectSpecular_half(half3 Specular, half Smoothness, half3 Direction, half3 Color, half3 WorldNormal, half3 WorldView, out half3 Out)
{
    #if SHADERGRAPH_PREVIEW
    Out = 0;
    #else
    Smoothness = exp2(10 * Smoothness + 1);
    WorldNormal = normalize(WorldNormal);
    WorldView = SafeNormalize(WorldView);
    Out = LightingSpecular(Color, Direction, WorldNormal, WorldView, half4(Specular, 0), Smoothness);
    #endif
}

void AdditionalLights_half(half3 SpecColor, half Smoothness, half3 WorldPosition, half3 WorldNormal, half3 WorldView, out half3 Diffuse, out half3 Specular)
{
    half3 diffuseColor = 0;
    half3 specularColor = 0;

    #ifndef SHADERGRAPH_PREVIEW
    Smoothness = exp2(10 * Smoothness + 1);
    WorldNormal = normalize(WorldNormal);
    WorldView = SafeNormalize(WorldView);
    int pixelLightCount = GetAdditionalLightsCount();
    for (int i = 0; i < pixelLightCount; ++i)
    {
        Light light = GetAdditionalLight(i, WorldPosition);
        half3 attenuatedLightColor = light.color * (light.distanceAttenuation * light.shadowAttenuation);
        diffuseColor += LightingLambert(attenuatedLightColor, light.direction, WorldNormal);
        specularColor += LightingSpecular(attenuatedLightColor, light.direction, WorldNormal, WorldView, half4(SpecColor, 0), Smoothness);
    }
    #endif

    Diffuse = diffuseColor;
    Specular = specularColor;
}

6386817–711753–BENCHMARK-MC-simple with vertex colors.zip (4.16 KB)

2

This isn’t a branch, it’s a conditional move.

1 Like
3

gotcha, thanks