add some extra assets FX and SFX

Assets/Game Kit Controller/Integrations/External Audio Systems/Documentation/GKC - External Audio Systems Integration.pdf.meta

@@ -8,8 +8,9 @@ DefaultImporter:
 AssetOrigin:
   serializedVersion: 1
   productId: 40995
-  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
-  packageVersion: 3.77g
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
   assetPath: Assets/Game Kit Controller/Integrations/External Audio Systems/Documentation/GKC
     - External Audio Systems Integration.pdf
-  uploadId: 814740
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/External Audio Systems/Wwise/Scripts/WwiseExternalAudioPlayer.cs.meta

@@ -4,7 +4,8 @@ timeCreated: 1667565343
 AssetOrigin:
   serializedVersion: 1
   productId: 40995
-  packageName: Game Kit Controller - Shooter Melee Adventure Creator 3D + 2.5D
-  packageVersion: 3.77g
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
   assetPath: Assets/Game Kit Controller/Integrations/External Audio Systems/Wwise/Scripts/WwiseExternalAudioPlayer.cs
-  uploadId: 814740
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice.meta

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

Assets/Game Kit Controller/Integrations/EzySlice/Framework.meta

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

Assets/Game Kit Controller/Integrations/EzySlice/Framework/IntersectionResult.cs

@@ -0,0 +1,150 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice {
+
+	/**
+	 * A Basic Structure which contains intersection information
+	 * for Plane->Triangle Intersection Tests
+	 * TO-DO -> This structure can be optimized to hold less data
+	 * via an optional indices array. Could lead for a faster
+	 * intersection test aswell.
+	 */
+	public sealed class IntersectionResult {
+
+		// general tag to check if this structure is valid
+		private bool is_success;
+
+		// our intersection points/triangles
+		private readonly Triangle[] upper_hull;
+		private readonly Triangle[] lower_hull;
+		private readonly Vector3[] intersection_pt;
+
+		// our counters. We use raw arrays for performance reasons
+		private int upper_hull_count;
+		private int lower_hull_count;
+		private int intersection_pt_count;
+
+		public IntersectionResult() {
+			this.is_success = false;
+
+			this.upper_hull = new Triangle[2];
+			this.lower_hull = new Triangle[2];
+			this.intersection_pt = new Vector3[2];
+
+			this.upper_hull_count = 0;
+			this.lower_hull_count = 0;
+			this.intersection_pt_count = 0;
+		}
+
+		public Triangle[] upperHull {
+			get { return upper_hull; }
+		}
+
+		public Triangle[] lowerHull {
+			get { return lower_hull; }
+		}
+
+		public Vector3[] intersectionPoints {
+			get { return intersection_pt; }
+		}
+
+		public int upperHullCount {
+			get { return upper_hull_count; }
+		}
+
+		public int lowerHullCount {
+			get { return lower_hull_count; }
+		}
+
+		public int intersectionPointCount {
+			get { return intersection_pt_count; }
+		}
+
+		public bool isValid {
+			get { return is_success; }
+		}
+
+		/**
+		 * Used by the intersector, adds a new triangle to the
+		 * upper hull section
+		 */
+		public IntersectionResult AddUpperHull(Triangle tri) {
+			upper_hull[upper_hull_count++] = tri;
+
+			is_success = true;
+
+			return this;
+		}
+
+		/**
+		 * Used by the intersector, adds a new triangle to the
+		 * lower gull section
+		 */
+		public IntersectionResult AddLowerHull(Triangle tri) {
+			lower_hull[lower_hull_count++] = tri;
+
+			is_success = true;
+
+			return this;
+		}
+
+		/**
+		 * Used by the intersector, adds a new intersection point
+		 * which is shared by both upper->lower hulls
+		 */
+		public void AddIntersectionPoint(Vector3 pt) {
+			intersection_pt[intersection_pt_count++] = pt;
+		}
+
+		/**
+		 * Clear the current state of this object 
+		 */
+		public void Clear() {
+			is_success = false;
+			upper_hull_count = 0;
+			lower_hull_count = 0;
+			intersection_pt_count = 0;
+		}
+
+		/**
+		 * Editor only DEBUG functionality. This should not be compiled in the final
+		 * Version.
+		 */
+		public void OnDebugDraw() {
+			OnDebugDraw(Color.white);
+		}
+
+		public void OnDebugDraw(Color drawColor) {
+            #if UNITY_EDITOR
+
+			if (!isValid) {
+				return;
+			}
+
+			Color prevColor = Gizmos.color;
+
+			Gizmos.color = drawColor;
+
+			// draw the intersection points
+			for (int i = 0; i < intersectionPointCount; i++) {
+				Gizmos.DrawSphere(intersectionPoints[i], 0.1f);
+			}
+
+			// draw the upper hull in RED
+			for (int i = 0; i < upperHullCount; i++) {
+				upperHull[i].OnDebugDraw(Color.red);
+			}
+
+			// draw the lower hull in BLUE
+			for (int i = 0; i < lowerHullCount; i++) {
+				lowerHull[i].OnDebugDraw(Color.blue);
+			}
+
+			Gizmos.color = prevColor;
+
+            #endif
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Framework/IntersectionResult.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 6348dbaec6c064505808c4ee233b5a0e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Framework/IntersectionResult.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Intersector.cs

@@ -0,0 +1,487 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice {
+	/**
+	 * Contains static functionality to perform geometric intersection tests.
+	 */
+	public sealed class Intersector {
+
+		/**
+		 * Perform an intersection between Plane and Line, storing intersection point
+		 * in reference q. Function returns true if intersection has been found or
+		 * false otherwise.
+		 */
+		public static bool Intersect(Plane pl, Line ln, out Vector3 q) {
+			return Intersector.Intersect(pl, ln.positionA, ln.positionB, out q);
+		}
+
+		/**
+		 * Perform an intersection between Plane and Line made up of points a and b. Intersection
+		 * point will be stored in reference q. Function returns true if intersection has been
+		 * found or false otherwise.
+		 */
+		public static bool Intersect(Plane pl, Vector3 a, Vector3 b, out Vector3 q) {
+			Vector3 normal = pl.normal;
+			Vector3 ab = b - a;
+
+			float t = (pl.dist - Vector3.Dot(normal, a)) / Vector3.Dot(normal, ab);
+
+			// need to be careful and compensate for floating errors
+            if (t >= -float.Epsilon && t <= (1 + float.Epsilon)) {
+				q = a + t * ab;
+
+				return true;
+			}
+
+			q = Vector3.zero;
+
+			return false;
+		}
+
+		/**
+		 * Support functionality 
+		 */
+		public static float TriArea2D(float x1, float y1, float x2, float y2, float x3, float y3) {
+			return (x1 - x2) * (y2 - y3) - (x2 - x3) * (y1 - y2);
+		}
+
+		/**
+		 * Perform an intersection between Plane and Triangle. This is a comprehensive function
+		 * which alwo builds a HULL Hirearchy useful for decimation projects. This obviously
+		 * comes at the cost of more complex code and runtime checks, but the returned results
+		 * are much more flexible.
+		 * Results will be filled into the IntersectionResult reference. Check result.isValid()
+		 * for the final results.
+		 */
+		public static void Intersect(Plane pl, Triangle tri, IntersectionResult result) {
+			// clear the previous results from the IntersectionResult
+			result.Clear();
+
+			// grab local variables for easier access
+			Vector3 a = tri.positionA;
+			Vector3 b = tri.positionB;
+			Vector3 c = tri.positionC;
+
+			// check to see which side of the plane the points all
+			// lay in. SideOf operation is a simple dot product and some comparison
+			// operations, so these are a very quick checks
+			SideOfPlane sa = pl.SideOf(a);
+			SideOfPlane sb = pl.SideOf(b);
+			SideOfPlane sc = pl.SideOf(c);
+
+			// we cannot intersect if the triangle points all fall on the same side
+			// of the plane. This is an easy early out test as no intersections are possible.
+			if (sa == sb && sb == sc) {
+				return;
+			}
+
+			// detect cases where two points lay straight on the plane, meaning
+			// that the plane is actually parralel with one of the edges of the triangle
+			else if ((sa == SideOfPlane.ON && sa == sb) || 
+				(sa == SideOfPlane.ON && sa == sc) || 
+				(sb == SideOfPlane.ON && sb == sc)) 
+			{
+				return;
+			}
+
+			// keep in mind that intersection points are shared by both
+			// the upper HULL and lower HULL hence they lie perfectly
+			// on the plane that cut them
+			Vector3 qa;
+			Vector3 qb;
+
+			// check the cases where the points of the triangle actually lie on the plane itself
+			// in these cases, there is only going to be 2 triangles, one for the upper HULL and
+			// the other on the lower HULL
+			// we just need to figure out which points to accept into the upper or lower hulls.
+			if (sa == SideOfPlane.ON) {
+				// if the point a is on the plane, test line b-c
+				if (Intersector.Intersect(pl, b, c, out qa)) {
+                    // line b-c intersected, construct out triangles and return approprietly
+                    result.AddIntersectionPoint(qa);
+                    result.AddIntersectionPoint(a);
+
+                    // our two generated triangles, we need to figure out which
+                    // triangle goes into the UPPER hull and which goes into the LOWER hull
+                    Triangle ta = new Triangle(a, b, qa);
+                    Triangle tb = new Triangle(a, qa, c);
+
+                    // generate UV coordinates if there is any
+                    if (tri.hasUV) {
+                        // the computed UV coordinate if the intersection point
+                        Vector2 pq = tri.GenerateUV(qa);
+                        Vector2 pa = tri.uvA;
+                        Vector2 pb = tri.uvB;
+                        Vector2 pc = tri.uvC;
+
+                        ta.SetUV(pa, pb, pq);
+                        tb.SetUV(pa, pq, pc);
+                    }
+
+                    // generate Normal coordinates if there is any
+                    if (tri.hasNormal) {
+                        // the computed Normal coordinate if the intersection point
+                        Vector3 pq = tri.GenerateNormal(qa);
+                        Vector3 pa = tri.normalA;
+                        Vector3 pb = tri.normalB;
+                        Vector3 pc = tri.normalC;
+
+                        ta.SetNormal(pa, pb, pq);
+                        tb.SetNormal(pa, pq, pc);
+                    }
+
+                    // generate Tangent coordinates if there is any
+                    if (tri.hasTangent) {
+                        // the computed Tangent coordinate if the intersection point
+                        Vector4 pq = tri.GenerateTangent(qa);
+                        Vector4 pa = tri.tangentA;
+                        Vector4 pb = tri.tangentB;
+                        Vector4 pc = tri.tangentC;
+
+                        ta.SetTangent(pa, pb, pq);
+                        tb.SetTangent(pa, pq, pc);
+                    }
+
+					// b point lies on the upside of the plane
+					if (sb == SideOfPlane.UP) {
+						result.AddUpperHull(ta).AddLowerHull(tb);
+					}
+
+					// b point lies on the downside of the plane
+					else if (sb == SideOfPlane.DOWN) {
+						result.AddUpperHull(tb).AddLowerHull(ta);
+					}
+				}
+			}
+
+			// test the case where the b point lies on the plane itself
+			else if (sb == SideOfPlane.ON) {
+				// if the point b is on the plane, test line a-c
+				if (Intersector.Intersect(pl, a, c, out qa)) {
+					// line a-c intersected, construct out triangles and return approprietly
+					result.AddIntersectionPoint(qa);
+					result.AddIntersectionPoint(b);
+
+					// our two generated triangles, we need to figure out which
+					// triangle goes into the UPPER hull and which goes into the LOWER hull
+					Triangle ta = new Triangle(a, b, qa);
+					Triangle tb = new Triangle(qa, b, c);
+
+                    // generate UV coordinates if there is any
+                    if (tri.hasUV) {
+                        // the computed UV coordinate if the intersection point
+                        Vector2 pq = tri.GenerateUV(qa);
+                        Vector2 pa = tri.uvA;
+                        Vector2 pb = tri.uvB;
+                        Vector2 pc = tri.uvC;
+
+                        ta.SetUV(pa, pb, pq);
+                        tb.SetUV(pq, pb, pc);
+                    }
+
+                    // generate Normal coordinates if there is any
+                    if (tri.hasNormal) {
+                        // the computed Normal coordinate if the intersection point
+                        Vector3 pq = tri.GenerateNormal(qa);
+                        Vector3 pa = tri.normalA;
+                        Vector3 pb = tri.normalB;
+                        Vector3 pc = tri.normalC;
+
+                        ta.SetNormal(pa, pb, pq);
+                        tb.SetNormal(pq, pb, pc);
+                    }
+
+                    // generate Tangent coordinates if there is any
+                    if (tri.hasTangent) {
+                        // the computed Tangent coordinate if the intersection point
+                        Vector4 pq = tri.GenerateTangent(qa);
+                        Vector4 pa = tri.tangentA;
+                        Vector4 pb = tri.tangentB;
+                        Vector4 pc = tri.tangentC;
+
+                        ta.SetTangent(pa, pb, pq);
+                        tb.SetTangent(pq, pb, pc);
+                    }
+
+					// a point lies on the upside of the plane
+					if (sa == SideOfPlane.UP) {
+						result.AddUpperHull(ta).AddLowerHull(tb);
+					}
+
+					// a point lies on the downside of the plane
+					else if (sa == SideOfPlane.DOWN) {
+						result.AddUpperHull(tb).AddLowerHull(ta);
+					}
+				}
+			}
+
+			// test the case where the c point lies on the plane itself
+			else if (sc == SideOfPlane.ON) {
+				// if the point c is on the plane, test line a-b
+				if (Intersector.Intersect(pl, a, b, out qa)) {
+					// line a-c intersected, construct out triangles and return approprietly
+					result.AddIntersectionPoint(qa);
+					result.AddIntersectionPoint(c);
+
+					// our two generated triangles, we need to figure out which
+					// triangle goes into the UPPER hull and which goes into the LOWER hull
+					Triangle ta = new Triangle(a, qa, c);
+					Triangle tb = new Triangle(qa, b, c);
+
+                    // generate UV coordinates if there is any
+                    if (tri.hasUV) {
+                        // the computed UV coordinate if the intersection point
+                        Vector2 pq = tri.GenerateUV(qa);
+                        Vector2 pa = tri.uvA;
+                        Vector2 pb = tri.uvB;
+                        Vector2 pc = tri.uvC;
+
+                        ta.SetUV(pa, pq, pc);
+                        tb.SetUV(pq, pb, pc);
+                    }
+
+                    // generate Normal coordinates if there is any
+                    if (tri.hasNormal) {
+                        // the computed Normal coordinate if the intersection point
+                        Vector3 pq = tri.GenerateNormal(qa);
+                        Vector3 pa = tri.normalA;
+                        Vector3 pb = tri.normalB;
+                        Vector3 pc = tri.normalC;
+
+                        ta.SetNormal(pa, pq, pc);
+                        tb.SetNormal(pq, pb, pc);
+                    }
+
+                    // generate Tangent coordinates if there is any
+                    if (tri.hasTangent) {
+                        // the computed Tangent coordinate if the intersection point
+                        Vector4 pq = tri.GenerateTangent(qa);
+                        Vector4 pa = tri.tangentA;
+                        Vector4 pb = tri.tangentB;
+                        Vector4 pc = tri.tangentC;
+
+                        ta.SetTangent(pa, pq, pc);
+                        tb.SetTangent(pq, pb, pc);
+                    }
+
+					// a point lies on the upside of the plane
+					if (sa == SideOfPlane.UP) {
+						result.AddUpperHull(ta).AddLowerHull(tb);
+					}
+
+					// a point lies on the downside of the plane
+					else if (sa == SideOfPlane.DOWN) {
+						result.AddUpperHull(tb).AddLowerHull(ta);
+					}
+				}
+			}
+
+			// at this point, all edge cases have been tested and failed, we need to perform
+			// full intersection tests against the lines. From this point onwards we will generate
+			// 3 triangles
+			else if (sa != sb && Intersector.Intersect(pl, a, b, out qa)) {
+				// intersection found against a - b
+				result.AddIntersectionPoint(qa);
+
+				// since intersection was found against a - b, we need to check which other
+				// lines to check (we only need to check one more line) for intersection.
+				// the line we check against will be the line against the point which lies on
+				// the other side of the plane.
+				if (sa == sc) {
+					// we likely have an intersection against line b-c which will complete this loop
+					if (Intersector.Intersect(pl, b, c, out qb)) {
+                        result.AddIntersectionPoint(qb);
+
+						// our three generated triangles. Two of these triangles will end
+						// up on either the UPPER or LOWER hulls.
+						Triangle ta = new Triangle(qa, b, qb);
+						Triangle tb = new Triangle(a, qa, qb);
+						Triangle tc = new Triangle(a, qb, c);
+
+                        // generate UV coordinates if there is any
+                        if (tri.hasUV) {
+                            // the computed UV coordinate if the intersection point
+                            Vector2 pqa = tri.GenerateUV(qa);
+                            Vector2 pqb = tri.GenerateUV(qb);
+                            Vector2 pa = tri.uvA;
+                            Vector2 pb = tri.uvB;
+                            Vector2 pc = tri.uvC;
+
+                            ta.SetUV(pqa, pb, pqb);
+                            tb.SetUV(pa, pqa, pqb);
+                            tc.SetUV(pa, pqb, pc);
+                        }
+
+                        // generate Normal coordinates if there is any
+                        if (tri.hasNormal) {
+                            // the computed Normal coordinate if the intersection point
+                            Vector3 pqa = tri.GenerateNormal(qa);
+                            Vector3 pqb = tri.GenerateNormal(qb);
+                            Vector3 pa = tri.normalA;
+                            Vector3 pb = tri.normalB;
+                            Vector3 pc = tri.normalC;
+
+                            ta.SetNormal(pqa, pb, pqb);
+                            tb.SetNormal(pa, pqa, pqb);
+                            tc.SetNormal(pa, pqb, pc);
+                        }
+
+                        // generate Tangent coordinates if there is any
+                        if (tri.hasTangent) {
+                            // the computed Tangent coordinate if the intersection point
+                            Vector4 pqa = tri.GenerateTangent(qa);
+                            Vector4 pqb = tri.GenerateTangent(qb);
+                            Vector4 pa = tri.tangentA;
+                            Vector4 pb = tri.tangentB;
+                            Vector4 pc = tri.tangentC;
+
+                            ta.SetTangent(pqa, pb, pqb);
+                            tb.SetTangent(pa, pqa, pqb);
+                            tc.SetTangent(pa, pqb, pc);
+                        }
+
+						if (sa == SideOfPlane.UP) {
+							result.AddUpperHull(tb).AddUpperHull(tc).AddLowerHull(ta);
+						} 
+						else {
+							result.AddLowerHull(tb).AddLowerHull(tc).AddUpperHull(ta);
+						}
+					}
+				}
+				else {
+					// in this scenario, the point a is a "lone" point which lies in either upper
+					// or lower HULL. We need to perform another intersection to find the last point
+					if (Intersector.Intersect(pl, a, c, out qb)) {
+						result.AddIntersectionPoint(qb);
+
+						// our three generated triangles. Two of these triangles will end
+						// up on either the UPPER or LOWER hulls.
+						Triangle ta = new Triangle(a, qa, qb);
+						Triangle tb = new Triangle(qa, b, c);
+						Triangle tc = new Triangle(qb, qa, c);
+
+                        // generate UV coordinates if there is any
+                        if (tri.hasUV) {
+                            // the computed UV coordinate if the intersection point
+                            Vector2 pqa = tri.GenerateUV(qa);
+                            Vector2 pqb = tri.GenerateUV(qb);
+                            Vector2 pa = tri.uvA;
+                            Vector2 pb = tri.uvB;
+                            Vector2 pc = tri.uvC;
+
+                            ta.SetUV(pa, pqa, pqb);
+                            tb.SetUV(pqa, pb, pc);
+                            tc.SetUV(pqb, pqa, pc);
+                        }
+
+                        // generate Normal coordinates if there is any
+                        if (tri.hasNormal) {
+                            // the computed Normal coordinate if the intersection point
+                            Vector3 pqa = tri.GenerateNormal(qa);
+                            Vector3 pqb = tri.GenerateNormal(qb);
+                            Vector3 pa = tri.normalA;
+                            Vector3 pb = tri.normalB;
+                            Vector3 pc = tri.normalC;
+
+                            ta.SetNormal(pa, pqa, pqb);
+                            tb.SetNormal(pqa, pb, pc);
+                            tc.SetNormal(pqb, pqa, pc);
+                        }
+
+                        // generate Tangent coordinates if there is any
+                        if (tri.hasTangent) {
+                            // the computed Tangent coordinate if the intersection point
+                            Vector4 pqa = tri.GenerateTangent(qa);
+                            Vector4 pqb = tri.GenerateTangent(qb);
+                            Vector4 pa = tri.tangentA;
+                            Vector4 pb = tri.tangentB;
+                            Vector4 pc = tri.tangentC;
+
+                            ta.SetTangent(pa, pqa, pqb);
+                            tb.SetTangent(pqa, pb, pc);
+                            tc.SetTangent(pqb, pqa, pc);
+                        }
+
+						if (sa == SideOfPlane.UP) {
+							result.AddUpperHull(ta).AddLowerHull(tb).AddLowerHull(tc);
+						} 
+						else {
+							result.AddLowerHull(ta).AddUpperHull(tb).AddUpperHull(tc);
+						}
+					}
+				}
+			}
+
+			// if line a-b did not intersect (or the lie on the same side of the plane)
+			// this simplifies the problem a fair bit. This means we have an intersection 
+			// in line a-c and b-c, which we can use to build a new UPPER and LOWER hulls
+			// we are expecting both of these intersection tests to pass, otherwise something
+			// went wrong (float errors? missed a checked case?)
+			else if (Intersector.Intersect(pl, c, a, out qa) && Intersector.Intersect(pl, c, b, out qb)) {
+				// in here we know that line a-b actually lie on the same side of the plane, this will
+				// simplify the rest of the logic. We also have our intersection points
+				// the computed UV coordinate of the intersection point
+
+				result.AddIntersectionPoint(qa);
+				result.AddIntersectionPoint(qb);
+
+				// our three generated triangles. Two of these triangles will end
+				// up on either the UPPER or LOWER hulls.
+				Triangle ta = new Triangle(qa, qb, c);
+				Triangle tb = new Triangle(a, qb, qa);
+				Triangle tc = new Triangle(a, b, qb);
+
+                // generate UV coordinates if there is any
+                if (tri.hasUV) {
+                    // the computed UV coordinate if the intersection point
+                    Vector2 pqa = tri.GenerateUV(qa);
+                    Vector2 pqb = tri.GenerateUV(qb);
+                    Vector2 pa = tri.uvA;
+                    Vector2 pb = tri.uvB;
+                    Vector2 pc = tri.uvC;
+
+                    ta.SetUV(pqa, pqb, pc);
+                    tb.SetUV(pa, pqb, pqa);
+                    tc.SetUV(pa, pb, pqb);
+                }
+
+                // generate Normal coordinates if there is any
+                if (tri.hasNormal) {
+                    // the computed Normal coordinate if the intersection point
+                    Vector3 pqa = tri.GenerateNormal(qa);
+                    Vector3 pqb = tri.GenerateNormal(qb);
+                    Vector3 pa = tri.normalA;
+                    Vector3 pb = tri.normalB;
+                    Vector3 pc = tri.normalC;
+
+                    ta.SetNormal(pqa, pqb, pc);
+                    tb.SetNormal(pa, pqb, pqa);
+                    tc.SetNormal(pa, pb, pqb);
+                }
+
+                // generate Tangent coordinates if there is any
+                if (tri.hasTangent) {
+                    // the computed Tangent coordinate if the intersection point
+                    Vector4 pqa = tri.GenerateTangent(qa);
+                    Vector4 pqb = tri.GenerateTangent(qb);
+                    Vector4 pa = tri.tangentA;
+                    Vector4 pb = tri.tangentB;
+                    Vector4 pc = tri.tangentC;
+
+                    ta.SetTangent(pqa, pqb, pc);
+                    tb.SetTangent(pa, pqb, pqa);
+                    tc.SetTangent(pa, pb, pqb);
+                }
+
+				if (sa == SideOfPlane.UP) {
+					result.AddUpperHull(tb).AddUpperHull(tc).AddLowerHull(ta);
+				}
+				else {
+					result.AddLowerHull(tb).AddLowerHull(tc).AddUpperHull(ta);
+				}
+			}
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Intersector.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 68977ed014f58453a8e1a8413810cb98
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Framework/Intersector.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Line.cs

@@ -0,0 +1,31 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice {
+	public struct Line {
+		private readonly Vector3 m_pos_a;
+		private readonly Vector3 m_pos_b;
+
+		public Line(Vector3 pta, Vector3 ptb) {
+			this.m_pos_a = pta;
+			this.m_pos_b = ptb;
+		}
+
+		public float dist {
+			get { return GKC_Utils.distance (this.m_pos_a, this.m_pos_b); }
+		}
+
+		public float distSq {
+			get { return (this.m_pos_a - this.m_pos_b).sqrMagnitude; }
+		}
+
+		public Vector3 positionA {
+			get { return this.m_pos_a; }
+		}
+
+		public Vector3 positionB {
+			get { return this.m_pos_b; }
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Line.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: f79fe4ab0d9d54fc0b2878eff9a317b7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Framework/Line.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Plane.cs

@@ -0,0 +1,142 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice
+{
+
+	/**
+	 * Quick Internal structure which checks where the point lays on the
+	 * Plane. UP = Upwards from the Normal, DOWN = Downwards from the Normal
+	 * ON = Point lays straight on the plane
+	 */
+	public enum SideOfPlane
+	{
+		UP,
+		DOWN,
+		ON
+	}
+
+	/**
+	 * Represents a simple 3D Plane structure with a position
+	 * and direction which extends infinitely in its axis. This provides
+	 * an optimal structure for collision tests for the slicing framework.
+	 */
+	public struct Plane
+	{
+		private Vector3 m_normal;
+		private float m_dist;
+
+		// this is for editor debugging only! do NOT try to access this
+		// variable at runtime, we will be stripping it out for final
+		// builds
+		#if UNITY_EDITOR
+		private Transform trans_ref;
+		#endif
+
+		public Plane (Vector3 pos, Vector3 norm)
+		{
+			this.m_normal = norm;
+			this.m_dist = Vector3.Dot (norm, pos);
+
+			// this is for editor debugging only!
+			#if UNITY_EDITOR
+			trans_ref = null;
+			#endif
+		}
+
+		public Plane (Vector3 norm, float dot)
+		{
+			this.m_normal = norm;
+			this.m_dist = dot;
+
+			// this is for editor debugging only!
+			#if UNITY_EDITOR
+			trans_ref = null;
+			#endif
+		}
+
+		public void Compute (Vector3 pos, Vector3 norm)
+		{
+			this.m_normal = norm;
+			this.m_dist = Vector3.Dot (norm, pos);
+		}
+
+		public void Compute (Transform trans)
+		{
+			Compute (trans.position, trans.up);
+
+			// this is for editor debugging only!
+			#if UNITY_EDITOR
+			trans_ref = trans;
+			#endif
+		}
+
+		public void Compute (GameObject obj)
+		{
+			Compute (obj.transform);
+		}
+
+		public Vector3 normal {
+			get { return this.m_normal; }
+		}
+
+		public float dist {
+			get { return this.m_dist; }
+		}
+
+		/**
+		 * Checks which side of the plane the point lays on.
+		 */
+		public SideOfPlane SideOf (Vector3 pt)
+		{
+			float result = Vector3.Dot (m_normal, pt) - m_dist;
+
+			if (result > float.Epsilon) {
+				return SideOfPlane.UP;
+			}
+
+			if (result < -float.Epsilon) {
+				return SideOfPlane.DOWN;
+			}
+
+			return SideOfPlane.ON;
+		}
+
+		/**
+		 * Editor only DEBUG functionality. This should not be compiled in the final
+		 * Version.
+		 */
+		public void OnDebugDraw ()
+		{
+			OnDebugDraw (Color.white);
+		}
+
+		public void OnDebugDraw (Color drawColor)
+		{
+			// NOTE -> Gizmos are only supported in the editor. We will keep these function
+			// signatures for consistancy however at final build, these will do nothing
+			// TO/DO -> Should we throw a runtime exception if this function tried to get executed
+			// at runtime?
+			#if UNITY_EDITOR
+
+			if (trans_ref == null) {
+				return;
+			}
+
+			Color prevColor = Gizmos.color;
+			Matrix4x4 prevMatrix = Gizmos.matrix;
+
+			// TO-DO
+			Gizmos.matrix = Matrix4x4.TRS (trans_ref.position, trans_ref.rotation, trans_ref.localScale);
+			Gizmos.color = drawColor;
+
+			Gizmos.DrawWireCube (Vector3.zero, new Vector3 (1.0f, 0.0f, 1.0f));
+
+			Gizmos.color = prevColor;
+			Gizmos.matrix = prevMatrix;
+
+			#endif
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Plane.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: ea181f2949b1a49968de7347c70f068a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Framework/Plane.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Framework/TextureRegion.cs

@@ -0,0 +1,117 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice {
+    /**
+     * TextureRegion defines a region of a specific texture which can be used
+     * for custom UV Mapping Routines.
+     * 
+     * TextureRegions are always stored in normalized UV Coordinate space between
+     * 0.0f and 1.0f
+     */
+    public struct TextureRegion {
+        private readonly float pos_start_x;
+        private readonly float pos_start_y;
+        private readonly float pos_end_x;
+        private readonly float pos_end_y;
+
+        public TextureRegion(float startX, float startY, float endX, float endY) {
+            this.pos_start_x = startX;
+            this.pos_start_y = startY;
+            this.pos_end_x = endX;
+            this.pos_end_y = endY;
+        }
+
+        public float startX { get { return this.pos_start_x; } }
+        public float startY { get { return this.pos_start_y; } }
+        public float endX { get { return this.pos_end_x; } }
+        public float endY { get { return this.pos_end_y; } }
+
+        public Vector2 start { get { return new Vector2(startX, startY); } }
+        public Vector2 end { get { return new Vector2(endX, endY); } }
+
+        /**
+         * Perform a mapping of a UV coordinate (computed in 0,1 space)
+         * into the new coordinates defined by the provided TextureRegion
+         */
+        public Vector2 Map(Vector2 uv) {
+            return Map(uv.x, uv.y);
+        }
+
+        /**
+         * Perform a mapping of a UV coordinate (computed in 0,1 space)
+         * into the new coordinates defined by the provided TextureRegion
+         */
+        public Vector2 Map(float x, float y) {
+            float mappedX = MAP(x, 0.0f, 1.0f, pos_start_x, pos_end_x);
+            float mappedY = MAP(y, 0.0f, 1.0f, pos_start_y, pos_end_y);
+
+            return new Vector2(mappedX, mappedY);
+        }
+
+        /**
+         * Our mapping function to map arbitrary values into our required texture region
+         */
+        private static float MAP(float x, float in_min, float in_max, float out_min, float out_max) {
+            return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
+        }
+    }
+
+    /**
+     * Define our TextureRegion extension to easily calculate
+     * from a Texture2D Object.
+     */
+    public static class TextureRegionExtension {
+
+//        /**
+//         * Helper function to quickly calculate the Texture Region from a material.
+//         * This extension function will use the mainTexture component to perform the
+//         * calculation. 
+//         * 
+//         * Will throw a null exception if the texture does not exist. See
+//         * Texture.getTextureRegion() for function details.
+//         */
+//        public static TextureRegion GetTextureRegion(this Material mat,
+//                                                     int pixX,
+//                                                     int pixY,
+//                                                     int pixWidth,
+//                                                     int pixHeight)
+//        {
+//            return mat.mainTexture.GetTextureRegion(pixX, pixY, pixWidth, pixHeight);
+//        }
+//
+//        /**
+//         * Using a Texture2D, calculate and return a specific TextureRegion
+//         * Coordinates are provided in pixel coordinates where 0,0 is the
+//         * bottom left corner of the texture.
+//         * 
+//         * The texture region will automatically be calculated to ensure that it
+//         * will fit inside the provided texture. 
+//         */
+//        public static TextureRegion GetTextureRegion(this Texture tex, 
+//                                                     int pixX, 
+//                                                     int pixY, 
+//                                                     int pixWidth, 
+//                                                     int pixHeight) 
+//        {
+//            int textureWidth = tex.width;
+//            int textureHeight = tex.height;
+//
+//            // ensure we are not referencing out of bounds coordinates
+//            // relative to our texture
+//            int calcWidth = Mathf.Min(textureWidth, pixWidth);
+//            int calcHeight = Mathf.Min(textureHeight, pixHeight);
+//            int calcX = Mathf.Min(Mathf.Abs(pixX), textureWidth);
+//            int calcY = Mathf.Min(Mathf.Abs(pixY), textureHeight);
+//
+//            float startX = calcX / (float)textureWidth;
+//            float startY = calcY / (float)textureHeight;
+//            float endX = (calcX + calcWidth) / (float)textureWidth;
+//            float endY = (calcY + calcHeight) / (float)textureHeight;
+//
+//            // texture region is a struct which is allocated on the stack
+//            return new TextureRegion(startX, startY, endX, endY);
+//        }
+    }
+}

Assets/Game Kit Controller/Integrations/EzySlice/Framework/TextureRegion.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: e51e783641a5e49d3862ecbee26cc521
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Framework/TextureRegion.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Triangle.cs

@@ -0,0 +1,352 @@
+using UnityEngine;
+
+namespace EzySlice {
+	/**
+	 * Represents a simple 3D Triangle structure with position
+	 * and UV map. The UV is required if the slicer needs
+	 * to recalculate the new UV position for texture mapping.
+	 */
+	public struct Triangle {
+		// the points which represent this triangle
+        // these have to be set and are immutable. Cannot be
+        // changed once set
+		private readonly Vector3 m_pos_a;
+		private readonly Vector3 m_pos_b;
+		private readonly Vector3 m_pos_c;
+
+        // the UV coordinates of this triangle
+        // these are optional and may not be set
+        private bool m_uv_set;
+        private Vector2 m_uv_a;
+        private Vector2 m_uv_b;
+		private Vector2 m_uv_c;
+
+        // the Normals of the Vertices
+        // these are optional and may not be set
+        private bool m_nor_set;
+        private Vector3 m_nor_a;
+        private Vector3 m_nor_b;
+        private Vector3 m_nor_c;
+
+        // the Tangents of the Vertices
+        // these are optional and may not be set
+        private bool m_tan_set;
+        private Vector4 m_tan_a;
+        private Vector4 m_tan_b;
+        private Vector4 m_tan_c;
+
+		public Triangle(Vector3 posa, 
+						Vector3 posb, 
+						Vector3 posc) 
+        {
+            this.m_pos_a = posa;
+            this.m_pos_b = posb;
+            this.m_pos_c = posc;
+
+            this.m_uv_set = false;
+            this.m_uv_a = Vector2.zero;
+            this.m_uv_b = Vector2.zero;
+            this.m_uv_c = Vector2.zero;
+
+            this.m_nor_set = false;
+            this.m_nor_a = Vector3.zero;
+            this.m_nor_b = Vector3.zero;
+            this.m_nor_c = Vector3.zero;
+
+            this.m_tan_set = false;
+            this.m_tan_a = Vector4.zero;
+            this.m_tan_b = Vector4.zero;
+            this.m_tan_c = Vector4.zero;
+        }
+
+		public Vector3 positionA {
+			get { return this.m_pos_a; }
+		}
+
+		public Vector3 positionB {
+			get { return this.m_pos_b; }
+		}
+
+		public Vector3 positionC {
+			get { return this.m_pos_c; }
+		}
+
+        public bool hasUV {
+            get { return this.m_uv_set; }
+        }
+
+        public void SetUV(Vector2 uvA, Vector2 uvB, Vector2 uvC) {
+            this.m_uv_a = uvA;
+            this.m_uv_b = uvB;
+            this.m_uv_c = uvC;
+
+            this.m_uv_set = true;
+        }
+
+		public Vector2 uvA {
+			get { return this.m_uv_a; }
+		}
+
+		public Vector2 uvB {
+			get { return this.m_uv_b; }
+		}
+
+		public Vector2 uvC {
+			get { return this.m_uv_c; }
+		}
+
+        public bool hasNormal {
+            get { return this.m_nor_set; }
+        }
+
+        public void SetNormal(Vector3 norA, Vector3 norB, Vector3 norC) {
+            this.m_nor_a = norA;
+            this.m_nor_b = norB;
+            this.m_nor_c = norC;
+
+            this.m_nor_set = true;
+        }
+
+        public Vector3 normalA {
+            get { return this.m_nor_a; }
+        }
+
+        public Vector3 normalB {
+            get { return this.m_nor_b; }
+        }
+
+        public Vector3 normalC {
+            get { return this.m_nor_c; }
+        }
+
+        public bool hasTangent {
+            get { return this.m_tan_set; }
+        }
+
+        public void SetTangent(Vector4 tanA, Vector4 tanB, Vector4 tanC) {
+            this.m_tan_a = tanA;
+            this.m_tan_b = tanB;
+            this.m_tan_c = tanC;
+
+            this.m_tan_set = true;
+        }
+
+        public Vector4 tangentA {
+            get { return this.m_tan_a; }
+        }
+
+        public Vector4 tangentB {
+            get { return this.m_tan_b; }
+        }
+
+        public Vector4 tangentC {
+            get { return this.m_tan_c; }
+        }
+
+        /**
+         * Compute and set the tangents of this triangle
+         * Derived From https://answers.unity.com/questions/7789/calculating-tangents-vector4.html
+         */
+        public void ComputeTangents() {
+            // computing tangents requires both UV and normals set
+            if (!m_nor_set || !m_uv_set) {
+                return;
+            }
+
+            Vector3 v1 = m_pos_a;
+            Vector3 v2 = m_pos_b;
+            Vector3 v3 = m_pos_c;
+
+            Vector2 w1 = m_uv_a;
+            Vector2 w2 = m_uv_b;
+            Vector2 w3 = m_uv_c;
+
+            float x1 = v2.x - v1.x;
+            float x2 = v3.x - v1.x;
+            float y1 = v2.y - v1.y;
+            float y2 = v3.y - v1.y;
+            float z1 = v2.z - v1.z;
+            float z2 = v3.z - v1.z;
+
+            float s1 = w2.x - w1.x;
+            float s2 = w3.x - w1.x;
+            float t1 = w2.y - w1.y;
+            float t2 = w3.y - w1.y;
+
+            float r = 1.0f / (s1 * t2 - s2 * t1);
+
+            Vector3 sdir = new Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
+            Vector3 tdir = new Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
+
+            Vector3 n1 = m_nor_a;
+            Vector3 nt1 = sdir;
+
+            Vector3.OrthoNormalize(ref n1, ref nt1);
+            Vector4 tanA = new Vector4(nt1.x, nt1.y, nt1.z, (Vector3.Dot(Vector3.Cross(n1, nt1), tdir) < 0.0f) ? -1.0f : 1.0f);
+
+            Vector3 n2 = m_nor_b;
+            Vector3 nt2 = sdir;
+
+            Vector3.OrthoNormalize(ref n2, ref nt2);
+            Vector4 tanB = new Vector4(nt2.x, nt2.y, nt2.z, (Vector3.Dot(Vector3.Cross(n2, nt2), tdir) < 0.0f) ? -1.0f : 1.0f);
+
+            Vector3 n3 = m_nor_c;
+            Vector3 nt3 = sdir;
+
+            Vector3.OrthoNormalize(ref n3, ref nt3);
+            Vector4 tanC = new Vector4(nt3.x, nt3.y, nt3.z, (Vector3.Dot(Vector3.Cross(n3, nt3), tdir) < 0.0f) ? -1.0f : 1.0f);
+
+            // finally set the tangents of this object
+            SetTangent(tanA, tanB, tanC);
+        }
+
+		/**
+		 * Calculate the Barycentric coordinate weight values u-v-w for Point p in respect to the provided
+		 * triangle. This is useful for computing new UV coordinates for arbitrary points.
+		 */
+		public Vector3 Barycentric(Vector3 p) {
+			Vector3 a = m_pos_a;
+			Vector3 b = m_pos_b;
+			Vector3 c = m_pos_c;
+
+			Vector3 m = Vector3.Cross(b - a, c - a);
+
+			float nu;
+			float nv;
+			float ood;
+
+			float x = Mathf.Abs(m.x);
+			float y = Mathf.Abs(m.y);
+			float z = Mathf.Abs(m.z);
+
+			// compute areas of plane with largest projections
+			if (x >= y && x >= z) {
+				// area of PBC in yz plane
+				nu = Intersector.TriArea2D(p.y, p.z, b.y, b.z, c.y, c.z);
+				// area of PCA in yz plane
+				nv = Intersector.TriArea2D(p.y, p.z, c.y, c.z, a.y, a.z);
+				// 1/2*area of ABC in yz plane
+				ood = 1.0f / m.x;
+			} 
+			else if (y >= x && y >= z) {
+				// project in xz plane
+				nu = Intersector.TriArea2D(p.x, p.z, b.x, b.z, c.x, c.z);
+				nv = Intersector.TriArea2D(p.x, p.z, c.x, c.z, a.x, a.z);
+				ood = 1.0f / -m.y;
+			} 
+			else {
+				// project in xy plane
+				nu = Intersector.TriArea2D(p.x, p.y, b.x, b.y, c.x, c.y);
+				nv = Intersector.TriArea2D(p.x, p.y, c.x, c.y, a.x, a.y);
+				ood = 1.0f / m.z;
+			}
+
+			float u = nu * ood;
+			float v = nv * ood;
+			float w = 1.0f - u - v;
+
+			return new Vector3(u, v, w);
+		}
+
+		/**
+		 * Generate a set of new UV coordinates for the provided point pt in respect to Triangle.
+		 * 
+		 * Uses weight values for the computation, so this triangle must have UV's set to return
+		 * the correct results. Otherwise Vector2.zero will be returned. check via hasUV().
+		 */
+		public Vector2 GenerateUV(Vector3 pt) {
+            // if not set, result will be zero, quick exit
+            if (!m_uv_set) {
+                return Vector2.zero;
+            }
+
+			Vector3 weights = Barycentric(pt);
+
+			return (weights.x * m_uv_a) + (weights.y * m_uv_b) + (weights.z * m_uv_c);
+		}
+
+        /**
+         * Generates a set of new Normal coordinates for the provided point pt in respect to Triangle.
+         * 
+         * Uses weight values for the computation, so this triangle must have Normal's set to return
+         * the correct results. Otherwise Vector3.zero will be returned. check via hasNormal().
+         */
+        public Vector3 GenerateNormal(Vector3 pt) {
+            // if not set, result will be zero, quick exit
+            if (!m_nor_set) {
+                return Vector3.zero;
+            }
+
+            Vector3 weights = Barycentric(pt);
+
+            return (weights.x * m_nor_a) + (weights.y * m_nor_b) + (weights.z * m_nor_c);
+        }
+
+        /**
+         * Generates a set of new Tangent coordinates for the provided point pt in respect to Triangle.
+         * 
+         * Uses weight values for the computation, so this triangle must have Tangent's set to return
+         * the correct results. Otherwise Vector4.zero will be returned. check via hasTangent().
+         */
+        public Vector4 GenerateTangent(Vector3 pt) {
+            // if not set, result will be zero, quick exit
+            if (!m_nor_set) {
+                return Vector4.zero;
+            }
+
+            Vector3 weights = Barycentric(pt);
+
+            return (weights.x * m_tan_a) + (weights.y * m_tan_b) + (weights.z * m_tan_c);
+        }
+
+		/**
+		 * Helper function to split this triangle by the provided plane and store
+		 * the results inside the IntersectionResult structure.
+		 * Returns true on success or false otherwise
+		 */
+		public bool Split(Plane pl, IntersectionResult result) {
+			Intersector.Intersect(pl, this, result);
+
+			return result.isValid;
+		}
+
+		/**
+		 * Check the triangle winding order, if it's Clock Wise or Counter Clock Wise 
+		 */
+		public bool IsCW() {
+            return SignedSquare(m_pos_a, m_pos_b, m_pos_c) >= float.Epsilon;
+		}
+
+		/**
+		 * Returns the Signed square of a given triangle, useful for checking the
+		 * winding order
+		 */
+		public static float SignedSquare(Vector3 a, Vector3 b, Vector3 c) {
+			return (a.x * (b.y * c.z - b.z * c.y) - 
+					a.y * (b.x * c.z - b.z * c.x) + 
+					a.z * (b.x * c.y - b.y * c.x));
+		}
+
+		/**
+		 * Editor only DEBUG functionality. This should not be compiled in the final
+		 * Version.
+		 */
+		public void OnDebugDraw() {
+			OnDebugDraw(Color.white);
+		}
+
+		public void OnDebugDraw(Color drawColor) {
+            #if UNITY_EDITOR
+			Color prevColor = Gizmos.color;
+
+			Gizmos.color = drawColor;
+
+			Gizmos.DrawLine(positionA, positionB);
+			Gizmos.DrawLine(positionB, positionC);
+			Gizmos.DrawLine(positionC, positionA);
+
+			Gizmos.color = prevColor;
+            #endif
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Triangle.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 631906439500e4795907654a51e7e4c4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Framework/Triangle.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Triangulator.cs

@@ -0,0 +1,201 @@
+using System.Collections;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice {
+
+	/**
+	 * Contains static functionality for performing Triangulation on arbitrary vertices.
+	 * Read the individual function descriptions for specific details.
+	 */
+	public sealed class Triangulator {
+
+		/**
+		 * Represents a 3D Vertex which has been mapped onto a 2D surface
+		 * and is mainly used in MonotoneChain to triangulate a set of vertices
+		 * against a flat plane.
+		 */
+		internal struct Mapped2D {
+			private readonly Vector3 original;
+			private readonly Vector2 mapped;
+
+			public Mapped2D(Vector3 newOriginal, Vector3 u, Vector3 v) {
+				this.original = newOriginal;
+				this.mapped = new Vector2(Vector3.Dot(newOriginal, u), Vector3.Dot(newOriginal, v));
+			}
+
+			public Vector2 mappedValue {
+				get { return this.mapped; }
+			}
+
+			public Vector3 originalValue {
+				get { return this.original; }
+			}
+		}
+
+		/**
+		 * Overloaded variant of MonotoneChain which will calculate UV coordinates of the Triangles
+		 * between 0.0 and 1.0 (default).
+		 * 
+		 * See MonotoneChain(vertices, normal, tri, TextureRegion) for full explanation
+		 */
+		public static bool MonotoneChain(List<Vector3> vertices, Vector3 normal, out List<Triangle> tri) {
+			// default texture region is in coordinates 0,0 to 1,1
+			return MonotoneChain(vertices, normal, out tri, new TextureRegion(0.0f, 0.0f, 1.0f, 1.0f));
+		}
+
+		/**
+		 * O(n log n) Convex Hull Algorithm. 
+		 * Accepts a list of vertices as Vector3 and triangulates them according to a projection
+		 * plane defined as planeNormal. Algorithm will output vertices, indices and UV coordinates
+		 * as arrays
+		 */
+		public static bool MonotoneChain(List<Vector3> vertices, Vector3 normal, out List<Triangle> tri, TextureRegion texRegion) {
+			int count = vertices.Count;
+
+			// we cannot triangulate less than 3 points. Use minimum of 3 points
+			if (count < 3) {
+				tri = null;
+				return false;
+			}
+
+			// first, we map from 3D points into a 2D plane represented by the provided normal
+			Vector3 u = Vector3.Normalize(Vector3.Cross(normal, Vector3.up));
+			if ( Vector3.zero == u)
+			{
+				u = Vector3.Normalize(Vector3.Cross(normal, Vector3.forward));
+			}
+			Vector3 v = Vector3.Cross(u, normal);
+
+			// generate an array of mapped values
+			Mapped2D[] mapped = new Mapped2D[count];
+
+			// these values will be used to generate new UV coordinates later on
+			float maxDivX = float.MinValue;
+			float maxDivY = float.MinValue;
+			float minDivX = float.MaxValue;
+			float minDivY = float.MaxValue;
+
+			// map the 3D vertices into the 2D mapped values
+			for (int i = 0; i < count; i++) {
+				Vector3 vertToAdd = vertices[i];
+
+				Mapped2D newMappedValue = new Mapped2D(vertToAdd, u, v);
+				Vector2 mapVal = newMappedValue.mappedValue;
+
+				// grab our maximal values so we can map UV's in a proper range
+				maxDivX = Mathf.Max(maxDivX, mapVal.x);
+				maxDivY = Mathf.Max(maxDivY, mapVal.y);
+				minDivX = Mathf.Min(minDivX, mapVal.x);
+				minDivY = Mathf.Min(minDivY, mapVal.y);
+
+				mapped[i] = newMappedValue;
+			}
+
+			// sort our newly generated array values
+			Array.Sort<Mapped2D>(mapped, (a, b) =>
+			{
+				Vector2 x = a.mappedValue;
+				Vector2 p = b.mappedValue;
+
+				return (x.x < p.x || (x.x == p.x && x.y < p.y)) ? -1 : 1;
+			});
+
+			// our final hull mappings will end up in here
+			Mapped2D[] hulls = new Mapped2D[count+1];
+
+			int k = 0;
+
+			// build the lower hull of the chain
+			for (int i = 0; i < count; i++) {
+				while (k >= 2) {
+					Vector2 mA = hulls[k - 2].mappedValue;
+					Vector2 mB = hulls[k - 1].mappedValue;
+					Vector2 mC = mapped[i].mappedValue;
+
+					if (Intersector.TriArea2D(mA.x, mA.y, mB.x, mB.y, mC.x, mC.y) > 0.0f) {
+						break;
+					}
+
+					k--;
+				}
+
+				hulls[k++] = mapped[i];
+			}
+
+			// build the upper hull of the chain
+			for (int i = count - 2, t = k + 1; i >= 0; i--) {
+				while (k >= t) {
+					Vector2 mA = hulls[k - 2].mappedValue;
+					Vector2 mB = hulls[k - 1].mappedValue;
+					Vector2 mC = mapped[i].mappedValue;
+
+					if (Intersector.TriArea2D(mA.x, mA.y, mB.x, mB.y, mC.x, mC.y) > 0.0f) {
+						break;
+					}
+
+					k--;
+				}
+
+				hulls[k++] = mapped[i];
+			}
+
+			// finally we can build our mesh, generate all the variables
+			// and fill them up
+			int vertCount = k - 1;
+			int triCount = (vertCount - 2) * 3;
+
+			// this should not happen, but here just in case
+			if (vertCount < 3) {
+				tri = null;
+				return false;
+			}
+
+			// ensure List does not dynamically grow, performing copy ops each time!
+			tri = new List<Triangle>(triCount / 3);
+
+			float width = maxDivX - minDivX;
+			float height = maxDivY - minDivY;
+
+			int indexCount = 1;
+
+			// generate both the vertices and uv's in this loop
+			for (int i = 0; i < triCount; i+=3) {
+				// the Vertices in our triangle
+				Mapped2D posA = hulls[0];
+				Mapped2D posB = hulls[indexCount];
+				Mapped2D posC = hulls[indexCount + 1];
+
+				// generate UV Maps
+				Vector2 uvA = posA.mappedValue;
+				Vector2 uvB = posB.mappedValue;
+				Vector2 uvC = posC.mappedValue;
+
+				uvA.x = (uvA.x - minDivX) / width;
+				uvA.y = (uvA.y - minDivY) / height;
+
+				uvB.x = (uvB.x - minDivX) / width;
+				uvB.y = (uvB.y - minDivY) / height;
+
+				uvC.x = (uvC.x - minDivX) / width;
+				uvC.y = (uvC.y - minDivY) / height;
+
+				Triangle newTriangle = new Triangle(posA.originalValue, posB.originalValue, posC.originalValue);
+
+				// ensure our UV coordinates are mapped into the requested TextureRegion
+				newTriangle.SetUV(texRegion.Map(uvA), texRegion.Map(uvB), texRegion.Map(uvC));
+
+				// the normals is the same for all vertices since the final mesh is completly flat
+				newTriangle.SetNormal(normal, normal, normal);
+				newTriangle.ComputeTangents();
+
+				tri.Add(newTriangle);
+
+				indexCount++;
+			}
+
+			return true;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Framework/Triangulator.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 6b3517c604b184880b3e9ab1264a1062
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Framework/Triangulator.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Scripts.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 795ed33319b47c341988e0704ae63e15
+folderAsset: yes
+timeCreated: 1576822976
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Game Kit Controller/Integrations/EzySlice/Scripts/Editor.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 9b164bc43b75c4bf7a5a1914a1dd507e
+folderAsset: yes
+timeCreated: 1513226830
+licenseType: Store
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Game Kit Controller/Integrations/EzySlice/Scripts/Editor/ShatterExampleEditor.cs

@@ -0,0 +1,48 @@
+using UnityEngine;
+using System.Collections;
+using UnityEditor;
+using EzySlice;
+
+/**
+ * This is a simple Editor helper script for rapid testing/prototyping! 
+ */
+[CustomEditor(typeof(ShatterExample))]
+public class ShatterExampleEditor : Editor {
+    public GameObject source;
+    public Material crossMat;
+    public int slice;
+
+    public override void OnInspectorGUI() {
+        ShatterExample plane = (ShatterExample)target;
+
+        source = (GameObject)EditorGUILayout.ObjectField(source, typeof(GameObject), true);
+
+        if (source == null) {
+            EditorGUILayout.LabelField("Add a GameObject to Shatter.");
+
+            return;
+        }
+
+        if (!source.activeInHierarchy) {
+            EditorGUILayout.LabelField("Object is Hidden. Cannot Slice.");
+
+            return;
+        }
+
+        if (source.GetComponent<MeshFilter>() == null) {
+            EditorGUILayout.LabelField("GameObject must have a MeshFilter.");
+
+            return;
+        }
+
+        crossMat = (Material)EditorGUILayout.ObjectField(crossMat, typeof(Material), true);
+        slice = EditorGUILayout.IntSlider(slice, 1, 20);
+
+        if (GUILayout.Button("Shatter Object")) {
+            if (plane.ShatterObject(source, slice, crossMat)) {
+                source.SetActive(false);
+            }
+        }
+    }
+}
+

Assets/Game Kit Controller/Integrations/EzySlice/Scripts/Editor/ShatterExampleEditor.cs.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: d0bc9b3efbea340c0ae2cb00d46f9a2c
+timeCreated: 1521778957
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Scripts/Editor/ShatterExampleEditor.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Scripts/RuntimeShatterExample.cs

@@ -0,0 +1,68 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using EzySlice;
+
+/**
+ * Represents a really badly written shatter script! use for reference purposes only.
+ */
+public class RuntimeShatterExample : MonoBehaviour {
+
+    public GameObject objectToShatter;
+    public Material crossSectionMaterial;
+
+    public List<GameObject> prevShatters = new List<GameObject>();
+
+    public GameObject[] ShatterObject(GameObject obj, Material crossSectionMaterial = null) {
+        return obj.SliceInstantiate(GetRandomPlane(obj.transform.position, obj.transform.localScale),
+                                                            new TextureRegion(0.0f, 0.0f, 1.0f, 1.0f),
+                                                            crossSectionMaterial);
+    }
+
+    public EzySlice.Plane GetRandomPlane(Vector3 positionOffset, Vector3 scaleOffset) {
+        Vector3 randomPosition = Random.insideUnitSphere;
+
+        //randomPosition += positionOffset;
+
+        Vector3 randomDirection = Random.insideUnitSphere.normalized;
+
+        return new EzySlice.Plane(randomPosition, randomDirection);
+    }
+
+    public void RandomShatter() {
+        if (prevShatters.Count == 0) {
+            GameObject[] shatters = ShatterObject(objectToShatter, crossSectionMaterial);
+
+            if (shatters != null && shatters.Length > 0) {
+                objectToShatter.SetActive(false);
+
+                // add rigidbodies and colliders
+                foreach (GameObject shatteredObject in shatters) {
+                    shatteredObject.AddComponent<MeshCollider>().convex = true;
+                    shatteredObject.AddComponent<Rigidbody>();
+
+                    prevShatters.Add(shatteredObject);
+                }
+            }
+
+            return;
+        }
+
+        // otherwise, shatter the previous shattered objects, randomly picked
+        GameObject randomObject = prevShatters[Random.Range(0, prevShatters.Count - 1)];
+
+        GameObject[] randShatter = ShatterObject(randomObject, crossSectionMaterial);
+
+        if (randShatter != null && randShatter.Length > 0) {
+            randomObject.SetActive(false);
+
+            // add rigidbodies and colliders
+            foreach (GameObject shatteredObject in randShatter) {
+                shatteredObject.AddComponent<MeshCollider>().convex = true;
+                shatteredObject.AddComponent<Rigidbody>();
+
+                prevShatters.Add(shatteredObject);
+            }
+        }
+    }
+}

Assets/Game Kit Controller/Integrations/EzySlice/Scripts/RuntimeShatterExample.cs.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: 7fed9a144ebdc46bd845b2b75e2e1854
+timeCreated: 1525669637
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Scripts/RuntimeShatterExample.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Scripts/ShatterExample.cs

@@ -0,0 +1,56 @@
+using UnityEngine;
+using System.Collections;
+using EzySlice;
+
+/**
+ * An example fun script to show how a shatter operation can be applied to a GameObject
+ * by repeatedly and randomly slicing an object
+ */
+public class ShatterExample : MonoBehaviour
+{
+
+	/**
+     * This function will slice the provided object by the plane defined in this
+     * GameObject. We use the GameObject this script is attached to define the position
+     * and direction of our cutting Plane. Results are then returned to the user.
+     */
+	public bool ShatterObject (GameObject obj, int iterations, Material crossSectionMaterial = null)
+	{
+		if (iterations > 0) {
+			GameObject[] slices = obj.SliceInstantiate (GetRandomPlane (obj.transform.position, obj.transform.localScale),
+				                               new TextureRegion (0.0f, 0.0f, 1.0f, 1.0f),
+				                               crossSectionMaterial);
+
+			if (slices != null) {
+				// shatter the shattered!
+				for (int i = 0; i < slices.Length; i++) {
+					if (ShatterObject (slices [i], iterations - 1, crossSectionMaterial)) {
+						// delete the parent
+						GameObject.DestroyImmediate (slices [i]);
+					}
+				}
+
+				return true;
+			}
+
+			return ShatterObject (obj, iterations - 1, crossSectionMaterial);
+		}
+
+		return false;
+	}
+
+	/**
+     * Given an offset position and an offset scale, calculate a random plane
+     * which can be used to randomly slice an object
+     */
+	public EzySlice.Plane GetRandomPlane (Vector3 positionOffset, Vector3 scaleOffset)
+	{
+		Vector3 randomPosition = Random.insideUnitSphere;
+
+		randomPosition += positionOffset;
+
+		Vector3 randomDirection = Random.insideUnitSphere.normalized;
+
+		return new EzySlice.Plane (randomPosition, randomDirection);
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Scripts/ShatterExample.cs.meta

@@ -0,0 +1,21 @@
+fileFormatVersion: 2
+guid: b942e4ba3b5404f77bd7dfba57a9359b
+timeCreated: 1521778957
+licenseType: Store
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Scripts/ShatterExample.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/SlicedHull.cs

@@ -0,0 +1,151 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice
+{
+
+	/**
+	 * The final generated data structure from a slice operation. This provides easy access
+	 * to utility functions and the final Mesh data for each section of the HULL.
+	 */
+	public sealed class SlicedHull
+	{
+		private Mesh upper_hull;
+		private Mesh lower_hull;
+
+		public SlicedHull (Mesh upperHull, Mesh lowerHull)
+		{
+			this.upper_hull = upperHull;
+			this.lower_hull = lowerHull;
+		}
+
+		public GameObject CreateUpperHull (GameObject original)
+		{
+			return CreateUpperHull (original, null);
+		}
+
+		public GameObject CreateUpperHull (GameObject original, Material crossSectionMat)
+		{
+			GameObject newObject = CreateUpperHull ();
+
+			if (newObject != null) {
+				newObject.transform.localPosition = original.transform.localPosition;
+				newObject.transform.localRotation = original.transform.localRotation;
+				newObject.transform.localScale = original.transform.localScale;
+
+				Material[] shared = original.GetComponent<MeshRenderer> ().sharedMaterials;
+				Mesh mesh = original.GetComponent<MeshFilter> ().sharedMesh;
+
+				// nothing changed in the hierarchy, the cross section must have been batched
+				// with the submeshes, return as is, no need for any changes
+				if (mesh.subMeshCount == upper_hull.subMeshCount) {
+					// the the material information
+					newObject.GetComponent<Renderer> ().sharedMaterials = shared;
+
+					return newObject;
+				}
+
+				// otherwise the cross section was added to the back of the submesh array because
+				// it uses a different material. We need to take this into account
+				Material[] newShared = new Material[shared.Length + 1];
+
+				// copy our material arrays across using native copy (should be faster than loop)
+				System.Array.Copy (shared, newShared, shared.Length);
+				newShared [shared.Length] = crossSectionMat;
+
+				// the the material information
+				newObject.GetComponent<Renderer> ().sharedMaterials = newShared;
+			}
+
+			return newObject;
+		}
+
+		public GameObject CreateLowerHull (GameObject original)
+		{
+			return CreateLowerHull (original, null);
+		}
+
+		public GameObject CreateLowerHull (GameObject original, Material crossSectionMat)
+		{
+			GameObject newObject = CreateLowerHull ();
+
+			if (newObject != null) {
+				newObject.transform.localPosition = original.transform.localPosition;
+				newObject.transform.localRotation = original.transform.localRotation;
+				newObject.transform.localScale = original.transform.localScale;
+
+				Material[] shared = original.GetComponent<MeshRenderer> ().sharedMaterials;
+				Mesh mesh = original.GetComponent<MeshFilter> ().sharedMesh;
+
+				// nothing changed in the hierarchy, the cross section must have been batched
+				// with the submeshes, return as is, no need for any changes
+				if (mesh.subMeshCount == lower_hull.subMeshCount) {
+					// the the material information
+					newObject.GetComponent<Renderer> ().sharedMaterials = shared;
+
+					return newObject;
+				}
+
+				// otherwise the cross section was added to the back of the submesh array because
+				// it uses a different material. We need to take this into account
+				Material[] newShared = new Material[shared.Length + 1];
+
+				// copy our material arrays across using native copy (should be faster than loop)
+				System.Array.Copy (shared, newShared, shared.Length);
+				newShared [shared.Length] = crossSectionMat;
+
+				// the the material information
+				newObject.GetComponent<Renderer> ().sharedMaterials = newShared;
+			}
+
+			return newObject;
+		}
+
+		/**
+         * Generate a new GameObject from the upper hull of the mesh
+         * This function will return null if upper hull does not exist
+         */
+		public GameObject CreateUpperHull ()
+		{
+			return CreateEmptyObject ("Upper_Hull", upper_hull);
+		}
+
+		/**
+		 * Generate a new GameObject from the Lower hull of the mesh
+		 * This function will return null if lower hull does not exist
+		 */
+		public GameObject CreateLowerHull ()
+		{
+			return CreateEmptyObject ("Lower_Hull", lower_hull);
+		}
+
+		public Mesh upperHull {
+			get { return this.upper_hull; }
+		}
+
+		public Mesh lowerHull {
+			get { return this.lower_hull; }
+		}
+
+		/**
+		 * Helper function which will create a new GameObject to be able to add
+		 * a new mesh for rendering and return.
+		 */
+		private static GameObject CreateEmptyObject (string name, Mesh hull)
+		{
+			if (hull == null) {
+				return null;
+			}
+
+			GameObject newObject = new GameObject (name);
+
+			newObject.AddComponent<MeshRenderer> ();
+			MeshFilter filter = newObject.AddComponent<MeshFilter> ();
+
+			filter.mesh = hull;
+
+			return newObject;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/SlicedHull.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 03a5a8c7a49854e60a93f3503c894543
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/SlicedHull.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/Slicer.cs

@@ -0,0 +1,478 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace EzySlice
+{
+    
+	/**
+     * Contains methods for slicing GameObjects
+     */
+	public sealed class Slicer
+	{
+
+		/**
+		 * An internal class for storing internal submesh values
+		 */ 
+		internal class SlicedSubmesh
+		{
+			public readonly List<Triangle> upperHull = new List<Triangle> ();
+			public readonly List<Triangle> lowerHull = new List<Triangle> ();
+
+			/**
+             * Check if the submesh has had any UV's added.
+             * NOTE -> This should be supported properly
+             */
+			public bool hasUV {
+				get {
+					// what is this abomination??
+					return upperHull.Count > 0 ? upperHull [0].hasUV : lowerHull.Count > 0 ? lowerHull [0].hasUV : false;
+				}
+			}
+
+			/**
+             * Check if the submesh has had any Normals added.
+             * NOTE -> This should be supported properly
+             */
+			public bool hasNormal {
+				get {
+					// what is this abomination??
+					return upperHull.Count > 0 ? upperHull [0].hasNormal : lowerHull.Count > 0 ? lowerHull [0].hasNormal : false;
+				}
+			}
+
+			/**
+             * Check if the submesh has had any Tangents added.
+             * NOTE -> This should be supported properly
+             */
+			public bool hasTangent {
+				get {
+					// what is this abomination??
+					return upperHull.Count > 0 ? upperHull [0].hasTangent : lowerHull.Count > 0 ? lowerHull [0].hasTangent : false;
+				}
+			}
+
+			/**
+             * Check if proper slicing has occured for this submesh. Slice occured if there
+             * are triangles in both the upper and lower hulls
+             */
+			public bool isValid {
+				get {
+					return upperHull.Count > 0 && lowerHull.Count > 0;
+				}
+			}
+		}
+
+		/**
+		 * Helper function to accept a gameobject which will transform the plane
+		 * approprietly before the slice occurs
+		 * See -> Slice(Mesh, Plane) for more info
+		 */
+		public static SlicedHull Slice (GameObject obj, Plane pl, TextureRegion crossRegion, Material crossMaterial)
+		{
+			MeshFilter filter = obj.GetComponent<MeshFilter> ();
+
+			// cannot continue without a proper filter
+			if (filter == null) {
+				Debug.LogWarning ("EzySlice::Slice -> Provided GameObject must have a MeshFilter Component.");
+
+				return null;
+			}
+
+			MeshRenderer renderer = obj.GetComponent<MeshRenderer> ();
+
+			// cannot continue without a proper renderer
+			if (renderer == null) {
+				Debug.LogWarning ("EzySlice::Slice -> Provided GameObject must have a MeshRenderer Component.");
+
+				return null;
+			}
+
+			Material[] materials = renderer.sharedMaterials;
+
+			Mesh mesh = filter.sharedMesh;
+
+			// cannot slice a mesh that doesn't exist
+			if (mesh == null) {
+				Debug.LogWarning ("EzySlice::Slice -> Provided GameObject must have a Mesh that is not NULL.");
+
+				return null;
+			}
+
+			int submeshCount = mesh.subMeshCount;
+
+			// to make things straightforward, exit without slicing if the materials and mesh
+			// array don't match. This shouldn't happen anyway
+			if (materials.Length != submeshCount) {
+				Debug.LogWarning ("EzySlice::Slice -> Provided Material array must match the length of submeshes.");
+
+				return null;
+			}
+
+			// we need to find the index of the material for the cross section.
+			// default to the end of the array
+			int crossIndex = materials.Length;
+
+			// for cases where the sliced material is null, we will append the cross section to the end
+			// of the submesh array, this is because the application may want to set/change the material
+			// after slicing has occured, so we don't assume anything
+			if (crossMaterial != null) {
+				for (int i = 0; i < crossIndex; i++) {
+					if (materials [i] == crossMaterial) {
+						crossIndex = i;
+						break;
+					}
+				}
+			}
+
+			return Slice (mesh, pl, crossRegion, crossIndex);
+		}
+
+		/**
+		 * Slice the gameobject mesh (if any) using the Plane, which will generate
+		 * a maximum of 2 other Meshes.
+		 * This function will recalculate new UV coordinates to ensure textures are applied
+		 * properly.
+		 * Returns null if no intersection has been found or the GameObject does not contain
+		 * a valid mesh to cut.
+		 */
+		public static SlicedHull Slice (Mesh sharedMesh, Plane pl, TextureRegion region, int crossIndex)
+		{
+			if (sharedMesh == null) {
+				return null;
+			}
+
+			Vector3[] verts = sharedMesh.vertices;
+			Vector2[] uv = sharedMesh.uv;
+			Vector3[] norm = sharedMesh.normals;
+			Vector4[] tan = sharedMesh.tangents;
+
+			int submeshCount = sharedMesh.subMeshCount;
+
+			// each submesh will be sliced and placed in its own array structure
+			SlicedSubmesh[] slices = new SlicedSubmesh[submeshCount];
+			// the cross section hull is common across all submeshes
+			List<Vector3> crossHull = new List<Vector3> ();
+
+			// we reuse this object for all intersection tests
+			IntersectionResult result = new IntersectionResult ();
+
+			// see if we would like to split the mesh using uv, normals and tangents
+			bool genUV = verts.Length == uv.Length;
+			bool genNorm = verts.Length == norm.Length;
+			bool genTan = verts.Length == tan.Length;
+
+			// iterate over all the submeshes individually. vertices and indices
+			// are all shared within the submesh
+			for (int submesh = 0; submesh < submeshCount; submesh++) {
+				int[] indices = sharedMesh.GetTriangles (submesh);
+				int indicesCount = indices.Length;
+
+				SlicedSubmesh mesh = new SlicedSubmesh ();
+
+				// loop through all the mesh vertices, generating upper and lower hulls
+				// and all intersection points
+				for (int index = 0; index < indicesCount; index += 3) {
+					int i0 = indices [index + 0];
+					int i1 = indices [index + 1];
+					int i2 = indices [index + 2];
+
+					Triangle newTri = new Triangle (verts [i0], verts [i1], verts [i2]);
+
+					// generate UV if available
+					if (genUV) {
+						newTri.SetUV (uv [i0], uv [i1], uv [i2]);
+					}
+
+					// generate normals if available
+					if (genNorm) {
+						newTri.SetNormal (norm [i0], norm [i1], norm [i2]);
+					}
+
+					// generate tangents if available
+					if (genTan) {
+						newTri.SetTangent (tan [i0], tan [i1], tan [i2]);
+					}
+
+					// slice this particular triangle with the provided
+					// plane
+					if (newTri.Split (pl, result)) {
+						int upperHullCount = result.upperHullCount;
+						int lowerHullCount = result.lowerHullCount;
+						int interHullCount = result.intersectionPointCount;
+
+						for (int i = 0; i < upperHullCount; i++) {
+							mesh.upperHull.Add (result.upperHull [i]);
+						}
+
+						for (int i = 0; i < lowerHullCount; i++) {
+							mesh.lowerHull.Add (result.lowerHull [i]);
+						}
+
+						for (int i = 0; i < interHullCount; i++) {
+							crossHull.Add (result.intersectionPoints [i]);
+						}
+					} else {
+						SideOfPlane side = pl.SideOf (verts [i0]);
+
+						if (side == SideOfPlane.UP || side == SideOfPlane.ON) {
+							mesh.upperHull.Add (newTri);
+						} else {
+							mesh.lowerHull.Add (newTri);
+						}
+					}
+				}
+
+				// register into the index
+				slices [submesh] = mesh;
+			}
+
+			// check if slicing actually occured
+			for (int i = 0; i < slices.Length; i++) {
+				// check if at least one of the submeshes was sliced. If so, stop checking
+				// because we need to go through the generation step
+				if (slices [i] != null && slices [i].isValid) {
+					return CreateFrom (slices, CreateFrom (crossHull, pl.normal, region), crossIndex);
+				}
+			}
+
+			// no slicing occured, just return null to signify
+			return null;
+		}
+
+		/**
+		 * Generates a single SlicedHull from a set of cut submeshes 
+		 */
+		private static SlicedHull CreateFrom (SlicedSubmesh[] meshes, List<Triangle> cross, int crossSectionIndex)
+		{
+			int submeshCount = meshes.Length;
+
+			int upperHullCount = 0;
+			int lowerHullCount = 0;
+
+			// get the total amount of upper, lower and intersection counts
+			for (int submesh = 0; submesh < submeshCount; submesh++) {
+				upperHullCount += meshes [submesh].upperHull.Count;
+				lowerHullCount += meshes [submesh].lowerHull.Count;
+			}
+
+			Mesh upperHull = CreateUpperHull (meshes, upperHullCount, cross, crossSectionIndex);
+			Mesh lowerHull = CreateLowerHull (meshes, lowerHullCount, cross, crossSectionIndex);
+
+			return new SlicedHull (upperHull, lowerHull);
+		}
+
+		private static Mesh CreateUpperHull (SlicedSubmesh[] mesh, int total, List<Triangle> crossSection, int crossSectionIndex)
+		{
+			return CreateHull (mesh, total, crossSection, crossSectionIndex, true);
+		}
+
+		private static Mesh CreateLowerHull (SlicedSubmesh[] mesh, int total, List<Triangle> crossSection, int crossSectionIndex)
+		{
+			return CreateHull (mesh, total, crossSection, crossSectionIndex, false);
+		}
+
+		/**
+		 * Generate a single Mesh HULL of either the UPPER or LOWER hulls. 
+		 */
+		private static Mesh CreateHull (SlicedSubmesh[] meshes, int total, List<Triangle> crossSection, int crossIndex, bool isUpper)
+		{
+			if (total <= 0) {
+				return null;
+			}
+
+			int submeshCount = meshes.Length;
+			int crossCount = crossSection != null ? crossSection.Count : 0;
+
+			Mesh newMesh = new Mesh ();
+
+			int arrayLen = (total + crossCount) * 3;
+
+			bool hasUV = meshes [0].hasUV;
+			bool hasNormal = meshes [0].hasNormal;
+			bool hasTangent = meshes [0].hasTangent;
+
+			// vertices and uv's are common for all submeshes
+			Vector3[] newVertices = new Vector3[arrayLen];
+			Vector2[] newUvs = hasUV ? new Vector2[arrayLen] : null;
+			Vector3[] newNormals = hasNormal ? new Vector3[arrayLen] : null;
+			Vector4[] newTangents = hasTangent ? new Vector4[arrayLen] : null;
+
+			// each index refers to our submesh triangles
+			List<int[]> triangles = new List<int[]> (submeshCount);
+
+			int vIndex = 0;
+
+			// first we generate all our vertices, uv's and triangles
+			for (int submesh = 0; submesh < submeshCount; submesh++) {
+				// pick the hull we will be playing around with
+				List<Triangle> hull = isUpper ? meshes [submesh].upperHull : meshes [submesh].lowerHull;
+				int hullCount = hull.Count;
+
+				int[] indices = new int[hullCount * 3];
+
+				// fill our mesh arrays
+				for (int i = 0, triIndex = 0; i < hullCount; i++, triIndex += 3) {
+					Triangle newTri = hull [i];
+
+					int i0 = vIndex + 0;
+					int i1 = vIndex + 1;
+					int i2 = vIndex + 2;
+
+					// add the vertices
+					newVertices [i0] = newTri.positionA;
+					newVertices [i1] = newTri.positionB;
+					newVertices [i2] = newTri.positionC;
+
+					// add the UV coordinates if any
+					if (hasUV) {
+						newUvs [i0] = newTri.uvA;
+						newUvs [i1] = newTri.uvB;
+						newUvs [i2] = newTri.uvC;
+					}
+
+					// add the Normals if any
+					if (hasNormal) {
+						newNormals [i0] = newTri.normalA;
+						newNormals [i1] = newTri.normalB;
+						newNormals [i2] = newTri.normalC;
+					}
+
+					// add the Tangents if any
+					if (hasTangent) {
+						newTangents [i0] = newTri.tangentA;
+						newTangents [i1] = newTri.tangentB;
+						newTangents [i2] = newTri.tangentC;
+					}
+
+					// triangles are returned in clocwise order from the
+					// intersector, no need to sort these
+					indices [triIndex] = i0;
+					indices [triIndex + 1] = i1;
+					indices [triIndex + 2] = i2;
+
+					vIndex += 3;
+				}
+
+				// add triangles to the index for later generation
+				triangles.Add (indices);
+			}
+
+			// generate the cross section required for this particular hull
+			if (crossSection != null && crossCount > 0) {
+				int[] crossIndices = new int[crossCount * 3];
+
+				for (int i = 0, triIndex = 0; i < crossCount; i++, triIndex += 3) {
+					Triangle newTri = crossSection [i];
+
+					int i0 = vIndex + 0;
+					int i1 = vIndex + 1;
+					int i2 = vIndex + 2;
+
+					// add the vertices
+					newVertices [i0] = newTri.positionA;
+					newVertices [i1] = newTri.positionB;
+					newVertices [i2] = newTri.positionC;
+
+					// add the UV coordinates if any
+					if (hasUV) {
+						newUvs [i0] = newTri.uvA;
+						newUvs [i1] = newTri.uvB;
+						newUvs [i2] = newTri.uvC;
+					}
+
+					// add the Normals if any
+					if (hasNormal) {
+						// invert the normals dependiong on upper or lower hull
+						if (isUpper) {
+							newNormals [i0] = -newTri.normalA;
+							newNormals [i1] = -newTri.normalB;
+							newNormals [i2] = -newTri.normalC;
+						} else {
+							newNormals [i0] = newTri.normalA;
+							newNormals [i1] = newTri.normalB;
+							newNormals [i2] = newTri.normalC;
+						}
+					}
+
+					// add the Tangents if any
+					if (hasTangent) {
+						newTangents [i0] = newTri.tangentA;
+						newTangents [i1] = newTri.tangentB;
+						newTangents [i2] = newTri.tangentC;
+					}
+
+					// add triangles in clockwise for upper
+					// and reversed for lower hulls, to ensure the mesh
+					// is facing the right direction
+					if (isUpper) {
+						crossIndices [triIndex] = i0;
+						crossIndices [triIndex + 1] = i1;
+						crossIndices [triIndex + 2] = i2;
+					} else {
+						crossIndices [triIndex] = i0;
+						crossIndices [triIndex + 1] = i2;
+						crossIndices [triIndex + 2] = i1;
+					}
+
+					vIndex += 3;
+				}
+
+				// add triangles to the index for later generation
+				if (triangles.Count <= crossIndex) {
+					triangles.Add (crossIndices);
+				} else {
+					// otherwise, we need to merge the triangles for the provided subsection
+					int[] prevTriangles = triangles [crossIndex];
+					int[] merged = new int[prevTriangles.Length + crossIndices.Length];
+
+					System.Array.Copy (prevTriangles, merged, prevTriangles.Length);
+					System.Array.Copy (crossIndices, 0, merged, prevTriangles.Length, crossIndices.Length);
+
+					// replace the previous array with the new merged array
+					triangles [crossIndex] = merged;
+				}
+			}
+
+			int totalTriangles = triangles.Count;
+
+			newMesh.subMeshCount = totalTriangles;
+			// fill the mesh structure
+			newMesh.vertices = newVertices;
+
+			if (hasUV) {
+				newMesh.uv = newUvs;
+			}
+
+			if (hasNormal) {
+				newMesh.normals = newNormals;
+			}
+
+			if (hasTangent) {
+				newMesh.tangents = newTangents;
+			}
+
+			// add the submeshes
+			for (int i = 0; i < totalTriangles; i++) {
+				newMesh.SetTriangles (triangles [i], i, false);
+			}
+
+			return newMesh;
+		}
+
+		/**
+		 * Generate Two Meshes (an upper and lower) cross section from a set of intersection
+		 * points and a plane normal. Intersection Points do not have to be in order.
+		 */
+		private static List<Triangle> CreateFrom (List<Vector3> intPoints, Vector3 planeNormal, TextureRegion region)
+		{
+			List<Triangle> tris;
+
+			if (Triangulator.MonotoneChain (intPoints, planeNormal, out tris, region)) {
+				return tris;
+			}
+
+			return null;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/Slicer.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 2b66cc51891b94dc8b74d99376095d10
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/Slicer.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/EzySlice/SlicerExtensions.cs

@@ -0,0 +1,101 @@
+using UnityEngine;
+using System.Collections;
+
+namespace EzySlice
+{
+	/**
+     * Define Extension methods for easy access to slicer functionality
+     */
+	public static class SlicerExtensions
+	{
+        
+		/**
+         * SlicedHull Return functions and appropriate overrides!
+         */
+		public static SlicedHull Slice (this GameObject obj, Plane pl, Material crossSectionMaterial = null)
+		{
+			return Slice (obj, pl, new TextureRegion (0.0f, 0.0f, 1.0f, 1.0f), crossSectionMaterial);
+		}
+
+		public static SlicedHull SliceObject (this GameObject obj, Vector3 position, Vector3 direction, Material crossSectionMaterial = null)
+		{
+			return Slice (obj, position, direction, new TextureRegion (0.0f, 0.0f, 1.0f, 1.0f), crossSectionMaterial);
+		}
+
+		public static SlicedHull Slice (this GameObject obj, Vector3 position, Vector3 direction, TextureRegion textureRegion, Material crossSectionMaterial = null)
+		{
+			Plane cuttingPlane = new Plane ();
+
+			Vector3 refUp = obj.transform.InverseTransformDirection (direction);
+			Vector3 refPt = obj.transform.InverseTransformPoint (position);
+
+			cuttingPlane.Compute (refPt, refUp);
+
+			return Slice (obj, cuttingPlane, textureRegion, crossSectionMaterial);
+		}
+
+		public static SlicedHull Slice (this GameObject obj, Plane pl, TextureRegion textureRegion, Material crossSectionMaterial = null)
+		{
+			return Slicer.Slice (obj, pl, textureRegion, crossSectionMaterial);
+		}
+
+		/**
+         * These functions (and overrides) will return the final indtaniated GameObjects types
+         */
+		public static GameObject[] SliceInstantiate (this GameObject obj, Plane pl)
+		{
+			return SliceInstantiate (obj, pl, new TextureRegion (0.0f, 0.0f, 1.0f, 1.0f));
+		}
+
+		public static GameObject[] SliceInstantiate (this GameObject obj, Vector3 position, Vector3 direction)
+		{
+			return SliceInstantiate (obj, position, direction, null);
+		}
+
+		public static GameObject[] SliceInstantiate (this GameObject obj, Vector3 position, Vector3 direction, Material crossSectionMat)
+		{
+			return SliceInstantiate (obj, position, direction, new TextureRegion (0.0f, 0.0f, 1.0f, 1.0f), crossSectionMat);
+		}
+
+		public static GameObject[] SliceInstantiate (this GameObject obj, Vector3 position, Vector3 direction, TextureRegion cuttingRegion, Material crossSectionMaterial = null)
+		{
+			EzySlice.Plane cuttingPlane = new EzySlice.Plane ();
+
+			Vector3 refUp = obj.transform.InverseTransformDirection (direction);
+			Vector3 refPt = obj.transform.InverseTransformPoint (position);
+
+			cuttingPlane.Compute (refPt, refUp);
+
+			return SliceInstantiate (obj, cuttingPlane, cuttingRegion, crossSectionMaterial);
+		}
+
+		public static GameObject[] SliceInstantiate (this GameObject obj, Plane pl, TextureRegion cuttingRegion, Material crossSectionMaterial = null)
+		{
+			SlicedHull slice = Slicer.Slice (obj, pl, cuttingRegion, crossSectionMaterial);
+
+			if (slice == null) {
+				return null;
+			}
+
+			GameObject upperHull = slice.CreateUpperHull (obj, crossSectionMaterial);
+			GameObject lowerHull = slice.CreateLowerHull (obj, crossSectionMaterial);
+
+			if (upperHull != null && lowerHull != null) {
+				return new GameObject[] { upperHull, lowerHull };
+			}
+
+			// otherwise return only the upper hull
+			if (upperHull != null) {
+				return new GameObject[] { upperHull };
+			}
+
+			// otherwise return only the lower hull
+			if (lowerHull != null) {
+				return new GameObject[] { lowerHull };
+			}
+
+			// nothing to return, so return nothing!
+			return null;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/EzySlice/SlicerExtensions.cs.meta

@@ -0,0 +1,19 @@
+fileFormatVersion: 2
+guid: 7b753d5a906054c028f5245efe262355
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/EzySlice/SlicerExtensions.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master.meta

@@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 760d5064ab7e68249933ee090297d549
+folderAsset: yes
+timeCreated: 1596431181
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 6860ec410d4e546ca9be7cbb25c7f24f
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/AbstractHackDecisionMaker.cs

@@ -0,0 +1,9 @@
+using UnityEngine;
+
+namespace NobleMuffins.LimbHacker
+{
+    public abstract class AbstractHackDecisionMaker : MonoBehaviour
+    {
+        public abstract bool ShouldHack(string joint);
+    }
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/AbstractHackDecisionMaker.cs.meta

@@ -0,0 +1,20 @@
+fileFormatVersion: 2
+guid: 9ebabc4cd40e94187b63d947f0fc3b42
+timeCreated: 1464179993
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/AbstractHackDecisionMaker.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/AbstractSliceHandler.cs

@@ -0,0 +1,18 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace NobleMuffins.LimbHacker
+{
+	public abstract class AbstractSliceHandler : MonoBehaviour
+	{
+		public virtual void handleSlice (GameObject[] results)
+		{
+			//Do nothing
+		}
+
+		public virtual bool cloneAlternate (Dictionary<string, bool> hierarchyPresence)
+		{
+			return true;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/AbstractSliceHandler.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 66a32b063468a4a3e98026538aa9e370
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/AbstractSliceHandler.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/Attachable Slicer.prefab.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ffb733fbd886c4e76a6ea9222cfec159
+NativeFormatImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/Attachable
+    Slicer.prefab
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/Hackable.cs

@@ -0,0 +1,268 @@
+using UnityEngine;
+using System.Collections.Generic;
+using System;
+using NobleMuffins.LimbHacker.Guts;
+using UnityEngine.Events;
+
+namespace NobleMuffins.LimbHacker
+{
+    public class Hackable : MonoBehaviour, ISliceable
+    {
+        [Header ("Main Settings")]
+        [Space]
+
+        public InfillMode infillMode = InfillMode.Sloppy;
+
+        public bool ignoreUpdateLastObjectSpeed;
+
+        public bool ignoreDestroyOriginalObject;
+
+        public bool setCustomIDOnSliceSpieces;
+
+        public string randomString = "";
+
+        public bool destructionPending = false;
+
+        [Space]
+        [Header ("Parts To Slice Settings")]
+        [Space]
+
+        public Transform [] severables = new Transform [0];
+
+        [Space]
+        [Header ("Events Settings")]
+        [Space]
+
+        public UnityEvent eventsOnIgnoreDestroyOriginalObject;
+
+        [Space]
+        [Header ("Components")]
+        [Space]
+
+        public surfaceToSlice mainSurfaceToSlice;
+
+        public GameObject objectToSlice;
+
+        public UnityEngine.Object alternatePrefab = null;
+
+        public Material infillMaterial = null;
+
+
+        public Dictionary<string, float> maximumTiltBySeverableName = new Dictionary<string, float> ();
+
+        bool valuesInitialized;
+
+        bool updateLastObjectSpeed;
+        Vector3 lastSpeed = Vector3.zero;
+
+
+        public string getRandomString ()
+        {
+            return randomString;
+        }
+
+        public void setRandomString (string newValue)
+        {
+            if (randomString.Equals ("")) {
+                randomString = newValue;
+            }
+        }
+
+        public void initializeValues ()
+        {
+            if (objectToSlice == null) {
+                objectToSlice = gameObject;
+            }
+
+            foreach (Transform bodyPart in severables) {
+                if (bodyPart != null) {
+                    ChildOfHackable referencer = bodyPart.GetComponent<ChildOfHackable> ();
+
+                    if (referencer == null)
+                        referencer = bodyPart.gameObject.AddComponent<ChildOfHackable> ();
+
+                    referencer.parentHackable = this;
+                }
+            }
+
+            valuesInitialized = true;
+        }
+
+        void checkInitializeValues ()
+        {
+            if (!valuesInitialized) {
+                initializeValues ();
+            }
+        }
+
+        public event EventHandler<SliceEventArgs> Sliced;
+
+        public void Slice (Vector3 positionInWorldSpace, Vector3 normalInWorldSpace)
+        {
+            if (destructionPending) {
+                return;
+            }
+
+            var decisionMaker = objectToSlice.GetComponent<AbstractHackDecisionMaker> ();
+
+            string jointName = null;
+
+            float rootTipProgression = 0f;
+
+            if (LimbHackerAgent.DetermineSlice (this, positionInWorldSpace, ref jointName, ref rootTipProgression) && (decisionMaker == null || decisionMaker.ShouldHack (jointName))) {
+                LimbHackerAgent.instance.SeverByJoint (objectToSlice, jointName, rootTipProgression, normalInWorldSpace);
+            }
+        }
+
+        public void handleSlice (GameObject [] results, Vector4 planeInWorldSpace, Vector3 focalPointInWorldSpace)
+        {
+            bool originalRemainsAfterSlice = false;
+
+            for (int i = 0; i < results.Length; i++)
+                originalRemainsAfterSlice |= results [i] == objectToSlice;
+
+            destructionPending = !originalRemainsAfterSlice;
+
+            AbstractSliceHandler [] handlers = objectToSlice.GetComponents<AbstractSliceHandler> ();
+
+            foreach (AbstractSliceHandler handler in handlers) {
+                handler.handleSlice (results);
+            }
+
+            if (Sliced != null) {
+                Sliced (this, new SliceEventArgs (new Plane (planeInWorldSpace, planeInWorldSpace.w), focalPointInWorldSpace, results));
+
+                if (!ignoreUpdateLastObjectSpeed) {
+                    if (updateLastObjectSpeed && lastSpeed != Vector3.zero) {
+
+                        for (int i = 0; i < results.Length; i++) {
+                            if (results [i] != null) {
+
+                                Component [] currentRigidbody = results [i].GetComponentsInChildren (typeof (Rigidbody));
+                                foreach (Rigidbody child in currentRigidbody) {
+                                    if (child.gameObject.activeInHierarchy) {
+                                        child.linearVelocity = lastSpeed;
+                                    }
+                                }
+
+                                //								print (results [i].name);
+                            }
+
+                        }
+                    }
+
+                    updateLastObjectSpeed = false;
+
+                    lastSpeed = Vector3.zero;
+                }
+            }
+        }
+
+        public bool cloneAlternate (Dictionary<string, bool> hierarchyPresence)
+        {
+            if (alternatePrefab == null) {
+                return false;
+            } else {
+                AbstractSliceHandler [] handlers = objectToSlice.GetComponents<AbstractSliceHandler> ();
+
+                bool result = false;
+
+                if (handlers.Length == 0) {
+                    result = true;
+                } else {
+                    foreach (AbstractSliceHandler handler in handlers) {
+                        result |= handler.cloneAlternate (hierarchyPresence);
+                    }
+                }
+
+                return result;
+
+            }
+        }
+
+        private readonly Queue<PendingSlice> pendingSlices = new Queue<PendingSlice> ();
+
+        bool sliceWaitingToFinish;
+
+        Vector3 normalInWorldSpace;
+
+        private List<GameObject> suppressUntilContactCeases = new List<GameObject> ();
+
+        class PendingSlice
+        {
+            public PendingSlice (Vector3 _point, ISliceable _target)
+            {
+                point = _point;
+                target = _target;
+            }
+
+            public readonly Vector3 point;
+            public readonly ISliceable target;
+        }
+
+
+        void LateUpdate ()
+        {
+            if (sliceWaitingToFinish) {
+                while (pendingSlices.Count > 0) {
+                    PendingSlice pendingSlice = pendingSlices.Dequeue ();
+
+                    var component = pendingSlice.target as MonoBehaviour;
+
+                    if (component != null) {
+                        var targetGameObject = component.gameObject;
+
+                        if (suppressUntilContactCeases.Contains (targetGameObject) == false) {
+
+                            pendingSlice.target.Sliced += PendingSlice_target_Sliced;
+
+                            pendingSlice.target.Slice (pendingSlice.point, normalInWorldSpace);
+                        }
+                    }
+                }
+
+                sliceWaitingToFinish = false;
+
+                ContactCeased (objectToSlice);
+            }
+        }
+
+        void PendingSlice_target_Sliced (object sender, SliceEventArgs e)
+        {
+            if (e.Parts.Length > 1) {
+                suppressUntilContactCeases.AddRange (e.Parts);
+            }
+        }
+
+        private void ContactCeased (GameObject other)
+        {
+            if (suppressUntilContactCeases.Contains (other)) {
+                suppressUntilContactCeases.Remove (other);
+            }
+        }
+
+        public void activateSlice (GameObject objectToSlice, Vector3 point, Vector3 newNormalInWorldSpaceValue,
+                                   bool updateLastObjectSpeedValue, Vector3 lastSpeedValue)
+        {
+            checkInitializeValues ();
+
+            ISliceable sliceable = objectToSlice.GetComponent (typeof (ISliceable)) as ISliceable;
+
+            if (sliceable != null) {
+                pendingSlices.Enqueue (new PendingSlice (point, sliceable));
+
+                normalInWorldSpace = newNormalInWorldSpaceValue;
+
+                sliceWaitingToFinish = true;
+
+                updateLastObjectSpeed = updateLastObjectSpeedValue;
+                lastSpeed = lastSpeedValue;
+            }
+        }
+
+        public void setDestructionPending (bool state)
+        {
+            destructionPending = state;
+        }
+    }
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/Hackable.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 6dd56a8ae574e4fd492ffaed7fb8e357
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/Hackable.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/ToRagdollOrNot.cs

@@ -0,0 +1,63 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace NobleMuffins.LimbHacker
+{
+    [RequireComponent(typeof(Hackable))]
+    public class ToRagdollOrNot : AbstractSliceHandler
+    {
+        public enum Operator { And, Or };
+        public enum Presentness { Equals, Not };
+
+        public Operator groupRule = Operator.And;
+        public Presentness totalityRule = Presentness.Not;
+
+        public Transform[] bones;
+
+        public override bool cloneAlternate(Dictionary<string, bool> hierarchyPresence)
+        {
+            List<bool> relevantStates = new List<bool>(bones.Length);
+
+            foreach (Transform t in bones)
+            {
+                string key = t.name;
+
+                if (hierarchyPresence.ContainsKey(key))
+                {
+                    relevantStates.Add(hierarchyPresence[key]);
+                }
+            }
+
+            bool totality = false;
+
+            if (groupRule == Operator.And)
+            {
+                totality = true;
+                foreach (bool b in relevantStates)
+                {
+                    totality &= b;
+                }
+            }
+            else if (groupRule == Operator.Or)
+            {
+                totality = false;
+                foreach (bool b in relevantStates)
+                {
+                    totality |= b;
+                }
+            }
+
+            if (totalityRule == Presentness.Not)
+            {
+                totality = !totality;
+            }
+
+            return totality;
+        }
+
+        public override void handleSlice(GameObject[] results)
+        {
+            //Do nothing.
+        }
+    }
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/ToRagdollOrNot.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 4bd7131eac6c14639b7b531425a23c8c
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Components/ToRagdollOrNot.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Editor.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 3cc7b62d124024e329b5391333a04175
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/Game Kit Controller/Integrations/LimbHacker-master/Editor/ChildOfHackableEditor.cs

@@ -0,0 +1,15 @@
+using UnityEditor;
+
+namespace NobleMuffins.LimbHacker.Guts
+{
+    [CustomEditor(typeof(ChildOfHackable))]
+    public class ChildOfHackableEditor : Editor
+    {
+        public override void OnInspectorGUI()
+        {
+            EditorGUILayout.LabelField("This is a Limb Hacker internal component.");
+            EditorGUILayout.LabelField("Do not add this to an object yourself.");
+        }
+
+    }
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Editor/ChildOfHackableEditor.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: ab06f9d6d2404f0459cea8be116c3802
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Editor/ChildOfHackableEditor.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Editor/HackableEditor.cs

@@ -0,0 +1,150 @@
+//using UnityEngine;
+//using UnityEditor;
+//using System.Collections.Generic;
+//using System.Linq;
+//using System.Text;
+//
+//namespace NobleMuffins.LimbHacker
+//{
+//	[CustomEditor (typeof(Hackable))]
+//	public class HackableEditor : Editor
+//	{
+//		Hackable manager;
+//
+//		void OnEnable ()
+//		{
+//			manager = (Hackable)target;
+//		}
+//
+//		public override void OnInspectorGUI ()
+//		{
+//			DrawDefaultInspector ();
+//
+//			EditorGUILayout.Space ();
+//
+//			if (GUILayout.Button ("Search Body Parts")) {
+//				manager.searchBodyParts ();
+//			}
+//
+//			EditorGUILayout.Space ();
+//		}
+//
+//		public static IEnumerable<Transform> FindBonesInTree (GameObject go)
+//		{
+//			var skinnedMeshRenderers = go.GetComponentsInChildren<SkinnedMeshRenderer> (true);
+//
+//			var bones = new HashSet<Transform> ();
+//
+//			var rootCandidates = new HashSet<Transform> ();
+//
+//			foreach (var smr in skinnedMeshRenderers) {
+//				if (smr.rootBone != null) {
+//					rootCandidates.Add (smr.rootBone);
+//				} else {
+//					//Just pick a bone and crawl up the path until we can verify that we found the root.
+//
+//					var rootCandidate = smr.bones.First ();
+//
+//					while (IsThisTheRootBone (rootCandidate, smr.bones)) {
+//						rootCandidate = rootCandidate.parent;
+//					}
+//
+//					rootCandidates.Add (rootCandidate);
+//				}
+//
+//				foreach (var bone in smr.bones) {
+//					bones.Add (bone);
+//				}
+//			}
+//
+//			//LimbHacker requires a single tree; there must be precisely one root. Conceptually
+//			//a root has no parent. In Unity, the root may have a parent but that is fine provided
+//			//that the parent is not part of the bone set.
+//
+//			//First we need to determine, from the set of root candidates, what the root is.
+//			//The root is the root candidate for which every other root is a child.
+//
+//			Transform root = null;
+//
+//			if (rootCandidates.Count == 1) {
+//				root = rootCandidates.First ();
+//			} else if (rootCandidates.Count > 0) {
+//				foreach (var rootCandidate in rootCandidates) {
+//					bool valid = true;
+//
+//					foreach (var possibleChild in rootCandidates) {
+//						if (possibleChild == rootCandidate)
+//							continue;
+//
+//						valid &= IsThisChildOfThat (possibleChild, rootCandidate);
+//
+//						if (!valid)
+//							break;
+//					}
+//
+//					if (valid) {
+//						root = rootCandidate;
+//						break;
+//					}
+//				}
+//			}
+//
+//			if (root == null) {
+//				var boneDescriptor = new StringBuilder ();
+//				foreach (var bone in bones) {
+//					boneDescriptor.AppendFormat ("{0}: {1}\n", bone.name, bone.parent == null ? "nil" : bone.parent.name);
+//				}
+//				throw new ForestException (string.Format ("{0} does not have a single, valid tree. LimbHacker compatible objects must have a single bone tree. Tree dump:\n{1}", go.name, boneDescriptor.ToString ()));
+//			}
+//
+//			return bones;
+//		}
+//
+//		private static bool IsThisTheRootBone (Transform candidate, ICollection<Transform> boneSet)
+//		{
+//			//A candidate can't be anything but the root if its parent is null.
+//
+//			if (candidate.parent == null) {
+//				return true;
+//			}
+//
+//			//A candidate is NOT the root if its parent is a subset of the bone set.
+//
+//			if (boneSet.Contains (candidate.parent)) {
+//				return false;
+//			}
+//
+//			//A candidate is the root bone if every other bone is a child of it.
+//
+//			bool allOthersAreChildren = true;
+//
+//			foreach (var bone in boneSet) {
+//				if (candidate == bone.parent) {
+//					continue;
+//				}
+//				if (IsThisChildOfThat (bone, candidate) == false) {
+//					allOthersAreChildren = false;
+//					break;
+//				}
+//			}
+//
+//			return allOthersAreChildren;
+//		}
+//
+//
+//		public class ForestException : System.Exception
+//		{
+//			public ForestException (string message) : base (message)
+//			{
+//			}
+//		}
+//
+//		private static bool IsThisChildOfThat (Transform subject, Transform parent)
+//		{
+//			do {
+//				subject = subject.parent;
+//			} while (subject != null && subject != parent);
+//			return subject == parent;
+//		}
+//	}
+//}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Editor/HackableEditor.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 6f50a56adfbe345c48268cae6aef308c
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Editor/HackableEditor.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 9555ac55ebcb06940a230e54baf6ca8a
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/AttachableSlicerController.cs

@@ -0,0 +1,21 @@
+using UnityEngine;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	[RequireComponent(typeof(SwordVelocityFilter))]
+	public class AttachableSlicerController : MonoBehaviour
+	{
+		private SwordVelocityFilter swordVelocityFilter;
+		public GameObject slicer;
+
+		void Start()
+		{
+			swordVelocityFilter = GetComponent<SwordVelocityFilter>();
+		}
+
+		void Update()
+		{
+			slicer.SetActive(swordVelocityFilter.IsFastEnoughToCut);
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/AttachableSlicerController.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: cb6aef6e851f6984d837632b1f736993
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/AttachableSlicerController.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Button.cs

@@ -0,0 +1,79 @@
+using UnityEngine;
+using System.Collections;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	[RequireComponent(typeof(Collider))]
+	public class Button : MonoBehaviour
+	{
+		const float changeTime = 0.033f;
+
+		public new Camera camera;
+
+		public GameObject target;
+		public string message;
+
+		public AudioClip clickSound;
+
+		public bool visible;
+
+		private new Transform transform;
+		private new Collider collider;
+		private Vector3 scaleAtStart;
+
+		private float size = 1f, sizeDelta = 0f;
+		private bool pressedAsButton = false;
+
+		void Start()
+		{
+			transform = GetComponent<Transform>();
+			collider = GetComponent<Collider>();
+
+			scaleAtStart = transform.localScale;
+
+			if (camera == null) camera = Camera.main;
+		}
+
+		private bool firstRun = true;
+
+		void Update()
+		{
+			Ray ray = camera.ScreenPointToRay(Input.mousePosition);
+
+			RaycastHit hitInfo;
+
+			bool hover = collider.Raycast(ray, out hitInfo, 2f);
+
+			pressedAsButton |= hover && Input.GetMouseButtonDown(0);
+
+			bool released = Input.GetMouseButtonUp(0);
+
+			bool releasedAsButton = pressedAsButton && hover && released;
+
+			if (released)
+			{
+				pressedAsButton = false;
+			}
+
+			if (releasedAsButton)
+			{
+				target.SendMessage(message);
+
+				if (clickSound != null)
+				{
+					AudioSource.PlayClipAtPoint(clickSound, Vector3.zero);
+				}
+			}
+
+			bool enlarge = hover || pressedAsButton;
+
+			float idealSize = (enlarge ? 1.1f : 1f) * (visible ? 1f : 0f);
+
+			size = firstRun ? idealSize : Mathf.SmoothDamp(size, idealSize, ref sizeDelta, changeTime);
+
+			firstRun = false;
+
+			transform.localScale = size * scaleAtStart;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Button.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: a54bd2a3c315546de98c80b0f49fdaa9
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Button.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/CameraPositionController.cs

@@ -0,0 +1,32 @@
+using UnityEngine;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	public class CameraPositionController : MonoBehaviour
+	{
+		public Transform backAwayPosition, upClosePosition;
+		public TimeForSlicingFilter timeForSlicingFilter;
+		public float transitionTime = 1f;
+
+		private new Transform transform;
+		private Vector3 position, positionDelta;
+
+		// Use this for initialization
+		void Start()
+		{
+			transform = GetComponent<Transform>();
+
+			position = transform.position;
+		}
+
+		// Update is called once per frame
+		void Update()
+		{
+			Vector3 idealPosition = timeForSlicingFilter.IsTimeForSlicing ? upClosePosition.position : backAwayPosition.position;
+
+			position = Vector3.SmoothDamp(position, idealPosition, ref positionDelta, transitionTime);
+
+			transform.position = position;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/CameraPositionController.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: f14870d2c7572544ebb0eac825b68362
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/CameraPositionController.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/CameraSteer.cs

@@ -0,0 +1,49 @@
+using UnityEngine;
+using System.Collections;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	public class CameraSteer : MonoBehaviour
+	{
+
+		private Vector3 naturalForward, naturalUp, naturalRight;
+
+		private Vector3 forward, forwardDelta;
+
+		private new Transform transform;
+
+		public float panSpeed = 0.33f;
+
+		void Awake()
+		{
+			transform = GetComponent<Transform>();
+
+			naturalForward = transform.forward;
+			naturalRight = transform.right;
+			naturalUp = transform.up;
+
+			forward = naturalForward;
+			forwardDelta = Vector3.zero;
+		}
+
+		// Update is called once per frame
+		void Update()
+		{
+			Vector2 center = new Vector2(Screen.width / 2f, Screen.height / 2f);
+			Vector2 current = (Vector2)Input.mousePosition;
+
+			Vector2 delta = current - center;
+
+			delta.x /= Screen.width;
+			delta.y /= Screen.height;
+
+			delta *= 0.33f;
+
+			Vector3 idealForward = (naturalForward + naturalRight * delta.x + naturalUp * delta.y).normalized;
+
+			forward = Vector3.SmoothDamp(forward, idealForward, ref forwardDelta, panSpeed);
+
+			transform.forward = forward;
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/CameraSteer.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 729e15f2b0d6e294ab13e49a19c997de
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/CameraSteer.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 40595bf38a7fd4c45882d92e2d2bbb42
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Animation Controller.controller

@@ -0,0 +1,159 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Animation Controller
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 110700000}
+    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!1101 &110100000
+AnimatorStateTransition:
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 110204645}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 1.5
+  m_TransitionOffset: 0
+  m_ExitTime: 0
+  m_HasExitTime: 1
+  m_HasFixedDuration: 0
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1101 &110117645
+AnimatorStateTransition:
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: 
+  m_Conditions: []
+  m_DstStateMachine: {fileID: 0}
+  m_DstState: {fileID: 110204645}
+  m_Solo: 0
+  m_Mute: 0
+  m_IsExit: 0
+  serializedVersion: 3
+  m_TransitionDuration: 0.19736843
+  m_TransitionOffset: 0
+  m_ExitTime: 0.80263156
+  m_HasExitTime: 1
+  m_HasFixedDuration: 0
+  m_InterruptionSource: 0
+  m_OrderedInterruption: 1
+  m_CanTransitionToSelf: 1
+--- !u!1102 &110200000
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Rise
+  m_Speed: 0.4
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 36, y: -120, z: 0}
+  m_IKOnFeet: 1
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_Motion: {fileID: 7400000, guid: 7a571e18b998b154190a06f1dd7da67b, type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+--- !u!1102 &110204645
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Standing
+  m_Speed: 0.05
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 156, y: -192, z: 0}
+  m_IKOnFeet: 1
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_Motion: {fileID: 7400004, guid: 7a571e18b998b154190a06f1dd7da67b, type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+--- !u!1102 &110217570
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Crouched
+  m_Speed: 0.5
+  m_CycleOffset: 0
+  m_Transitions:
+  - {fileID: 110100000}
+  m_StateMachineBehaviours: []
+  m_Position: {x: 168, y: -48, z: 0}
+  m_IKOnFeet: 1
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_Motion: {fileID: 7400002, guid: 7a571e18b998b154190a06f1dd7da67b, type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+--- !u!1107 &110700000
+AnimatorStateMachine:
+  serializedVersion: 5
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 110204645}
+    m_Position: {x: 156, y: -192, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: 110217570}
+    m_Position: {x: 168, y: -48, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 48, y: 12, 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: 110217570}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Animation Controller.controller.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: c35d48e5604c74f24892398081bf3c3b
+NativeFormatImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Animation
+    Controller.controller
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkerperson ragdoll.prefab.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: 253e6f9721d604d97b674c7ddf4e8993
+NativeFormatImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkerperson
+    ragdoll.prefab
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkerperson.prefab.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: bfc185066ed8e42b1bfc4dfe93ef6e66
+NativeFormatImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkerperson.prefab
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkers.mat

@@ -0,0 +1,106 @@
+%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: Checkers
+  m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _EMISSION
+  - _GLOSSINESS_FROM_BASE_ALPHA
+  - _SPECULAR_COLOR
+  m_InvalidKeywords: []
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: f720465dd6601462aa8b304392a139c5, 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}
+    - _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}
+    - _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:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _GlossinessSource: 0
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Shininess: 0
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 1
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &2401247225920078037
+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: 10

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkers.mat.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 3e712d1b46d3b4b61b90928342616387
+NativeFormatImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkers.mat
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkers.png.meta

@@ -0,0 +1,53 @@
+fileFormatVersion: 2
+guid: f720465dd6601462aa8b304392a139c5
+TextureImporter:
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: .25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 1024
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: .5, y: .5}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 0
+  textureType: -1
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+  spritePackingTag: 
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Checkers.png
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Materials.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: fda6ef7b5100940f7b31b583bb45227c
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Materials/Checkerperson.mat

@@ -0,0 +1,106 @@
+%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: Checkerperson
+  m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _EMISSION
+  - _GLOSSINESS_FROM_BASE_ALPHA
+  - _SPECULAR_COLOR
+  m_InvalidKeywords: []
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: 2fba0f6812d304ed0a1a6bcc447e4af8, 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}
+    - _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}
+    - _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:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _GlossinessSource: 0
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Shininess: 0
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 1
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1
+--- !u!114 &4084420163468262454
+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: 10

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Materials/Checkerperson.mat.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: deecda6b38e164a76beae141117472f9
+NativeFormatImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/Materials/Checkerperson.mat
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/lightCheckers.png.meta

@@ -0,0 +1,53 @@
+fileFormatVersion: 2
+guid: 2fba0f6812d304ed0a1a6bcc447e4af8
+TextureImporter:
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: .25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 1024
+  textureSettings:
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: .5, y: .5}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 0
+  textureType: -1
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+  spritePackingTag: 
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/lightCheckers.png
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/mesh.fbx.meta

@@ -0,0 +1,298 @@
+fileFormatVersion: 2
+guid: e3edf8014b1aa4a658386663240d0446
+ModelImporter:
+  serializedVersion: 22200
+  internalIDToNameTable:
+  - first:
+      1: 100000
+    second: //RootNode
+  - first:
+      1: 100002
+    second: toe_R
+  - first:
+      1: 100004
+    second: foot_R
+  - first:
+      1: 100006
+    second: shin_R
+  - first:
+      1: 100008
+    second: thigh_R
+  - first:
+      1: 100010
+    second: toe_L
+  - first:
+      1: 100012
+    second: foot_L
+  - first:
+      1: 100014
+    second: shin_L
+  - first:
+      1: 100016
+    second: thigh_L
+  - first:
+      1: 100018
+    second: head
+  - first:
+      1: 100020
+    second: neck_000
+  - first:
+      1: 100022
+    second: neck
+  - first:
+      1: 100024
+    second: hand_R
+  - first:
+      1: 100026
+    second: forearm_R
+  - first:
+      1: 100028
+    second: upper_arm_R
+  - first:
+      1: 100030
+    second: shoulder_R
+  - first:
+      1: 100032
+    second: hand_L
+  - first:
+      1: 100034
+    second: forearm_L
+  - first:
+      1: 100036
+    second: upper_arm_L
+  - first:
+      1: 100038
+    second: shoulder_L
+  - first:
+      1: 100040
+    second: ribs
+  - first:
+      1: 100042
+    second: spine
+  - first:
+      1: 100044
+    second: hips
+  - first:
+      1: 100046
+    second: Armature
+  - first:
+      1: 100048
+    second: Dude
+  - first:
+      1: 100050
+    second: wrist_L
+  - first:
+      1: 100052
+    second: wrist_R
+  - first:
+      4: 400000
+    second: //RootNode
+  - first:
+      4: 400002
+    second: toe_R
+  - first:
+      4: 400004
+    second: foot_R
+  - first:
+      4: 400006
+    second: shin_R
+  - first:
+      4: 400008
+    second: thigh_R
+  - first:
+      4: 400010
+    second: toe_L
+  - first:
+      4: 400012
+    second: foot_L
+  - first:
+      4: 400014
+    second: shin_L
+  - first:
+      4: 400016
+    second: thigh_L
+  - first:
+      4: 400018
+    second: head
+  - first:
+      4: 400020
+    second: neck_000
+  - first:
+      4: 400022
+    second: neck
+  - first:
+      4: 400024
+    second: hand_R
+  - first:
+      4: 400026
+    second: forearm_R
+  - first:
+      4: 400028
+    second: upper_arm_R
+  - first:
+      4: 400030
+    second: shoulder_R
+  - first:
+      4: 400032
+    second: hand_L
+  - first:
+      4: 400034
+    second: forearm_L
+  - first:
+      4: 400036
+    second: upper_arm_L
+  - first:
+      4: 400038
+    second: shoulder_L
+  - first:
+      4: 400040
+    second: ribs
+  - first:
+      4: 400042
+    second: spine
+  - first:
+      4: 400044
+    second: hips
+  - first:
+      4: 400046
+    second: Armature
+  - first:
+      4: 400048
+    second: Dude
+  - first:
+      4: 400050
+    second: wrist_L
+  - first:
+      4: 400052
+    second: wrist_R
+  - first:
+      43: 4300000
+    second: Mesh
+  - first:
+      43: 4300002
+    second: Dude
+  - first:
+      74: 7400000
+    second: Default Take
+  - first:
+      95: 9500000
+    second: //RootNode
+  - first:
+      111: 11100000
+    second: //RootNode
+  - first:
+      137: 13700000
+    second: hips
+  - first:
+      137: 13700002
+    second: Dude
+  externalObjects: {}
+  materials:
+    materialImportMode: 0
+    materialName: 0
+    materialSearch: 1
+    materialLocation: 0
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    removeConstantScaleCurves: 0
+    motionNodeName: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    importConstraints: 0
+    animationCompression: 3
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 3
+    addColliders: 0
+    useSRGBMaterialColor: 1
+    sortHierarchyByName: 1
+    importPhysicalCameras: 1
+    importVisibility: 0
+    importBlendShapes: 0
+    importCameras: 0
+    importLights: 0
+    nodeNameCollisionStrategy: 0
+    fileIdsGeneration: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    keepQuads: 0
+    weldVertices: 1
+    bakeAxisConversion: 0
+    preserveHierarchy: 0
+    skinWeightsMode: 0
+    maxBonesPerVertex: 4
+    minBoneWeight: 0.001
+    optimizeBones: 1
+    meshOptimizationFlags: -1
+    indexFormat: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVMarginMethod: 0
+    secondaryUVMinLightmapResolution: 40
+    secondaryUVMinObjectScale: 1
+    secondaryUVPackMargin: 4
+    useFileScale: 0
+    strictVertexDataChecks: 0
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 4
+    normalCalculationMode: 0
+    legacyComputeAllNormalsFromSmoothingGroupsWhenMeshHasBlendShapes: 1
+    blendShapeNormalImportMode: 1
+    normalSmoothingSource: 0
+  referencedClips: []
+  importAnimation: 0
+  humanDescription:
+    serializedVersion: 3
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    globalScale: 1
+    rootMotionBoneName: Armature
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 0
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  autoGenerateAvatarMappingIfUnspecified: 1
+  animationType: 2
+  humanoidOversampling: 1
+  avatarSetup: 1
+  addHumanoidExtraRootOnlyWhenUsingAvatar: 0
+  importBlendShapeDeformPercent: 0
+  remapMaterialsIfMaterialImportModeIsNone: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/mesh.fbx
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/mesh@Rise.fbx.meta

@@ -0,0 +1,196 @@
+fileFormatVersion: 2
+guid: 7a571e18b998b154190a06f1dd7da67b
+ModelImporter:
+  serializedVersion: 15
+  fileIDToRecycleName:
+    100000: Armature
+    100002: foot_L
+    100004: foot_R
+    100006: forearm_L
+    100008: forearm_R
+    100010: hand_L
+    100012: hand_R
+    100014: head
+    100016: hips
+    100018: //RootNode
+    100020: neck
+    100022: neck_000
+    100024: ribs
+    100026: shin_L
+    100028: shin_R
+    100030: shoulder_L
+    100032: shoulder_R
+    100034: spine
+    100036: thigh_L
+    100038: thigh_R
+    100040: toe_L
+    100042: toe_R
+    100044: upper_arm_L
+    100046: upper_arm_R
+    400000: Armature
+    400002: foot_L
+    400004: foot_R
+    400006: forearm_L
+    400008: forearm_R
+    400010: hand_L
+    400012: hand_R
+    400014: head
+    400016: hips
+    400018: //RootNode
+    400020: neck
+    400022: neck_000
+    400024: ribs
+    400026: shin_L
+    400028: shin_R
+    400030: shoulder_L
+    400032: shoulder_R
+    400034: spine
+    400036: thigh_L
+    400038: thigh_R
+    400040: toe_L
+    400042: toe_R
+    400044: upper_arm_L
+    400046: upper_arm_R
+    7400000: Rise
+    7400002: Crouched
+    7400004: Standing
+    9500000: //RootNode
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    optimizeGameObjects: 0
+    animationCompression: 1
+    animationRotationError: .5
+    animationPositionError: .5
+    animationScaleError: .5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    clipAnimations:
+    - serializedVersion: 16
+      name: Rise
+      takeName: mixamo.com
+      firstFrame: 10
+      lastFrame: 76
+      wrapMode: 0
+      orientationOffsetY: 0
+      level: 0
+      cycleOffset: 0
+      loop: 0
+      loopTime: 0
+      loopBlend: 0
+      loopBlendOrientation: 0
+      loopBlendPositionY: 0
+      loopBlendPositionXZ: 0
+      keepOriginalOrientation: 1
+      keepOriginalPositionY: 0
+      keepOriginalPositionXZ: 0
+      heightFromFeet: 1
+      mirror: 0
+      bodyMask: 01000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000
+      curves: []
+      events: []
+      transformMask: []
+      maskType: 0
+      maskSource: {instanceID: 0}
+    - serializedVersion: 16
+      name: Crouched
+      takeName: mixamo.com
+      firstFrame: 0
+      lastFrame: 10
+      wrapMode: 0
+      orientationOffsetY: 0
+      level: 0
+      cycleOffset: 0
+      loop: 0
+      loopTime: 0
+      loopBlend: 0
+      loopBlendOrientation: 0
+      loopBlendPositionY: 0
+      loopBlendPositionXZ: 0
+      keepOriginalOrientation: 0
+      keepOriginalPositionY: 1
+      keepOriginalPositionXZ: 0
+      heightFromFeet: 0
+      mirror: 0
+      bodyMask: 01000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000
+      curves: []
+      events: []
+      transformMask: []
+      maskType: 0
+      maskSource: {instanceID: 0}
+    - serializedVersion: 16
+      name: Standing
+      takeName: mixamo.com
+      firstFrame: 65
+      lastFrame: 76
+      wrapMode: 0
+      orientationOffsetY: 0
+      level: 0
+      cycleOffset: 0
+      loop: 0
+      loopTime: 1
+      loopBlend: 1
+      loopBlendOrientation: 1
+      loopBlendPositionY: 0
+      loopBlendPositionXZ: 0
+      keepOriginalOrientation: 0
+      keepOriginalPositionY: 1
+      keepOriginalPositionXZ: 0
+      heightFromFeet: 0
+      mirror: 0
+      bodyMask: 01000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000
+      curves: []
+      events: []
+      transformMask: []
+      maskType: 0
+      maskSource: {instanceID: 0}
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: .00999999978
+    meshCompression: 0
+    addColliders: 0
+    importBlendShapes: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+  tangentSpace:
+    normalSmoothAngle: 60
+    splitTangentsAcrossUV: 1
+    normalImportMode: 0
+    tangentImportMode: 1
+  importAnimation: 1
+  copyAvatar: 1
+  humanDescription:
+    human: []
+    skeleton: []
+    armTwist: .5
+    foreArmTwist: .5
+    upperLegTwist: .5
+    legTwist: .5
+    armStretch: .0500000007
+    legStretch: .0500000007
+    feetSpacing: 0
+    rootMotionBoneName: Armature
+  lastHumanDescriptionAvatarSource: {fileID: 9000000, guid: b9355d8f5f5d8c6409897381301de0ea,
+    type: 3}
+  animationType: 2
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/mesh@Rise.fbx
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/mesh@hit_reaction_1.fbx.meta

@@ -0,0 +1,119 @@
+fileFormatVersion: 2
+guid: 38d92e05d165d4bdebebb06c2b6cd053
+ModelImporter:
+  serializedVersion: 15
+  fileIDToRecycleName:
+    100000: //RootNode
+    100002: toe_R
+    100004: foot_R
+    100006: shin_R
+    100008: thigh_R
+    100010: toe_L
+    100012: foot_L
+    100014: shin_L
+    100016: thigh_L
+    100018: head
+    100020: neck_000
+    100022: neck
+    100024: hand_R
+    100026: wrist_R
+    100028: forearm_R
+    100030: upper_arm_R
+    100032: shoulder_R
+    100034: hand_L
+    100036: wrist_L
+    100038: forearm_L
+    100040: upper_arm_L
+    100042: shoulder_L
+    100044: ribs
+    100046: spine
+    100048: hips
+    100050: Armature
+    400000: //RootNode
+    400002: toe_R
+    400004: foot_R
+    400006: shin_R
+    400008: thigh_R
+    400010: toe_L
+    400012: foot_L
+    400014: shin_L
+    400016: thigh_L
+    400018: head
+    400020: neck_000
+    400022: neck
+    400024: hand_R
+    400026: wrist_R
+    400028: forearm_R
+    400030: upper_arm_R
+    400032: shoulder_R
+    400034: hand_L
+    400036: wrist_L
+    400038: forearm_L
+    400040: upper_arm_L
+    400042: shoulder_L
+    400044: ribs
+    400046: spine
+    400048: hips
+    400050: Armature
+    7400000: mixamo.com
+    11100000: //RootNode
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    optimizeGameObjects: 0
+    animationCompression: 1
+    animationRotationError: .5
+    animationPositionError: .5
+    animationScaleError: .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
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+  tangentSpace:
+    normalSmoothAngle: 60
+    splitTangentsAcrossUV: 1
+    normalImportMode: 0
+    tangentImportMode: 1
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    human: []
+    skeleton: []
+    armTwist: .5
+    foreArmTwist: .5
+    upperLegTwist: .5
+    legTwist: .5
+    armStretch: .0500000007
+    legStretch: .0500000007
+    feetSpacing: 0
+    rootMotionBoneName: 
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 1
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Checkerperson/mesh@hit_reaction_1.fbx
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/MarkOfCain.cs

@@ -0,0 +1,25 @@
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	public class MarkOfCain : MonoBehaviour
+	{
+		private readonly static List<GameObject> markedObjects = new List<GameObject>();
+
+		void Start()
+		{
+			markedObjects.Add(gameObject);
+		}
+
+		public static void DestroyAllMarkedObjects()
+		{
+			foreach (var go in markedObjects)
+			{
+				if (go != null) Destroy(go);
+			}
+
+			markedObjects.Clear();
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/MarkOfCain.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: a831c20dd08af2f47adc8aede0ed3ef7
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/MarkOfCain.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/RestartButton.cs

@@ -0,0 +1,28 @@
+using UnityEngine;
+using System.Collections;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	[RequireComponent(typeof(Button))]
+	public class RestartButton : MonoBehaviour
+	{
+		public Spawner spawner;
+
+		private Button button;
+
+		void Start()
+		{
+			button = gameObject.GetComponent<Button>();
+		}
+
+		void Update()
+		{
+			button.visible = spawner.CanInstantiate;
+		}
+
+		void OnClick()
+		{
+			spawner.Instantiate();
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/RestartButton.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 3df59312996834b4b823ade7ab630bfd
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/RestartButton.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Spawner.cs

@@ -0,0 +1,45 @@
+using UnityEngine;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	public class Spawner : MonoBehaviour
+	{
+
+		public GameObject puppet;
+
+		public Object prefab;
+
+		public System.Action<GameObject> instantiationListeners;
+
+		public GUISkin skin;
+
+		// Use this for initialization
+		void Start()
+		{
+			Instantiate();
+		}
+
+		public void Instantiate()
+		{
+			if (CanInstantiate)
+			{
+				MarkOfCain.DestroyAllMarkedObjects();
+
+				if (puppet == null)
+				{
+					puppet = GameObject.Instantiate(prefab, transform.position, transform.rotation) as GameObject;
+				}
+
+				instantiationListeners(puppet);
+			}
+		}
+
+		public bool CanInstantiate
+		{
+			get
+			{
+				return puppet == null;
+			}
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Spawner.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: 94e16bde5a8c4c04e8c3aadf1455d858
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Spawner.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword Demo.unity.meta

@@ -0,0 +1,13 @@
+fileFormatVersion: 2
+guid: ecb038663812037469362e4c20786b37
+DefaultImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword
+    Demo.unity
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword.meta

@@ -0,0 +1,5 @@
+fileFormatVersion: 2
+guid: 311925ff44bdb11429398b5885460737
+folderAsset: yes
+DefaultImporter:
+  userData: 

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/metalDiffuse.png.meta

@@ -0,0 +1,44 @@
+fileFormatVersion: 2
+guid: fc74e81d1012e8b49828233a25bb42d5
+TextureImporter:
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: .25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 0
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 1024
+  textureSettings:
+    filterMode: 0
+    aniso: 0
+    mipBias: -1
+    wrapMode: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  alphaIsTransparency: 0
+  textureType: -1
+  buildTargetSettings: []
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/metalDiffuse.png
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/metalReflection.png.meta

@@ -0,0 +1,56 @@
+fileFormatVersion: 2
+guid: 9f661c9c6520d5b4a9c9dc34a59f0b34
+TextureImporter:
+  fileIDToRecycleName:
+    8900000: generatedCubemap
+  serializedVersion: 2
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    linearTexture: 0
+    correctGamma: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: .25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 5
+  seamlessCubemap: 0
+  textureFormat: -1
+  maxTextureSize: 1024
+  textureSettings:
+    filterMode: -1
+    aniso: 2
+    mipBias: -1
+    wrapMode: 1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: .5, y: .5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaIsTransparency: 0
+  textureType: 3
+  buildTargetSettings: []
+  spriteSheet:
+    sprites: []
+  spritePackingTag: 
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/metalReflection.png
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/swordMesh.fbx.meta

@@ -0,0 +1,72 @@
+fileFormatVersion: 2
+guid: 6cd367af2a3596145937b3e3071be4c9
+ModelImporter:
+  serializedVersion: 15
+  fileIDToRecycleName:
+    100000: //RootNode
+    400000: //RootNode
+    2300000: //RootNode
+    3300000: //RootNode
+    4300000: Sword
+    7400000: Default Take
+    9500000: //RootNode
+  materials:
+    importMaterials: 0
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    animationCompression: 1
+    animationRotationError: .5
+    animationPositionError: .5
+    animationScaleError: .5
+    animationWrapMode: 0
+    clipAnimations: []
+    isReadable: 0
+  meshes:
+    lODScreenPercentages: []
+    globalScale: .0599999987
+    meshCompression: 3
+    addColliders: 0
+    importBlendShapes: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+  tangentSpace:
+    normalSmoothAngle: 60
+    splitTangentsAcrossUV: 1
+    normalImportMode: 1
+    tangentImportMode: 1
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    human: []
+    skeleton: []
+    handles: []
+    armTwist: .5
+    foreArmTwist: .5
+    upperLegTwist: .5
+    legTwist: .5
+    armStretch: .0500000007
+    legStretch: .0500000007
+    feetSpacing: 0
+    rootMotionBoneName: 
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  additionalBone: 1
+  animationType: 0
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/swordMesh.fbx
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/swordMetal.mat

@@ -0,0 +1,111 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &-4018318121080751760
+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: 10
+--- !u!21 &2100000
+Material:
+  serializedVersion: 8
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: swordMetal
+  m_Shader: {fileID: 4800000, guid: 8d2bb70cbf9db8d4da26e15b26e74248, type: 3}
+  m_Parent: {fileID: 0}
+  m_ModifiedSerializedProperties: 0
+  m_ValidKeywords:
+  - _EMISSION
+  - _GLOSSINESS_FROM_BASE_ALPHA
+  - _SPECULAR_COLOR
+  m_InvalidKeywords: []
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap:
+    RenderType: Opaque
+  disabledShaderPasses:
+  - MOTIONVECTORS
+  m_LockedProperties: 
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BaseMap:
+        m_Texture: {fileID: 2800000, guid: fc74e81d1012e8b49828233a25bb42d5, 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}
+    - _Cube:
+        m_Texture: {fileID: 8900000, guid: 9f661c9c6520d5b4a9c9dc34a59f0b34, type: 3}
+        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}
+    - _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:
+    - _AddPrecomputedVelocity: 0
+    - _AlphaClip: 0
+    - _AlphaToMask: 0
+    - _Blend: 0
+    - _BlendModePreserveSpecular: 1
+    - _BumpScale: 1
+    - _Cull: 2
+    - _Cutoff: 0.5
+    - _DstBlend: 0
+    - _DstBlendAlpha: 0
+    - _GlossinessSource: 0
+    - _QueueOffset: 0
+    - _ReceiveShadows: 1
+    - _Shininess: 0
+    - _Smoothness: 0.5
+    - _SmoothnessSource: 1
+    - _SpecSource: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _SrcBlendAlpha: 1
+    - _Surface: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0, g: 0, b: 0, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _ReflectColor: {r: 0.8235294, g: 0.905071, b: 1, a: 0.5019608}
+    - _SpecColor: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}
+  m_BuildTextureStacks: []
+  m_AllowLocking: 1

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/swordMetal.mat.meta

@@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 71e8e5bf0611d9b478047369cc73480f
+NativeFormatImporter:
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/Sword/swordMetal.mat
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/SwordTransformController.cs

@@ -0,0 +1,74 @@
+using UnityEngine;
+using System.Collections;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	public class SwordTransformController : MonoBehaviour
+	{
+
+		// Rotation order is YXZ
+
+		private new Transform transform;
+		private Transform cameraTransform;
+
+		public new Camera camera;
+
+		private Vector3 idealForward = Vector3.forward;
+		private Vector3 forward = Vector3.forward;
+		private Vector3 forwardVelocity = Vector3.zero;
+
+		private Vector3 idealUp = Vector3.up;
+		private Vector3 up = Vector3.up;
+		private Vector3 upVelocity = Vector3.zero;
+
+		public float trackingTime = 0.1f;
+
+		public float deadzone = 5f;
+
+		public float reach = 3f;
+
+		private Vector3 previousMousePosition = Vector3.zero;
+
+		// Use this for initialization
+		void Start()
+		{
+			transform = GetComponent<Transform>();
+
+			if (camera == null)
+			{
+				Debug.LogError("TSD3SwordTransformController requires a camera to orient the sword.");
+				enabled = false;
+			}
+			else
+			{
+				cameraTransform = camera.transform;
+			}
+		}
+
+		// Update is called once per frame
+		void Update()
+		{
+			Vector3 mousePosition = Input.mousePosition;
+
+			Vector3 mouseDelta = previousMousePosition - mousePosition;
+
+			if (mouseDelta.magnitude > deadzone)
+			{
+				Vector3 cursorInThreeSpace = mousePosition;
+				cursorInThreeSpace.z = reach;
+
+				idealForward = (camera.ScreenToWorldPoint(cursorInThreeSpace) - transform.position).normalized;
+
+				Matrix4x4 cameraLocalToWorld = cameraTransform.localToWorldMatrix;
+
+				idealUp = cameraLocalToWorld.MultiplyVector(previousMousePosition - mousePosition).normalized;
+
+				previousMousePosition = mousePosition;
+			}
+
+			forward = Vector3.SmoothDamp(forward, idealForward, ref forwardVelocity, trackingTime);
+			up = Vector3.SmoothDamp(up, idealUp, ref upVelocity, trackingTime);
+			transform.rotation = Quaternion.LookRotation(forward, up);
+		}
+	}
+}

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/SwordTransformController.cs.meta

@@ -0,0 +1,16 @@
+fileFormatVersion: 2
+guid: cf65669bb61917e4bb9db084960985b2
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+AssetOrigin:
+  serializedVersion: 1
+  productId: 40995
+  packageName: Game Kit Controller - Shooter Melee Adventure FPS TPS Creator 3D +
+    2.5D
+  packageVersion: 3.77h
+  assetPath: Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/SwordTransformController.cs
+  uploadId: 889948

Assets/Game Kit Controller/Integrations/LimbHacker-master/Example/SwordVelocityFilter.cs

@@ -0,0 +1,49 @@
+using UnityEngine;
+
+namespace NobleMuffins.LimbHacker.Examples
+{
+	public class SwordVelocityFilter : MonoBehaviour
+	{
+		public float tipSpeedForCutting = 1f;
+		public float lengthInWorldUnits = 5f;
+
+		private new Transform transform;
+
+		void Start()
+		{
+			transform = GetComponent<Transform>();
+
+			priorTipPositionInWorldSpace = deriveTipPosition();
+		}
+
+		private Vector3 priorTipPositionInWorldSpace;
+
+		private bool _IsFastEnoughToCut = false;
+		public bool IsFastEnoughToCut
+		{
+			get
+			{
+				return _IsFastEnoughToCut;
+			}
+		}
+
+		private Vector3 deriveTipPosition()
+		{
+			return transform.localToWorldMatrix.MultiplyPoint3x4(Vector3.forward * lengthInWorldUnits);
+		}
+
+		// Update is called once per frame
+		void Update()
+		{
+			Vector3 tipPositionInWorldSpace = deriveTipPosition();
+
+			Vector3 tipDelta = tipPositionInWorldSpace - priorTipPositionInWorldSpace;
+
+			float tipSpeed = tipDelta.magnitude / Time.deltaTime;
+
+			_IsFastEnoughToCut = tipSpeed > tipSpeedForCutting;
+
+			priorTipPositionInWorldSpace = tipPositionInWorldSpace;
+		}
+	}
+}