Fluids implemented (olivenoel + kochtopf)

Viagg-io/Assets/2Ginge.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 62cf5026784eb264abc8a33577b2fefe
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 060d50eb9a342b84aafc2193bc48e08b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/CommonMeshes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e33f2737641e91148974a1abb9146131
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/CommonMeshes/BottleOpening.fbx.meta

@@ -0,0 +1,80 @@
+fileFormatVersion: 2
+guid: 80b3b66545e11cc48accc1e260c0a108
+timeCreated: 1515302053
+licenseType: Store
+ModelImporter:
+  serializedVersion: 19
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: Cylinder
+  materials:
+    importMaterials: 0
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    importBlendShapes: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    rootMotionBoneRotation: {x: 0, y: 0, z: 0, w: 1}
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: adf954a106f63144eba9b1f393d6e490
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/BottleSmash.cs

@@ -0,0 +1,185 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class BottleSmash : MonoBehaviour {
+
+	// Use this for initialization
+    //all of the required items in order to gie the impression of hte glass breaking.
+    [ColorUsageAttribute(true, true, 0f, 8f, 0.125f, 3f)]
+    public Color color;
+    //to use to find any delta
+    [SerializeField]
+    [HideInInspector]
+    private Color cachedColor;
+    //used to update any colors when the value changes, not by polling
+    [SerializeField]
+    [HideInInspector]
+    private List<ColorBase> registeredComponents;
+
+
+    public GameObject Cork, Liquid, Glass, Glass_Shattered, Label;
+    //default despawn time;
+    public float DespawnTime = 5.0f;
+    //splash effect.
+    public ParticleSystem Effect;
+    //3D mesh on hte ground (given a specific height).
+    public GameObject Splat;
+    //such as the ground layer otherwise the broken glass could be considered the 'ground'
+    public LayerMask SplatMask;
+    //distance of hte raycast
+    public float maxSplatDistance = 5.0f;
+    //if the change in velocity is greater than this THEN it breaks
+    public float shatterAtSpeed = 2.0f;
+    //if the is disabled then it wont shatter by itself.
+    public bool allowShattering = true;
+    //if it collides with an object then and only then is there a period of 0.2f seconds to shatter.
+    public bool onlyAllowShatterOnCollision = true;
+    //for the ability to find the change in velocity.
+    [SerializeField]
+    [HideInInspector]
+    private Vector3 previousPos;
+    [SerializeField]
+    [HideInInspector]
+    private Vector3 previousVelocity;
+    [SerializeField]
+    [HideInInspector]
+    private Vector3 randomRot;
+    [SerializeField]
+    [HideInInspector]
+    private float _lastHitSpeed = 0;
+    //dont break if we have already broken, only applies to self breaking logic, not by calling Smash()
+    bool broken = false;
+    //timeout
+    float collidedRecently = -1;
+	void Start () {
+        previousPos = transform.position;
+	}
+	//Smash function so it can be tied to buttons.
+    public void RandomizeColor()
+    {
+        color = new Color(Random.Range(0, 1), Random.Range(0, 1), Random.Range(0, 1), 1);
+    }
+    void OnCollisionEnter(Collision collision)
+    {
+        //set a timer for about 0.2s to be able to be broken
+        _lastHitSpeed = collision.impulse.magnitude;
+        if (collision.transform.tag != "Liquid")
+            collidedRecently = 0.2f;
+        
+    }
+
+    public void AttemptCollision(Collision col)
+    {
+        OnCollisionEnter(col);
+    }
+
+    public void RegisterColorBase(ColorBase cb)
+    {
+        registeredComponents.Add(cb);
+    }
+
+    public void ChangedColor()
+    {
+        if(cachedColor != color)
+        {
+            cachedColor = color;
+
+            //update all registered components
+            foreach (ColorBase cb in registeredComponents)
+            {
+                cb.Unify();
+            }
+        }
+    }
+    public Vector3 GetRandomRotation()
+    {
+        return randomRot;
+    }
+    public void RandomRotation()
+    {
+        randomRot = (Random.insideUnitSphere + Vector3.forward).normalized;
+    }
+
+    public void Smash()
+    {
+        
+        broken = true;
+        //the Corks collider needs to be turned on;
+        if (Cork != null)
+        {
+            Cork.transform.parent = null;
+            Cork.GetComponent<Collider>().enabled = true;
+            Cork.GetComponent<Rigidbody>().isKinematic = false;
+            Destroy(Cork.gameObject, DespawnTime);
+        }
+        //the Liquid gets removed after n seconds
+        if (Liquid != null)
+        {
+            float t = 0.0f;
+            //if (Effect != null)
+            //    t = (Effect.main.startLifetime.constantMin + Effect.main.startLifetime.constantMax)/2;
+            Destroy(Liquid.gameObject, t);
+        }
+        //particle effect
+        if(Effect != null)
+        {
+            Effect.Play();
+            Destroy(Effect.gameObject, Effect.main.startLifetime.constantMax);
+        }
+
+        //now the label;
+        if (Label != null)
+        {
+            //Label.transform.parent = null;
+            //Label.GetComponent<Collider>().enabled = true;
+            //Label.GetComponent<Rigidbody>().isKinematic = false;
+            Destroy(Label.gameObject);
+        }
+        //turn Glass off and the shattered on.
+        if (Glass != null)
+        {
+            Destroy(Glass.gameObject);
+        }
+        if (Glass_Shattered != null)
+        {
+            Glass_Shattered.SetActive(true);
+            Glass_Shattered.transform.parent = null;
+            Destroy(Glass_Shattered, DespawnTime);
+        }
+
+        //instantiate the splat.
+        RaycastHit info = new RaycastHit();
+        if(Splat != null)
+        if (Physics.Raycast(transform.position, Vector3.down, out info, maxSplatDistance, SplatMask))
+        {
+            GameObject newSplat = Instantiate(Splat);
+            newSplat.transform.position = info.point;
+            
+        }
+        Destroy(transform.gameObject, DespawnTime);
+
+    }
+	// Update is called once per frame, for the change in velocity and all that jazz...
+	void FixedUpdate () {
+        ChangedColor();
+
+        collidedRecently -= Time.deltaTime;
+        Vector3 currentVelocity = (transform.position - previousPos) / Time.fixedDeltaTime;
+        if ((onlyAllowShatterOnCollision && collidedRecently >= 0.0f) | !onlyAllowShatterOnCollision)
+        {
+            if (allowShattering)
+            {
+                if (Vector3.Distance(currentVelocity, previousVelocity) > shatterAtSpeed || _lastHitSpeed > shatterAtSpeed)
+                {
+                    if (!broken)
+                        Smash();
+                }
+            }
+        }
+        _lastHitSpeed = 0;
+
+        previousVelocity = currentVelocity;
+        previousPos = transform.position;
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/BottleSmash.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: aaf538c07796e5745a75c30bc3ec6117
+timeCreated: 1491022450
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7cebff22536f3734da4eba2d8b0fdf23
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/ColorBase.cs

@@ -0,0 +1,15 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ColorBase : MonoBehaviour {
+
+    protected virtual void RegisterWithController()
+    {
+
+    }
+    public virtual void Unify()
+    {
+
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/ColorBase.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 774af25737ccc4041a5c45bf551af4b3
+timeCreated: 1518256870
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/LiquidColor.cs

@@ -0,0 +1,50 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class LiquidColor : ColorBase {
+
+	// Use this for initialization
+    public BottleSmash bottleSmash;
+    private LiquidVolumeAnimator lva;
+    public bool UpdateSurfaceColor = true;
+    public bool UpdateColor = true;
+    public bool UpdateSurfaceEmission = true;
+    public bool UpdateEmission = true;
+    void Start ()
+	{
+	    //mat = GetComponent<MeshRenderer>();
+	    lva = GetComponent<LiquidVolumeAnimator>();
+        if(bottleSmash == null)
+        {
+            bottleSmash = GetComponentInParent<BottleSmash>();
+        }
+        RegisterWithController();
+	}
+    protected override void RegisterWithController()
+    {
+        bottleSmash.RegisterColorBase(this);
+    }
+    // Update is called once per frame
+    public override void Unify()
+	{
+        if (UpdateColor)
+        {
+            lva.mats[0].SetColor("_Color", bottleSmash.color);
+        }
+        if (UpdateEmission)
+        {
+            lva.mats[0].SetColor("_EmissionColor", bottleSmash.color);
+        }
+        if (UpdateSurfaceColor)
+        {
+            lva.mats[0].SetColor("_SColor", bottleSmash.color);
+        }
+        if (UpdateSurfaceEmission)
+        {
+            lva.mats[0].SetColor("_SEmissionColor", bottleSmash.color);
+            //ahh these need to be registered.
+        }
+
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/LiquidColor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 8821811f704fa594182c00cc2811db0f
+timeCreated: 1496904762
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/PS_Color.cs

@@ -0,0 +1,38 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PS_Color : ColorBase {
+
+    // Use this for initialization
+    public BottleSmash bottleSmash;
+    private ParticleSystem ps;
+    void Start ()
+    {
+        ps = GetComponent<ParticleSystem>();
+        if (bottleSmash == null)
+        {
+            bottleSmash = GetComponentInParent<BottleSmash>();
+        }
+        RegisterWithController();
+    }
+    protected override void RegisterWithController()
+    {
+        bottleSmash.RegisterColorBase(this);
+    }
+    // Update is called once per frame
+    public override void Unify()
+    {
+        UpdateValues();
+    }
+    public void UpdateValues ()
+	{
+        //get the main block.
+	    ParticleSystem.MainModule mm = ps.main;
+        //apply the color;
+        mm.startColor = new ParticleSystem.MinMaxGradient(bottleSmash.color);
+	    
+
+
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/PS_Color.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f8e6bfdb03686b84f93898dfd2b5116e
+timeCreated: 1496906557
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/ParticleColor.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ParticleColor : ColorBase {
+
+	// Use this for initialization
+    public BottleSmash bottleSmash;
+    private ParticleSystemRenderer ps;
+    public ColorID colorType;
+
+    public enum ColorID
+    {
+        _TintColor,
+        _Color
+    }
+
+	void Start ()
+	{
+	    ps = GetComponent<ParticleSystemRenderer>();
+        if (bottleSmash == null)
+        {
+            bottleSmash = GetComponentInParent<BottleSmash>();
+        }
+        RegisterWithController();
+    }
+    protected override void RegisterWithController()
+    {
+        bottleSmash.RegisterColorBase(this);
+    }
+    public override void Unify()
+    {
+        //apply the material color
+        switch (colorType)
+        {
+            case ColorID._TintColor:
+            {
+                ps.material.SetColor("_TintColor", bottleSmash.color);
+                break;
+            }
+            case ColorID._Color:
+            {
+                ps.material.SetColor("_Color", bottleSmash.color);
+                break;
+            }
+        }
+
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/ParticleColor.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 2e9c2f57237ace1488c320e2710ec995
+timeCreated: 1496905395
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/ResetColors.cs

@@ -0,0 +1,35 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ResetColors : MonoBehaviour {
+
+	// Use this for initialization
+    public LiquidVolumeAnimator LVA;
+    public float timeout = 5;
+    private float tReset;
+    public BottleSmash BS;
+	public Color Color1,Color2;
+	void Start ()
+	{
+	    tReset = timeout;
+
+	}
+	
+	// Update is called once per frame
+	void Update ()
+	{
+	    timeout -= Time.deltaTime;
+	    if (timeout <= 0.0f)
+	    {
+	        if(BS.color == Color1)
+                BS.color = Color2;
+	        else
+	        {
+	            BS.color = Color1;
+	        }
+	        LVA.level = 1;
+	        timeout = tReset;
+	    }
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ColorUnification/ResetColors.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 0eefa95962e56ea43905b3d2492fe268
+timeCreated: 1498035320
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/DemoRotation.cs

@@ -0,0 +1,24 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class DemoRotation : MonoBehaviour {
+
+	// Use this for initialization
+    private BottleSmash BS;
+    public float rotSpeed = 30.0f;
+	void Start ()
+	{
+	    BS = GetComponent<BottleSmash>();
+	}
+	
+	// Update is called once per frame
+	void Update () {
+		Vector3 a;
+		a = BS.GetRandomRotation ().normalized;
+		if(a != Vector3.zero)
+		if (Vector3.Dot(BS.GetRandomRotation ().normalized, (BS.transform.up + Vector3.up).normalized) < 0.98f) {
+			BS.transform.rotation = Quaternion.RotateTowards (BS.transform.rotation, Quaternion.LookRotation (BS.GetRandomRotation (), (BS.transform.up + Vector3.up).normalized), rotSpeed * Time.deltaTime);
+		}
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/DemoRotation.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f311986f616e27b4e821fd1db2a5ae89
+timeCreated: 1498116019
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ForceTest.cs

@@ -0,0 +1,23 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ForceTest : MonoBehaviour {
+
+	// Use this for initialization
+    public bool AddForce = false;
+    public Vector3 force;
+    private LiquidVolumeAnimator lva;
+	void Start () {
+        lva = GetComponent<LiquidVolumeAnimator>();
+	}
+	
+	// Update is called once per frame
+	void Update () {
+        if(AddForce)
+        {
+            lva.AddForce(force);
+            AddForce = false;
+        }
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/ForceTest.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4c3ce4b3b56a17a41843c0d0a9bc775b
+timeCreated: 1504421482
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidAbsorption.cs

@@ -0,0 +1,70 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class LiquidAbsorption : MonoBehaviour {
+
+    //public int collisionCount = 0;
+    public Color currentColor;
+    public BottleSmash smashScript;
+    public float particleValue = 0.02f;
+    public LiquidVolumeAnimator LVA;
+	// Use this for initialization
+	void Start () {
+        if(LVA == null)
+        LVA = GetComponent<LiquidVolumeAnimator>();
+	}
+    void OnParticleCollision(GameObject other)
+    {
+        //check if it is the same factory.
+        if (other.transform.parent == transform.parent)
+            return;
+        bool available = false;
+        if (smashScript.Cork == null)
+        {
+            available = true;
+        }
+        else
+        {
+            //if the cork is not on!
+            if (!smashScript.Cork.activeSelf)
+            {
+
+                available = true;
+            }
+                //or it is disabled (through kinamism)? is that even a word?
+            else if (!smashScript.Cork.GetComponent<Rigidbody>().isKinematic)
+            {
+                available = true;
+            }
+        }
+        if (available)
+        {
+            currentColor = smashScript.color;
+            if (LVA.level < 1.0f - particleValue)
+            {
+
+                //essentially, take the ratio of the bottle that has liquid (0 to 1), then see how much the level will change, then interpolate the color based on the dif.
+                Color impactColor = other.GetComponentInParent<BottleSmash>().color;
+
+                if (LVA.level <= float.Epsilon * 10)
+                {
+                    currentColor = impactColor;
+                }
+                else
+                {
+                    currentColor = Color.Lerp(currentColor, impactColor, particleValue / LVA.level);
+                }
+                //collisionCount += 1;
+                LVA.level += particleValue;
+                smashScript.color = currentColor;
+            }
+        }
+    }
+	// Update is called once per frame
+	void Update ()
+	{
+	    currentColor = smashScript.color;
+
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidAbsorption.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3c72153d81fccf5428e6e49ee41c9f4f
+timeCreated: 1496752098
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidAbsorptionV2.cs

@@ -0,0 +1,74 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class LiquidAbsorptionV2 : MonoBehaviour {
+
+    //public int collisionCount = 0;
+    public Color currentColor;
+    public BottleSmash smashScript;
+    public MeshLiquidEmission LiquidEmission;
+    public LiquidVolumeAnimator LVA;
+    // Use this for initialization
+    float particleValue = 1;
+
+    void Start () {
+        if(LVA == null)
+        LVA = GetComponent<LiquidVolumeAnimator>();
+	}
+    void OnParticleCollision(GameObject other)
+    {
+        //check if it is the same factory.
+        if (other.transform.parent == transform.parent)
+            return;
+        bool available = false;
+        if (smashScript.Cork == null)
+        {
+            available = true;
+        }
+        else
+        {
+            //if the cork is not on!
+            if (!smashScript.Cork.activeSelf)
+            {
+
+                available = true;
+            }
+                //or it is disabled (through kinamism)? is that even a word?
+            else if (!smashScript.Cork.GetComponent<Rigidbody>().isKinematic)
+            {
+                available = true;
+            }
+        }
+        float finalParticleValue = particleValue * (1.0f / LiquidEmission.volumeOfParticles);
+        if (available)
+        {
+            currentColor = smashScript.color;
+            if (LVA.level < 1.0f - finalParticleValue)
+            {
+
+                //essentially, take the ratio of the bottle that has liquid (0 to 1), then see how much the level will change, then interpolate the color based on the dif.
+                Color impactColor = other.GetComponentInParent<BottleSmash>().color;//cant be cached
+
+                if (LVA.level <= float.Epsilon * 10)
+                {
+                    currentColor = impactColor;
+                }
+                else
+                {
+                    currentColor = Color.Lerp(currentColor, impactColor, finalParticleValue / LVA.level);
+                }
+                //collisionCount += 1;
+                LVA.level += finalParticleValue;
+                smashScript.color = currentColor;
+                
+            }
+        }
+    }
+	// Update is called once per frame
+	void Update ()
+	{
+	    currentColor = smashScript.color;
+
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidAbsorptionV2.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 425a25cf2882b0549b0fc086445c4036
+timeCreated: 1496752098
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidPool.cs

@@ -0,0 +1,49 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class LiquidPool : MonoBehaviour {
+
+	// Use this for initialization
+    public float minSize = 0.5f;
+    public float maxSize = 1.0f;
+    public float timeToComplete = 0.5f;
+    float randomSize;
+    float currentTime = 0.0f;
+    bool fadingOut = false;
+    MeshRenderer mr;
+    Material mat;
+	void Start () {
+
+        transform.localScale = Vector3.zero;
+        randomSize = Random.Range(minSize, maxSize);
+        mr = GetComponent<MeshRenderer>();
+        mat = mr.material;
+        mat = Instantiate(mat);
+        mr.material = mat;
+	}
+	
+	// Update is called once per frame
+	void Update () {
+        currentTime += Time.deltaTime * ((fadingOut) ? -1 : 1);
+        if (currentTime >= timeToComplete)
+        {
+            fadingOut = true;
+        }
+        if(fadingOut)
+        {
+            mat.color = new Color(mat.color.r,mat.color.g,mat.color.b,Mathf.Lerp(0.0f, 1.0f, currentTime/timeToComplete));
+        }
+        else
+        {
+            transform.localScale = Vector3.one * Mathf.Lerp(0.0f, randomSize, currentTime / timeToComplete);
+        }
+        if(fadingOut)
+        {
+            if(currentTime <= 0)
+            {
+                Destroy(transform.gameObject);
+            }
+        }
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidPool.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 882eae614fd4a1744a300f31e7a3506a
+timeCreated: 1491029086
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidVolumeAnimator.cs

@@ -0,0 +1,330 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+[System.Serializable]
+public class LiquidVolumeAnimator : MonoBehaviour {
+
+	// Use this for initialization
+    //just incase we have multiple materials;
+    [HideInInspector]
+    [SerializeField]
+    public Material[] mats;
+    //the level of the liquid on a hyperplane.
+    [Range(0,1)]
+    [SerializeField]
+    public float level = 0.5f;
+    private float finalLevel;
+    
+    //the current bound given a direction
+    public Vector2 minMaxBounds;
+    //the mesh to 
+    [HideInInspector]
+    [SerializeField]
+    private MeshFilter mf;
+    [HideInInspector]
+    [SerializeField]
+    private MeshRenderer mr;
+    [HideInInspector]
+    [SerializeField]
+    private Mesh m;
+    //in order to see how its working, physics is kind of hacked in
+    public bool DebugAnchor = false;
+    //debugsize is how large the handles are
+    public float debugSize = 1.0f;
+    //how much mass it has? kind of?
+    public float _anchorLength = 0.5f;
+    //how much the rotation and movement applies to the anchor
+    [Range(0,1)]
+    public float dampening;
+    //it always wants to be rotated to down
+    [HideInInspector]
+    [SerializeField]
+    private Vector3 anchor;
+    //velocity of the direction of 'gravity'
+    [HideInInspector]
+    [SerializeField]
+    private Vector3 anchorVelocity;
+    //direction of velocity after clamp. ALSO used to see if the position has changed and use that as a velocity reference;
+    [HideInInspector]
+    [SerializeField]
+    private Vector3 transformedPoint, prevTransformedPoint;
+    public bool calculateTextureProjection = true;
+    public float TextureSize = 1.0f;
+    public float TextureSizeScalar = 1;
+    public AnimationCurve texCurveSize = AnimationCurve.Linear(0, 1, 1, 1);
+    //for rotation of the texture;
+    Quaternion previous;
+    float totalRotation = 0.0f;
+    [HideInInspector]
+    [SerializeField]
+    private Vector3 TopLeft, TopRight, BottomLeft, BottomRight;
+
+    public Transform ExposedLiquidT;
+    public Vector3 GravityDirection = Vector3.down;
+    public bool normalizeGravityDirection = true;
+    //vert cache
+    [HideInInspector]
+    [SerializeField]
+    Vector3[] verts;
+	int shader_Key_localHeight;
+	int shader_Key_anchor;
+	int shader_Key_point;
+	int shader_Key_level;
+    float prvLevel = -1;
+    Quaternion prevQ = Quaternion.identity;
+    //for debugging purposes
+    //for caching
+    [HideInInspector]
+    [SerializeField]
+    Vector3 cPos = Vector3.zero;
+
+	//output values:
+	public Vector3 finalAnchor, finalPoint;
+    [HideInInspector]
+    [SerializeField]
+    string[] shaderNames;
+    void OnDrawGizmosSelected()
+    {
+        float anchorLength = _anchorLength * Mathf.Max(transform.lossyScale.x, transform.lossyScale.y, transform.lossyScale.z);
+        if(DebugAnchor)
+        {
+            cPos = transform.position;
+            //Vector3 prevTransformedPointD = transform.TransformDirection(Vector3.down);
+            Vector3 anchorD = cPos - transform.TransformDirection(Vector3.up) * anchorLength;
+            if (anchor == Vector3.zero)
+                anchor = anchorD;
+            //makes sure something is available (even while not playing).
+
+            CalculateSquare(anchor);
+            //the location of the anchor (static)
+            Gizmos.DrawSphere(anchorD, 0.25f * transform.lossyScale.magnitude * 0.1f * debugSize);
+            //line between the anchor and the surface
+            Gizmos.DrawLine(cPos, anchorD);
+            Gizmos.color = Color.blue;
+            //the ocation of the anchor (physics)
+            Gizmos.DrawSphere(anchor, 0.25f * transform.lossyScale.magnitude * 0.1f * debugSize);
+           
+            Gizmos.color = Color.red;
+            Gizmos.DrawSphere(cPos - (anchorD - cPos).normalized * finalLevel, 0.1f * transform.lossyScale.magnitude * 0.01f * debugSize);
+            //All four corners of the texture
+            Gizmos.color = Color.yellow;
+            Gizmos.DrawSphere(TopLeft, 0.25f * transform.lossyScale.magnitude * 0.01f * debugSize);
+            Gizmos.DrawSphere(TopRight, 0.25f * transform.lossyScale.magnitude * 0.01f * debugSize);
+            Gizmos.DrawSphere(BottomLeft, 0.25f * transform.lossyScale.magnitude * 0.01f * debugSize);
+            Gizmos.DrawSphere(BottomRight, 0.25f * transform.lossyScale.magnitude * 0.01f * debugSize);
+            Gizmos.color = Color.white;
+            CalculateSquare(anchor);
+        }
+    }
+
+    void CalculateSquare(Vector3 anch)
+    {
+        if (!calculateTextureProjection)
+        {
+            return;
+        }
+        Vector3 pos1 = cPos - (anch - cPos).normalized * finalLevel;
+        Vector3 nrm = (cPos - (anch - cPos).normalized * finalLevel - anch).normalized;
+        Vector3 beginningRight = Quaternion.Euler(0, totalRotation, 0) * Vector3.right;
+        Vector3 f1 = Vector3.Cross(beginningRight, nrm.normalized).normalized;
+        Vector3 r1 = Vector3.Cross(f1, nrm).normalized;
+        f1 = Vector3.Cross(r1, nrm).normalized;
+        float tSize = TextureSize * texCurveSize.Evaluate(Mathf.Clamp01(level)) * transform.lossyScale.magnitude * 0.001f;
+        
+        TopLeft = r1 * tSize + f1 * tSize + pos1;
+        TopRight = r1 * tSize * -1 + f1 * tSize + pos1;
+        BottomLeft = r1 * tSize + f1 * tSize * -1 + pos1;
+        BottomRight = r1 * tSize * -1 - f1 * tSize + pos1;
+    }
+
+	void Start ()
+	{
+        cPos = transform.position;
+		shader_Key_localHeight = Shader.PropertyToID ("_localHeight");
+		shader_Key_anchor = Shader.PropertyToID ("_anchor");
+		shader_Key_point = Shader.PropertyToID ("_point");
+		shader_Key_level = Shader.PropertyToID ("_level");
+        //delta
+		prevTransformedPoint = transformedPoint = transform.TransformDirection((normalizeGravityDirection) ? GravityDirection.normalized : GravityDirection);
+        //anchor = cPos - transform.TransformDirection(Vector3.up) * anchorLength;
+        anchor -= ((normalizeGravityDirection) ? GravityDirection.normalized : GravityDirection) * -1 * Time.deltaTime * (1.0f - dampening);
+        anchor.Normalize();
+	    mr = GetComponent<MeshRenderer>();
+	    mats = mr.materials;
+        shaderNames = new string[mats.Length];
+
+        for (int i = 0; i < mats.Length; ++i)
+	    {
+	        mats[i] = Instantiate(mats[i]);
+            shaderNames[i] = mats[i].shader.name;
+
+        }
+	    mf = GetComponent<MeshFilter>();
+	    m = mf.sharedMesh;
+		verts = new Vector3[m.vertices.Length];
+	    verts = m.vertices;
+	    minMaxBounds.x = minMaxBounds.y = verts[0].y;
+        
+	    for (int i = 0; i < verts.Length; ++i)
+	    {
+            Vector3 wPos = transform.TransformDirection(verts[i]);
+            if (wPos.y > minMaxBounds.y)
+	        {
+	            minMaxBounds.y = wPos.y;
+	        }
+	        if (wPos.y < minMaxBounds.x)
+	        {
+	            minMaxBounds.x = wPos.y;
+	        }
+	    }
+	    minMaxBounds.x -= cPos.y;
+	    minMaxBounds.y -= cPos.y;
+	    for (int i = 0; i < mats.Length; ++i)
+	    {
+			mats[i].SetFloat(shader_Key_localHeight, Mathf.Lerp(minMaxBounds.x,minMaxBounds.y,level));
+	    }
+
+	    mr.materials = mats;
+
+	}
+	public void AddForce(Vector3 force)
+    {
+        anchorVelocity += force;
+    }
+	// Update is called once per frame
+	void FixedUpdate ()
+	{
+        cPos = transform.position;
+        float nLength = _anchorLength * Mathf.Max(transform.lossyScale.x, transform.lossyScale.y, transform.lossyScale.z);
+        //prevTransformedPoint = transform.TransformDirection(Vector3.down);
+        //anchor = transform.position - transform.TransformDirection(Vector3.up) * nLength;
+        transformedPoint = transform.TransformDirection((normalizeGravityDirection) ? GravityDirection.normalized : GravityDirection);
+        
+        ////Now we need to move the anchor down by gravity;
+        //anchorVelocity += Vector3.down * Time.deltaTime * 0.1f;
+        anchor += anchorVelocity * (1.0f - dampening);
+        Vector3 prevPos = anchor;
+        anchor -= ((normalizeGravityDirection) ? GravityDirection.normalized : GravityDirection) * -1 * Time.deltaTime * (1.0f - dampening);
+        
+        //clamp it
+        float d = Vector3.Distance(anchor, cPos);
+        //float difference = (nLength - d) / d;
+        //float d2 = d / nLength;
+
+        if (d > nLength)
+        {
+            anchor = cPos + (anchor - cPos).normalized * nLength;
+            //connections[i].position = connections[i].position + (cPos - connections[i].position).normalized * difference * 0.5f;
+        }
+		Vector3 addition = (anchor - prevPos) + (transformedPoint - prevTransformedPoint) * -1 * (1.0f / nLength) * Time.deltaTime;
+		//if there is no change dont bother updating.
+		if (addition == Vector3.zero)
+        {
+            if (prvLevel == level && prevQ == transform.rotation)
+			    return;
+        }
+        anchorVelocity += addition;
+        //find the difference and add it to the velocity;
+
+        //Vector3 lastPos = anchor;
+        //anchor += anchorVelocity * Time.deltaTime;
+        //anchor = (anchor - cPos).normalized * anchorLength;
+        //add the direction as velocity;
+        //anchorVelocity += (b - lastPos);
+        Matrix4x4 localToWorld = transform.localToWorldMatrix;
+        minMaxBounds.x = minMaxBounds.y = (transform.TransformPoint(verts[0])).y;
+        for (int i = 0; i < verts.Length; ++i)
+        {
+            Vector3 wPos = localToWorld.MultiplyPoint(verts[i]);
+            //Vector3 wPos = transform.TransformPoint(verts[i]);
+            if (wPos.y > minMaxBounds.y)
+            {
+                minMaxBounds.y = wPos.y;
+            }
+            if (wPos.y < minMaxBounds.x)
+            {
+                minMaxBounds.x = wPos.y;
+            }
+        }
+        minMaxBounds.y -= cPos.y;
+        minMaxBounds.x -= cPos.y;
+        //minMaxBounds.x += cPos.y;
+        //minMaxBounds.y += cPos.y;
+        finalLevel = Mathf.Lerp(minMaxBounds.x, minMaxBounds.y, level);
+        if(level <= Single.Epsilon * 10)
+        {
+            //dont render (turn off renderer)
+            anchor = Vector3.down * nLength + cPos;
+        }
+		finalPoint = (cPos - (anchor - cPos).normalized * finalLevel);
+			
+        for (int i = 0; i < mats.Length; ++i)
+        {
+			mats[i].SetFloat(shader_Key_localHeight, Mathf.Lerp(minMaxBounds.x - Single.Epsilon * 10, minMaxBounds.y + Single.Epsilon * 10, level));
+			mats[i].SetVector(shader_Key_anchor, transform.InverseTransformPoint(anchor));
+			mats[i].SetVector(shader_Key_point, transform.InverseTransformPoint(cPos - (anchor - cPos).normalized * finalLevel));
+			mats[i].SetFloat(shader_Key_level, level - Single.Epsilon);//to make sure its not rendered accidentally by rotations
+        }
+
+
+        //lets update the size of the plane (for texture projection);
+	   // Vector3 anchorD = cPos - transform.TransformDirection(Vector3.up) * anchorLength;
+		finalAnchor = anchor;
+        CalculateSquare(anchor);
+        //lets find the delta y rotation; (global);
+        //Quaternion rot = Quaternion.RotateTowards(previous, transform.rotation, 360);
+        //make two quaternions static on the xz plane (only rotation about the y)
+        Quaternion q1 = Quaternion.LookRotation(previous * Vector3.right, Vector3.up);
+        //to find the obtuse angle
+        Vector3 vqf = q1 * Vector3.right;
+        //returns the acute angle, very cute indeed.
+        Quaternion q2 = Quaternion.LookRotation(transform.rotation * Vector3.right, Vector3.up);
+        float angle = Quaternion.Angle(q1, q2) * ((Vector3.Dot(vqf,q2 * Vector3.forward) < 0) ? -1 : 1);
+        float ydelta = angle;
+        //to correct weird rotations (from cross product potentially). (approximation errors)
+        if(Mathf.Abs(ydelta) > 0.05f)
+        totalRotation += ydelta;
+        if(totalRotation > 360)
+        {
+            totalRotation -= 360;
+        }
+        else if(totalRotation < 0)
+        {
+            totalRotation += 360;
+        }
+
+        if (ExposedLiquidT != null)
+        {
+            ExposedLiquidT.position = cPos - (anchor - cPos).normalized * finalLevel;
+            ExposedLiquidT.localScale = Vector3.one *texCurveSize.Evaluate(Mathf.Clamp01(level)) * transform.lossyScale.magnitude * 0.001f * TextureSize * TextureSizeScalar;
+            ExposedLiquidT.up = (finalPoint - finalAnchor).normalized;
+            
+        }
+
+
+        prevTransformedPoint = transformedPoint;
+        previous = transform.rotation;
+        //finally, lets set the plane.
+
+        Vector4 sTopLeft = transform.InverseTransformPoint(TopLeft);
+        Vector4 sTopRight = transform.InverseTransformPoint((TopRight));
+        Vector4 sBotLeft = transform.InverseTransformPoint((BottomLeft));
+        Vector4 sBotRight = transform.InverseTransformPoint((BottomRight));
+        Vector4 sCenter = transform.InverseTransformPoint(cPos - (anchor - cPos).normalized * finalLevel);
+        for (int i = 0; i < mats.Length; ++i)
+        {
+			if (!shaderNames[i].Contains ("_Texture"))
+				continue;
+			mats[i].SetVector("_TL", sTopLeft);
+			mats[i].SetVector("_TR", sTopRight);
+			mats[i].SetVector("_BL", sBotLeft);
+			mats[i].SetVector("_BR", sBotRight);
+			mats[i].SetVector("_CENTER", sCenter);
+        }
+        prvLevel = level;
+        prevQ = transform.rotation;
+
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/LiquidVolumeAnimator.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: eaa316a3d12ddaa4e83caf66ca7e9804
+timeCreated: 1490790906
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/MeshLiquidEmission.cs

@@ -0,0 +1,358 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+public class MeshLiquidEmission : MonoBehaviour {
+
+    // Use this for initialization
+    [System.Serializable]
+    private class BVertex
+    {
+        public Vector3 p;
+        public Vector3 n;
+        public bool b;
+    }
+    [HideInInspector]
+    [SerializeField]
+    private MeshFilter r;
+    
+	public LiquidVolumeAnimator LVA;
+    [HideInInspector]
+    [SerializeField]
+    int[] calculatedTriangles;
+    [HideInInspector]
+    [SerializeField]
+    BVertex[] calculatedVerts;
+    public ParticleSystem system;
+    float particlesToEmit = 0;
+    public float emissionSpeed = 0.0f;
+	private Mesh m;
+    [HideInInspector]
+    [SerializeField]
+    int[] tris;
+    [HideInInspector]
+    [SerializeField]
+    Vector3[] verts, norms;
+    public bool debug = false;
+    public float debugScale = 1.0f;
+    public bool CullNullNormals = false;
+    public Rigidbody Cork;
+    public float volumeOfParticles = 70.0f;
+    public bool emitting = true;
+    public BottleSmash bottleSmash;
+    public float angleSpeedScalar = 1.0f;
+    int CVOB = 0;
+    void Start () {
+        r = GetComponent<MeshFilter>();
+		m = r.mesh;
+        calculatedVerts = new BVertex[m.vertexCount * 6];
+
+        for(int i = 0; i < calculatedVerts.Length; ++i)
+        {
+            calculatedVerts[i] = new BVertex();
+        }
+        verts = m.vertices;
+        tris = m.triangles;
+        norms = m.normals;
+    }
+    bool LinePlaneIntersection(Vector3 p0, Vector3 p1, Vector3 planePoint, Vector3 planeNormal, out Vector3 coordinate)
+    {
+        Vector3 line = p1 - p0;
+        coordinate = Vector3.zero;
+        float d = Vector3.Dot(planeNormal.normalized, line);
+        if(Mathf.Abs(d) > float.Epsilon)
+        {
+            Vector3 w = p0 - planePoint;
+            float fac = (Vector3.Dot(planeNormal.normalized, w) * -1) / d;
+            line = line * fac;
+            coordinate = p0 + line;
+            return true;
+        }
+        else
+        {
+            
+            return false;
+        }
+    }
+	void OnDrawGizmos()
+	{
+        if (!debug)
+            return;
+        if(calculatedVerts != null)
+        {
+            for(int i =0; i < calculatedVerts.Length; ++i)
+            {
+                if (!calculatedVerts[i].b)
+                    break;
+                Gizmos.DrawSphere(transform.TransformPoint(calculatedVerts[i].p), 0.01f * transform.lossyScale.magnitude * debugScale);
+            }
+        }
+
+
+    }
+	// Update is called once per frame
+    void SetDual(int under1, int under2, int above, ref Vector3 dir, ref Vector3 lpos, ref int currentVOB, ref Vector3 tmpV)
+    {
+        
+        calculatedVerts[currentVOB].p = verts[under1];
+        calculatedVerts[currentVOB].n = norms[under1];
+        calculatedVerts[currentVOB].b = true;
+
+        LinePlaneIntersection(verts[under1], verts[above], lpos, (dir * -1), out tmpV);
+        calculatedVerts[currentVOB + 1].p = tmpV;
+        calculatedVerts[currentVOB + 1].n = Vector3.Lerp(norms[under1], norms[above], (tmpV - verts[under1]).magnitude / (verts[under1] - verts[above]).magnitude);
+        calculatedVerts[currentVOB + 1].b = true;
+
+        calculatedVerts[currentVOB + 2].p = verts[under2];
+        calculatedVerts[currentVOB + 2].n = norms[under2];
+        calculatedVerts[currentVOB + 2].b = true;
+
+        calculatedVerts[currentVOB + 3].p = verts[under2];
+        calculatedVerts[currentVOB + 3].n = norms[under2];
+        calculatedVerts[currentVOB + 3].b = true;
+
+        calculatedVerts[currentVOB + 4].p = tmpV;
+        calculatedVerts[currentVOB + 4].n = calculatedVerts[currentVOB + 1].n;
+        calculatedVerts[currentVOB + 4].b = true;
+
+        LinePlaneIntersection(verts[under2], verts[above], lpos, (dir * -1), out tmpV);
+        calculatedVerts[currentVOB + 5].p = tmpV;
+        calculatedVerts[currentVOB + 5].n = Vector3.Lerp(norms[under2], norms[above], (tmpV - verts[under2]).magnitude / (verts[under2] - verts[above]).magnitude);
+        calculatedVerts[currentVOB + 5].b = true;
+    }
+    void SetDualInverted(int under1, int above1, int above2, ref Vector3 dir, ref Vector3 lpos, ref int currentVOB, ref Vector3 tmpV)
+    {
+
+        calculatedVerts[currentVOB].p = verts[under1];
+        calculatedVerts[currentVOB].n = norms[under1];
+        calculatedVerts[currentVOB].b = true;
+
+        LinePlaneIntersection(verts[under1], verts[above1], lpos, (dir * -1), out tmpV);
+        calculatedVerts[currentVOB + 1].p = tmpV;
+        calculatedVerts[currentVOB + 1].n = Vector3.Lerp(norms[under1], norms[above1], (tmpV - verts[under1]).magnitude / (verts[under1] - verts[above1]).magnitude);
+        calculatedVerts[currentVOB + 1].b = true;
+
+        LinePlaneIntersection(verts[under1], verts[above2], lpos, (dir * -1), out tmpV);
+        calculatedVerts[currentVOB + 2].p = tmpV;
+        calculatedVerts[currentVOB + 2].n = Vector3.Lerp(norms[under1], norms[above2], (tmpV - verts[under1]).magnitude / (verts[under1] - verts[above2]).magnitude);
+        calculatedVerts[currentVOB + 2].b = true;
+
+    }
+    void CalculateTrianglesToEmitFrom(int[] tris, Vector3[] verts)
+    {
+        Vector3 dir = (LVA.finalAnchor - LVA.finalPoint).normalized;
+        Vector3 lpos = transform.InverseTransformPoint(LVA.finalPoint);
+        dir = transform.InverseTransformDirection(dir).normalized;
+        int currentVOB = 0;
+        Vector3 tmpV = Vector3.zero;
+        //for every triangle, check if ANY vertex is below the level.   
+        for (int i = 2; i < tris.Length; i+=3)
+        {
+            int v1i = tris[i - 2], v2i = tris[i - 1], v3i = tris[i];
+            Vector3 v1 = verts[v1i], v2 = verts[v2i], v3 = verts[v3i];
+            
+            Vector3 v1d = v1 - lpos;
+            bool v1b = Vector3.Dot(dir, v1d) >= 0;
+            Vector3 v2d = v2 - lpos;
+            bool v2b = Vector3.Dot(dir, v2d) >= 0;
+            Vector3 v3d = v3 - lpos;
+            bool v3b = Vector3.Dot(dir, v3d) >= 0;
+            //all are under
+            if(v3b && v2b && v1b)
+            {
+                //add ALL vertices to buffer
+                calculatedVerts[currentVOB].p = v1;
+                calculatedVerts[currentVOB].n = norms[v1i];
+                calculatedVerts[currentVOB].b = true;
+                calculatedVerts[currentVOB+1].p = v2;
+                calculatedVerts[currentVOB+1].n = norms[v2i];
+                calculatedVerts[currentVOB+1].b = true;
+                calculatedVerts[currentVOB+2].p = v3;
+                calculatedVerts[currentVOB+2].n = norms[v2i];
+                calculatedVerts[currentVOB+2].b = true;
+                currentVOB += 3;
+                continue;
+
+            }
+            else if(!(v3b || v2b || v1b))
+            {
+                //none are in, do nothing
+                continue;
+            }
+            else
+            {
+                //one or TWO of them out of 3 are under;
+                bool found = false;
+                if(v1b && v2b)
+                {
+
+                    //subdivide face with projected vertices
+                    SetDual(v1i, v2i, v3i, ref dir, ref lpos, ref currentVOB, ref tmpV);
+                    currentVOB += 6;
+                    found = true;
+                }
+                if (v1b && v3b)
+                {
+                    SetDual(v1i, v3i, v2i, ref dir, ref lpos, ref currentVOB, ref tmpV);
+                    currentVOB += 6;
+                    found = true;
+                }
+                if (v2b && v3b)
+                {
+                    SetDual(v3i, v2i, v1i, ref dir, ref lpos, ref currentVOB, ref tmpV);
+                    currentVOB += 6;
+                    found = true;
+                }
+                if(found)
+                {
+                    continue;
+                }
+                if(v1b)
+                {
+                    SetDualInverted(v1i, v2i, v3i, ref dir, ref lpos, ref currentVOB, ref tmpV);
+                    currentVOB += 3;
+                    
+                    continue;
+                }
+                if (v2b)
+                {
+                    SetDualInverted(v2i, v1i, v3i, ref dir, ref lpos, ref currentVOB, ref tmpV);
+                    currentVOB += 3;
+
+                    continue;
+                }
+                if (v3b)
+                {
+                    SetDualInverted(v3i, v2i, v1i, ref dir, ref lpos, ref currentVOB, ref tmpV);
+                    currentVOB += 3;
+
+                    continue;
+                }
+                continue;
+            }
+
+        }
+        if(currentVOB < calculatedVerts.Length)
+        {
+            calculatedVerts[currentVOB].b = false;
+        }
+        CVOB = currentVOB;
+
+    }
+    float GetPS_StartSpeed()
+    {
+        switch (system.main.startSpeed.mode)
+        {
+            case ParticleSystemCurveMode.TwoConstants:
+                return UnityEngine.Random.Range(system.main.startSpeed.constantMin, system.main.startSpeed.constantMax);
+            case ParticleSystemCurveMode.Constant:
+                return system.main.startSpeed.constant;
+            case ParticleSystemCurveMode.Curve:
+                return system.main.startSpeed.Evaluate(UnityEngine.Random.value);
+            case ParticleSystemCurveMode.TwoCurves:
+                return system.main.startSpeed.Evaluate(UnityEngine.Random.value);
+
+            default:
+                return 0.0f;
+        }
+    }
+    bool EmitFromSubmesh()
+    {
+        //randomly select ONE triangle;
+        // div by 3
+
+        int index = UnityEngine.Random.Range(0,(CVOB / 3)-1);
+        //multiply out to corresponding id;
+        index *= 3;
+        //find the position to emit from;
+        //pick vert1, lerp to v2 randomly, then v3 randomly.
+        float r1 = UnityEngine.Random.value;
+        float r2 = UnityEngine.Random.value;
+        Vector3 pos = Vector3.Lerp(calculatedVerts[index].p, calculatedVerts[index + 1].p, r1);
+        Vector3 nrm = Vector3.Lerp(calculatedVerts[index].n, calculatedVerts[index + 1].n, r1).normalized;
+        pos = Vector3.Lerp(pos, calculatedVerts[index + 2].p, r2);
+        nrm = Vector3.Lerp(nrm, calculatedVerts[index + 2].n, r2).normalized;
+        //ParticleSystem.Particle p = new ParticleSystem.Particle();
+        //p.position = pos;
+        //p.angularVelocity3D = 
+        ParticleSystem.EmitParams param = new ParticleSystem.EmitParams();
+        float pouringAngle = 1;
+
+        if (bottleSmash != null)
+        {
+            Vector3 wNrm = transform.TransformDirection(nrm).normalized;
+            pouringAngle = ((1.0f + Vector3.Dot((LVA.finalAnchor - LVA.finalPoint).normalized, wNrm))/2.0f);
+            param.velocity = wNrm * GetPS_StartSpeed() * pouringAngle * angleSpeedScalar;
+        }
+        else
+        {
+            param.velocity = transform.TransformDirection(nrm).normalized * GetPS_StartSpeed();
+        }
+        
+        param.position = transform.TransformPoint(pos);
+        if (param.velocity == Vector3.zero && CullNullNormals)
+            return false;
+
+        particlesToEmit -= 1;
+
+        //adjust level
+        if (Cork != null)
+        {
+            if (Cork.isKinematic && volumeOfParticles > 0)
+            {
+                //
+                LVA.level = Mathf.Clamp01((volumeOfParticles * LVA.level - 1) / volumeOfParticles);
+                
+            }
+        }
+        else if(volumeOfParticles > 0)
+        {
+            LVA.level = Mathf.Clamp01((volumeOfParticles * LVA.level - 1) / volumeOfParticles);
+        }
+
+        system.Emit(param, 1);
+        return true;
+    }
+	void Update () {
+
+        if (!emitting || Cork != null)
+            return;
+        if (LVA.level <= 0)
+            return;
+        CalculateTrianglesToEmitFrom(tris, verts);
+        //triangles are in order
+        particlesToEmit += emissionSpeed * Time.deltaTime;
+        if(calculatedVerts.Length == 0)
+        {
+            particlesToEmit = 0;
+        }
+        else
+        {
+            if(calculatedVerts[0].b == false)
+                particlesToEmit = 0;
+        }
+        int maxFailInASeq = 10;
+        int seq = maxFailInASeq;
+        while(particlesToEmit > 0 && (GetPS_StartSpeed() > 0 || !CullNullNormals))
+        {
+            if (EmitFromSubmesh())
+            {
+                seq = maxFailInASeq;
+            }
+            else
+            {
+                seq -= 1;
+            }
+            if (seq <= 0)
+            {
+                break;
+            }
+
+            
+        }
+
+
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/MeshLiquidEmission.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 23f1469ed98ee1c4a95001a5905576fb
+timeCreated: 1514976424
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/Physics.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 812c09618a5f00248947f77f1f89fd55
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/Physics/ConveyImpacts.cs

@@ -0,0 +1,13 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class ConveyImpacts : MonoBehaviour {
+
+    public GhostPhysics _physics;
+
+    void OnCollisionEnter(Collision collision)
+    {
+        _physics.SendCollision(collision);
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/Physics/ConveyImpacts.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 7b36b887c8b0e7b44be11b2c95dd6f42
+timeCreated: 1532345246
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/Physics/GhostPhysics.cs

@@ -0,0 +1,71 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class GhostPhysics : MonoBehaviour {
+
+    // Use this for initialization
+    private BottleSmash _smash;
+    private Transform _ghost;
+
+    public GameObject _ghostObject;
+    public bool _redirectSelection = false;
+
+    [Header("Reference")]
+    public Transform _externalTransform;
+
+	void Start () {
+        _smash = GetComponent<BottleSmash>();
+        _ghost = Instantiate(_ghostObject).transform;
+        _ghost.position = transform.position;
+        _ghost.rotation = transform.rotation;
+        _ghost.localScale = _smash.Glass.transform.localScale;
+        _externalTransform = _ghost;
+        MeshCollider mc = _ghost.gameObject.GetComponent<MeshCollider>();
+        mc.sharedMesh = _smash.Glass.GetComponent<MeshFilter>().sharedMesh;
+
+        _ghost.GetComponent<ConveyImpacts>()._physics = this;
+
+	}
+
+    private void OnDestroy()
+    {
+        if (_ghost != null)
+        {
+            Destroy(_ghost.gameObject);
+        }
+    }
+
+    public void SendCollision(Collision col)
+    {
+        if (_smash != null)
+        {
+            _smash.AttemptCollision(col);
+        }
+    }
+
+    public Transform GetController()
+    {
+
+        return _ghost;
+
+    }
+
+    // Update is called once per frame
+    void Update () {
+		if(_ghost != null)
+        {
+            transform.position = _ghost.position;
+            transform.rotation = _ghost.rotation;
+        }
+#if UNITY_EDITOR
+        if(_redirectSelection)
+        {
+            if(UnityEditor.Selection.activeTransform == this.transform)
+            {
+                UnityEditor.Selection.activeTransform = _ghost;
+            }
+        }
+#endif
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/Physics/GhostPhysics.cs.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 1fe6f8fb1a6321d45b7b7991928c4ef2
+timeCreated: 1532341479
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/PickUpPotion.cs

@@ -0,0 +1,69 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PickUpPotion : MonoBehaviour {
+
+	// Use this for initialization
+    private GameObject Obj;
+    private Rigidbody rObj;
+    private float dist;
+	float d;
+	public float offsetValue = 1;
+	private Vector2 beginDist;
+	void Start () {
+		
+	}
+	
+	// Update is called once per frame
+	void Update () {
+
+        Ray r = Camera.main.ScreenPointToRay(Input.mousePosition);
+        if (Input.GetMouseButtonDown(0) && Obj == null)
+        {
+
+
+            RaycastHit hitInfo = new RaycastHit();
+            
+            bool hit = Physics.Raycast(r, out hitInfo);
+            if (hit)
+            {
+                //Debug.Log("Hit " + hitInfo.transform.gameObject.name);
+                if (hitInfo.transform.gameObject.tag == "Potion")
+                {
+                    dist = hitInfo.distance;
+					beginDist = Input.mousePosition;
+                    Obj = hitInfo.transform.gameObject;
+                    rObj = Obj.GetComponent<Rigidbody>();
+                }
+                else
+                {
+
+                }
+            }
+            else
+            {
+
+            }
+        }
+        else if(Obj !=null && Input.GetMouseButtonDown(0))
+        {
+            rObj.isKinematic = false;
+            rObj.useGravity = true;
+            rObj = null;
+            Obj = null;
+        }
+        if(Obj != null)
+        {
+			Vector2 d1 = (beginDist - (Vector2)Input.mousePosition);
+			d1 = new Vector2 (d1.x / (beginDist.x / 2), d1.y / (beginDist.y / 2));
+			d = d1.magnitude;
+			Obj.transform.position = r.origin + r.direction.normalized * dist + (r.direction.normalized * (d) * -1 * offsetValue);  
+
+        }
+
+            
+
+		
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/PickUpPotion.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 781a203698e6c8a4f93445cb25c35090
+timeCreated: 1510145323
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/PourLiquid.cs

@@ -0,0 +1,73 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class PourLiquid : MonoBehaviour {
+
+	// Use this for initialization
+    //how quickly it takes to empty
+    public float rateOfFlow = 1.0f;
+    //such b....stuff
+    public BottleSmash smashScript;
+    public LiquidVolumeAnimator liquid;
+    public Transform controllingTransform;
+    public ParticleSystem pouringParticleSystem;
+    //how many particles it takes to empty
+    public float volumeOfParticles = 70.0f;
+    private Rigidbody corkRB;
+	void Start () {
+        if (smashScript != null)
+        {
+            if (smashScript.Cork != null)
+            {
+                corkRB = smashScript.Cork.GetComponent<Rigidbody>();
+            }
+        }
+	}
+	
+	// Update is called once per frame
+	void Update () {
+        if(corkRB != null)
+        {
+            if (corkRB.isKinematic)
+                return;
+            else if (!corkRB.gameObject.activeInHierarchy)
+                return;
+        }
+
+        float d = Vector3.Dot(controllingTransform.up, (liquid.finalPoint  - liquid.finalAnchor).normalized);
+        float d2 = (d + 1.0f) / 2;
+        float particleVal = 0.0f;
+        if(d2 < liquid.level)
+        {
+            particleVal = (liquid.level - d2) * rateOfFlow;
+            liquid.level = Mathf.Lerp(liquid.level, d2, Time.deltaTime * rateOfFlow);
+        }
+        if(d <= 0.0f)
+        {
+            if(liquid.level > float.Epsilon)
+                particleVal = liquid.level;
+            liquid.level = Mathf.Lerp(liquid.level, 0, Time.deltaTime * rateOfFlow);
+        }
+        if(pouringParticleSystem != null)
+        {
+            ParticleSystem.MinMaxCurve emi = pouringParticleSystem.emission.rateOverTime;
+            emi.constant = volumeOfParticles * particleVal;
+            ParticleSystem.EmissionModule emod = pouringParticleSystem.emission;
+            emod.rateOverTime = emi;
+            //pouringParticleSystem.emission = emod;
+            if(particleVal > 0)
+            {
+                if(!pouringParticleSystem.isEmitting)
+                {
+                    pouringParticleSystem.Play();
+                }
+            }
+            else
+            {
+                pouringParticleSystem.Stop(false, ParticleSystemStopBehavior.StopEmitting);
+            }
+        }
+		
+	}
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Scripts/PourLiquid.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 9595bd8a6648b72478d69bc5182430eb
+timeCreated: 1493623177
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Shaders.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: d6ccac31b1b63404094c89c55f8cb421
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Shaders/Glass_Potion.shader

@@ -0,0 +1,95 @@
+Shader "2Ginge/Potion/Glass_Potion_URP" {
+    Properties {
+        _Color ("Color", Color) = (0.5, 0.5, 0.5, 1)
+        _Fres_Exp ("Fresnel Exp", Float ) = 0
+        _metallic ("Metallic", Range(0, 1)) = 0
+        _Gloss ("Gloss", Range(0, 1)) = 0
+        _Texture ("Texture", 2D) = "white" {}
+        _Normal ("Normal", 2D) = "bump" {}
+        [HideInInspector]_Cutoff ("Alpha cutoff", Range(0,1)) = 0.5
+    }
+    SubShader {
+        Tags {
+            "RenderType"="Transparent"
+            "Queue"="Transparent"
+        }
+        Pass {
+            Name "FORWARD"
+            Tags { "LightMode"="UniversalForward" }
+            Blend SrcAlpha OneMinusSrcAlpha
+            ZWrite Off
+
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            #pragma multi_compile_fragment _ _MAIN_LIGHT_SHADOWS _ADDITIONAL_LIGHTS
+            #pragma multi_compile_fragment _ _SHADOWS_SOFT
+            #pragma multi_compile_fragment _ _LIGHT_LAYERS
+            #pragma multi_compile_fog
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
+
+            struct Attributes {
+                float4 positionOS : POSITION;
+                float3 normalOS : NORMAL;
+                float4 tangentOS : TANGENT;
+                float2 uv : TEXCOORD0;
+            };
+
+            struct Varyings {
+                float4 positionCS : SV_POSITION;
+                float2 uv : TEXCOORD0;
+                float3 normalWS : TEXCOORD1;
+                float3 tangentWS : TEXCOORD2;
+                float3 bitangentWS : TEXCOORD3;
+                float3 viewDirWS : TEXCOORD4;
+            };
+
+            CBUFFER_START(UnityPerMaterial)
+            float4 _Color;
+            float _Fres_Exp;
+            float _metallic;
+            float _Gloss;
+            CBUFFER_END
+
+            TEXTURE2D(_Texture); SAMPLER(sampler_Texture);
+            TEXTURE2D(_Normal); SAMPLER(sampler_Normal);
+
+            Varyings vert(Attributes IN) {
+                Varyings OUT;
+                VertexPositionInputs posInputs = GetVertexPositionInputs(IN.positionOS.xyz);
+                VertexNormalInputs normalInputs = GetVertexNormalInputs(IN.normalOS, IN.tangentOS);
+
+                OUT.positionCS = posInputs.positionCS;
+                OUT.uv = IN.uv;
+                OUT.normalWS = normalInputs.normalWS;
+                OUT.tangentWS = normalInputs.tangentWS;
+                OUT.bitangentWS = normalInputs.bitangentWS;
+                OUT.viewDirWS = GetWorldSpaceViewDir(posInputs.positionWS);
+
+                return OUT;
+            }
+
+            half4 frag(Varyings IN) : SV_Target {
+                float3 normalTS = UnpackNormal(SAMPLE_TEXTURE2D(_Normal, sampler_Normal, IN.uv));
+                float3x3 TBN = float3x3(IN.tangentWS, IN.bitangentWS, IN.normalWS);
+                float3 normalWS = normalize(mul(normalTS, TBN));
+
+                float3 viewDir = normalize(IN.viewDirWS);
+                float3 lightDir = normalize(GetMainLight().direction);
+                float3 lightColor = GetMainLight().color;
+
+                float fresnelEffect = pow(1.0 - dot(viewDir, normalWS), _Fres_Exp);
+                float3 diffuse = lightColor * max(dot(normalWS, lightDir), 0.0);
+                float3 specular = pow(max(dot(reflect(-lightDir, normalWS), viewDir), 0.0), _Gloss * 128) * _metallic;
+
+                float4 baseColor = SAMPLE_TEXTURE2D(_Texture, sampler_Texture, IN.uv) * _Color;
+                float3 finalColor = baseColor.rgb * diffuse + specular + fresnelEffect;
+
+                return float4(finalColor, baseColor.a);
+            }
+            ENDHLSL
+        }
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Shaders/Glass_Potion.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 4e1e52cea6b0d16479364955a0f6be01
+timeCreated: 1489460397
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Shaders/Legacy_Glass.shader

@@ -0,0 +1,83 @@
+Shader "2Ginge/Potion/URP_Glass"
+{
+    Properties
+    {
+        _MainTex ("Main Texture", 2D) = "white" {}
+        _TintColor ("Tint Color", Color) = (0.5,0.5,0.5,1)
+        _FresnelTightness ("Fresnel Tightness", Float) = 0
+        [HideInInspector]_Cutoff ("Alpha Cutoff", Range(0,1)) = 0.5
+    }
+
+    SubShader
+    {
+        Tags { "Queue"="Transparent" "RenderPipeline"="UniversalRenderPipeline" "RenderType"="Transparent" }
+        Blend SrcAlpha OneMinusSrcAlpha
+        ZWrite Off
+        Cull Back
+        
+        Pass
+        {
+            Name "ForwardLit"
+            Tags { "LightMode"="UniversalForward" }
+            
+            HLSLPROGRAM
+            #pragma vertex vert
+            #pragma fragment frag
+            
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
+            
+            struct Attributes
+            {
+                float4 positionOS   : POSITION;
+                float3 normalOS     : NORMAL;
+                float2 uv           : TEXCOORD0;
+                float4 color        : COLOR;
+            };
+
+            struct Varyings
+            {
+                float4 positionHCS  : SV_POSITION;
+                float2 uv           : TEXCOORD0;
+                float3 normalWS     : TEXCOORD1;
+                float3 viewDirWS    : TEXCOORD2;
+                float4 color        : COLOR;
+            };
+            
+            TEXTURE2D(_MainTex);
+            SAMPLER(sampler_MainTex);
+            
+            CBUFFER_START(UnityPerMaterial)
+                float4 _MainTex_ST;
+                float4 _TintColor;
+                float _FresnelTightness;
+            CBUFFER_END
+
+            Varyings vert(Attributes IN)
+            {
+                Varyings OUT;
+                OUT.positionHCS = TransformObjectToHClip(IN.positionOS.xyz);
+                OUT.uv = TRANSFORM_TEX(IN.uv, _MainTex);
+                OUT.normalWS = TransformObjectToWorldNormal(IN.normalOS);
+                OUT.viewDirWS = GetWorldSpaceViewDir(TransformObjectToWorld(IN.positionOS.xyz));
+                OUT.color = IN.color;
+                return OUT;
+            }
+
+            half4 frag(Varyings IN) : SV_Target
+            {
+                IN.normalWS = normalize(IN.normalWS);
+                float3 viewDir = normalize(IN.viewDirWS);
+                
+                float4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, IN.uv);
+                float fresnel = pow(1.0 - saturate(dot(IN.normalWS, viewDir)), _FresnelTightness);
+                
+                float3 emissive = texColor.rgb * IN.color.rgb * _TintColor.rgb * 2.0;
+                float alpha = (texColor.a * IN.color.a * _TintColor.a) + fresnel;
+                
+                return float4(emissive, alpha);
+            }
+            ENDHLSL
+        }
+    }
+}

Viagg-io/Assets/2Ginge/LiquidSimulation/Shaders/Legacy_Glass.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ebcafcb900359684f91d0384e9197877
+timeCreated: 1511342574
+licenseType: Store
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/LiquidSimulation/Shaders/Legacy_Liquid_Potion.shader

@@ -0,0 +1,185 @@
+Shader "2Ginge/Potion/Legacy_Liquid_Potion"
+{
+	Properties
+	{
+		//_MainTex("Albedo (RGB)", 2D) = "white" {}
+			[HDR]_SEmissionColor("Surface Emission Color", Color) = (1, 1, 1, 1)
+			[HDR]_EmissionColor("Volume Emission Color", Color) = (1,1, 1, 1)
+			_EmissionScalar("Emission Intensity", Float) = 1
+			// for later implementation
+			// _StencilMask ("Mask Layer", Range(0, 255)) = 1 
+	}
+	SubShader
+		{
+			Pass
+			{
+				Tags{ "RenderType" = "Opaque" "Queue" = "AlphaTest+100" }
+				LOD 200
+				Cull Front
+				// Stencil {
+				// 	Ref 255
+				// 	WriteMask [_StencilMask]
+				// 	Comp always
+				// 	Pass replace
+				// }
+				CGPROGRAM
+
+#pragma vertex vert
+#pragma fragment frag
+				// make fog work
+#pragma multi_compile_fog
+
+#include "UnityCG.cginc"
+#pragma target 2.0
+				float _localHeight;
+				float _EmissionScalar;
+				float4 _SEmissionColor;
+				//in local space;
+				float4 _anchor;
+				//in local space
+				float4 _point;
+				float _level;
+				struct appdata
+				{
+					float4 vertex : POSITION;
+					float2 uv : TEXCOORD0;
+					float3 normal : NORMAL;
+				};
+
+				struct v2f
+				{
+					float2 uv : TEXCOORD0;
+					UNITY_FOG_COORDS(1)
+						float4 vertex : SV_POSITION;
+					//float dif; // now stored in localPos.w;
+					float4 localPos : TEXCOORD5;
+					float4 screenPos : TEXCOORD2;
+					float3 myC : TEXCOORD3;
+					float3 nrm : TEXCOORD4;
+				};
+
+				//sampler2D _MainTex;
+				float4 _MainTex_ST;
+
+				v2f vert(appdata v)
+				{
+					v2f o;
+					UNITY_INITIALIZE_OUTPUT(v2f,o);
+					float3 worldP = mul((float4x4)unity_ObjectToWorld, v.vertex) - mul((float4x4)unity_ObjectToWorld, float4(0, 0, 0,0));
+						o.localPos.w = worldP.y;
+					o.localPos.xyz = v.vertex.xyz;
+
+					float3 worldNormal = mul((float4x4)unity_ObjectToWorld, float4(v.normal,0));
+						if (dot(normalize(UNITY_MATRIX_IT_MV[2].xyz), worldNormal.xyz) < 0.0)
+						{
+							o.myC = float3(1, 0, 0);
+						}
+						else
+						{
+							o.myC = float3(0, 1, 0);
+						}
+					v.normal = normalize(_point - _anchor);
+					o.screenPos = ComputeScreenPos(UnityObjectToClipPos(v.vertex.xyz));
+
+					o.vertex = UnityObjectToClipPos(v.vertex);
+					o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+					UNITY_TRANSFER_FOG(o, o.vertex);
+					return o;
+				}
+
+				fixed4 frag(v2f i) : SV_Target
+				{
+					if (dot(normalize(i.localPos.xyz - _point), normalize(_point - _anchor)) > 0)
+					{
+						discard;
+					}
+					// sample the texture
+					fixed4 col =  _SEmissionColor * _EmissionScalar;
+					// apply fog
+					UNITY_APPLY_FOG(i.fogCoord, col);
+					return col;
+				}
+					ENDCG
+			}
+				
+			Pass
+			{
+				Tags{ "RenderType" = "Opaque" "Queue" = "AlphaTest+100" }
+				LOD 200
+				Cull Back
+				// Stencil {
+				// 	Ref 0
+				// 	Comp always
+				// 	Pass replace
+				// }
+				CGPROGRAM
+				#pragma vertex vert
+				#pragma fragment frag
+								// make fog work
+				#pragma multi_compile_fog
+
+				#include "UnityCG.cginc"
+				#pragma target 2.0
+
+
+				float _localHeight;
+				float _EmissionScalar;
+				float4 _EmissionColor;
+				//in local space;
+				float4 _anchor;
+				//in local space
+				float4 _point;
+				float _level;
+				struct appdata
+				{
+					float4 vertex : POSITION;
+					float2 uv : TEXCOORD0;
+					float3 normal : NORMAL;
+				};
+
+				struct v2f
+				{
+					float2 uv : TEXCOORD0;
+					UNITY_FOG_COORDS(1)
+						float4 vertex : SV_POSITION;
+					//float dif; // now stored in localPos.w;
+					float4 localPos : TEXCOORD5;
+					float4 screenPos : TEXCOORD2;
+					float3 myC : TEXCOORD3;
+					float3 nrm : TEXCOORD4;
+				};
+
+				//sampler2D _MainTex;
+				float4 _MainTex_ST;
+
+				v2f vert(appdata v)
+				{
+					v2f o;
+					UNITY_INITIALIZE_OUTPUT(v2f,o);
+					float3 worldP = mul((float4x4)unity_ObjectToWorld, v.vertex) - mul((float4x4)unity_ObjectToWorld, float4(0, 0, 0,0));
+						o.localPos.w = worldP.y;
+					o.localPos.xyz = v.vertex.xyz;
+
+					o.vertex = UnityObjectToClipPos(v.vertex);
+					o.uv = TRANSFORM_TEX(v.uv, _MainTex);
+					UNITY_TRANSFER_FOG(o, o.vertex);
+					return o;
+				}
+
+				fixed4 frag(v2f i) : SV_Target
+				{
+					if (dot(normalize(i.localPos.xyz - _point), normalize(_point - _anchor)) > 0)
+					{
+						discard;
+					}
+					// sample the texture
+					fixed4 col = _EmissionColor * _EmissionScalar;
+					// apply fog
+					UNITY_APPLY_FOG(i.fogCoord, col);
+					return col;
+				}
+					ENDCG
+			}
+		}
+}
+

Viagg-io/Assets/2Ginge/LiquidSimulation/Shaders/Legacy_Liquid_Potion.shader.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 9594e787c5bf502479a025310293a0cc
+timeCreated: 1510223057
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c423eacd0852bf847a8d11c911f31258
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 92b1e7481cbf4df4fba9d7fae1c1d3e4
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b57b900ccfa49e440bc8524e48f2c389
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/InkBottlePouring.controller

@@ -0,0 +1,72 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: InkBottlePouring
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 1107412206164436548}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1102 &1102585002363925994
+AnimatorState:
+  serializedVersion: 6
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: InkPour
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: 53a3e09a5935a3c4cab2bd51d54a8123, type: 2}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1107 &1107412206164436548
+AnimatorStateMachine:
+  serializedVersion: 6
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 1102585002363925994}
+    m_Position: {x: 200, y: 0, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: 1102585002363925994}

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/InkBottlePouring.controller.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 2752c0ecc45c0c64fb16387b7eb7f2ec
+timeCreated: 1498644852
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/InkPour.anim

@@ -0,0 +1,303 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!74 &7400000
+AnimationClip:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: InkPour
+  serializedVersion: 7
+  m_Legacy: 0
+  m_Compressed: 0
+  m_UseHighQualityCurve: 1
+  m_RotationCurves: []
+  m_CompressedRotationCurves: []
+  m_EulerCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: {x: 0, y: 0, z: 0}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 1
+        value: {x: 0, y: 0, z: -180}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 2
+        value: {x: 0, y: 0, z: -180}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 3
+        value: {x: 0, y: 0, z: 0}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 4
+        value: {x: 0, y: 0, z: 0}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    path: 
+  m_PositionCurves: []
+  m_ScaleCurves: []
+  m_FloatCurves: []
+  m_PPtrCurves: []
+  m_SampleRate: 60
+  m_WrapMode: 0
+  m_Bounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}
+  m_ClipBindingConstant:
+    genericBindings:
+    - serializedVersion: 2
+      path: 0
+      attribute: 4
+      script: {fileID: 0}
+      typeID: 4
+      customType: 4
+      isPPtrCurve: 0
+      isIntCurve: 0
+      isSerializeReferenceCurve: 0
+    pptrCurveMapping: []
+  m_AnimationClipSettings:
+    serializedVersion: 2
+    m_AdditiveReferencePoseClip: {fileID: 0}
+    m_AdditiveReferencePoseTime: 0
+    m_StartTime: 0
+    m_StopTime: 4
+    m_OrientationOffsetY: 0
+    m_Level: 0
+    m_CycleOffset: 0
+    m_HasAdditiveReferencePose: 0
+    m_LoopTime: 1
+    m_LoopBlend: 0
+    m_LoopBlendOrientation: 0
+    m_LoopBlendPositionY: 0
+    m_LoopBlendPositionXZ: 0
+    m_KeepOriginalOrientation: 0
+    m_KeepOriginalPositionY: 1
+    m_KeepOriginalPositionXZ: 0
+    m_HeightFromFeet: 0
+    m_Mirror: 0
+  m_EditorCurves:
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 2
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 4
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.x
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 2
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 4
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.y
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 1
+        value: -180
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 2
+        value: -180
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 3
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 4
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.z
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  m_EulerEditorCurves:
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.x
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.y
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.z
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  m_HasGenericRootTransform: 1
+  m_HasMotionFloatCurves: 0
+  m_Events: []

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/InkPour.anim.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 53a3e09a5935a3c4cab2bd51d54a8123
+timeCreated: 1498644852
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/Recepticle.controller

@@ -0,0 +1,72 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Recepticle
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 1107101855636790056}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1102 &1102884215436818850
+AnimatorState:
+  serializedVersion: 6
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: RecepticlePour
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: 42c3ed6d2f736914db8b7ad6c35eadba, type: 2}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1107 &1107101855636790056
+AnimatorStateMachine:
+  serializedVersion: 6
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 1102884215436818850}
+    m_Position: {x: 200, y: 0, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: 1102884215436818850}

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/Recepticle.controller.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3e3f2ea9f0b78e3479923a4e8393e1ae
+timeCreated: 1498644997
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/RecepticlePour.anim

@@ -0,0 +1,267 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!74 &7400000
+AnimationClip:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: RecepticlePour
+  serializedVersion: 7
+  m_Legacy: 0
+  m_Compressed: 0
+  m_UseHighQualityCurve: 1
+  m_RotationCurves: []
+  m_CompressedRotationCurves: []
+  m_EulerCurves:
+  - curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: {x: 0, y: 0, z: 0}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 2.5
+        value: {x: 0, y: 0, z: 0}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 3.0166667
+        value: {x: 0, y: 0, z: 180}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 3.5
+        value: {x: 0, y: 0, z: 180}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      - serializedVersion: 3
+        time: 4
+        value: {x: 0, y: 0, z: 0}
+        inSlope: {x: 0, y: 0, z: 0}
+        outSlope: {x: 0, y: 0, z: 0}
+        tangentMode: 0
+        weightedMode: 0
+        inWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+        outWeight: {x: 0.33333334, y: 0.33333334, z: 0.33333334}
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    path: 
+  m_PositionCurves: []
+  m_ScaleCurves: []
+  m_FloatCurves: []
+  m_PPtrCurves: []
+  m_SampleRate: 60
+  m_WrapMode: 0
+  m_Bounds:
+    m_Center: {x: 0, y: 0, z: 0}
+    m_Extent: {x: 0, y: 0, z: 0}
+  m_ClipBindingConstant:
+    genericBindings:
+    - serializedVersion: 2
+      path: 0
+      attribute: 4
+      script: {fileID: 0}
+      typeID: 4
+      customType: 4
+      isPPtrCurve: 0
+      isIntCurve: 0
+      isSerializeReferenceCurve: 0
+    pptrCurveMapping: []
+  m_AnimationClipSettings:
+    serializedVersion: 2
+    m_AdditiveReferencePoseClip: {fileID: 0}
+    m_AdditiveReferencePoseTime: 0
+    m_StartTime: 0
+    m_StopTime: 4
+    m_OrientationOffsetY: 0
+    m_Level: 0
+    m_CycleOffset: 0
+    m_HasAdditiveReferencePose: 0
+    m_LoopTime: 1
+    m_LoopBlend: 0
+    m_LoopBlendOrientation: 0
+    m_LoopBlendPositionY: 0
+    m_LoopBlendPositionXZ: 0
+    m_KeepOriginalOrientation: 0
+    m_KeepOriginalPositionY: 1
+    m_KeepOriginalPositionXZ: 0
+    m_HeightFromFeet: 0
+    m_Mirror: 0
+  m_EditorCurves:
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 2.5
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.x
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 2.5
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.y
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve:
+      - serializedVersion: 3
+        time: 0
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 2.5
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 3.0166667
+        value: 180
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 3.5
+        value: 180
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      - serializedVersion: 3
+        time: 4
+        value: 0
+        inSlope: 0
+        outSlope: 0
+        tangentMode: 136
+        weightedMode: 0
+        inWeight: 0.33333334
+        outWeight: 0.33333334
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: localEulerAnglesRaw.z
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  m_EulerEditorCurves:
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.x
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.y
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  - serializedVersion: 2
+    curve:
+      serializedVersion: 2
+      m_Curve: []
+      m_PreInfinity: 2
+      m_PostInfinity: 2
+      m_RotationOrder: 4
+    attribute: m_LocalEulerAngles.z
+    path: 
+    classID: 4
+    script: {fileID: 0}
+    flags: 16
+  m_HasGenericRootTransform: 1
+  m_HasMotionFloatCurves: 0
+  m_Events: []

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoAnimations/RecepticlePour.anim.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 42c3ed6d2f736914db8b7ad6c35eadba
+timeCreated: 1498644997
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoScripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 9d8069cb182f9234790fe084a3f7fa88
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoScripts/Reset.cs

@@ -0,0 +1,16 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UI;
+using UnityEngine.SceneManagement;
+
+public class Reset : MonoBehaviour {
+
+	// Use this for initialization
+    
+	public void ResetScene()
+    {
+        //pretty complex, might need to make a powerpoint slide...
+        SceneManager.LoadScene(0);
+    }
+}

Viagg-io/Assets/2Ginge/MagicPotions/Demo/DemoScripts/Reset.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 4a3788df32c67724b85adc7522cdcabe
+timeCreated: 1491128488
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/WorkshopAssets.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ee7284d5879b2d048bb0f74ad148ed6c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/WorkshopAssets/Scripts.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f8359969e66d74946836a3fa6cd23c62
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Demo/WorkshopAssets/Scripts/Flicker.cs

@@ -0,0 +1,54 @@
+using UnityEngine;
+using System.Collections;
+
+public class Flicker : MonoBehaviour
+{
+	public float MaxReduction;
+	public float MaxIncrease;
+	public float RateDamping;
+	public float Strength;
+	public bool StopFlickering;
+
+	private Light _lightSource;
+	private float _baseIntensity;
+	private bool _flickering;
+
+	public void Reset()
+	{
+		MaxReduction = 0.2f;
+		MaxIncrease = 0.2f;
+		RateDamping = 0.1f;
+		Strength = 300;
+	}
+
+	public void Start()
+	{
+		_lightSource = GetComponent<Light>();
+		if (_lightSource == null)
+		{
+			Debug.LogError("Flicker script must have a Light Component on the same GameObject.");
+			return;
+		}
+		_baseIntensity = _lightSource.intensity;
+		StartCoroutine(DoFlicker());
+	}
+
+	void Update()
+	{
+		if (!StopFlickering && !_flickering)
+		{
+			StartCoroutine(DoFlicker());
+		}
+	}
+
+	private IEnumerator DoFlicker()
+	{
+		_flickering = true;
+		while (!StopFlickering)
+		{
+			_lightSource.intensity = Mathf.Lerp(_lightSource.intensity, Random.Range(_baseIntensity - MaxReduction, _baseIntensity + MaxIncrease), Strength * Time.deltaTime);
+			yield return new WaitForSeconds(RateDamping);
+		}
+		_flickering = false;
+	}
+}

Viagg-io/Assets/2Ginge/MagicPotions/Demo/WorkshopAssets/Scripts/Flicker.cs.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: f449b00476d637f43921639714114c7d
+timeCreated: 1509823171
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 77cdc0b6432727a4285fd208215484fb
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Containers.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 30c88ab6738e304478b8f8523a993cf3
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Containers/Glass.mat

@@ -0,0 +1,60 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Glass
+  m_Shader: {fileID: 4800000, guid: 4e1e52cea6b0d16479364955a0f6be01, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _ALPHAPREMULTIPLY_ON
+  - _EMISSION
+  - _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Normal:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _Texture:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - <noninit>: 1
+    - _Cutoff: 0.5
+    - _Fres_Exp: 1
+    - _FresnelTightness: 3.18
+    - _Gloss: 0
+    - _WaveFrequency: 1
+    - _WaveHeight: 0.1
+    - _WaveSpeed: 1
+    - _metallic: 0
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 0.522}
+    - _TintColor: {r: 1, g: 1, b: 1, a: 0.153}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Containers/Glass.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 318f079ba32e1334f827c7de9673d28d
+timeCreated: 1486504376
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Containers/Mobile Glass.mat

@@ -0,0 +1,45 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Mobile Glass
+  m_Shader: {fileID: 4800000, guid: ebcafcb900359684f91d0384e9197877, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _ALPHAPREMULTIPLY_ON
+  - _EMISSION
+  - _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - <noninit>: 1
+    - _Cutoff: 0.5
+    - _FresnelTightness: 3
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}
+    - _TintColor: {r: 0.2647059, g: 0.2647059, b: 0.2647059, a: 0}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Containers/Mobile Glass.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c1c05f18ff6fc0349bcbd20a69300dad
+timeCreated: 1486504376
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 3f5430d3b06205d4aa297b0d34f5dc86
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials/Mobile_LiquidMaterials.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 74e4f6aae5ba44842a846fae247d6a12
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials/Mobile_LiquidMaterials/Legacy_Black.mat

@@ -0,0 +1,38 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Legacy_Black
+  m_Shader: {fileID: 4800000, guid: 9594e787c5bf502479a025310293a0cc, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2550
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - <noninit>: 1
+    - _EmissionScalar: 0.5
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SEmissionColor: {r: 0, g: 0, b: 0, a: 1}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials/Mobile_LiquidMaterials/Legacy_Black.mat.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4d309ac631bf0a1499c6d9e0fa2f4bc2
+timeCreated: 1520232664
+licenseType: Store
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials/Mobile_LiquidMaterials/Legacy_Pink.mat

@@ -0,0 +1,39 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Legacy_Pink
+  m_Shader: {fileID: 4800000, guid: 9594e787c5bf502479a025310293a0cc, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2550
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - <noninit>: 1
+    - _EmissionScalar: 2
+    - _StencilMask: 1
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 1, g: 0.41176468, b: 0.8133873, a: 1}
+    - _SEmissionColor: {r: 1, g: 0.6691177, b: 0.9497971, a: 1}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials/Mobile_LiquidMaterials/Legacy_Pink.mat.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 27d5ac683a2251e458a37ef0db522b66
+timeCreated: 1512045364
+licenseType: Store
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials/Mobile_LiquidMaterials/Legacy_Red.mat

@@ -0,0 +1,39 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Legacy_Red
+  m_Shader: {fileID: 4800000, guid: 9594e787c5bf502479a025310293a0cc, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords: []
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2550
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - <noninit>:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - <noninit>: 1
+    - _EmissionScalar: 2
+    - _StencilMask: 1
+    m_Colors:
+    - <noninit>: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0.7689655, g: 0, b: 0, a: 1}
+    - _SEmissionColor: {r: 1, g: 0, b: 0, a: 1}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/Liquid_Materials/Mobile_LiquidMaterials/Legacy_Red.mat.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 476e691e4f5e2494984e3e4cfabee534
+timeCreated: 1512045364
+licenseType: Store
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: aea1b68ba6536244ca155f16f05c1035
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/ParticleFX.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 342825cb02ff3714687b6d42b35afb27
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/ParticleFX/BlueLiquid_Particles.mat

@@ -0,0 +1,105 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: BlueLiquid_Particles
+  m_Shader: {fileID: 203, guid: 0000000000000000f000000000000000, type: 0}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _ALPHATEST_ON
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 2e0cfde2486a1244f8fe36d277de9c78, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.27
+    - _DetailNormalMapScale: 1
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0
+    - _DstBlend: 0
+    - _EmissionEnabled: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _InvFade: 1
+    - _LightingEnabled: 0
+    - _Metallic: 0
+    - _Mode: 1
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 0.50735295, g: 0.97961456, b: 1, a: 1}
+    - _ColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _TintColor: {r: 0, g: 1, b: 0.9460001, a: 0.5}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/ParticleFX/BlueLiquid_Particles.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6c95bea0a85cbfe4ead93aec4074e16c
+timeCreated: 1497945648
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/ParticleFX/GreenLiquid_Particles.mat

@@ -0,0 +1,136 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: GreenLiquid_Particles
+  m_Shader: {fileID: 4800000, guid: 0406db5a14f94604a8c57ccfbc9f3b46, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _ALPHATEST_ON
+  - _EMISSION
+  m_InvalidKeywords:
+  - _FLIPBOOKBLENDING_OFF
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2450
+  stringTagMap:
+    RenderType: TransparentCutout
+  disabledShaderPasses:
+  - GRABPASS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 2e0cfde2486a1244f8fe36d277de9c78, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 2e0cfde2486a1244f8fe36d277de9c78, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 1
+    - _AlphaToMask: 1
+    - _Blend: 0
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _EmissionEnabled: 0
+    - _FlipbookBlending: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _InvFade: 3
+    - _LightingEnabled: 0
+    - _Metallic: 0
+    - _Mode: 1
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0, g: 1, b: 0.08965514, a: 1}
+    - _BaseColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 0, g: 1, b: 0.08965511, a: 1}
+    - _ColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _TintColor: {r: 0, g: 1, b: 0.13103437, a: 0.372}
+  m_BuildTextureStacks: []
+--- !u!114 &8985368429448845089
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 7

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/ParticleFX/GreenLiquid_Particles.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: b3c58a8837885dd4c941610c6e950075
+timeCreated: 1493891990
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/ParticleFX/PinkLiquid_Particles.mat

@@ -0,0 +1,105 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: PinkLiquid_Particles
+  m_Shader: {fileID: 203, guid: 0000000000000000f000000000000000, type: 0}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _ALPHATEST_ON
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 2e0cfde2486a1244f8fe36d277de9c78, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _BlendOp: 0
+    - _BumpScale: 1
+    - _CameraFadingEnabled: 0
+    - _CameraFarFadeDistance: 2
+    - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DistortionBlend: 0.5
+    - _DistortionEnabled: 0
+    - _DistortionStrength: 1
+    - _DistortionStrengthScaled: 0
+    - _DstBlend: 0
+    - _EmissionEnabled: 0
+    - _FlipbookMode: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _InvFade: 3
+    - _LightingEnabled: 0
+    - _Metallic: 0
+    - _Mode: 1
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SoftParticlesEnabled: 0
+    - _SoftParticlesFarFadeDistance: 1
+    - _SoftParticlesNearFadeDistance: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _CameraFadeParams: {r: 0, g: Infinity, b: 0, a: 0}
+    - _Color: {r: 1, g: 0.72794116, b: 0.9362069, a: 1}
+    - _ColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}
+    - _TintColor: {r: 1, g: 0.33823532, b: 0.60801, a: 0.347}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/ParticleFX/PinkLiquid_Particles.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 17345879d22914841b306223c4251b5b
+timeCreated: 1493891990
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/Splats.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: ee6630d537222174caf2653ce6d97992
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/Splats/BlackSplat.mat

@@ -0,0 +1,144 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-993167355915577448
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 7
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: BlackSplat
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _ALPHAPREMULTIPLY_ON
+  - _EMISSION
+  - _SPECULAR_SETUP
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _ALPHABLEND_ON
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - DepthOnly
+  - SHADOWCASTER
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EmissionScalar: 0.5
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 1
+    - _Glossiness: 0.547
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 2
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 0.547
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _UVSec: 0
+    - _WorkflowMode: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 0.0441176, g: 0.0441176, b: 0.0441176, a: 1}
+    - _Color: {r: 0.044117577, g: 0.044117577, b: 0.044117577, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.102941155, g: 0.102941155, b: 0.102941155, a: 1}
+    - _UpVector: {r: 0, g: 1, b: 0, a: 0}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/Splats/BlackSplat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 03d23bb632fa7c7498d87cb82a40f564
+timeCreated: 1489289175
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/Splats/PinkSplat.mat

@@ -0,0 +1,142 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-6933790845112335691
+MonoBehaviour:
+  m_ObjectHideFlags: 11
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  version: 7
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: PinkSplat
+  m_Shader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _ALPHAPREMULTIPLY_ON
+  - _EMISSION
+  - _SPECULAR_SETUP
+  - _SURFACE_TYPE_TRANSPARENT
+  m_InvalidKeywords:
+  - _ALPHABLEND_ON
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - DepthOnly
+  - SHADOWCASTER
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_Lightmaps:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_LightmapsInd:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - unity_ShadowMasks:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _ClearCoatMask: 0
+    - _ClearCoatSmoothness: 0
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DetailAlbedoMapScale: 1
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _DstBlendAlpha: 10
+    - _EnvironmentReflections: 1
+    - _GlossMapScale: 1
+    - _Glossiness: 1
+    - _GlossyReflections: 1
+    - _Metallic: 0.29
+    - _Mode: 2
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Smoothness: 1
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 1
+    - _UVSec: 0
+    - _WorkflowMode: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 0.45588237, b: 0.84989876, a: 1}
+    - _Color: {r: 1, g: 0.45588237, b: 0.84989876, a: 1}
+    - _EmissionColor: {r: 0.6857475, g: 0.21501945, b: 0.71323526, a: 1}
+    - _SpecColor: {r: 0.09558821, g: 0.09558821, b: 0.09558821, a: 1}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/Splats/PinkSplat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 48f5fafdbbaff564ba6e04494fe576dc
+timeCreated: 1491029507
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/Splats/Splat.mat

@@ -0,0 +1,89 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Splat
+  m_Shader: {fileID: 203, guid: 0000000000000000f000000000000000, type: 0}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords: []
+  m_InvalidKeywords:
+  - _ALPHABLEND_ON
+  - _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 341f03677e39b4d4fb0622ef1d19927b, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Ints: []
+    m_Floats:
+    - PixelSnap: 0
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _GlossMapScale: 1
+    - _Glossiness: 0
+    - _GlossyReflections: 1
+    - _InvFade: 1
+    - _Metallic: 0
+    - _Mode: 2
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _UVSec: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmisColor: {r: 0.2, g: 0.2, b: 0.2, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _TintColor: {r: 1, g: 1, b: 1, a: 1}
+  m_BuildTextureStacks: []

Viagg-io/Assets/2Ginge/MagicPotions/Materials/VFX/Splats/Splat.mat.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 926d019fbb9e0134b9b50b9e8f98ac6e
+timeCreated: 1491015652
+licenseType: Store
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Meshes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 145e488ea36c9a64bbc5fa542db3969e
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Meshes/AuxiliaryMeshes.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7e8703b77a11d354ebfc8fcea2d5868f
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Viagg-io/Assets/2Ginge/MagicPotions/Meshes/AuxiliaryMeshes/Splat.fbx.meta

@@ -0,0 +1,80 @@
+fileFormatVersion: 2
+guid: 29b2a0584bad33542a4aa554aea5bd9d
+timeCreated: 1491014691
+licenseType: Store
+ModelImporter:
+  serializedVersion: 19
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: Plane.003
+  materials:
+    importMaterials: 0
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    importBlendShapes: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    rootMotionBoneRotation: {x: 0, y: 0, z: 0, w: 1}
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 0
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: