add some extra assets FX and SFX

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);
+//        }
+    }
+}