using UnityEngine;
using System.Collections;
using System.Threading;


public class ParticleController_Sample : MonoBehaviour {
   
   
   public Texture2D particleTexture;
   
   public Shader shader;
   private Material mat;
   
   public float PScale = 1.0f;
   
   public ComputeShader cs;
   
   public int particleCount = 1000;
   public Transform OriginLocation;
   

   private Vector3[] particleLocations;
   private Vector3[] particleColors;
   private Vector3[] particleVelocities;

   private ComputeBuffer particleBuffer;
   private ComputeBuffer particleColorBuffer;
   private ComputeBuffer velocityBuffer;



   Thread csThread;
   

   void Start()
   {
   
      particleLocations = new Vector3[particleCount];
      particleColors      = new Vector3[particleCount];
      particleVelocities   = new Vector3[particleCount];

      
      for (int i = 0; i < particleCount; i++)
      {
        
         particleLocations[i] = OriginLocation.position + Random.insideUnitSphere;
         particleVelocities[i] = Random.insideUnitSphere;
         particleColors[i] = new Vector3(Random.value,Random.value,Random.value);


      }

      particleBuffer = new ComputeBuffer(particleCount, 12);
      particleBuffer.SetData(particleLocations);

      velocityBuffer= new ComputeBuffer(particleCount, 12);
      velocityBuffer.SetData (particleVelocities);
      
      particleColorBuffer = new ComputeBuffer(particleCount, 12);
      particleColorBuffer.SetData (particleColors);
      



      
      mat = new Material(shader);
      mat.hideFlags = HideFlags.HideAndDontSave;
      
      mat.SetTexture ("_Sprite", particleTexture);
      mat.SetFloat ("Size", PScale );

   }
   
   private void ReleaseResources()
   {
      csThread.Abort ();

      particleBuffer.Release ();
      particleColorBuffer.Release ();
      velocityBuffer.Release ();

      Object.DestroyImmediate (mat);
   }
   
   void OnDisable()
   {
      ReleaseResources ();
   }
   
   
   void Update()
   {


            cs.SetFloat ("Time",Time.timeSinceLevelLoad);
            cs.SetVector ("Origin", OriginLocation.position);
         
            cs.SetBuffer (cs.FindKernel ("CSMain"), "colBuffer", particleColorBuffer);
            cs.SetBuffer (cs.FindKernel ("CSMain"), "posBuffer", particleBuffer);   
            cs.SetBuffer (cs.FindKernel ("CSMain"), "velBuffer", velocityBuffer);

            cs.Dispatch  (cs.FindKernel ("CSMain"), particleCount, 1, 1);
   
   }
   
   void OnRenderImage(RenderTexture src, RenderTexture dst)
   {


      Graphics.Blit( src, dst);      
   
      mat.SetBuffer("particleBuffer", particleBuffer);
      mat.SetBuffer("particleColor", particleColorBuffer);
      mat.SetPass (0);

      Graphics.DrawProcedural(MeshTopology.Triangles, particleCount);



   }
}

#pragma kernel CSMain



RWStructuredBuffer posBuffer : register(u0);
RWStructuredBuffer velBuffer : register(u1);
RWStructuredBuffer colBuffer : register(u2);


float Time;
float4 Origin;
float PI = 3.1415926;


[numthreads(16,1,1)]
void CSMain (uint3 id : SV_DispatchThreadID)
{

    uint Tid = id.x;    

   colBuffer[Tid ].r = 0.1;
   colBuffer[Tid ].g =1.0;
   colBuffer[Tid ].b = 0.4;
   float3 NewPos;

   NewPos.x = Origin.x +  (sin(Time/10.0 * Tid ) ) * 30;
   NewPos.y = Origin.y +  (cos((Time/10.0+PI ) * Tid ) ) *30;
   NewPos.z = Origin.z +  (cos(Time /10.0 * Tid ) )*30;


   velBuffer[Tid ].x  = NewPos.x - posBuffer[Tid ].x;
   velBuffer[Tid ].y =  NewPos.y - posBuffer[Tid ].y;
   velBuffer[Tid ].z =  NewPos.z - posBuffer[Tid ].z;
      
      
   posBuffer[Tid ].x += velBuffer[Tid ].x / 40;
   posBuffer[Tid ].y += velBuffer[Tid ].y / 40;
   posBuffer[Tid ].z += velBuffer[Tid ].z / 40;
   
}

Shader "Custom/RenderParticles" {
Properties {
   _Sprite ("Sprite", 2D) = "white" {}
}
   
SubShader {
Pass{
   ZWrite Off ZTest Always Cull Off Fog { Mode Off }
   Blend SrcAlpha One


   CGPROGRAM
   #pragma target 5.0

   #pragma vertex vert
   #pragma geometry geom
   #pragma fragment frag

   #include "UnityCG.cginc"
   
   StructuredBuffer particleBuffer;
   StructuredBuffer particleColor;

   
   float Size = 0.3f;
   sampler2D _Sprite;
   
   struct vs_out {
      float4 pos : SV_POSITION;
      float4 col : COLOR;
   };
   
   vs_out vert (uint id : SV_VertexID)
   {
      vs_out o;
      o.pos =mul(_Object2World, float4(particleBuffer[id], 1.0f));
      o.col = float4(particleColor[id], 1.0f);
      return o;
   }
   
   struct gs_out {
      float4 pos : SV_POSITION;
      float2 uv  : TEXCOORD0;
      float4 col : COLOR;
   };
   
   [maxvertexcount(4)]
   void geom (point vs_out input[1], inout TriangleStream outStream)
   {

      
      float dx = Size;
      float dy = Size * _ScreenParams.x / _ScreenParams.y;
      gs_out output;
      
           
      float4 corLoc = mul(UNITY_MATRIX_MVP, input[0].pos); 
      output.pos = corLoc + float4(-dx, dy,0,0); output.uv=float2(0,0); 
      output.col = input[0].col; outStream.Append (output);
      output.pos = corLoc + float4( dx, dy,0,0); output.uv=float2(1,0); 
      output.col = input[0].col; outStream.Append (output);
      output.pos = corLoc + float4(-dx,-dy,0,0); output.uv=float2(0,1); 
      output.col = input[0].col; outStream.Append (output);
      output.pos = corLoc + float4( dx,-dy,0,0); output.uv=float2(1,1); 
      output.col = input[0].col; outStream.Append (output);
      
      outStream.RestartStrip();
   }
   
   
      
   fixed4 frag (gs_out i ) : COLOR0
   {
      fixed4 col = tex2D(_Sprite, i.uv);
      col.a = 0.8f;
      col *= i.col;
      return col;
   }
   
   ENDCG
   
   }
}

Fallback Off
}