Texture-Sampled Vertex Distortion - 2015

Shader "Base_Artifact"
{
    Properties
    {
        _DataTex ( "Data Artifact", 2D ) = "black" {}
        _Rate ( "Artifact Rate", float ) = 2.0
        _Screeny_rate ( "Screen Rate", float ) = 6.0
        _WarpScale ( "Warp Scale", range( -2, 2 ) ) = 0.5

        _FresnelEmitColor ( "Fresnel Emit Color", Color ) = ( 0.89, 0.945, 1.0, 0.0 )
        _FresnelEmitPower ( "Fresnel Emit Power", Range( 0.0, 1.0 ) ) = 0.7

        _FresnelInnerColor ( "Fresnel Inner Color", Color ) = ( 0.89, 0.945, 1.0, 0.0 )
        _FresnelInnerPower ( "Fresnel Inner Power", Range( 0.0, 1.0 ) ) = 0.7

        _SkylightColor ( "Skylight Color", Color ) = ( 0.89, 0.945, 1.0, 0.0 )
        _SkylightPower ( "Skylight Power", Range( 0.0, 1.0 ) ) = 0.7

        _DiffuseAmount ( "Diffuse Amount", Range( 0.0, 1.0 ) ) = 0.25
        _TexAmount ( "Texture Amount", Range( 0.0, 1.0 ) ) = 0.25
        _SpecAmount ( "Specular Amount", Range( 0.0, 2.0 ) ) = 1.0
        _SpecTexAmount ( "Spec Texture Amount", Range( 0.0, 1.0 ) ) = 0.25

        _Diffusemap ( "Diffusemap", 2D ) = "diffuse" {}
        _Normalmap ( "Normalmap", 2D ) = "normal" {}
        _Specmap ( "Specmap", 2D ) = "spec" {}

        _Gloss ( "Gloss", Range( 0.001, 2.0 ) ) = 1.0
    }

    SubShader
    {
Tags { "Queue"="Geometry" "IgnoreProjector"="False" "RenderType"="Opaque" }

        Cull Back
        ZWrite On
        ZTest LEqual

        CGPROGRAM
        #pragma glsl
        #pragma target 3.0
        #pragma surface surf Lambert noambient nolightmap vertex:vert

        sampler2D _DataTex;
        float4 _DataTex_ST;

        float _WarpScale;
        float _Rate;
        float _Screeny_rate;

        float _Gloss;
        fixed _SpecAmount;

        struct Input
        {
            float2 uv_Normalmap;
            float2 uv_Specmap;
            float2 uv_DataTex;

            float4 pos : POSITION;
            //float4 dataUV : TEXCOORD1;
            float3 viewDir;
            float worldNormal; INTERNAL_DATA
        };

        void vert ( inout appdata_full v, out Input o )
        {
            o.pos = mul( UNITY_MATRIX_MVP, v.vertex );
            float4 screenuv = v.vertex.xzyx;
            screenuv.y += _Time.x * _Screeny_rate;
            screenuv.z += _Time.x * _Screeny_rate * 0.753;
            screenuv.w += _Time.x * _Screeny_rate * 1.383;

            float4 dataUV = screenuv;
            dataUV.xy = TRANSFORM_TEX( dataUV.xy, _DataTex );
            //dataUV.zw = TRANSFORM_TEX( dataUV.zw, _DataTex );

            float4 tex = tex2Dlod( _DataTex, float4( dataUV.xy, 0, 0 ) );
            tex       += tex2Dlod( _DataTex, float4( dataUV.zw, 0, 0 ) );
            tex       *= -0.5;
            tex       += 0.25;

            float3 warp = float3(
                sin( v.normal.x*tex.r),
                sin( v.normal.y*tex.g),
                sin( v.normal.z*tex.b)
            );
            //warp *= 1.0 - ( v.normal * rand3d_3d( v.normal ) * _WarpOffset );// * _WarpOffset * sin( _Time.x * _Rate );

            float finalWarpScale = _WarpScale;
            finalWarpScale *= 0.025;
            v.vertex.xyz = lerp( v.vertex.xyz + warp * finalWarpScale, v.vertex.xyz, warp );
            o.pos = mul( UNITY_MATRIX_MVP, v.vertex );

            UNITY_INITIALIZE_OUTPUT(Input,o);
        }

        sampler2D _Diffusemap;
        sampler2D _Normalmap;
        sampler2D _Specmap;

        fixed _SpecTexAmount;
        fixed _TexAmount;
        fixed _DiffuseAmount;

        float4 _FresnelEmitColor;
        float  _FresnelEmitPower;

        float4 _FresnelInnerColor;
        float  _FresnelInnerPower;

        float4 _SkylightColor;
        float  _SkylightPower;

        float D_Beckmann( float NoH, float Roughness )
        {
            float m = Roughness * Roughness;
            float m2 = m * m;
            float NoH2 = NoH * NoH;
            float final = exp( (NoH2 - 1.0) / (m2 * NoH2) ) / ( 3.14159265359 * m2 * NoH2 * NoH2 );
            return saturate( final * 0.125 );
        }

        void surf( Input IN, inout SurfaceOutput o )
        {
            float spec = tex2D( _Specmap, IN.uv_Specmap ).r;

            o.Normal = UnpackNormal( tex2D( _Normalmap, IN.uv_Normalmap ) );

            float fresnelDot = saturate( dot( normalize( IN.viewDir ), o.Normal ) );
            float skyDot = max( dot( float3( 0.0f, 1.0f, 0.0f ), WorldNormalVector( IN, o.Normal ) ), 0.0 );
            float innerDot = fresnelDot * ( 1.0f - skyDot );

            float innerFresnel = D_Beckmann( innerDot, _FresnelInnerPower ); //lerp( innerPrimaryBlob, innerSecondaryBlob, _FresnelInnerPrimarySecondary );

            fresnelDot = 1.0 - fresnelDot;

            float emitFresnel = D_Beckmann( fresnelDot, _FresnelEmitPower ); //lerp( emitPrimaryBlob, emitSecondaryBlob, _FresnelEmitPrimarySecondary );
            float skylightFresnel = D_Beckmann( skyDot, _SkylightPower ); //lerp( skylightPrimaryBlob, skylightSecondaryBlob, _SkylightPrimarySecondary );

            o.Emission = ( (   innerFresnel * _FresnelInnerColor.rgb * (_FresnelInnerColor.a * 16.0f ) )
                         + (skylightFresnel * _SkylightColor.rgb     * (_SkylightColor.a * 16.0f ) )
                         + (    emitFresnel * _FresnelEmitColor.rgb  * ( _FresnelEmitColor.a * 16.0f ) ) ) * spec;

            o.Specular = _SpecAmount;
            o.Gloss = lerp( spec * 2.0, 0.5, _SpecTexAmount ) * _Gloss;
            o.Albedo = _DiffuseAmount * lerp( spec, 1.0, _TexAmount );
        }

        ENDCG
    }

    Fallback "Diffuse"
}