﻿//v1.1
//Full Rework
//Added Refraction
Shader "Doppels shaders/Models shaders/Burning Glasses 1.1"
{
    Properties
    {
        _Color("Color", color) = (0.2,0.35,1,1)
        _glow("Glow", range(0, 1)) = 0.05
        _scale("Scale", float) = 1.0
        _dspow("Distortion power", range(0, 1)) = 0.3
        _groffs("Gradient Offset", range(0, 1)) = 0.5
        _grsh("Gradient Sharpness", range(0, 1)) = 0.45
        _noiscount("Count", range(0, 1)) = 0.7
        _ap("Alpha Power", range(0, 1)) = 0.3
        _nspeed("Flame Speed", range(0, 1)) = 1.0
        _wspeed("Waves Speed", range(0, 1)) = 0.25
        _wpow("Waves Power", range(0, 1)) = 0.1
        _refraction("Refraction", range(-1, 1)) = 0.1
        [Enum(Off, 0, On, 1)]_ZWrite("ZWrite", Int) = 1

    }
    CustomEditor "BGGUI"
    SubShader
    {
        Tags { "RenderType"="Transparent" "Queue"="Transparent+1" }
        Blend SrcAlpha OneMinusSrcAlpha
        ZWrite [_ZWrite]
        GrabPass {"_bggp"}
        Pass
        {
            CGPROGRAM
            #pragma vertex vert
            #pragma fragment frag
            #include "UnityCG.cginc"

            struct appdata 
            {
                float4 vertex       : POSITION;
                float3 normal       : NORMAL;
                float4 tangent      : TANGENT;
                float2 uv           : TEXCOORD0;
            };

            struct v2f
            {
                float4 vertex       : SV_POSITION;
                float2 uv           : TEXCOORD0;
                float4 grabuv       : TEXCOORD1;
                float2 pr           : TEXCOORD2;
            };

            uniform half _glow, _scale, _noiscount, _ap, _groffs, _grsh, _dspow, _nspeed, _wspeed, _wpow, _refraction;
            uniform fixed4 _Color;
            uniform sampler2D _bggp;

            v2f vert (appdata v)
            {
                float3 normalDir = normalize(UnityObjectToWorldNormal(v.normal));
                float3 tangentDir = normalize(mul(unity_ObjectToWorld, float4(v.tangent.xyz, 0.0)).xyz);
                float3 bitangentDir = normalize(cross(normalDir, tangentDir) * v.tangent.w);
                float3 vdir = normalize(WorldSpaceViewDir(v.vertex));
                v2f o;
                o.vertex = UnityObjectToClipPos(v.vertex);
                o.grabuv = ComputeGrabScreenPos(o.vertex);
                o.pr = mul(float3x3(tangentDir, bitangentDir, normalDir), vdir);
                o.uv = v.uv;
                return o;
            }

            float hash21(float2 p)
            {
                return frac(sin(dot(p, float2(12.9898, 78.233))) * 47758.5453);
            }

            float noise(float2 p)
            {
                float2 id = floor(p);
                p = smoothstep(0.0, 1.0, frac(p));
                return lerp(lerp(hash21(id), hash21(id + float2(1.0, 0.0)), p.x), lerp(hash21(id + float2(0.0, 1.0)), hash21(id + float2(1.0, 1.0)), p.x), p.y);
            }

            float fbm(float2 p, float t)
            {
                float r = 0, z = 2;
                for(int i = 0; i < 7; i++)
                {
                    r += noise(p) / z;
                    z *= 1.8;
                    p *= 1.8;
                    p.y -= t;
                }
                return saturate(pow(r, 2.0));
            }

            float flamenoise(float2 p)
            {
                p *= _scale;
                p.x += sin(p.y * 30.0 + 4.0 * _Time.y * _wspeed) * 0.05 * _wpow;
                return fbm(p*30.0 + 19, _Time.y * 0.5 * _nspeed + 12) * fbm(p * 30.0 + 15, _Time.y * 0.33 * _nspeed + 18);
            }

            fixed4 frag (v2f i) : SV_Target
            {
                float2 grabuv = i.grabuv.xy/i.grabuv.w, uv = i.uv, pr = i.pr;
                float n = pow(saturate(smoothstep(1.0 - _grsh, 0.0, uv.y + _groffs * 2 - 1) * 10.0 * (1.0 + 9.0 * _noiscount) * flamenoise(uv - 0.5)), 1.0 + _ap * 15.0), n2 = 500.0 * pow(1 - n, 3.0) * n;
                fixed3 bgtex = fixed3(tex2D(_bggp, grabuv + _dspow * n - pr*0.1*_refraction).r, tex2D(_bggp, grabuv + _dspow * n).g, tex2D(_bggp, grabuv + _dspow * n + pr*0.1*_refraction).b);
                return fixed4(clamp(lerp(bgtex, n2 * _Color * _glow * 10, saturate(n)), 0.0, 3.0), 1.0);
            }
            ENDCG
        }
    }
}
