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
}

void Start () {

      // this array should be filled before you can use EncryptedPlayerPrefs :

      EncryptedPlayerPrefs.keys=new string[5];

      EncryptedPlayerPrefs.keys[0]="23Wrudre";

      EncryptedPlayerPrefs.keys[1]="SP9DupHa";

      EncryptedPlayerPrefs.keys[2]="frA5rAS3";

      EncryptedPlayerPrefs.keys[3]="tHat2epr";

      EncryptedPlayerPrefs.keys[4]="jaw3eDAs";

      

      EncryptedPlayerPrefs.SetString("test_string", "Hello World");

      Debug.Log(EncryptedPlayerPrefs.GetString("test_string", "default"));

      

      EncryptedPlayerPrefs.SetInt("test_int", 500);

      Debug.Log(EncryptedPlayerPrefs.GetInt("test_int", -1));

      

      EncryptedPlayerPrefs.SetFloat("test_float", 500.456);

      Debug.Log(EncryptedPlayerPrefs.GetFloat("test_float", -1f));

  }

using UnityEngine;

using System.Collections;

using System.Security.Cryptography;

using System.Text;

 

public class EncryptedPlayerPrefs  {

 

    // Encrypted PlayerPrefs

    // Written by Sven Magnus

    // MD5 code by Matthew Wegner (from [url]http://www.unifycommunity.com/wiki/index.php?title=MD5[/url])

    

    

    // Modify this key in this file :

    private static string privateKey="9ETrEsWaFRach3gexaDr";

    

    // Add some values to this array before using EncryptedPlayerPrefs

    public static string[] keys;

    

    

    public static string Md5(string strToEncrypt) {

        UTF8Encoding ue = new UTF8Encoding();

        byte[] bytes = ue.GetBytes(strToEncrypt);

 

        MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();

        byte[] hashBytes = md5.ComputeHash(bytes);

 

        string hashString = "";

 

        for (int i = 0; i < hashBytes.Length; i++) {

            hashString += System.Convert.ToString(hashBytes[i], 16).PadLeft(2, '0');

        }

 

        return hashString.PadLeft(32, '0');

    }

    

    public static void SaveEncryption(string key, string type, string value) {

        int keyIndex = (int)Mathf.Floor(Random.value * keys.Length);

        string secretKey = keys[keyIndex];

        string check = Md5(type + "_" + privateKey + "_" + secretKey + "_" + value);

        PlayerPrefs.SetString(key + "_encryption_check", check);

        PlayerPrefs.SetInt(key + "_used_key", keyIndex);

    }

    

    public static bool CheckEncryption(string key, string type, string value) {

        int keyIndex = PlayerPrefs.GetInt(key + "_used_key");

        string secretKey = keys[keyIndex];

        string check = Md5(type + "_" + privateKey + "_" + secretKey + "_" + value);

        if(!PlayerPrefs.HasKey(key + "_encryption_check")) return false;

        string storedCheck = PlayerPrefs.GetString(key + "_encryption_check");

        return storedCheck == check;

    }

    

    public static void SetInt(string key, int value) {

        PlayerPrefs.SetInt(key, value);

        SaveEncryption(key, "int", value.ToString());

    }

    

    public static void SetFloat(string key, float value) {

        PlayerPrefs.SetFloat(key, value);

        SaveEncryption(key, "float", Mathf.Floor(value*1000).ToString());

    }

    

    public static void SetString(string key, string value) {

        PlayerPrefs.SetString(key, value);

        SaveEncryption(key, "string", value);

    }

    

    public static int GetInt(string key) {

        return GetInt(key, 0);

    }

    

    public static float GetFloat(string key) {

        return GetFloat(key, 0f);

    }

    

    public static string GetString(string key) {

        return GetString(key, "");

    }

    

    public static int GetInt(string key,int defaultValue) {

        int value = PlayerPrefs.GetInt(key);

        if(!CheckEncryption(key, "int", value.ToString())) return defaultValue;

        return value;

    }

    

    public static float GetFloat(string key, float defaultValue) {

        float value = PlayerPrefs.GetFloat(key);

        if(!CheckEncryption(key, "float", Mathf.Floor(value*1000).ToString())) return defaultValue;

        return value;

    }

    

    public static string GetString(string key, string defaultValue) {

        string value = PlayerPrefs.GetString(key);

        if(!CheckEncryption(key, "string", value)) return defaultValue;

        return value;

    }

    

    public static bool HasKey(string key) {

        return PlayerPrefs.HasKey(key);

    }

    

    public static void DeleteKey(string key) {

        PlayerPrefs.DeleteKey(key);

        PlayerPrefs.DeleteKey(key + "_encryption_check");

        PlayerPrefs.DeleteKey(key + "_used_key");

    }

    

}

public  string Md5Sum(string strToEncrypt)
{
   System.Text.UTF8Encoding ue = new System.Text.UTF8Encoding();
   byte[] bytes = ue.GetBytes(strToEncrypt);
 
   // encrypt bytes
   System.Security.Cryptography.MD5CryptoServiceProvider md5 = new System.Security.Cryptography.MD5CryptoServiceProvider();
   byte[] hashBytes = md5.ComputeHash(bytes);
 
   // Convert the encrypted bytes back to a string (base 16)
   string hashString = "";
 
   for (int i = 0; i < hashBytes.Length; i++)
   {
      hashString += System.Convert.ToString(hashBytes[i], 16).PadLeft(2, '0');
   }
 
   return hashString.PadLeft(32, '0');
}

using UnityEngine;

using System.Collections;

using System.Security.Cryptography;

using System.Text;

using System;

using Org.BouncyCastle.Crypto;

using Org.BouncyCastle.Crypto.Paddings;

using Org.BouncyCastle.Crypto.Engines;

using Org.BouncyCastle.Crypto.Parameters;

 

public class Encoding : MonoBehaviour 

{

    public class BCEngine

    {

        private readonly Encoding _encoding;

        private readonly IBlockCipher _blockCipher;

        private PaddedBufferedBlockCipher _cipher;

        private IBlockCipherPadding _padding;

 

        public BCEngine(IBlockCipher blockCipher)

        {

            _blockCipher = blockCipher;

        }

 

        public void SetPadding(IBlockCipherPadding padding)

        {

            if(padding != null)

                _padding = padding;

        }

 

        public string Encrypt(string plain, string key)

        {

            byte[] result = BouncyCastleCrypto(true, System.Text.Encoding.ASCII.GetBytes(plain), key);

            return Convert.ToBase64String(result);

        }

 

        public string Decrypt(string cipher, string key)

        {

            byte[] result = BouncyCastleCrypto(false, Convert.FromBase64String(cipher), key);

            return System.Text.Encoding.ASCII.GetString(result);

        }

 

        /// 


        /// 

        /// 

        /// 

        /// 

        /// 

        /// 

        /// 

 

 

        private byte[] BouncyCastleCrypto(bool forEncrypt, byte[] input, string key)

        {

            try

            {

                _cipher = _padding == null ? new PaddedBufferedBlockCipher(_blockCipher) : new PaddedBufferedBlockCipher(_blockCipher, _padding);

                byte[] keyByte = System.Text.Encoding.ASCII.GetBytes(key);

                _cipher.Init(forEncrypt, new KeyParameter(keyByte));

                return _cipher.DoFinal(input);

            }

            catch (Org.BouncyCastle.Crypto.CryptoException ex)

            {

                throw new CryptoException(ex.ToString());

            }

        }

        

    }   

 

    BCEngine bc = new BCEngine(new BlowfishEngine());

    

    public string EncodePassword(string input, string salt = "$2a$13$AcDc1326./qZrrFpoXx0$")

    {

        return bc.Encrypt(input, salt);

    }

    

    

    public string CalculateMD5Hash(string input)

    {

        // step 1, calculate MD5 hash from input

        MD5 md5 = System.Security.Cryptography.MD5.Create();

        byte[] inputBytes = System.Text.Encoding.ASCII.GetBytes(input);

        byte[] hash = md5.ComputeHash(inputBytes);

        

        return Convert.ToBase64String(hash);

    }

}