第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（動的ループ）なので 2.0 ではなく 3.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 で切り替えたいので
            // shader_feature(未使用variantが剥がれる)ではなく multi_compile を使う。
            // キーワードごとに別variantになるため、生成コードには選んだ関数だけが出る（分岐オーバーヘッド無し）。
            // グローバルキーワードなので TranscendentalBenchmark 側から一括で制御できる。
            // キーワードが1つも立っていない場合は先頭の _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);
}