Shader "Particles/~MultiPurpose" {
Properties {

   _TintColor ("Tint Color", Color) = (0.5,0.5,0.5,0.5)
   _MainTex ("Particle Texture", 2D) = "white" {}
   _InvFade ("Soft Particles Factor", Range(0.01,3.0)) = 1.0

   _RotateSpeed ("RotateSpeed", Float) = 0.0


   _ColorIndices ("ColorIndices Texture", 2D) = "white" {}
   _SelectColorIndices("SelectColorIndices", Range(0.0,1.0)) = 1.0

   _SliceColor ("Slice Color", Color) = (0.5,0.5,0.5,0.5)
   _SliceGuide ("Slice Guide (RGB)", 2D) = "white" {}
   _SliceEdge ("Slice Edge (RGB)", 2D) = "Gray" {}
   _SliceAmount ("Slice Amount", Range(-1.2, 1.2)) = 0.5


   _Flowmap("Flowmap", 2D) = "black" {}
   _FlowAmount("Flow Amount", Range(-2.0, 2.0)) = 0.0

   _MaskTex ("Mask Texture", 2D) = "white" {}

   _VertexFlowTex ("VertexFlow Texture ", 2D) = "white" {}
   _VertexFlowAmount ("VertexFlow Amount", Range(0, 10.0)) = 0.0

   _CC_Bright("CC_Bright", Range(0.0,2.0)) = 0.5
   _CC_Saturate("CC_Saturate", Range(0.0,1.0)) = 0.5
   _CC_Contrast("CC_Contrast", Range(0.0,3.0)) = 1.2

   _CC_Hue("CC_Hue", Range(-10.0,10.0)) = 0.5
   _CC_Saturation("CC_Saturation", Range(0.0,1.0)) = 0.8
   _CC_Luminosity("CC_Luminosity", Range(0.0,2.0)) = 0.6
}

Category {

   Tags { "Queue"="Transparent" "IgnoreProjector"="True" "RenderType"="Transparent" }
   Blend One OneMinusSrcAlpha
   ColorMask RGB
   Cull Off Lighting Off ZWrite Off Fog { Color (0,0,0,1) }
   BindChannels {
      Bind "Color", color
      Bind "Vertex", vertex
      Bind "TexCoord", texcoord
   }
   
   // ---- Fragment program cards
   SubShader {
      Pass {
      
         CGPROGRAM
         
         #pragma glsl
         #pragma vertex vert
         #pragma fragment frag
         #pragma fragmentoption ARB_precision_hint_fastest
         #pragma multi_compile_particles
#pragma  target 4.0
         #include "UnityCG.cginc"

sampler2D _MainTex;

float     _RotateSpeed;
float4x4   pulsateMatrix ;

sampler2D _ColorIndices;
float     _SelectColorIndices;

fixed4    _SliceColor ;

sampler2D _SliceGuide;
sampler2D _SliceEdge;
float     _SliceAmount;

sampler2D _Flowmap;
float     _FlowAmount;

sampler2D _MaskTex;
sampler2D _VertexFlowTex;
float4    _VertexFlowTex_ST;
float     _VertexFlowAmount;


float     _CC_Bright;
float     _CC_Saturate;
float     _CC_Contrast;

float     _CC_Hue;
float     _CC_Saturation;
float     _CC_Luminosity;


fixed4    _TintColor;


         
         struct appdata_t {
            float4 vertex : POSITION;
            fixed4 color : COLOR;
            float2 texcoord : TEXCOORD0;
         };

         struct v2f {
            float4 vertex  :  SV_POSITION;
            fixed4 color : COLOR;
            float2 texcoord : TEXCOORD0;
         #ifdef SOFTPARTICLES_ON
            float4 projPos : TEXCOORD1;
         #endif   
                 float2 texcoord_orig : TEXCOORD2;
         };

         float4 _MainTex_ST;


float2 Rotator(float2 UV)
{
      float sine     = sin(_Time*_RotateSpeed);
      float cosine = cos(_Time*_RotateSpeed);

       pulsateMatrix._m00 = pulsateMatrix._m11 = cosine;
       pulsateMatrix._m10 = -sine;
       pulsateMatrix._m01 = sine;
       float4 tempUV = float4(UV.x-0.5,UV.y-0.5,0,0);
       float4 temp     = mul(pulsateMatrix,tempUV);
       UV.x = temp.x+0.5;
       UV.y = temp.y+0.5;
      return UV;
}      

float3 ContrastSaturationBrightness(float3 color, float brt, float sat, float con)
{
   
    float AvgLumR = 0.5;
    float AvgLumG = 0.5;
    float AvgLumB = 0.5;
   
   float3 LumCoeff = float3(0.2125, 0.7154, 0.0721);
   
   float3 AvgLumin = float3(AvgLumR, AvgLumG, AvgLumB);
   float3 brtColor = color * brt;
   float intensityf = dot(brtColor, LumCoeff);
   float3 intensity = float3(intensityf, intensityf, intensityf);
   float3 satColor = lerp(intensity, brtColor, sat);
   float3 conColor = lerp(AvgLumin, satColor, con);
   return conColor;
}

float3 RGBToHSL(float3 color)
{
   float3 hsl; // init to 0 to avoid warnings ? (and reverse if + remove first part)
   
   float fmin = min(min(color.r, color.g), color.b);    //Min. value of RGB
   float fmax = max(max(color.r, color.g), color.b);    //Max. value of RGB
   float delta = fmax - fmin;             //Delta RGB value

   hsl.z = (fmax + fmin) / 2.0; // Luminance

   if (delta == 0.0)      //This is a gray, no chroma...
   {
      hsl.x = 0.0;   // Hue
      hsl.y = 0.0;   // Saturation
   }
   else                                    //Chromatic data...
   {
      if (hsl.z < 0.5)
         hsl.y = delta / (fmax + fmin); // Saturation
      else
         hsl.y = delta / (2.0 - fmax - fmin); // Saturation
      
      float deltaR = (((fmax - color.r) / 6.0) + (delta / 2.0)) / delta;
      float deltaG = (((fmax - color.g) / 6.0) + (delta / 2.0)) / delta;
      float deltaB = (((fmax - color.b) / 6.0) + (delta / 2.0)) / delta;

      if (color.r == fmax )
         hsl.x = deltaB - deltaG; // Hue
      else if (color.g == fmax)
         hsl.x = (1.0 / 3.0) + deltaR - deltaB; // Hue
      else if (color.b == fmax)
         hsl.x = (2.0 / 3.0) + deltaG - deltaR; // Hue

      if (hsl.x < 0.0)
         hsl.x += 1.0; // Hue
      else if (hsl.x > 1.0)
         hsl.x -= 1.0; // Hue
   }

   return hsl;
}

float HueToRGB(float f1, float f2, float hue)
{
   if (hue < 0.0)
      hue += 1.0;
   else if (hue > 1.0)
      hue -= 1.0;
   float res;
   if ((6.0 * hue) < 1.0)
      res = f1 + (f2 - f1) * 6.0 * hue;
   else if ((2.0 * hue) < 1.0)
      res = f2;
   else if ((3.0 * hue) < 2.0)
      res = f1 + (f2 - f1) * ((2.0 / 3.0) - hue) * 6.0;
   else
      res = f1;
   return res;
}

float3 HSLToRGB(float3 hsl)
{
   float3 rgb;
   
   if (hsl.y == 0.0)
      rgb = float3(hsl.z, hsl.z, hsl.z); // Luminance
   else
   {
      float f2;
      
      if (hsl.z < 0.5)
         f2 = hsl.z * (1.0 + hsl.y);
      else
         f2 = (hsl.z + hsl.y) - (hsl.y * hsl.z);
         
      float f1 = 2.0 * hsl.z - f2;
      
      rgb.r = HueToRGB(f1, f2, hsl.x + (1.0/3.0));
      rgb.g = HueToRGB(f1, f2, hsl.x);
      rgb.b= HueToRGB(f1, f2, hsl.x - (1.0/3.0));
   }
   
   return rgb;
}





v2f vert (appdata_t v)
{
      v2f o;
      
      
      o.vertex = mul(UNITY_MATRIX_MVP, v.vertex);
      
      
      #ifdef SOFTPARTICLES_ON
            o.projPos = ComputeScreenPos (o.vertex);
            COMPUTE_EYEDEPTH(o.projPos.z);
      #endif
      
      o.color = v.color;
      
       o.texcoord_orig   =   Rotator( v.texcoord.xy);
       o.texcoord  =   Rotator( v.texcoord);
       o.texcoord  =   TRANSFORM_TEX( o.texcoord,_MainTex);
        
      half2  VertexFlowUV　= TRANSFORM_TEX( v.texcoord,  _VertexFlowTex);
      half3  VertexFlowVec = tex2Dlod(_VertexFlowTex, float4(VertexFlowUV.xy,0,0)).rgb * 2.0-1.0;
 
       o.vertex.xyz +=  VertexFlowVec.xyz *  _VertexFlowAmount;
       

      return o;
      
      }


sampler2D _CameraDepthTexture;
float     _InvFade;



         
fixed4 frag (v2f i) : COLOR
{
      #ifdef SOFTPARTICLES_ON
            float sceneZ = LinearEyeDepth (UNITY_SAMPLE_DEPTH(
                           tex2Dproj(_CameraDepthTexture, UNITY_PROJ_COORD(i.projPos))));
            float partZ = i.projPos.z;
            float fade = saturate (_InvFade * (sceneZ-partZ));
            i.color *= fade;
      #endif
      
      
      

////FlowMap////////////////////////////////////////////////////////////

    half2 FlowtexUV = tex2D(  _Flowmap,i.texcoord_orig).rg * 2.0-1.0;
          
    half2 texUV; 

    texUV.x =clamp( ( i.texcoord_orig.x *2.0 -1.0)+ (FlowtexUV.x  *_FlowAmount ),-1,1);
    texUV.y =clamp( ( i.texcoord_orig.y *2.0 -1.0)+ (FlowtexUV.y  *_FlowAmount ),-1,1);

    texUV.x =( texUV.x +1.0)/2.0*_MainTex_ST.x +_MainTex_ST.z;
    texUV.y =( texUV.y +1.0)/2.0*_MainTex_ST.y +_MainTex_ST.w;
         

//  Mask///////////////////////////////////////////////////////////////////////
   fixed4 tex = tex2D(_MainTex,  texUV);

   float  MaskVal;
    half4  MaskColor=half4(1,1,1,1);

             
    MaskColor =  tex2D ( _MaskTex,i.texcoord_orig);
              
    tex.a =MaskColor.a ;
    
    
   fixed4 col;   
      


// ColorIndices/////////////////////////////////////////////////////


   half2 ColorIndicesUV ;

   ColorIndicesUV.x = tex.r;
   ColorIndicesUV.y =1.0-_SelectColorIndices ;

   fixed4 ColorIndices = tex2D(_ColorIndices, ColorIndicesUV );
   
   
   col.rgb =_TintColor.rgb *  ColorIndices.rgb * tex.rgb * i.color.rgb * 2.0f;
   

// Dissolve with Alpha channel/////////////////////////////////////////


   float   AbsSliceAmount = abs(_SliceAmount );

   clip(tex2D (_SliceGuide, i.texcoord_orig).rgb - AbsSliceAmount );

   half2 SliceEdgeUV;

   SliceEdgeUV.x =  (tex2D (_SliceGuide, i.texcoord_orig).r -AbsSliceAmount  );
   SliceEdgeUV.y =  0.5;
    
   fixed3 EdgeColor = _SliceColor* tex2D (_SliceEdge, SliceEdgeUV).rgb* 1.8;

   if (_SliceAmount >0.1  )
   col.rgb += EdgeColor.rgb;
   else if (_SliceAmount < -0.1  )
   col.rgb *=  1- EdgeColor.rgb*0.5;




//  ColorCollect /////////////////////////////////////////////////////////////////////

   col.rgb= ContrastSaturationBrightness(col.rgb,  _CC_Bright, _CC_Saturate, _CC_Contrast);

   float3 HSL =  RGBToHSL(col.rgb);
   
   HSL.r *= _CC_Hue;
   HSL.g *= _CC_Saturation;
   HSL.b *= _CC_Luminosity;

   col.rgb = HSLToRGB(HSL);
   
//////////////////////////////////////////////////////////////////////////////////////
   
   
    col.a = (1 - tex.a) * (_TintColor.a * i.color.a * 2.0f) ;


   return col;
   
   
   
         }
   ENDCG 
   
   
      }
   }    

   // ---- Dual texture cards
   SubShader {
      Pass {
         SetTexture [_MainTex] {
            constantColor [_TintColor]
            combine constant * texture, constant * primary DOUBLE
         }
         SetTexture [_MainTex] {
            combine previous * primary DOUBLE, one - texture * previous
         }
      }
   }
   
   // ---- Single texture cards (does not do color tint)
   SubShader {
      Pass {
         SetTexture [_MainTex] {
            combine texture * primary DOUBLE, one - texture * primary
         }
      }
   }
}
}