portals and dash. Also a bit of terrain building and level design

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common.meta

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

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GGeneralParams.cs

@@ -0,0 +1,86 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GGeneralParams
+    {
+        public const string DEFAULT_DIRECTORY = "Assets/Polaris Exported/";
+
+        [SerializeField]
+        private GTextureGenerationMode mode;
+        public GTextureGenerationMode Mode
+        {
+            get
+            {
+                return mode;
+            }
+            set
+            {
+                mode = value;
+            }
+        }
+
+        [SerializeField]
+        private int resolution;
+        public int Resolution
+        {
+            get
+            {
+                return resolution;
+            }
+            set
+            {
+                resolution = Mathf.Clamp(Mathf.ClosestPowerOfTwo(value), 32, 4096);
+            }
+        }
+
+        [SerializeField]
+        private GImageFileExtension extension;
+        public GImageFileExtension Extension
+        {
+            get
+            {
+                return extension;
+            }
+            set
+            {
+                extension = value;
+            }
+        }
+
+        [SerializeField]
+        private bool useHighPrecisionTexture;
+        public bool UseHighPrecisionTexture
+        {
+            get
+            {
+                return useHighPrecisionTexture;
+            }
+            set
+            {
+                useHighPrecisionTexture = value;
+            }
+        }
+
+        [SerializeField]
+        private string directory;
+        public string Directory
+        {
+            get
+            {
+                if (string.IsNullOrEmpty(directory))
+                {
+                    directory = DEFAULT_DIRECTORY;
+                }
+                return directory;
+            }
+            set
+            {
+                directory = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GGeneralParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: db667563fc2bc904182e0036964e72b8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GImageFileExtension.cs

@@ -0,0 +1,9 @@
+#if GRIFFIN
+namespace Pinwheel.Griffin.TextureTool
+{
+    public enum GImageFileExtension
+    {
+        PNG, JPG, EXR, TGA
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GImageFileExtension.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: cf9397227bc5cdf419fb4ca0cc10125c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GLivePreviewMode.cs

@@ -0,0 +1,9 @@
+#if GRIFFIN
+namespace Pinwheel.Griffin.TextureTool
+{
+    public enum GLivePreviewMode
+    {
+        Mask, ColorMap, Geometry
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GLivePreviewMode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6cc2e8c1e2dce1449a40454483056ecf
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GLivePreviewParams.cs

@@ -0,0 +1,66 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GLivePreviewParams
+    {
+        [SerializeField]
+        private bool enable;
+        public bool Enable
+        {
+            get
+            {
+                return enable;
+            }
+            set
+            {
+                enable = value;
+            }
+        }
+
+        [SerializeField]
+        private GStylizedTerrain terrain;
+        public GStylizedTerrain Terrain
+        {
+            get
+            {
+                return terrain;
+            }
+            set
+            {
+                terrain = value;
+            }
+        }
+
+        [SerializeField]
+        private Color color;
+        public Color Color
+        {
+            get
+            {
+                return color;
+            }
+            set
+            {
+                color = value;
+            }
+        }
+
+        [SerializeField]
+        private GLivePreviewMode mode;
+        public GLivePreviewMode Mode
+        {
+            get
+            {
+                return mode;
+            }
+            set
+            {
+                mode = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GLivePreviewParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a700fbe553620344aa47c882b8f7f8f8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GTextureToolParams.cs

@@ -0,0 +1,186 @@
+#if GRIFFIN
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    //[CreateAssetMenu(menuName = "Griffin/Texture Tool Params")]
+    public partial class GTextureToolParams : ScriptableObject
+    {
+        private static GTextureToolParams instance;
+        public static GTextureToolParams Instance
+        {
+            get
+            {
+                if (instance == null)
+                {
+                    instance = Resources.Load<GTextureToolParams>("TextureToolParams");
+                    if (instance == null)
+                    {
+                        instance = ScriptableObject.CreateInstance<GTextureToolParams>();
+                    }
+                }
+                return instance;
+            }
+        }
+
+        [SerializeField]
+        private GGeneralParams general;
+        public GGeneralParams General
+        {
+            get
+            {
+                return general;
+            }
+            set
+            {
+                general = value;
+            }
+        }
+
+        [SerializeField]
+        private GLivePreviewParams livePreview;
+        public GLivePreviewParams LivePreview
+        {
+            get
+            {
+                return livePreview;
+            }
+            set
+            {
+                livePreview = value;
+            }
+        }
+
+        [SerializeField]
+        private GHeightMapGeneratorParams heightMap;
+        public GHeightMapGeneratorParams HeightMap
+        {
+            get
+            {
+                return heightMap;
+            }
+            set
+            {
+                heightMap = value;
+            }
+        }
+
+        [SerializeField]
+        private GHeightMapFromMeshGeneratorParams heightMapFromMesh;
+        public GHeightMapFromMeshGeneratorParams HeightMapFromMesh
+        {
+            get
+            {
+                return heightMapFromMesh;
+            }
+            set
+            {
+                heightMapFromMesh = value;
+            }
+        }
+
+        [SerializeField]
+        private GNormalMapGeneratorParams normalMap;
+        public GNormalMapGeneratorParams NormalMap
+        {
+            get
+            {
+                return normalMap;
+            }
+            set
+            {
+                normalMap = value;
+            }
+        }
+
+        [SerializeField]
+        private GSteepnessMapGeneratorParams steepness;
+        public GSteepnessMapGeneratorParams Steepness
+        {
+            get
+            {
+                return steepness;
+            }
+            set
+            {
+                steepness = value;
+            }
+        }
+
+        [SerializeField]
+        private GNoiseMapGeneratorParams noise;
+        public GNoiseMapGeneratorParams Noise
+        {
+            get
+            {
+                return noise;
+            }
+            set
+            {
+                noise = value;
+            }
+        }
+
+        [SerializeField]
+        private GColorMapGeneratorParams colorMap;
+        public GColorMapGeneratorParams ColorMap
+        {
+            get
+            {
+                return colorMap;
+            }
+            set
+            {
+                colorMap = value;
+            }
+        }
+
+        [SerializeField]
+        private GBlendMapGeneratorParams blend;
+        public GBlendMapGeneratorParams Blend
+        {
+            get
+            {
+                return blend;
+            }
+            set
+            {
+                blend = value;
+            }
+        }
+
+        [SerializeField]
+        private GFoliageDistributionMapGeneratorParams treeDistribution;
+        public GFoliageDistributionMapGeneratorParams TreeDistribution
+        {
+            get
+            {
+                return treeDistribution;
+            }
+            set
+            {
+                treeDistribution = value;
+            }
+        }
+
+        [SerializeField]
+        private List<GTextureFilterLayer> filters;
+        public List<GTextureFilterLayer> Filters
+        {
+            get
+            {
+                if (filters == null)
+                {
+                    filters = new List<GTextureFilterLayer>();
+                }
+                return filters;
+            }
+            set
+            {
+                filters = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Common/GTextureToolParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e25ce2f15ef01dc45916675d163d0dd2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters.meta

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

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GBlurFilter.cs

@@ -0,0 +1,50 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GBlurFilter : IGTextureFilter
+    {
+        private static RenderTexture bgRt;
+
+        private static Material mat;
+        private static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.blurRadiusShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Apply(RenderTexture targetRt, GTextureFilterParams param)
+        {
+            GBlurParams blurParam = param.Blur;
+            RenderTexture bg = CloneBg(targetRt);
+
+            Mat.SetTexture("_MainTex", bg);
+            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, blurParam.Radius);
+        }
+
+        private RenderTexture CloneBg(RenderTexture targetRt)
+        {
+            if (bgRt == null)
+            {
+                bgRt = new RenderTexture(targetRt);
+            }
+            else if (bgRt.width != targetRt.width || bgRt.height != targetRt.height || bgRt.format != targetRt.format)
+            {
+                bgRt.Release();
+                GUtilities.DestroyObject(bgRt);
+                bgRt = new RenderTexture(targetRt);
+            }
+
+            GCommon.CopyToRT(targetRt, bgRt);
+            return bgRt;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GBlurFilter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: eb819d330b1635b4bb8472db52525b66
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GBlurParams.cs

@@ -0,0 +1,31 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GBlurParams
+    {
+        [SerializeField]
+        private int radius;
+        public int Radius
+        {
+            get
+            {
+                return radius;
+            }
+            set
+            {
+                radius = Mathf.Clamp(value, 0, 20);
+            }
+        }
+
+        public static GBlurParams Create()
+        {
+            GBlurParams param = new GBlurParams();
+            param.radius = 10;
+            return param;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GBlurParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 32bcf1dfe09c95e45b552f986ea36f36
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GCurveFilter.cs

@@ -0,0 +1,65 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GCurveFilter : IGTextureFilter
+    {
+        private static RenderTexture bgRt;
+
+        private static Material mat;
+        private static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.curveFilterShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Apply(RenderTexture targetRt, GTextureFilterParams param)
+        {
+            GCurveParams curveParam = param.Curve;
+            RenderTexture bg = CloneBg(targetRt);
+            Texture2D masterCurveTex = GCommon.CreateTextureFromCurve(curveParam.MasterCurve, 1024, 1);
+            Texture2D redCurveTex = GCommon.CreateTextureFromCurve(curveParam.RedCurve, 1024, 1);
+            Texture2D greenCurveTex = GCommon.CreateTextureFromCurve(curveParam.GreenCurve, 1024, 1);
+            Texture2D blueCurveTex = GCommon.CreateTextureFromCurve(curveParam.BlueCurve, 1024, 1);
+            Texture2D alphaCurveTex = GCommon.CreateTextureFromCurve(curveParam.AlphaCurve, 1024, 1);
+            Mat.SetTexture("_MainTex", bg);
+            Mat.SetTexture("_MasterCurve", masterCurveTex);
+            Mat.SetTexture("_RedCurve", redCurveTex);
+            Mat.SetTexture("_GreenCurve", greenCurveTex);
+            Mat.SetTexture("_BlueCurve", blueCurveTex);
+            Mat.SetTexture("_AlphaCurve", alphaCurveTex);
+            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, 0);
+
+            GUtilities.DestroyObject(masterCurveTex);
+            GUtilities.DestroyObject(redCurveTex);
+            GUtilities.DestroyObject(greenCurveTex);
+            GUtilities.DestroyObject(blueCurveTex);
+            GUtilities.DestroyObject(alphaCurveTex);
+        }
+
+        private RenderTexture CloneBg(RenderTexture targetRt)
+        {
+            if (bgRt == null)
+            {
+                bgRt = new RenderTexture(targetRt);
+            }
+            else if (bgRt.width != targetRt.width || bgRt.height != targetRt.height || bgRt.format != targetRt.format)
+            {
+                bgRt.Release();
+                GUtilities.DestroyObject(bgRt);
+                bgRt = new RenderTexture(targetRt);
+            }
+
+            GCommon.CopyToRT(targetRt, bgRt);
+            return bgRt;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GCurveFilter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 59ed4e7586327d844b184d72ee35e618
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GCurveParams.cs

@@ -0,0 +1,111 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GCurveParams
+    {
+        [SerializeField]
+        private AnimationCurve masterCurve;
+        public AnimationCurve MasterCurve
+        {
+            get
+            {
+                if (masterCurve == null)
+                {
+                    masterCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
+                }
+                return masterCurve;
+            }
+            set
+            {
+                masterCurve = value;
+            }
+        }
+
+        [SerializeField]
+        private AnimationCurve redCurve;
+        public AnimationCurve RedCurve
+        {
+            get
+            {
+                if (redCurve == null)
+                {
+                    redCurve = AnimationCurve.Linear(0, 0, 1, 1);
+                }
+                return redCurve;
+            }
+            set
+            {
+                redCurve = value;
+            }
+        }
+
+        [SerializeField]
+        private AnimationCurve greenCurve;
+        public AnimationCurve GreenCurve
+        {
+            get
+            {
+                if (greenCurve == null)
+                {
+                    greenCurve = AnimationCurve.Linear(0, 0, 1, 1);
+                }
+                return greenCurve;
+            }
+            set
+            {
+                greenCurve = value;
+            }
+        }
+
+        [SerializeField]
+        private AnimationCurve blueCurve;
+        public AnimationCurve BlueCurve
+        {
+            get
+            {
+                if (blueCurve == null)
+                {
+                    blueCurve = AnimationCurve.Linear(0, 0, 1, 1);
+                }
+                return blueCurve;
+            }
+            set
+            {
+                blueCurve = value;
+            }
+        }
+
+        [SerializeField]
+        private AnimationCurve alphaCurve;
+        public AnimationCurve AlphaCurve
+        {
+            get
+            {
+                if (alphaCurve == null)
+                {
+                    alphaCurve = AnimationCurve.Linear(0, 0, 1, 1);
+                }
+                return alphaCurve;
+            }
+            set
+            {
+                alphaCurve = value;
+            }
+        }
+
+        public static GCurveParams Create()
+        {
+            GCurveParams param = new GCurveParams();
+            param.MasterCurve = AnimationCurve.EaseInOut(0, 0, 1, 1);
+            param.RedCurve = AnimationCurve.Linear(0, 0, 1, 1);
+            param.GreenCurve = AnimationCurve.Linear(0, 0, 1, 1);
+            param.BlueCurve = AnimationCurve.Linear(0, 0, 1, 1);
+            param.AlphaCurve = AnimationCurve.Linear(0, 0, 1, 1);
+            return param;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GCurveParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bcc61236a6ec13c4e9f41437a1a109f2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GInvertFilter.cs

@@ -0,0 +1,53 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GInvertFilter : IGTextureFilter
+    {
+        private static RenderTexture bgRt;
+
+        private static Material mat;
+        private static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.invertFilterShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Apply(RenderTexture targetRt, GTextureFilterParams param)
+        {
+            GInvertParams invertParam = param.Invert;
+            RenderTexture bg = CloneBg(targetRt);
+            Mat.SetTexture("_MainTex", bg);
+            Mat.SetInt("_InvertRed", invertParam.InvertRed ? 1 : 0);
+            Mat.SetInt("_InvertGreen", invertParam.InvertGreen ? 1 : 0);
+            Mat.SetInt("_InvertBlue", invertParam.InvertBlue ? 1 : 0);
+            Mat.SetInt("_InvertAlpha", invertParam.InvertAlpha ? 1 : 0);
+            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, 0);
+        }
+
+        private RenderTexture CloneBg(RenderTexture targetRt)
+        {
+            if (bgRt == null)
+            {
+                bgRt = new RenderTexture(targetRt);
+            }
+            else if (bgRt.width != targetRt.width || bgRt.height != targetRt.height || bgRt.format != targetRt.format)
+            {
+                bgRt.Release();
+                GUtilities.DestroyObject(bgRt);
+                bgRt = new RenderTexture(targetRt);
+            }
+
+            GCommon.CopyToRT(targetRt, bgRt);
+            return bgRt;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GInvertFilter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b2b12ba9db29d6748a2e64cc4b0beec8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GInvertParams.cs

@@ -0,0 +1,76 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GInvertParams
+    {
+        [SerializeField]
+        private bool invertRed;
+        public bool InvertRed
+        {
+            get
+            {
+                return invertRed;
+            }
+            set
+            {
+                invertRed = value;
+            }
+        }
+
+        [SerializeField]
+        private bool invertGreen;
+        public bool InvertGreen
+        {
+            get
+            {
+                return invertGreen;
+            }
+            set
+            {
+                invertGreen = value;
+            }
+        }
+
+        [SerializeField]
+        private bool invertBlue;
+        public bool InvertBlue
+        {
+            get
+            {
+                return invertBlue;
+            }
+            set
+            {
+                invertBlue = value;
+            }
+        }
+
+        [SerializeField]
+        private bool invertAlpha;
+        public bool InvertAlpha
+        {
+            get
+            {
+                return invertAlpha;
+            }
+            set
+            {
+                invertAlpha = value;
+            }
+        }
+
+        public static GInvertParams Create()
+        {
+            GInvertParams param = new GInvertParams();
+            param.invertRed = true;
+            param.invertGreen = true;
+            param.invertBlue = true;
+            param.invertAlpha = true;
+            return param;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GInvertParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 202066cd612ae134d97970e7ea87f4f3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GStepFilter.cs

@@ -0,0 +1,51 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GStepFilter : IGTextureFilter
+    {
+        private static RenderTexture bgRt;
+
+        private static Material mat;
+        private static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.stepFilterShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Apply(RenderTexture targetRt, GTextureFilterParams param)
+        {
+            GStepParams stepParam = param.Step;
+            RenderTexture bg = CloneBg(targetRt);
+            Mat.SetTexture("_MainTex", bg);
+            Mat.SetInt("_Count", stepParam.Count);
+
+            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, 0);
+        }
+
+        private RenderTexture CloneBg(RenderTexture targetRt)
+        {
+            if (bgRt == null)
+            {
+                bgRt = new RenderTexture(targetRt);
+            }
+            else if (bgRt.width != targetRt.width || bgRt.height != targetRt.height || bgRt.format != targetRt.format)
+            {
+                bgRt.Release();
+                GUtilities.DestroyObject(bgRt);
+                bgRt = new RenderTexture(targetRt);
+            }
+
+            GCommon.CopyToRT(targetRt, bgRt);
+            return bgRt;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GStepFilter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 724245159c5d1aa429e8a6c14e51a6ec
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GStepParams.cs

@@ -0,0 +1,31 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GStepParams
+    {
+        [SerializeField]
+        private int count;
+        public int Count
+        {
+            get
+            {
+                return count;
+            }
+            set
+            {
+                count = Mathf.Clamp(value, 1, 256);
+            }
+        }
+
+        public static GStepParams Create()
+        {
+            GStepParams param = new GStepParams();
+            param.Count = 256;
+            return param;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GStepParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f774fb74afb42eb499df241501298bfe
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GTextureFilterLayer.cs

@@ -0,0 +1,87 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public class GTextureFilterLayer
+    {
+        [SerializeField]
+        private bool enabled;
+        public bool Enabled
+        {
+            get
+            {
+                return enabled;
+            }
+            set
+            {
+                enabled = value;
+            }
+        }
+
+        [SerializeField]
+        private GTextureFilterType type;
+        public GTextureFilterType Type
+        {
+            get
+            {
+                return type;
+            }
+        }
+
+        [SerializeField]
+        private GTextureFilterParams param;
+        public GTextureFilterParams Param
+        {
+            get
+            {
+                return param;
+            }
+            set
+            {
+                param = value;
+            }
+        }
+
+        private GTextureFilterLayer()
+        {
+            enabled = true;
+            type = GTextureFilterType.Curve;
+        }
+
+        public GTextureFilterLayer(GTextureFilterType t)
+        {
+            enabled = true;
+            type = t;
+            param = GTextureFilterParams.Default;
+        }
+
+        public void Apply(RenderTexture targetRt)
+        {
+            if (!Enabled)
+                return;
+            if (Type == GTextureFilterType.Curve)
+            {
+                new GCurveFilter().Apply(targetRt, param);
+            }
+            else if (Type == GTextureFilterType.Blur)
+            {
+                new GBlurFilter().Apply(targetRt, param);
+            }
+            else if (Type == GTextureFilterType.Invert)
+            {
+                new GInvertFilter().Apply(targetRt, param);
+            }
+            else if (Type == GTextureFilterType.Step)
+            {
+                new GStepFilter().Apply(targetRt, param);
+            }
+            else if (Type == GTextureFilterType.Warp)
+            {
+                new GWarpFilter().Apply(targetRt, param);
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GTextureFilterLayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0fcd736b55eb3514ba998ccace287829
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GTextureFilterParams.cs

@@ -0,0 +1,94 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GTextureFilterParams
+    {
+        public static GTextureFilterParams Default
+        {
+            get
+            {
+                GTextureFilterParams param = new GTextureFilterParams();
+                param.Blur = GBlurParams.Create();
+                param.Curve = GCurveParams.Create();
+                param.Invert = GInvertParams.Create();
+                param.Step = GStepParams.Create();
+                param.Warp = GWarpParams.Create();
+                return param;
+            }
+        }
+
+        [SerializeField]
+        private GBlurParams blur;
+        public GBlurParams Blur
+        {
+            get
+            {
+                return blur;
+            }
+            set
+            {
+                blur = value;
+            }
+        }
+
+        [SerializeField]
+        private GCurveParams curve;
+        public GCurveParams Curve
+        {
+            get
+            {
+                return curve;
+            }
+            set
+            {
+                curve = value;
+            }
+        }
+
+        [SerializeField]
+        private GInvertParams invert;
+        public GInvertParams Invert
+        {
+            get
+            {
+                return invert;
+            }
+            set
+            {
+                invert = value;
+            }
+        }
+
+        [SerializeField]
+        private GStepParams step;
+        public GStepParams Step
+        {
+            get
+            {
+                return step;
+            }
+            set
+            {
+                step = value;
+            }
+        }
+
+        [SerializeField]
+        private GWarpParams warp;
+        public GWarpParams Warp
+        {
+            get
+            {
+                return warp;
+            }
+            set
+            {
+                warp = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GTextureFilterParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 369928bdd48475e4b8e2328ab5137148
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GTextureFilterType.cs

@@ -0,0 +1,9 @@
+#if GRIFFIN
+namespace Pinwheel.Griffin.TextureTool
+{
+    public enum GTextureFilterType
+    {
+        Curve, Blur, Invert, Step, Warp
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GTextureFilterType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 31e7cb696e24f0744a4ba4865050f9e3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GWarpFilter.cs

@@ -0,0 +1,53 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GWarpFilter : IGTextureFilter
+    {
+        private static RenderTexture bgRt;
+
+        private static Material mat;
+        private static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.warpFilterShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Apply(RenderTexture targetRt, GTextureFilterParams param)
+        {
+            GWarpParams warpParam = param.Warp;
+            RenderTexture bg = CloneBg(targetRt);
+            Mat.SetTexture("_MainTex", bg);
+            Mat.SetTexture("_Mask", warpParam.UseBackgroundAsMask ? (Texture)bg : (Texture)warpParam.Mask);
+            Mat.SetFloat("_Strength", warpParam.Strength);
+            GCommon.SetMaterialKeywordActive(Mat, "MASK_IS_NORMAL", warpParam.MaskIsNormalMap);
+
+            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, 0);
+        }
+
+        private RenderTexture CloneBg(RenderTexture targetRt)
+        {
+            if (bgRt == null)
+            {
+                bgRt = new RenderTexture(targetRt);
+            }
+            else if (bgRt.width != targetRt.width || bgRt.height != targetRt.height || bgRt.format != targetRt.format)
+            {
+                bgRt.Release();
+                GUtilities.DestroyObject(bgRt);
+                bgRt = new RenderTexture(targetRt);
+            }
+
+            GCommon.CopyToRT(targetRt, bgRt);
+            return bgRt;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GWarpFilter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 97f76d6e2cfb27644a47815da45fde5a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GWarpParams.cs

@@ -0,0 +1,76 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GWarpParams
+    {
+        [SerializeField]
+        private Texture2D mask;
+        public Texture2D Mask
+        {
+            get
+            {
+                return mask;
+            }
+            set
+            {
+                mask = value;
+            }
+        }
+
+        [SerializeField]
+        private bool maskIsNormalMap;
+        public bool MaskIsNormalMap
+        {
+            get
+            {
+                return maskIsNormalMap;
+            }
+            set
+            {
+                maskIsNormalMap = value;
+            }
+        }
+
+        [SerializeField]
+        private float strength;
+        public float Strength
+        {
+            get
+            {
+                return strength;
+            }
+            set
+            {
+                strength = Mathf.Max(0, value);
+            }
+        }
+
+        [SerializeField]
+        private bool useBackgroundAsMask;
+        public bool UseBackgroundAsMask
+        {
+            get
+            {
+                return useBackgroundAsMask;
+            }
+            set
+            {
+                useBackgroundAsMask = value;
+            }
+        }
+
+        public static GWarpParams Create()
+        {
+            GWarpParams param = new GWarpParams();
+            param.Mask = null;
+            param.MaskIsNormalMap = false;
+            param.Strength = 1;
+            param.UseBackgroundAsMask = false;
+            return param;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/GWarpParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1c3f43dd3e7304a49b8bf7bf1fba09cc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/IGTextureFilter.cs

@@ -0,0 +1,11 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public interface IGTextureFilter
+    {
+        void Apply(RenderTexture targetRt, GTextureFilterParams param);
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Filters/IGTextureFilter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e42609618a414904c9baa79bdec14254
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators.meta

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

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendDataSource.cs

@@ -0,0 +1,9 @@
+#if GRIFFIN
+namespace Pinwheel.Griffin.TextureTool
+{
+    public enum GBlendDataSource
+    {
+        Texture, Number, Vector
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendDataSource.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a70f64fb13c9c834694ebf15278b3df6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendLayer.cs

@@ -0,0 +1,135 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public class GBlendLayer
+    {
+        [SerializeField]
+        private GBlendDataSource dataSource;
+        public GBlendDataSource DataSource
+        {
+            get
+            {
+                return dataSource;
+            }
+            set
+            {
+                dataSource = value;
+            }
+        }
+
+        [SerializeField]
+        private Texture2D texture;
+        public Texture2D Texture
+        {
+            get
+            {
+                return texture;
+            }
+            set
+            {
+                texture = value;
+            }
+        }
+
+        [SerializeField]
+        private float number;
+        public float Number
+        {
+            get
+            {
+                return number;
+            }
+            set
+            {
+                number = value;
+            }
+        }
+
+        [SerializeField]
+        private Vector4 vector;
+        public Vector4 Vector
+        {
+            get
+            {
+                return vector;
+            }
+            set
+            {
+                vector = value;
+            }
+        }
+
+        [SerializeField]
+        private GBlendOperation blendOps;
+        public GBlendOperation BlendOps
+        {
+            get
+            {
+                return blendOps;
+            }
+            set
+            {
+                blendOps = value;
+            }
+        }
+
+        [SerializeField]
+        private float lerpFactor;
+        public float LerpFactor
+        {
+            get
+            {
+                return lerpFactor;
+            }
+            set
+            {
+                lerpFactor = Mathf.Clamp01(value);
+            }
+        }
+
+        [SerializeField]
+        private Texture2D lerpMask;
+        public Texture2D LerpMask
+        {
+            get
+            {
+                return lerpMask;
+            }
+            set
+            {
+                lerpMask = value;
+            }
+        }
+
+        [SerializeField]
+        private bool saturate;
+        public bool Saturate
+        {
+            get
+            {
+                return saturate;
+            }
+            set
+            {
+                saturate = value;
+            }
+        }
+
+        public static GBlendLayer Create()
+        {
+            GBlendLayer layer = new GBlendLayer();
+            layer.dataSource = GBlendDataSource.Texture;
+            layer.texture = null;
+            layer.number = 1;
+            layer.vector = Vector4.one;
+            layer.blendOps = GBlendOperation.Add;
+            layer.lerpFactor = 0.5f;
+            layer.saturate = true;
+            return layer;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendLayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2dad0566eee99ab4a830748b97e3f8b8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendMapGenerator.cs

@@ -0,0 +1,50 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GBlendMapGenerator : IGTextureGenerator
+    {
+        private static Material mat;
+        public static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.blendMapGeneratorShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Generate(RenderTexture targetRt)
+        {
+            GBlendMapGeneratorParams param = GTextureToolParams.Instance.Blend;
+
+            RenderTexture bg = new RenderTexture(targetRt);
+            GCommon.CopyToRT(targetRt, bg);
+
+            GCommon.FillTexture(targetRt, Color.black);
+            for (int i = 0; i < param.Layers.Count; ++i)
+            {
+                GBlendLayer l = param.Layers[i];
+                Mat.SetTexture("_Background", bg);
+                Mat.SetTexture("_Foreground", l.Texture);
+                Mat.SetFloat("_Number", l.Number);
+                Mat.SetVector("_Vector", l.Vector);
+                Mat.SetInt("_Ops", (int)l.BlendOps);
+                Mat.SetFloat("_LerpFactor", l.LerpFactor);
+                Mat.SetTexture("_LerpMask", l.LerpMask);
+                Mat.SetInt("_Saturate", l.Saturate ? 1 : 0);
+
+                GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, (int)l.DataSource);
+                GCommon.CopyToRT(targetRt, bg);
+            }
+
+            bg.Release();
+            GUtilities.DestroyObject(bg);
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendMapGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: dc9d04b8a939c3949805dba0f405bfad
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendMapGeneratorParams.cs

@@ -0,0 +1,29 @@
+#if GRIFFIN
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GBlendMapGeneratorParams
+    {
+        [SerializeField]
+        private List<GBlendLayer> layers;
+        public List<GBlendLayer> Layers
+        {
+            get
+            {
+                if (layers == null)
+                {
+                    layers = new List<GBlendLayer>();
+                }
+                return layers;
+            }
+            set
+            {
+                layers = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendMapGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: fb21a8ceaa3eb644a927226d6db36832
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendOperation.cs

@@ -0,0 +1,9 @@
+#if GRIFFIN
+namespace Pinwheel.Griffin.TextureTool
+{
+    public enum GBlendOperation
+    {
+        Add, Subtract, Multiply, Divide, Min, Max, Different, Lerp
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GBlendOperation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: acf4ea0084ce167498c9aaa683f069b0
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GColorMapGenerator.cs

@@ -0,0 +1,62 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GColorMapGenerator : IGTextureGenerator
+    {
+        public void Generate(RenderTexture targetRt)
+        {
+            GColorMapGeneratorParams param = GTextureToolParams.Instance.ColorMap;
+            if (param.Terrain == null || param.Terrain.TerrainData == null)
+            {
+                GCommon.FillTexture(targetRt, Color.black);
+            }
+            else
+            {
+                RenderColorMap(param.Terrain, targetRt);
+            }
+        }
+
+        private void RenderColorMap(GStylizedTerrain t, RenderTexture targetRt)
+        {
+            GShading shading = t.TerrainData.Shading;
+            if (shading.Splats == null)
+                return;
+            Material mat = GInternalMaterials.SplatsToAlbedoMaterial;
+
+            for (int i = 0; i < shading.SplatControlMapCount; ++i)
+            {
+                Texture2D controlMap = shading.GetSplatControlOrDefault(i);
+                mat.SetTexture("_Control0", controlMap);
+                for (int channel = 0; channel < 4; ++channel)
+                {
+                    int prototypeIndex = i * 4 + channel;
+                    if (prototypeIndex < shading.Splats.Prototypes.Count)
+                    {
+                        GSplatPrototype p = shading.Splats.Prototypes[prototypeIndex];
+                        mat.SetTexture("_Splat" + channel, p.Texture);
+                        Vector2 terrainSize = new Vector2(t.TerrainData.Geometry.Width, t.TerrainData.Geometry.Length);
+                        Vector2 textureScale = new Vector2(
+                            p.TileSize.x != 0 ? terrainSize.x / p.TileSize.x : 0,
+                            p.TileSize.y != 0 ? terrainSize.y / p.TileSize.y : 0);
+                        Vector2 textureOffset = new Vector2(
+                            p.TileOffset.x != 0 ? terrainSize.x / p.TileOffset.x : 0,
+                            p.TileOffset.y != 0 ? terrainSize.y / p.TileOffset.y : 0);
+                        mat.SetTextureScale("_Splat" + channel, textureScale);
+                        mat.SetTextureOffset("_Splat" + channel, textureOffset);
+                    }
+                    else
+                    {
+                        mat.SetTexture("_Splat" + channel, null);
+                        mat.SetTextureScale("_Splat" + channel, Vector2.zero);
+                        mat.SetTextureOffset("_Splat" + channel, Vector2.zero);
+                    }
+                }
+
+                GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, mat, 0);
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GColorMapGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1e1f467c2b4ace04c80b9919adc839dd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GColorMapGeneratorParams.cs

@@ -0,0 +1,24 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GColorMapGeneratorParams
+    {
+        [SerializeField]
+        private GStylizedTerrain terrain;
+        public GStylizedTerrain Terrain
+        {
+            get
+            {
+                return terrain;
+            }
+            set
+            {
+                terrain = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GColorMapGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 33a58e2a6a8c9ec4bbe521986047f9a6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GFoliageDistributionMapGenerator.cs

@@ -0,0 +1,122 @@
+#if GRIFFIN
+using System.Collections.Generic;
+using UnityEngine;
+using Rand = System.Random;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GFoliageDistributionMapGenerator : IGTextureGenerator
+    {
+        private Material mat;
+        private Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.distributionMapGeneratorShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Generate(RenderTexture targetRt)
+        {
+            GFoliageDistributionMapGeneratorParams param = GTextureToolParams.Instance.TreeDistribution;
+            GCommon.FillTexture(targetRt, Color.clear);
+
+            List<Vector2> pos = new List<Vector2>();
+            if (param.Terrain != null &&
+                param.Terrain.TerrainData != null &&
+                param.Terrain.TerrainData.Foliage.Trees != null &&
+                param.Terrain.TerrainData.Foliage.Trees.Prototypes.Count != 0)
+            {
+                GetTreePosition(param, pos);
+                Draw(targetRt, param, pos);
+            }
+            if (param.Terrain != null &&
+                param.Terrain.TerrainData != null &&
+                param.Terrain.TerrainData.Foliage.Grasses != null &&
+                param.Terrain.TerrainData.Foliage.Grasses.Prototypes.Count != 0)
+            {
+                GGrassPatch[] patches = param.Terrain.TerrainData.Foliage.GrassPatches;
+                for (int i = 0; i < patches.Length; ++i)
+                {
+                    GetGrassPosition(param, patches[i], pos);
+                    Draw(targetRt, param, pos);
+                }
+            }
+        }
+
+        private void GetTreePosition(GFoliageDistributionMapGeneratorParams param, List<Vector2> pos)
+        {
+            pos.Clear();
+            HashSet<int> indices = new HashSet<int>(param.TreePrototypeIndices);
+            List<GTreeInstance> instances = param.Terrain.TerrainData.Foliage.TreeInstances;
+
+            for (int i = 0; i < instances.Count; ++i)
+            {
+                if (indices.Contains(instances[i].PrototypeIndex))
+                {
+                    pos.Add(new Vector2(instances[i].Position.x, instances[i].Position.z));
+                }
+            }
+        }
+
+        private void GetGrassPosition(GFoliageDistributionMapGeneratorParams param, GGrassPatch patch, List<Vector2> pos)
+        {
+            pos.Clear();
+            HashSet<int> indices = new HashSet<int>(param.GrassPrototypeIndices);
+            List<GGrassInstance> instances = patch.Instances;
+
+            for (int i = 0; i < instances.Count; ++i)
+            {
+                if (indices.Contains(instances[i].PrototypeIndex))
+                {
+                    pos.Add(new Vector2(instances[i].Position.x, instances[i].Position.z));
+                }
+            }
+        }
+
+        private void Draw(RenderTexture targetRt, GFoliageDistributionMapGeneratorParams param, List<Vector2> pos)
+        {
+            RenderTexture.active = targetRt;
+            GL.PushMatrix();
+            Mat.SetTexture("_MainTex", param.BrushMask);
+            Mat.SetFloat("_Opacity", param.Opacity);
+            Mat.SetPass(0);
+            GL.LoadOrtho();
+            GL.Begin(GL.QUADS);
+
+            Rand rand = new Rand(pos.Count);
+            Rect r = new Rect();
+            r.size = param.Size * Vector2.one;
+            for (int i = 0; i < pos.Count; ++i)
+            {
+                r.center = pos[i];
+                Matrix4x4 matrix = Matrix4x4.TRS(
+                    r.center,
+                    Quaternion.Euler(0, 0, Mathf.Lerp(param.RotationMin, param.RotationMax, (float)rand.NextDouble())),
+                    Vector3.one);
+                Vector3 bl = matrix.MultiplyPoint(new Vector3(-r.width, -r.height, 0) * 0.5f);
+                Vector3 tl = matrix.MultiplyPoint(new Vector3(-r.width, r.height, 0) * 0.5f);
+                Vector3 tr = matrix.MultiplyPoint(new Vector3(r.width, r.height, 0) * 0.5f);
+                Vector3 br = matrix.MultiplyPoint(new Vector3(r.width, -r.height, 0) * 0.5f);
+
+                GL.TexCoord(new Vector3(0, 0, 0));
+                GL.Vertex3(bl.x, bl.y, 0);
+                GL.TexCoord(new Vector3(0, 1, 0));
+                GL.Vertex3(tl.x, tl.y, 0);
+                GL.TexCoord(new Vector3(1, 1, 0));
+                GL.Vertex3(tr.x, tr.y, 0);
+                GL.TexCoord(new Vector3(1, 0, 0));
+                GL.Vertex3(br.x, br.y, 0);
+            }
+
+            GL.End();
+            GL.PopMatrix();
+            RenderTexture.active = null;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GFoliageDistributionMapGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a5c1fd39d19e75f40adb21e515c455e6
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GFoliageDistributionMapGeneratorParams.cs

@@ -0,0 +1,131 @@
+#if GRIFFIN
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GFoliageDistributionMapGeneratorParams
+    {
+        [SerializeField]
+        private GStylizedTerrain terrain;
+        public GStylizedTerrain Terrain
+        {
+            get
+            {
+                return terrain;
+            }
+            set
+            {
+                terrain = value;
+            }
+        }
+
+        [SerializeField]
+        private List<int> treePrototypeIndices;
+        public List<int> TreePrototypeIndices
+        {
+            get
+            {
+                if (treePrototypeIndices == null)
+                {
+                    treePrototypeIndices = new List<int>();
+                }
+                return treePrototypeIndices;
+            }
+            set
+            {
+                treePrototypeIndices = value;
+            }
+        }
+
+        [SerializeField]
+        private List<int> grassPrototypeIndices;
+        public List<int> GrassPrototypeIndices
+        {
+            get
+            {
+                if (grassPrototypeIndices == null)
+                {
+                    grassPrototypeIndices = new List<int>();
+                }
+                return grassPrototypeIndices;
+            }
+            set
+            {
+                grassPrototypeIndices = value;
+            }
+        }
+
+        [SerializeField]
+        private float size;
+        public float Size
+        {
+            get
+            {
+                return size;
+            }
+            set
+            {
+                size = Mathf.Clamp01(value);
+            }
+        }
+
+        [SerializeField]
+        private float opacity;
+        public float Opacity
+        {
+            get
+            {
+                return opacity;
+            }
+            set
+            {
+                opacity = Mathf.Clamp01(value);
+            }
+        }
+
+        [SerializeField]
+        private Texture2D brushMask;
+        public Texture2D BrushMask
+        {
+            get
+            {
+                return brushMask;
+            }
+            set
+            {
+                brushMask = value;
+            }
+        }
+
+        [SerializeField]
+        private float rotationMin;
+        public float RotationMin
+        {
+            get
+            {
+                return rotationMin;
+            }
+            set
+            {
+                rotationMin = value;
+            }
+        }
+
+        [SerializeField]
+        private float rotationMax;
+        public float RotationMax
+        {
+            get
+            {
+                return rotationMax;
+            }
+            set
+            {
+                rotationMax = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GFoliageDistributionMapGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b36399c21dbed6447a3296b4790f4b22
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapFromMeshGenerator.cs

@@ -0,0 +1,95 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GHeightMapFromMeshGenerator : IGTextureGenerator
+    {
+        public const float DEFAULT_CAMERA_ORTHO_SIZE = 10;
+
+        private Camera camera;
+        private GameObject gameObject;
+
+        public void Generate(RenderTexture targetRt)
+        {
+            GHeightMapFromMeshGeneratorParams param = GTextureToolParams.Instance.HeightMapFromMesh;
+            if (param.SrcMesh == null)
+            {
+                GCommon.FillTexture(targetRt, Color.black);
+            }
+            else
+            {
+                try
+                {
+                    SetUp(param, targetRt);
+                    Render(param, targetRt);
+                }
+                catch (System.Exception e)
+                {
+                    Debug.Log(e);
+                }
+                finally
+                {
+                    CleanUp();
+                }
+            }
+        }
+
+        private void SetUp(GHeightMapFromMeshGeneratorParams param, RenderTexture targetRt)
+        {
+            GameObject camGo = new GameObject("~HeightMapFromMeshCamera");
+            camGo.transform.position = -Vector3.one * 5000;
+            camGo.transform.rotation = Quaternion.Euler(90, 0, 0);
+            camGo.transform.localScale = Vector3.one;
+
+            camera = camGo.AddComponent<Camera>();
+            camera.orthographic = true;
+            camera.enabled = false;
+            camera.clearFlags = CameraClearFlags.SolidColor;
+            camera.backgroundColor = Color.clear;
+            camera.nearClipPlane = 0;
+            camera.farClipPlane = param.ProjectionDepth;
+            camera.orthographicSize = DEFAULT_CAMERA_ORTHO_SIZE;
+            camera.aspect = 1;
+            camera.targetTexture = targetRt;
+
+            gameObject = new GameObject("~HeightMapFromMeshGameObjectPivot");
+            gameObject.transform.position = camGo.transform.position + param.Offset;
+            gameObject.transform.rotation = param.Rotation;
+            gameObject.transform.localScale = param.Scale;
+
+            GameObject model = new GameObject("~Model");
+            GUtilities.ResetTransform(model.transform, gameObject.transform);
+            model.transform.localPosition = -param.SrcMesh.bounds.center;
+
+            MeshFilter mf = model.AddComponent<MeshFilter>();
+            mf.sharedMesh = param.SrcMesh;
+
+            MeshRenderer mr = model.AddComponent<MeshRenderer>();
+            mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
+            mr.receiveShadows = false;
+            mr.sharedMaterials = new Material[] { GInternalMaterials.HeightMapFromMeshMaterial };
+
+        }
+
+        private void Render(GHeightMapFromMeshGeneratorParams param, RenderTexture targetRt)
+        {
+            camera.targetTexture = targetRt;
+            camera.Render();
+        }
+
+        private void CleanUp()
+        {
+            if (camera != null)
+            {
+                camera.targetTexture = null;
+                GUtilities.DestroyGameobject(camera.gameObject);
+            }
+            if (gameObject != null)
+            {
+                GUtilities.DestroyGameobject(gameObject);
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapFromMeshGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e97e0d5dfaffa8049959729278d80cd9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapFromMeshGeneratorParams.cs

@@ -0,0 +1,80 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GHeightMapFromMeshGeneratorParams
+    {
+        [SerializeField]
+        private Mesh srcMesh;
+        public Mesh SrcMesh
+        {
+            get
+            {
+                return srcMesh;
+            }
+            set
+            {
+                srcMesh = value;
+            }
+        }
+
+        [SerializeField]
+        private Vector3 offset;
+        public Vector3 Offset
+        {
+            get
+            {
+                return offset;
+            }
+            set
+            {
+                offset = value;
+            }
+        }
+
+        [SerializeField]
+        private Quaternion rotation;
+        public Quaternion Rotation
+        {
+            get
+            {
+                return rotation;
+            }
+            set
+            {
+                rotation = value;
+            }
+        }
+
+        [SerializeField]
+        private Vector3 scale;
+        public Vector3 Scale
+        {
+            get
+            {
+                return scale;
+            }
+            set
+            {
+                scale = value;
+            }
+        }
+
+        [SerializeField]
+        private float projectionDepth;
+        public float ProjectionDepth
+        {
+            get
+            {
+                return projectionDepth;
+            }
+            set
+            {
+                projectionDepth = Mathf.Max(0, value);
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapFromMeshGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 01e25bc981b863e4f894478f9ea681a1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapGenerator.cs

@@ -0,0 +1,46 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GHeightMapGenerator : IGTextureGenerator
+    {
+        public void Generate(RenderTexture targetRt)
+        {
+            GHeightMapGeneratorParams param = GTextureToolParams.Instance.HeightMap;
+            if (param.Terrain == null || param.Terrain.TerrainData == null)
+            {
+                GCommon.CopyToRT(Texture2D.blackTexture, targetRt);
+            }
+            else
+            {
+                if (param.UseRealGeometry)
+                {
+                    RenderGeometryHeightMap(param.Terrain, targetRt);
+                }
+                else
+                {
+                    RenderPixelHeightMap(param.Terrain, targetRt);
+                }
+            }
+        }
+
+        private void RenderGeometryHeightMap(GStylizedTerrain terrain, RenderTexture targetRt)
+        {
+            GGeneralParams param = GTextureToolParams.Instance.General;
+            RenderTexture rt = terrain.GetHeightMap(param.Resolution);
+            GCommon.CopyToRT(rt, targetRt);
+        }
+
+        private void RenderPixelHeightMap(GStylizedTerrain terrain, RenderTexture targetRt)
+        {
+            Texture2D source = terrain.TerrainData.Geometry.HeightMap;
+            RenderTexture.active = targetRt;
+            Material mat = GInternalMaterials.HeightmapDecodeGrayscaleMaterial;
+            mat.SetTexture("_MainTex", source);
+            Graphics.Blit(source, mat);
+            RenderTexture.active = null;
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2d864b8640b0abd4e9a03f9cd461ae3f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapGeneratorParams.cs

@@ -0,0 +1,38 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GHeightMapGeneratorParams
+    {
+        [SerializeField]
+        private GStylizedTerrain terrain;
+        public GStylizedTerrain Terrain
+        {
+            get
+            {
+                return terrain;
+            }
+            set
+            {
+                terrain = value;
+            }
+        }
+
+        [SerializeField]
+        private bool useRealGeometry;
+        public bool UseRealGeometry
+        {
+            get
+            {
+                return useRealGeometry;
+            }
+            set
+            {
+                useRealGeometry = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GHeightMapGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2b5c974351464a64f8d51732f033f48a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNoiseMapGenerator.cs

@@ -0,0 +1,40 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GNoiseMapGenerator : IGTextureGenerator
+    {
+        private static Material mat;
+        public static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.noiseMapGeneratorShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Generate(RenderTexture targetRt)
+        {
+            GNoiseMapGeneratorParams param = GTextureToolParams.Instance.Noise;
+            Generate(targetRt, param);
+        }
+
+        public void Generate(RenderTexture targetRt, GNoiseMapGeneratorParams param)
+        {
+            Mat.SetVector("_Origin", param.Origin);
+            Mat.SetFloat("_Frequency", param.Frequency);
+            Mat.SetFloat("_Lacunarity", param.Lacunarity);
+            Mat.SetFloat("_Persistence", param.Persistence);
+            Mat.SetInt("_Octaves", param.Octaves);
+            Mat.SetFloat("_Seed", param.Seed);
+
+            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, (int)param.Type);
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNoiseMapGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 311012cf6b3d1ba46b953786f308d985
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNoiseMapGeneratorParams.cs

@@ -0,0 +1,108 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GNoiseMapGeneratorParams
+    {
+        [SerializeField]
+        private GNoiseType type;
+        public GNoiseType Type
+        {
+            get
+            {
+                return type;
+            }
+            set
+            {
+                type = value;
+            }
+        }
+
+        [SerializeField]
+        private Vector2 origin;
+        public Vector2 Origin
+        {
+            get
+            {
+                return origin;
+            }
+            set
+            {
+                origin = value;
+            }
+        }
+
+        [SerializeField]
+        private float frequency;
+        public float Frequency
+        {
+            get
+            {
+                return frequency;
+            }
+            set
+            {
+                frequency = value;
+            }
+        }
+
+        [SerializeField]
+        private float laccunarity;
+        public float Lacunarity
+        {
+            get
+            {
+                return laccunarity;
+            }
+            set
+            {
+                laccunarity = Mathf.Max(1, value);
+            }
+        }
+
+        [SerializeField]
+        private float persistent;
+        public float Persistence
+        {
+            get
+            {
+                return persistent;
+            }
+            set
+            {
+                persistent = Mathf.Clamp(value, 0.01f, 1);
+            }
+        }
+
+        [SerializeField]
+        private int octaves;
+        public int Octaves
+        {
+            get
+            {
+                return octaves;
+            }
+            set
+            {
+                octaves = Mathf.Clamp(value, 1, 4);
+            }
+        }
+
+        [SerializeField]
+        private float seed;
+        public float Seed
+        {
+            get
+            {
+                return seed;
+            }
+            set
+            {
+                seed = Mathf.Max(1, value);
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNoiseMapGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 92a2e915a1760fd448f1d38a04f65b86
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNoiseType.cs

@@ -0,0 +1,9 @@
+#if GRIFFIN
+namespace Pinwheel.Griffin.TextureTool
+{
+    public enum GNoiseType
+    {
+        Perlin, Billow, Ridged, Voronoi, Value
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNoiseType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 51221aa93fed1014f967726876cd63a8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNormalMapGenerator.cs

@@ -0,0 +1,155 @@
+#if GRIFFIN
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GNormalMapGenerator : IGTextureGenerator
+    {
+        public void Generate(RenderTexture targetRt)
+        {
+            GNormalMapGeneratorParams param = GTextureToolParams.Instance.NormalMap;
+            Color defaultColor = param.Space == GNormalMapSpace.Local ? new Color(0.5f, 1, 0.5f, 1) : new Color(0.5f, 0.5f, 1, 1);
+            if (param.Terrain == null || param.Terrain.TerrainData == null)
+            {
+                GCommon.FillTexture(targetRt, defaultColor);
+            }
+            else
+            {
+                if (param.Mode == GNormalMapMode.Sharp)
+                {
+                    RenderSharpNormalMap(param, targetRt);
+                }
+                else if (param.Mode == GNormalMapMode.Interpolated)
+                {
+                    RenderInterpolatedNormalMap(param, targetRt);
+                }
+                else if (param.Mode == GNormalMapMode.PerPixel)
+                {
+                    RenderPerPixelNormalMap(param, targetRt);
+                }
+                else
+                {
+                    GCommon.FillTexture(targetRt, defaultColor);
+                }
+            }
+        }
+
+        public void RenderSharpNormalMap(GNormalMapGeneratorParams param, RenderTexture targetRt)
+        {
+            Material mat = GInternalMaterials.TerrainNormalMapRendererMaterial;
+            mat.SetInt("_TangentSpace", param.Space == GNormalMapSpace.Tangent ? 1 : 0);
+            mat.SetPass(0);
+            RenderTexture.active = targetRt;
+            GL.PushMatrix();
+            GL.LoadOrtho();
+            GL.Begin(GL.TRIANGLES);
+
+            Vector2 terrainSize = param.Terrain.Rect.size;
+            GTerrainChunk[] chunks = param.Terrain.GetChunks();
+            for (int i = 0; i < chunks.Length; ++i)
+            {
+                Vector3 chunkLocalPosition = chunks[i].transform.localPosition;
+                Mesh m = chunks[i].MeshFilterComponent.sharedMesh;
+                if (m == null)
+                    continue;
+
+                Vector3[] vertices = m.vertices;
+                Vector3[] normals = m.normals;
+
+                for (int j = 0; j < vertices.Length; ++j)
+                {
+                    //vx = uvx*sizex-posx;
+                    //vx+posx = uvx*sizex
+                    // uvx = (vx+posx)/sizex;
+                    GL.TexCoord(normals[j]);
+                    GL.Vertex3(
+                        (vertices[j].x + chunkLocalPosition.x) / terrainSize.x,
+                        (vertices[j].z + chunkLocalPosition.z) / terrainSize.y,
+                        0);
+                }
+            }
+            GL.End();
+            GL.PopMatrix();
+            RenderTexture.active = null;
+        }
+
+        public void RenderInterpolatedNormalMap(GNormalMapGeneratorParams param, RenderTexture targetRt)
+        {
+            List<Vector2> uvs = new List<Vector2>();
+            Dictionary<Vector2, Vector3> normals = new Dictionary<Vector2, Vector3>();
+            Dictionary<Vector2, int> normalsCount = new Dictionary<Vector2, int>();
+
+            Vector3 terrainSize = param.Terrain.Rect.size;
+            GTerrainChunk[] chunks = param.Terrain.GetChunks();
+            for (int i = 0; i < chunks.Length; ++i)
+            {
+                Vector3 chunkLocalPosition = chunks[i].transform.localPosition;
+                Mesh m = chunks[i].MeshFilterComponent.sharedMesh;
+                if (m == null)
+                    continue;
+
+                //Vector2[] meshUv = m.uv;
+                Vector3[] meshVertices = m.vertices;
+                Vector3[] meshNormal = m.normals;
+
+                for (int j = 0; j < meshVertices.Length; ++j)
+                {
+                    //vx = uvx*sizex-posx;
+                    //vx+posx = uvx*sizex
+                    // uvx = (vx+posx)/sizex;
+                    Vector2 meshUv = new Vector2(
+                        (meshVertices[j].x + chunkLocalPosition.x) / terrainSize.x,
+                        (meshVertices[j].z + chunkLocalPosition.z) / terrainSize.y);
+                    uvs.Add(meshUv);
+                    if (normals.ContainsKey(meshUv))
+                        normals[meshUv] += meshNormal[j];
+                    else
+                        normals[meshUv] = meshNormal[j];
+
+                    if (normalsCount.ContainsKey(meshUv))
+                        normalsCount[meshUv] += 1;
+                    else
+                        normalsCount[meshUv] = 1;
+                }
+            }
+
+            List<Vector3> smoothNormals = new List<Vector3>();
+            for (int i = 0; i < uvs.Count; ++i)
+            {
+                smoothNormals.Add(normals[uvs[i]] / normalsCount[uvs[i]]);
+            }
+
+            Material mat = GInternalMaterials.TerrainNormalMapRendererMaterial;
+            mat.SetInt("_TangentSpace", param.Space == GNormalMapSpace.Tangent ? 1 : 0);
+            mat.SetPass(0);
+            RenderTexture.active = targetRt;
+            GL.PushMatrix();
+            GL.LoadOrtho();
+            GL.Begin(GL.TRIANGLES);
+
+            for (int i = 0; i < uvs.Count; ++i)
+            {
+                GL.TexCoord(smoothNormals[i]);
+                GL.Vertex3(uvs[i].x, uvs[i].y, 0);
+            }
+
+            GL.End();
+            GL.PopMatrix();
+            RenderTexture.active = null;
+        }
+
+        public void RenderPerPixelNormalMap(GNormalMapGeneratorParams param, RenderTexture targetRt)
+        {
+            Material mat = GInternalMaterials.TerrainPerPixelNormalMapRendererMaterial;
+            mat.SetTexture("_HeightMap", param.Terrain.TerrainData.Geometry.HeightMap);
+            mat.SetFloat("_Width", param.Terrain.TerrainData.Geometry.Width);
+            mat.SetFloat("_Height", param.Terrain.TerrainData.Geometry.Height);
+            mat.SetFloat("_Length", param.Terrain.TerrainData.Geometry.Length);
+            mat.SetInt("_TangentSpace", param.Space == GNormalMapSpace.Tangent ? 1 : 0);
+
+            GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, mat, 0);
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNormalMapGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 554bd7bb888a8834eac6b5e3df07a22d
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNormalMapGeneratorParams.cs

@@ -0,0 +1,52 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GNormalMapGeneratorParams
+    {
+        [SerializeField]
+        private GStylizedTerrain terrain;
+        public GStylizedTerrain Terrain
+        {
+            get
+            {
+                return terrain;
+            }
+            set
+            {
+                terrain = value;
+            }
+        }
+
+        [SerializeField]
+        private GNormalMapMode mode;
+        public GNormalMapMode Mode
+        {
+            get
+            {
+                return mode;
+            }
+            set
+            {
+                mode = value;
+            }
+        }
+
+        [SerializeField]
+        private GNormalMapSpace space;
+        public GNormalMapSpace Space
+        {
+            get
+            {
+                return space;
+            }
+            set
+            {
+                space = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GNormalMapGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4ede717ea1ad4294fb02e7b561956346
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GSteepnessMapGenerator.cs

@@ -0,0 +1,59 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public class GSteepnessMapGenerator : IGTextureGenerator
+    {
+        private static Material mat;
+        private static Material Mat
+        {
+            get
+            {
+                if (mat == null)
+                {
+                    mat = new Material(GRuntimeSettings.Instance.internalShaders.steepnessMapGeneratorShader);
+                }
+                return mat;
+            }
+        }
+
+        public void Generate(RenderTexture targetRt)
+        {
+            GSteepnessMapGeneratorParams param = GTextureToolParams.Instance.Steepness;
+            if (param.Terrain == null || param.Terrain.TerrainData == null)
+            {
+                GCommon.FillTexture(targetRt, Color.clear);
+            }
+            else
+            {
+                GNormalMapGeneratorParams normalMapParam = new GNormalMapGeneratorParams();
+                normalMapParam.Terrain = param.Terrain;
+                normalMapParam.Space = GNormalMapSpace.Local;
+                normalMapParam.Mode = param.Mode;
+
+                RenderTexture normalMap = new RenderTexture(targetRt);
+                GNormalMapGenerator gen = new GNormalMapGenerator();
+                if (param.Mode == GNormalMapMode.Sharp)
+                {
+                    gen.RenderSharpNormalMap(normalMapParam, normalMap);
+                }
+                else if (param.Mode == GNormalMapMode.Interpolated)
+                {
+                    gen.RenderInterpolatedNormalMap(normalMapParam, normalMap);
+                }
+                else if (param.Mode == GNormalMapMode.PerPixel)
+                {
+                    gen.RenderPerPixelNormalMap(normalMapParam, normalMap);
+                }
+
+                Mat.SetTexture("_BumpMap", normalMap);
+                GCommon.DrawQuad(targetRt, GCommon.FullRectUvPoints, Mat, 0);
+
+                normalMap.Release();
+                GUtilities.DestroyObject(normalMap);
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GSteepnessMapGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a17c4e821e925604d82720f7bac0b629
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GSteepnessMapGeneratorParams.cs

@@ -0,0 +1,38 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    [System.Serializable]
+    public struct GSteepnessMapGeneratorParams
+    {
+        [SerializeField]
+        private GStylizedTerrain terrain;
+        public GStylizedTerrain Terrain
+        {
+            get
+            {
+                return terrain;
+            }
+            set
+            {
+                terrain = value;
+            }
+        }
+
+        [SerializeField]
+        private GNormalMapMode mode;
+        public GNormalMapMode Mode
+        {
+            get
+            {
+                return mode;
+            }
+            set
+            {
+                mode = value;
+            }
+        }
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GSteepnessMapGeneratorParams.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e9ab69cfdc7f9594daa69f87341fe5c4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GTextureGenerationMode.cs

@@ -0,0 +1,16 @@
+#if GRIFFIN
+namespace Pinwheel.Griffin.TextureTool
+{
+    public enum GTextureGenerationMode
+    {
+        HeightMap,
+        HeightMapFromMesh,
+        NormalMap,
+        SteepnessMap,
+        NoiseMap,
+        ColorMap,
+        BlendMap,
+        FoliageDistributionMap
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/GTextureGenerationMode.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 99aec3143b31a574499a4c3c4868c6bc
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/IGTextureGenerator.cs

@@ -0,0 +1,11 @@
+#if GRIFFIN
+using UnityEngine;
+
+namespace Pinwheel.Griffin.TextureTool
+{
+    public interface IGTextureGenerator
+    {
+        void Generate(RenderTexture targetRt);
+    }
+}
+#endif

Assets/Polaris - Low Poly Ecosystem/Polaris - Low Poly Terrain Engine/Runtime/Scripts/TextureTool/Generators/IGTextureGenerator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 297212eae94fced458d9d5be2cb4483c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: