Moonflow-RampMaker/MFRampMaker.shader at main · Moonflow-Studio/Moonflow-RampMaker · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
Shader"Hidden/Moonflow/RampMaker"
{
    Properties
    {
        _MainTex ("Texture", 2D) = "white" {}
        _Color("Color", Color) = (1,1,0,1)
    }
    SubShader
    {
        Tags { "RenderType"="Opaque" }
        LOD 100

        Pass
        {
            HLSLPROGRAM
            #pragma shader_feature _LERP_MODE
            #pragma shader_feature _GAMMA_MODE
            #pragma shader_feature _QUAD_MODE
            #pragma shader_feature _LOOP_MODE
            #pragma vertex vert
            #pragma fragment frag
            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"

            struct appdata
            {
               float4 vertex : POSITION;
               float2 uv : TEXCOORD0;
            };

            struct v2f
            {
               float4 vertex : SV_POSITION;
               float2 uv : TEXCOORD0;
            };

            Texture2D _MainTex;
            SamplerState sampler_MainTex;
            float4 _MainTex_ST;
            float4 _Color;

            float _RealNum;
            float4 _ColorArray[80];
            float _PointArray[80];

            float linearstep(float u, float left, float right)
            {
                return (u-left)/(right-left);
            }
            float4 GetGradient(int num, float u)
            {
                int i = 0;
                int left = 0;
                int right = 7;
                UNITY_UNROLL
                for (i = 0; i < 8; i++)
                {
                    if(_PointArray[num * 10 + i] >= u)
                    {
                        right = i;
                        break;
                    }
                }
                left = max(0, right - 1);
                float4 resultColor = lerp(_ColorArray[num * 10 + left], _ColorArray[num * 10 + right], linearstep(u, _PointArray[num * 10 + left], _PointArray[num * 10 + right]));
            #ifdef _GAMMA_MODE
                return pow(resultColor, 2.2);
            #else
                return resultColor;
            #endif
            }

            v2f vert (appdata v)
            {
                v2f o;
                o.vertex = TransformObjectToHClip(v.vertex.xyz);
                o.uv = v.uv;
                return o;
            }

            half4 frag (v2f i) : SV_Target
            {
                int realNum = _RealNum;
            #if defined(_LERP_MODE) && !defined (_LOOP_MODE)
                if(_RealNum>1) realNum = realNum - 1;
            #endif
                // float uvBandwidth = 1 / realNum;
                float y = 1 - i.uv.y;
                float yLevel = y * realNum;
            #ifdef _LERP_MODE
                    int next = ceil(yLevel);
                #ifdef _LOOP_MODE
                    next = (next > _RealNum - 1) ? 0 : next;
                #endif

                    float balance = frac(yLevel);
                #ifndef _QUAD_MODE
                    balance = balance * 2 - 1;
                #endif
                return lerp(GetGradient(floor(yLevel), i.uv.x), GetGradient(next, i.uv.x), saturate(balance));
            #else
                return GetGradient(floor(yLevel), i.uv.x);
            #endif
            }
            ENDHLSL
        }
    }
}