第4章. 行動裝置著色器最佳化：超越函數的測量與輕量化

Shader "Benchmark/Transcendental"
{
    Properties
    {
        // uGUI（CanvasRenderer）會將紋理繫結到 "_MainTex"，因此名稱固定
        [PerRendererData][MainTexture] _MainTex("Sprite Texture", 2D) = "white" {}
        [MainColor] _BaseColor("Tint", Color) = (1, 1, 1, 1)

        // Mask（UI/Mask）用的模板設定。Mask 元件會替換 Material 並寫入
        _StencilComp("Stencil Comparison", Float) = 8
        _Stencil("Stencil ID", Float) = 0
        _StencilOp("Stencil Operation", Float) = 0
        _StencilWriteMask("Stencil Write Mask", Float) = 255
        _StencilReadMask("Stencil Read Mask", Float) = 255

        _ColorMask("Color Mask", Float) = 15

        [Toggle(UNITY_UI_ALPHACLIP)] _UseUIAlphaClip("Use Alpha Clip", Float) = 0
    }

    SubShader
    {
        Tags
        {
            "Queue" = "Transparent"
            "RenderType" = "Transparent"
            "RenderPipeline" = "UniversalPipeline"
            "IgnoreProjector" = "True"
            "PreviewType" = "Plane"
            "CanUseSpriteAtlas" = "True"
        }

        Stencil
        {
            Ref [_Stencil]
            Comp [_StencilComp]
            Pass [_StencilOp]
            ReadMask [_StencilReadMask]
            WriteMask [_StencilWriteMask]
        }

        Cull Off
        ZWrite Off
        ZTest [unity_GUIZTestMode]
        Blend SrcAlpha OneMinusSrcAlpha
        ColorMask [_ColorMask]

        Pass
        {
            HLSLPROGRAM

            #pragma vertex vert
            #pragma fragment frag
            // 迴圈次數是 uniform（動態迴圈），因此需要 3.0 而非 2.0
            #pragma target 3.0

            // 支援 RectMask2D / Mask 的 Alpha Clip
            #pragma multi_compile_local _ UNITY_UI_CLIP_RECT
            #pragma multi_compile_local _ UNITY_UI_ALPHACLIP

            // 切換要測量的超越函數。因為想在執行階段以 Shader.EnableKeyword 切換，
            // 所以使用 multi_compile 而非 shader_feature（未使用的 variant 會被剔除）。
            // 每個關鍵字會成為不同的 variant，因此產生的程式碼只會出現所選的函數（沒有分支額外負擔）。
            // 由於是全域關鍵字，可從 TranscendentalBenchmark 端統一控制。
            // 若沒有任何關鍵字啟用，則使用開頭的 _FUNC_NONE variant。
            #pragma multi_compile_fragment _FUNC_NONE _FUNC_SIN _FUNC_SIN_APPROX _FUNC_COS _FUNC_TAN _FUNC_TAN_TAYLOR _FUNC_TAN_PADE _FUNC_ASIN _FUNC_ACOS _FUNC_ATAN _FUNC_EXP _FUNC_EXP2 _FUNC_POW _FUNC_LOG _FUNC_LOG2 _FUNC_LOG10

            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct Attributes
            {
                float4 positionOS : POSITION;
                float4 color : COLOR;
                float2 uv : TEXCOORD0;
                UNITY_VERTEX_INPUT_INSTANCE_ID
            };

            struct Varyings
            {
                float4 positionHCS : SV_POSITION;
                float2 uv : TEXCOORD0;
                float4 positionOS : TEXCOORD1; // 以與 _ClipRect 相同的空間（Canvas 區域座標）保存
            };

            TEXTURE2D(_MainTex);
            SAMPLER(sampler_MainTex);

            CBUFFER_START(UnityPerMaterial)
                half4 _BaseColor;
            CBUFFER_END

            // 由 TranscendentalBenchmark 設定的全域值。
            // 不是以材質為單位的值，因此不放進 UnityPerMaterial（放進去會破壞 SRP Batcher）
            int _TranscendentalLoopCount;
            float _PowExponent;

            // 相當於 UnityUI.cginc 的 UnityGet2DClipping（以 HLSL 自行定義）
            float Get2DClipping(float2 position, float4 clipRect)
            {
                float2 inside = step(clipRect.xy, position.xy) * step(position.xy, clipRect.zw);
                return inside.x * inside.y;
            }

            // 將傳給超越函數的值限制在 (0.05, 0.95) 範圍內。
            // 一併避開 asin/acos 的定義域 |x| <= 1、log 系的定義域 x > 0，
            // 以及 exp 系的溢位。由於是所有 variant 共通的前處理，其成本會在差值中相互抵銷。
            float PrepareInput(float seed)
            {
                return seed;
                // return frac(seed) * 0.9 + 0.05;
            }

            float sinApprox(float x)
            {
                // sin 的拋物線近似。只需乘法與 abs，用來觀察與真正的 sin 指令之間的成本差異。
                // 定義域為 |x| <= PI（PrepareInput 的輸出落在此範圍內）。
                // 係數會被常數折疊，因此執行階段沒有除法成本。
                return (4.0 / PI) * x - (4.0 / (PI * PI)) * x * abs(x);
            }

            float tanTaylor(float x)
            {
                // tan 的泰勒展開取到 3 次項（僅乘法）。用來觀察與真正的 tan 指令之間的成本差異。
                // 定義域為 |x| < PI/2，超過 π/4 後精度會急速下降。
                float x2 = x * x;
                return x * (1.0 + x2 * 0.3333333); // 1.0/3.0
            }

            float tanPade(float x)
            {
                // tan 的 帕德近似（乘法＋1 次除法）。定義域為 |x| < PI/2。
                // 分母的零點 x ≈ ±1.581 位於 tan 的極點 ±PI/2 附近，因此能貼近到極點附近。
                float x2 = x * x;
                return x * (15.0 - x2) / (15.0 - 6.0 * x2);
            }

            // 要測量的超越函數。每個關鍵字只會保留 1 個，
            // 因此產生的程式碼中只會出現所選函數的展開結果。
            float Transcendental(float x)
            {
                #if defined(_FUNC_SIN)
                    return sin(x);
                #elif defined(_FUNC_SIN_APPROX)
                    return sinApprox(x);
                #elif defined(_FUNC_COS)
                    return cos(x);
                #elif defined(_FUNC_TAN)
                    return tan(x);
                #elif defined(_FUNC_TAN_TAYLOR)
                    return tanTaylor(x);
                #elif defined(_FUNC_TAN_PADE)
                    return tanPade(x);
                #elif defined(_FUNC_ASIN)
                    return asin(x);
                #elif defined(_FUNC_ACOS)
                    return acos(x);
                #elif defined(_FUNC_ATAN)
                    return atan(x);
                #elif defined(_FUNC_EXP)
                    return exp(x);
                #elif defined(_FUNC_EXP2)
                    return exp2(x);
                #elif defined(_FUNC_POW)
                    // 若指數為常數，會被折疊成 pow(x, 2) -> x * x 的形式，
                    // 因此傳入 uniform 以走通用的 pow 路徑
                    return pow(x, _PowExponent);
                #elif defined(_FUNC_LOG)
                    return log(x);
                #elif defined(_FUNC_LOG2)
                    return log2(x);
                #elif defined(_FUNC_LOG10)
                    return log10(x);
                #else // _FUNC_NONE：不含超越函數的基準線
                    return x;
                #endif
            }

            Varyings vert(Attributes IN)
            {
                Varyings OUT;
                OUT.positionOS = IN.positionOS;
                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
                OUT.uv = IN.uv * 300.0;
                return OUT;
            }

            half4 frag(Varyings IN) : SV_Target
            {
                // 這裡是測量對象（外觀沒有意義）。
                // 以 UNITY_LOOP 抑制迴圈展開，使 _TranscendentalLoopCount 次的成本直接累加。
                // 除了超越函數的內容之外，所有 variant 的形式完全相同，
                // 因此與 _FUNC_NONE 的差值即為該函數的成本。
                float accum = 0.0;

                UNITY_LOOP
                for (int i = 0; i < _TranscendentalLoopCount; i++)
                {
                    // 若成為迴圈不變式會被提升到迴圈外，因此將 i 混入引數
                    float x = IN.uv.x + i * 0.017;

                    accum += Transcendental(x);
                }
                return half4(saturate(accum.xxx) * 0.02, 1);
            }
            ENDHLSL
        }
    }
}

float sinApprox = (4.0 / PI) * x - (4.0 / (PI * PI)) * x * abs(x);

float tanTaylor(float x) {
    float x2 = x * x;
    return x * (1.0 + x2 * 0.3333333);
}

float tanPade(float x) {
    float x2 = x * x;
    return x * (15.0 - x2) / (15.0 - 6.0 * x2);
}