제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 쪽에서 일괄 제어할 수 있다.
            // 키워드가 하나도 켜져 있지 않으면 맨 앞의 _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);
            }

            // 계측 대상 초월 함수. 키워드마다 하나만 남으므로
            // 생성 코드에는 선택한 함수의 전개 결과만 나타난다.
            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);
}