添加了更多的材质函数，部分与引擎新特性重合，这是为了能够脱离引擎在多个版本中更具可移植性。

添加了多种对程序流程控制与保全的脚本，而且现在可以更快速的构建一个具有线性关系的协程了。
  添加了一个支持多种模式的单维梯度控制器，类似unity的颜色梯度类型。
  添加了一个用于看向某个物体的旋转控制器。
  添加了一个加载宏。
  完善了批处理脚本流程。

CHANGELOG.md

@@ -1,11 +1,32 @@
 # Changelog
-All notable changes to this package will be documented in this file.
 
-The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+### future
-and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-## [0.1.0] - 2023-08-26
+### 0.2.4
+  添加了更多的材质函数，部分与引擎新特性重合，这是为了能够脱离引擎在多个版本中更具可移植性。
+  添加了多种对程序流程控制与保全的脚本，而且现在可以更快速的构建一个具有线性关系的协程了。
+  添加了一个支持多种模式的单维梯度控制器，类似unity的颜色梯度类型。
+  添加了一个用于看向某个物体的旋转控制器。
+  添加了一个加载宏。
+  完善了批处理脚本流程。
 
-### This is the first release of *\<Xeric Library\>*.
+### 0.2.2
+  添加编辑器阶段快捷生成、移除脚本
+  添加基本几何体拼接算法
+  添加线性变换目标类型，类似多种颜色设置功能
+  添加一些基本的shader函数，用于计算二维圆形，二维旋转等。
+  
+### 0.2.1
+  修改：事件扩展 InvokeConservative 从ExtendType类中移到了MacroEvent
 
-*Short description of this release*
+### 0.1.1
+  添加对象宏：组件查找，关系判断  
+  添加事件宏：事件调用  
+  添加数学宏：值循环与类型扩展  
+  添加枚举宏：枚举扩展  
+  添加字符宏：字符功能扩展  
+  移植弱类型：用于统一类型的判断，提供编号功能  
+  移植特性宏：重命名  
+
+### 0.1.0
+  建立一些快捷的数学宏，数学算法，数学常数；

README.md

@@ -2,26 +2,7 @@
 
 提供一些快捷方法。
 
-#### 版本
 
-* new   
-  添加编辑器阶段快捷生成、移除脚本
-  添加基本几何体拼接算法
-
-* 0.2.1
-  修改：事件扩展 InvokeConservative 从ExtendType类中移到了MacroEvent
-
-* 0.1.1
-  添加对象宏：组件查找，关系判断  
-  添加事件宏：事件调用  
-  添加数学宏：值循环与类型扩展  
-  添加枚举宏：枚举扩展  
-  添加字符宏：字符功能扩展  
-  移植弱类型：用于统一类型的判断，提供编号功能  
-  移植特性宏：重命名  
-
-* 0.1.0
-  建立一些快捷的数学宏，数学算法，数学常数；
 
 
 

Runtime/CustomDrawer/GroupAttribute.cs

@@ -0,0 +1,55 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+
+using UnityEditor;
+
+using UnityEngine;
+
+using static UnityEngine.GraphicsBuffer;
+
+namespace XericLibrary.Runtime.CustomDrawer
+{
+    public class GroupAttribute : PropertyAttribute
+    {
+		public string group;
+
+		public GroupAttribute(string groupName)
+		{
+			group = groupName;
+		}
+	}
+
+
+	/// <summary>
+	/// ʹÓ÷Ö×鹦ÄܵÄʾÀý
+	/// </summary>
+	//[CustomEditor(typeof(GroupAttribute))]
+	public class GroupExampleEditor : Editor
+	{
+		public override void OnInspectorGUI()
+		{
+			base.OnInspectorGUI();
+
+			//ShowGroupInspector(target);
+		}
+
+		public static void ShowGroupInspector(Editor editor, object target)
+		{
+			// Iterate through the fields
+			foreach(var field in target.GetType().GetFields())
+			{
+				var groupAttribute = field.GetCustomAttribute<GroupAttribute>();
+				if(groupAttribute != null)
+				{
+					EditorGUILayout.Space();
+					EditorGUILayout.LabelField(groupAttribute.group, EditorStyles.boldLabel);
+				}
+
+				EditorGUILayout.PropertyField(editor.serializedObject.FindProperty(field.Name), true);
+			}
+
+			editor.serializedObject.ApplyModifiedProperties();
+		}
+	}
+}

Runtime/CustomDrawer/GroupAttribute.cs.meta

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

Runtime/Lrss3.XericLibrary.asmdef

@@ -1,6 +1,6 @@
 {
     "name": "Lrss3.XericLibrary",
-    "rootNamespace": "",
+    "rootNamespace": "XericLibrary",
     "references": [],
     "includePlatforms": [],
     "excludePlatforms": [],

Runtime/MicroLibrary/MacroList.cs

@@ -145,5 +145,7 @@ namespace XericLibrary.Runtime.MacroLibrary
 		}
 
 		#endregion
+
+
 	}
 }

Runtime/MicroLibrary/MacroMath.cs

@@ -14,7 +14,72 @@ namespace XericLibrary.Runtime.MacroLibrary
     public static partial class MacroMath
     {
 		#region 随机
-		
+
+		/// <summary>
+		/// 获取一个被特定随机数填充的矩阵，这通常是无意义的
+		/// </summary>
+		/// <param name="vec"></param>
+		/// <returns></returns>
+		public static Matrix4x4 RandomMatrix4(float range)
+		{
+			return new Matrix4x4(
+				RandomVector4(range), 
+				RandomVector4(range), 
+				RandomVector4(range), 
+				RandomVector4(range));
+		}
+
+		/// <summary>
+		/// 获取一个在指定坐标范围内的随机矢量(矩形范围)
+		/// </summary>
+		/// <param name="vec"></param>
+		/// <returns></returns>
+		public static Vector4 RandomVector4(float range)
+		{
+			var rand = new System.Random();
+			range *= 100;
+			Func<float> GetNextRand = () =>
+			{
+				return rand.Next((int)-range, (int)range) * 0.01f;
+			};
+
+			return new Vector4(GetNextRand(), GetNextRand(), GetNextRand(), GetNextRand());
+		}
+
+		/// <summary>
+		/// 获取一个在指定坐标范围内的随机矢量(矩形范围)
+		/// </summary>
+		/// <param name="vec"></param>
+		/// <returns></returns>
+		public static Vector3 RandomVector3(float range)
+		{
+			var rand = new System.Random();
+			range *= 100;
+			Func<float> GetNextRand = () =>
+			{
+				return rand.Next((int)-range, (int)range) * 0.01f;
+			};
+
+			return new Vector3(GetNextRand(), GetNextRand(), GetNextRand());
+		}
+
+		/// <summary>
+		/// 获取一个在指定坐标范围内的随机矢量(矩形范围)
+		/// </summary>
+		/// <param name="vec"></param>
+		/// <returns></returns>
+		public static Vector2 RandomVector2(float range)
+		{
+			var rand = new System.Random();
+			range *= 100;
+			Func<float> GetNextRand = () =>
+			{
+				return rand.Next((int)-range, (int)range) * 0.01f;
+			};
+
+			return new Vector2(GetNextRand(), GetNextRand());
+		}
+
 		/// <summary>
 		/// 哈希后处理
 		/// </summary>
@@ -85,11 +150,22 @@ namespace XericLibrary.Runtime.MacroLibrary
 				return z;
 		}
 
-
+		/// <summary>
+		/// 获取两者的最小值，但不包括负数；
+		/// </summary>
+		/// <param name="a"></param>
+		/// <param name="b"></param>
+		/// <returns></returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static float MinPositive(float a, float b)
 			=> Math.Min(Math.Max(0, a), Math.Max(0, b));
 
+		/// <summary>
+		/// 获取两者的最小值，但不包括负数；
+		/// </summary>
+		/// <param name="a"></param>
+		/// <param name="b"></param>
+		/// <returns></returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static int MinPositive(int a, int b)
 			=> Math.Min(Math.Max(0, a), Math.Max(0, b));
@@ -162,7 +238,5 @@ namespace XericLibrary.Runtime.MacroLibrary
 
 		#endregion
 
-
-
 	}
 }

Runtime/MicroLibrary/MacroResources.cs

@@ -0,0 +1,108 @@
+#define _DEBUG_
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+using UnityEngine;
+
+namespace XericLibrary.Runtime.MacroLibrary
+{
+	/// <summary>
+	/// 加载宏
+	/// </summary>
+	public static class MacroResources
+	{
+		#region 字段属性
+
+		public static readonly Dictionary<string, string> FilePathName = new ()
+		{
+		// 图片
+		{ "Sprite","Sprite" },
+		{ "Texture2D","Sprite" },
+		// 声音
+		{ "Audio","Audio"},
+		// 字体
+		{ "Font","Font"},
+		// 脚本
+		{ "MonoBehaviour","Script"},
+		// 脚本
+		{ "RuntimeAnimatorController","Animation"},
+		// 材质
+		{ "PhysicMaterial","Material"},
+		{ "Material","Material"},
+		{ "Shader","Material"},
+		// 模型
+		{ "Mesh","Mesh"},
+		// 预制体
+		{ "GameObject","Prefab"},
+		// 场景
+		{ "Scene","Scene"},
+		};
+
+		private static System.Type CacheType;
+
+		private static UnityEngine.Object[] ResourceCache;
+
+		#endregion
+
+		#region 加载方法
+
+		/// <summary>
+		/// 获取一个类型应该存在的根路径
+		/// </summary>
+		/// <param name="type"></param>
+		/// <param name="path"></param>
+		/// <returns></returns>
+		public static bool GetFileRootPath(System.Type type, out string path)
+		{
+			var name = type.Name;
+
+			if(FilePathName.TryGetValue(name, out path))
+				return true;
+#if _DEBUG_
+			Debug.LogError($"在Resources中加载{name}时并未找到一个有效的根路径");
+#endif
+			return false;
+		}
+
+		/// <summary>
+		/// 获取一个类型应该存在的根路径
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="path"></param>
+		/// <returns></returns>
+		public static bool GetFileRootPath<T>(out string path)
+		{
+			return GetFileRootPath(typeof(T), out path);
+		}
+
+		/// <summary>
+		/// 加载一个给定名称的特定文件类型的文件
+		/// </summary>
+		/// <typeparam name="T"></typeparam>
+		/// <param name="fileName"></param>
+		/// <returns></returns>
+		public static bool LoadFile<T>(this string fileName, out T result)
+		where T : UnityEngine.Object
+		{
+			var type = typeof(T);
+			if(!GetFileRootPath(type, out var path))
+			{
+				result = null;
+				return false;
+			}
+			if(CacheType != type)
+			{
+				CacheType = type;
+				ResourceCache = Resources.LoadAll<T>(path);
+			}
+			result = ResourceCache.FirstOrDefault(a => a.name == fileName) as T;
+			return result != null;
+		}
+
+		#endregion
+
+	}
+}

Runtime/MicroLibrary/MacroResources.cs.meta

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

Runtime/MicroLibrary/MacroSmooth.cs

@@ -0,0 +1,363 @@
+using Codice.Client.BaseCommands.BranchExplorer;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using XericLibrary.Runtime.Type;
+
+namespace XericLibrary.Runtime.MacroLibrary
+{
+	/// <summary>
+	/// 平滑宏
+	/// </summary>
+	public static partial class MacroSmooth
+	{
+		#region y=f(x)
+
+		public static double Linear(double k)
+		{
+			return k;
+		}
+		public static double QuadraticIn(double k)
+		{
+			return k * k;
+		}
+		public static double QuadraticOut(double k)
+		{
+			return k * (2 - k);
+		}
+		public static double QuadraticInOut(double k)
+		{
+			if((k *= 2) < 1)
+			{
+				return 0.5 * k * k;
+			}
+			return -0.5 * (--k * (k - 2) - 1);
+		}
+		public static double CubicIn(double k)
+		{
+			return k * k * k;
+		}
+		public static double CubicOut(double k)
+		{
+			return --k * k * k + 1;
+		}
+		public static double CubicInOut(double k)
+		{
+			if((k *= 2) < 1)
+			{
+				return 0.5 * k * k * k;
+			}
+			return 0.5 * ((k -= 2) * k * k + 2);
+		}
+		public static double QuarticIn(double k)
+		{
+			return k * k * k * k;
+		}
+		public static double QuarticOut(double k)
+		{
+			return 1 - --k * k * k * k;
+		}
+		public static double QuarticInOut(double k)
+		{
+			if((k *= 2) < 1)
+			{
+				return 0.5 * k * k * k * k;
+			}
+			return -0.5 * ((k -= 2) * k * k * k - 2);
+		}
+		public static double QuinticIn(double k)
+		{
+			return k * k * k * k * k;
+		}
+		public static double QuinticOut(double k)
+		{
+			return --k * k * k * k * k + 1;
+		}
+		public static double QuinticInOut(double k)
+		{
+			if((k *= 2) < 1)
+			{
+				return 0.5 * k * k * k * k * k;
+			}
+			return 0.5 * ((k -= 2) * k * k * k * k + 2);
+		}
+		public static double SinusoidalIn(double k)
+		{
+			return 1 - Math.Cos((k * Math.PI) / 2);
+		}
+		public static double SinusoidalOut(double k)
+		{
+			return Math.Sin((k * Math.PI) / 2);
+		}
+		public static double SinusoidalInOut(double k)
+		{
+			return 0.5 * (1 - Math.Cos(Math.PI * k));
+		}
+		public static double ExponentialIn(double k)
+		{
+			return k == 0 ? 0 : Math.Pow(1024, k - 1);
+		}
+		public static double ExponentialOut(double k)
+		{
+			return k == 1 ? 1 : 1 - Math.Pow(2, -10 * k);
+		}
+		public static double ExponentialInOut(double k)
+		{
+			if(k == 0)
+			{
+				return 0;
+			}
+			if(k == 1)
+			{
+				return 1;
+			}
+			if((k *= 2) < 1)
+			{
+				return 0.5 * Math.Pow(1024, k - 1);
+			}
+			return 0.5 * (-Math.Pow(2, -10 * (k - 1)) + 2);
+		}
+		public static double CircularIn(double k)
+		{
+			return 1 - Math.Sqrt(1 - k * k);
+		}
+		public static double CircularOut(double k)
+		{
+			return Math.Sqrt(1 - --k * k);
+		}
+		public static double CircularInOut(double k)
+		{
+			if((k *= 2) < 1)
+			{
+				return -0.5 * (Math.Sqrt(1 - k * k) - 1);
+			}
+			return 0.5 * (Math.Sqrt(1 - (k -= 2) * k) + 1);
+		}
+		public static double ElasticIn(double k)
+		{
+			double s;
+			var a = 0.1;
+			var p = 0.4;
+			if(k == 0)
+			{
+				return 0;
+			}
+			if(k == 1)
+			{
+				return 1;
+			}
+			if(a != 0 || a < 1)
+			{
+				a = 1;
+				s = p / 4;
+			}
+			else
+			{
+				s = (p * Math.Asin(1 / a)) / (2 * Math.PI);
+			}
+			return -(
+			  a *
+			  Math.Pow(2, 10 * (k -= 1)) *
+			  Math.Sin(((k - s) * (2 * Math.PI)) / p)
+			);
+		}
+		public static double ElasticOut(double k)
+		{
+			double s;
+			var a = 0.1;
+			var p = 0.4;
+			if(k == 0)
+			{
+				return 0;
+			}
+			if(k == 1)
+			{
+				return 1;
+			}
+			if(a != 0 || a < 1)
+			{
+				a = 1;
+				s = p / 4;
+			}
+			else
+			{
+				s = (p * Math.Asin(1 / a)) / (2 * Math.PI);
+			}
+			return (
+			  a * Math.Pow(2, -10 * k) * Math.Sin(((k - s) * (2 * Math.PI)) / p) + 1
+			);
+		}
+		public static double ElasticInOut(double k)
+		{
+			double s;
+			var a = 0.1;
+			var p = 0.4;
+			if(k == 0)
+			{
+				return 0;
+			}
+			if(k == 1)
+			{
+				return 1;
+			}
+			if(a != 0 || a < 1)
+			{
+				a = 1;
+				s = p / 4;
+			}
+			else
+			{
+				s = (p * Math.Asin(1 / a)) / (2 * Math.PI);
+			}
+			if((k *= 2) < 1)
+			{
+				return (
+				  -0.5 *
+				  (a *
+					Math.Pow(2, 10 * (k -= 1)) *
+					Math.Sin(((k - s) * (2 * Math.PI)) / p))
+				);
+			}
+			return (
+			  a *
+				Math.Pow(2, -10 * (k -= 1)) *
+				Math.Sin(((k - s) * (2 * Math.PI)) / p) *
+				0.5 +
+			  1
+			);
+		}
+		// 在某一动画开始沿指示的路径进行动画处理前稍稍收回该动画的移动
+		public static double BackIn(double k)
+		{
+			var s = 1.70158;
+			return k * k * ((s + 1) * k - s);
+		}
+		public static double BackOut(double k)
+		{
+			var s = 1.70158;
+			return --k * k * ((s + 1) * k + s) + 1;
+		}
+		public static double BackInOut(double k)
+		{
+			var s = 1.70158 * 1.525;
+			if((k *= 2) < 1)
+			{
+				return 0.5 * (k * k * ((s + 1) * k - s));
+			}
+			return 0.5 * ((k -= 2) * k * ((s + 1) * k + s) + 2);
+		}
+		public static double BounceIn(double k)
+		{
+			return 1 - BounceOut(1 - k);
+		}
+		public static double BounceOut(double k)
+		{
+			if(k < 1 / 2.75)
+			{
+				return 7.5625 * k * k;
+			}
+			else if(k < 2 / 2.75)
+			{
+				return 7.5625 * (k -= 1.5 / 2.75) * k + 0.75;
+			}
+			else if(k < 2.5 / 2.75)
+			{
+				return 7.5625 * (k -= 2.25 / 2.75) * k + 0.9375;
+			}
+			else
+			{
+				return 7.5625 * (k -= 2.625 / 2.75) * k + 0.984375;
+			}
+		}
+		public static double BounceInOut(double k)
+		{
+			if(k < 0.5)
+			{
+				return BounceIn(k * 2) * 0.5;
+			}
+			return BounceIn(k * 2 - 1) * 0.5 + 0.5;
+		}
+
+		#endregion
+
+		#region 多函数一站式解决
+
+		/// <summary>
+		/// 切换缓动模式
+		/// </summary>
+		/// <param name="k"></param>
+		/// <param name="mode"></param>
+		/// <returns></returns>
+		public static double SwitchEasing(this double k, EasingMode mode)
+		{
+			switch(mode)
+			{
+				default:
+				case EasingMode.Linear:
+				return Linear(k);
+				case EasingMode.QuadraticIn:
+				return QuadraticIn(k);
+				case EasingMode.QuadraticOut:
+				return QuadraticOut(k);
+				case EasingMode.QuadraticInOut:
+				return QuadraticInOut(k);
+				case EasingMode.CubicIn:
+				return CubicIn(k);
+				case EasingMode.CubicOut:
+				return CubicOut(k);
+				case EasingMode.CubicInOut:
+				return CubicInOut(k);
+				case EasingMode.QuarticIn:
+				return QuarticIn(k);
+				case EasingMode.QuarticOut:
+				return QuarticOut(k);
+				case EasingMode.QuarticInOut:
+				return QuarticInOut(k);
+				case EasingMode.QuinticIn:
+				return QuinticIn(k);
+				case EasingMode.QuinticOut:
+				return QuinticOut(k);
+				case EasingMode.QuinticInOut:
+				return QuinticInOut(k);
+				case EasingMode.SinusoidalIn:
+				return SinusoidalIn(k);
+				case EasingMode.SinusoidalOut:
+				return SinusoidalOut(k);
+				case EasingMode.SinusoidalInOut:
+				return SinusoidalInOut(k);
+				case EasingMode.ExponentialIn:
+				return ExponentialIn(k);
+				case EasingMode.ExponentialOut:
+				return ExponentialOut(k);
+				case EasingMode.ExponentialInOut:
+				return ExponentialInOut(k);
+				case EasingMode.CircularIn:
+				return CircularIn(k);
+				case EasingMode.CircularOut:
+				return CircularOut(k);
+				case EasingMode.CircularInOut:
+				return CircularInOut(k);
+				case EasingMode.ElasticIn:
+				return ElasticIn(k);
+				case EasingMode.ElasticOut:
+				return ElasticOut(k);
+				case EasingMode.ElasticInOut:
+				return ElasticInOut(k);
+				case EasingMode.BackIn:
+				return BackIn(k);
+				case EasingMode.BounceIn:
+				return BounceIn(k);
+				case EasingMode.BounceOut:
+				return BounceOut(k);
+				case EasingMode.BounceInOut:
+				return BounceInOut(k);
+			}
+		}
+
+		#endregion
+
+	}
+}

Runtime/MicroLibrary/MacroSmooth.cs.meta

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

Runtime/MicroLibrary/MacroString.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Globalization;
@@ -9,8 +10,7 @@ namespace XericLibrary.Runtime.MacroLibrary
 {
 	public static partial class MacroMath
 	{
-
+		#region 名称文本
-		#region 文本
 
 		/// <summary>
 		/// 获取此处的物体名称，如果带有（clone）后缀，则省略这个后缀
@@ -39,6 +39,28 @@ namespace XericLibrary.Runtime.MacroLibrary
 
 		#endregion
 
+		#region 转文本
+
+		/// <summary>
+		/// 将一个数值四舍五入后转为一个文本，并保留特定的小数点位，如果这个小数位为0则省略不写
+		/// </summary>
+		/// <param name="value"></param>
+		/// <param name="decimals">目标小数位</param>
+		/// <returns></returns>
+		public static string RoundToString(this double value, int decimals)
+		{
+			if(value == 0)
+				return "0";
+			return Math.Round(value, decimals).ToString();
+		}
+
+		public static string RoundToString(this float value, int decimals)
+		{
+			return ((double)value).RoundToString(decimals);
+		}
+
+		#endregion
+
 		#region 区域与语言
 
 #if false

Runtime/MicroLibrary/MacroVector3.cs

@@ -0,0 +1,40 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XericLibrary.Runtime.MacroLibrary
+{
+    /// <summary>
+    /// 矢量宏库
+    /// </summary>
+    [Obsolete("与扩展库放在一起，不要单独出现")]
+	public static class MacroVector3
+    {
+		/// <summary>
+		/// 获取与世界正交轴最近的一条轴线
+		/// </summary>
+		/// <param name="vector"></param>
+		/// <returns></returns>
+		
+		public static Vector3 GetWorldNormalAxis(Vector3 vector)
+		{
+			Vector3[] axes = { Vector3.right, Vector3.up, Vector3.forward };
+			float minAngle = float.MaxValue;
+			Vector3 minAngleAxis = Vector3.zero;
+
+			foreach(Vector3 axis in axes)
+			{
+				float dot = Vector3.Dot(vector, axis);
+				float angle = Mathf.Abs(dot);
+				if(angle < minAngle)
+				{
+					minAngle = angle;
+					minAngleAxis = axis * Mathf.Sign(dot);
+				}
+			}
+
+			return minAngleAxis;
+		}
+	}
+}

Runtime/MicroLibrary/MacroVector3.cs.meta

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

Runtime/MicroLibrary/Vector3Extend.cs

@@ -9,6 +9,8 @@ namespace XericLibrary.Runtime.MacroLibrary
 {
     public static class Vector3Extend
     {
+		#region 四则运算
+
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static Vector3 Add(this Vector3 a, Vector3 b)
 			=> new Vector3(
@@ -105,6 +107,9 @@ namespace XericLibrary.Runtime.MacroLibrary
 			a.z / b
 			);
 
+		#endregion
+
+		#region 扩展运算
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static Vector3 Xonly(this Vector3 a)
@@ -174,6 +179,9 @@ namespace XericLibrary.Runtime.MacroLibrary
 		public static Vector3 Floor(this Vector3 vec)
 			=> new Vector3((int)vec.x, (int)vec.y, (int)vec.z);
 
+		#endregion
+
+		#region 高级运算
 
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static Vector3 Min(this Vector3 a, Vector3 b)
@@ -242,6 +250,9 @@ namespace XericLibrary.Runtime.MacroLibrary
 			return result;
 		}
 
+		#endregion
+
+		#region 特殊运算
 
 		/// <summary>
 		/// 将这个向量投影到一个给定坐标的向上的平面上，同时变换到平面坐标
@@ -294,11 +305,37 @@ namespace XericLibrary.Runtime.MacroLibrary
 		/// <returns></returns>
 		[MethodImpl(MethodImplOptions.AggressiveInlining)]
 		public static Vector3 Orthogonalization(this Vector3 vec)
-			=> new Vector3(
+		{
-			(float)Math.Round(vec.x),
+			Vector3[] axes = { Vector3.right, Vector3.up, Vector3.forward };
-			(float)Math.Round(vec.y),
+			float minAngle = float.MaxValue;
-			(float)Math.Round(vec.z)
+			Vector3 minAngleAxis = Vector3.zero;
-			);
+
+			foreach(Vector3 axis in axes)
+			{
+				float dot = Vector3.Dot(vec, axis);
+				float angle = Mathf.Abs(dot);
+				if(angle < minAngle)
+				{
+					minAngle = angle;
+					minAngleAxis = axis * Mathf.Sign(dot);
+				}
+			}
+
+			return minAngleAxis;
+		}
+
+		/// <summary>
+		/// 获取与世界正交轴最近的一条轴线
+		/// </summary>
+		/// <param name="vector"></param>
+		/// <returns></returns>
+		[Obsolete("可以使用Orthogonalization代替")]
+		public static Vector3 GetWorldNormalAxis(this Vector3 vec)
+		{
+			return vec.Orthogonalization();
+		}
+
+		#endregion
 
 	}
 

Runtime/Security/ProgramFlowLinear.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using XericLibrary.Runtime.Type;
+
+namespace XericLibrary
+{
+	/// <summary>
+	/// 线性处理流程
+	/// </summary>
+    public class ProgramFlowLinear : WeaklyObject
+    {
+		#region 委托事件
+
+		/// <summary>
+		/// 恢复待执行事件列表
+		/// </summary>
+		public event Action RecoveredCoroutineList;
+
+		#endregion
+
+		#region 字段属性
+
+		/// <summary>
+		/// 设定是否循环处理所有协程
+		/// </summary>
+		public bool LoopProgramFlow
+		{
+			get => loopProgramFlow;
+			set
+			{
+				if(TargetEvent == null)
+					loopProgramFlow = value;
+				else
+					Debug.LogError("不允许在协程运行中进行处理流程模式的切换");
+			}
+		}
+
+		/// <summary>
+		/// 循环处理所有协程
+		/// </summary>
+		private bool loopProgramFlow = true;
+
+		/// <summary>
+		/// 最大执行计数
+		/// </summary>
+		public int MaxEmbeddedLoopCount = 100;
+
+		/// <summary>
+		/// 当前协程内执行流程计数
+		/// </summary>
+		private int embeddedLoopCount = 0;
+
+		/// <summary>
+		/// 等待执行的协程
+		/// </summary>
+		private LinkedList<IEnumerator> routines = new LinkedList<IEnumerator>();
+
+		/// <summary>
+		/// 当前执行的协程
+		/// </summary>
+		private Coroutine TargetEvent;
+
+		/// <summary>
+		/// 持久担保者
+		/// </summary>
+		private MonoBehaviour assure;
+
+		/// <summary>
+		/// 第一次执行
+		/// </summary>
+		private bool firstTime = true;
+
+		#endregion
+
+		/// <summary>
+		/// 线性协程处理器，将一系列协程进行线性处理；
+		/// </summary>
+		/// <param name="recoveredListTodo">将添加协程的过程进行定义</param>
+		/// <param name="assure">协程处理的担保脚本</param>
+		/// <param name="executeImmediately">在定义完成后立即执行协程</param>
+		/// <param name="loopProgram">设定协程循环执行，如果不循环则需要手动调用start方法</param>
+		public ProgramFlowLinear(Action recoveredListTodo, MonoBehaviour assure, bool executeImmediately = true, bool loopProgram = true)
+		{
+			RecoveredCoroutineList = recoveredListTodo;
+			this.loopProgramFlow = loopProgram;
+			firstTime = true;
+			if(executeImmediately)
+				StartCoroutine();
+		}
+
+		#region 方法
+
+		/// <summary>
+		/// 添加待处理协程
+		/// </summary>
+		/// <param name="routine"></param>
+		public void AddCoroutine(IEnumerator routine)
+		{
+			routines.AddLast(routine);
+		}
+
+		/// <summary>
+		/// 协程！启动！
+		/// </summary>
+		public void StartCoroutine()
+		{
+			if(TargetEvent == null)
+			{
+				if(firstTime && routines.Count <= 0)
+					RecoveredCoroutineList();
+				if(routines.Count <= 0)
+				{
+					Debug.LogError("协程步骤为空，可能是并非初始，或复位栈为空");
+					return;
+				}
+				TargetEvent = assure.StartCoroutine(routines.First.Value);
+
+				routines.RemoveFirst();
+				firstTime = false;
+			}
+		}
+
+		/// <summary>
+		/// 执行下一个协程
+		/// </summary>
+		public void NextCoroutine()
+		{
+			if(loopProgramFlow && routines.Count <= 0)
+				RecoveredCoroutineList();
+			if(TargetEvent != null)
+				TargetEvent = null;
+			else
+				Debug.LogError("执行的协程步骤来自初始？");
+			StartCoroutine();
+		}
+
+		/// <summary>
+		/// 尝试增加协程执行计数，当计数超越预设范围后将提示停止协程
+		/// </summary>
+		public bool TryPromoteEmbedded()
+		{
+			if(++embeddedLoopCount > MaxEmbeddedLoopCount)
+			{
+				embeddedLoopCount = 0;
+				return true;
+			}
+			return false;
+		}
+
+
+		#endregion
+
+	}
+}

Runtime/Security/ProgramFlowLinear.cs.meta

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

Runtime/Security/ProgramFlowSecurity.cs

@@ -1,26 +1,29 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Linq;
+
 using UnityEngine;
 
 using XericLibrary.Runtime.Type;
 
 namespace XericLibrary.Runtime.Security
 {
-    /// <summary>
+	/// <summary>
-    /// 程序流程保全
+	/// 基本的保全调用方法；
-    /// </summary>
+	/// 需要手动在委托的前后安置保全标识
+	/// </summary>
     public class ProgramFlowSecurity : WeaklyObject
-    {
+	{
-		#region 字段属性
+		#region 字段属性 
 
 		/// <summary>
-		/// 保护标志位
+		/// 外部保护标志位
 		/// </summary>
 		private int conservativeFlag;
 
 		/// <summary>
-		/// 单步标志位
+		/// 外部单步标志位
 		/// </summary>
 		private int DoOnceFlag;
 
@@ -36,7 +39,7 @@ namespace XericLibrary.Runtime.Security
 
 		#endregion
 
-		#region 方法
+		#region 外部方法
 
 		/// <summary>
 		/// 标志一段程序的开始
@@ -131,4 +134,4 @@ namespace XericLibrary.Runtime.Security
 
 		#endregion
 	}
-}
+}

Runtime/Security/ProgramFlowSecurity.cs.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: a7fec265b4bc05249b53e040d279b079
+guid: 3aa1a126b33b746438d102310ab9e983
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Runtime/Security/ProgramFlowSecurityExtend.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+using UnityEngine;
+
+using XericLibrary.Runtime.Type;
+
+namespace XericLibrary.Runtime.Security
+{
+    /// <summary>
+    /// 程序流程保全
+    /// </summary>
+    public class ProgramFlowSecurityExtend : WeaklyObject
+    {
+		#region 字段属性
+
+		/// <summary>
+		/// 可扩展事件
+		/// </summary>
+		public event Action ExtensibleDelegation
+		{
+			add
+			{
+				if(!DelegateContains(value))
+					DelegateAdd(value);
+			}
+			remove
+			{
+				DelegateRemove(value);
+			}
+		}
+
+		/// <summary>
+		/// 事件列表
+		/// </summary>
+		private List<DelegateExtensibleFlag> delegateList;
+
+		#endregion
+
+		#region 类内类
+
+		/// <summary>
+		/// 事件扩展标识
+		/// </summary>
+		public class DelegateExtensibleFlag
+		{
+			/// <summary>
+			/// 事件
+			/// </summary>
+			public Action Event;
+			/// <summary>
+			/// 单步执行
+			/// </summary>
+			public bool Doonce;
+			/// <summary>
+			/// 调用保护
+			/// </summary>
+			public bool Conservate;
+
+			public DelegateExtensibleFlag(Action action, bool doonce = false)
+			{
+				this.Event = action;
+				this.Doonce = doonce;
+				this.Conservate = false;
+			}
+
+			public override bool Equals(object obj)
+			{
+				if(obj is DelegateExtensibleFlag def)
+					return def.Event == this.Event;
+
+				return false;
+			}
+
+			public override int GetHashCode()
+			{
+				return Event.GetHashCode();
+			}
+		}
+
+		public DelegateExtensibleFlag DelegateFind(Action action)
+		{
+			return delegateList
+			.Where(a => a.Event == action)
+			.FirstOrDefault();
+		}
+
+		public bool DelegateContains(Action action)
+		{
+			return DelegateFind(action) == null;
+		}
+
+		public void DelegateAdd(Action action, bool doonce = false)
+		{
+			delegateList.Add(new DelegateExtensibleFlag(action, doonce));
+		}
+
+		public bool DelegateRemove(Action action)
+		{
+			return delegateList.Remove(new DelegateExtensibleFlag(action));
+		}
+
+		#endregion
+
+		#region 构造
+
+		public ProgramFlowSecurityExtend()
+		{
+			
+		}
+
+		#endregion
+
+		#region 主要流程
+
+		/// <summary>
+		/// 调用所有的已注册扩展事件，注意：这会比使用繁琐的外部方法更慢。
+		/// </summary>
+		public void InvokedAllDelegate()
+		{
+			for(int i = 0; i < delegateList.Count; i++)
+			{
+				if(delegateList[i].Conservate)
+					continue;
+
+				try
+				{
+					delegateList[i].Event.Invoke();
+				}
+				catch(Exception e)
+				{
+					delegateList[i].Conservate = true;
+					Debug.LogError(e);
+				}
+			}
+		}
+
+		#endregion
+	}
+}

Runtime/Security/ProgramFlowSecurityExtend.cs.meta

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

Runtime/Security/ProgramFlowSecuttyContract.cs

@@ -0,0 +1,17 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+using XericLibrary.Runtime.Type;
+
+namespace XericLibrary.Runtime.Security
+{
+    /// <summary>
+    /// 使用委托名称契约进行调用的保全，
+    /// 性能上应该比使用try catch更好。
+    /// </summary>
+    public class ProgramFlowSecuttyContract : WeaklyObject
+	{
+        
+    }
+}

Runtime/Security/ProgramFlowSecuttyContract.cs.meta

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

Runtime/SpatialTransform/LookAtSomething.cs

@@ -0,0 +1,102 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using XericLibrary.Runtime.Type;
+
+namespace XericLibrary
+{
+    /// <summary>
+    /// 看向某物
+    /// </summary>
+    public class LookAtSomething : WeaklyMonoBase
+	{
+		#region 字段属性
+
+		/// <summary>
+		/// 看向目标的名称
+		/// </summary>
+		public string lookAtTargetName = "";
+
+		/// <summary>
+		/// 看向的目标
+		/// </summary>
+		[SerializeField]
+		private Transform lookAtTarget = null;
+
+		/// <summary>
+		/// 设定看向的目标
+		/// </summary>
+		public Transform LookAtTarget
+		{
+			get => lookAtTarget;
+			set
+			{
+				lookAtTarget = value;
+				targetValid = lookAtTarget != null;
+			}
+		}
+
+		/// <summary>
+		/// 反转看向轴
+		/// </summary>
+		public bool ReversLookVector = false;
+
+		/// <summary>
+		/// 看向的轴
+		/// </summary>
+		public Vector3 LookAtVector = Vector3.forward;
+
+		/// <summary>
+		/// 启用旋转的轴
+		/// </summary>
+		public Vector3 UseableRotateVector = Vector3.one;
+
+		/// <summary>
+		/// 旋转角速度
+		/// </summary>
+		public float RotateSpeed = 1;
+
+		/// <summary>
+		/// 看向的目标有效
+		/// </summary>
+		private bool targetValid = true;
+
+
+		#endregion
+
+		#region 生命周期
+
+		private void Awake()
+		{
+			if(lookAtTarget == null && lookAtTargetName != null && lookAtTargetName != "")
+			{
+				lookAtTarget = GameObject.Find(lookAtTargetName)?.transform;
+			}
+		}
+
+		public void OnEnable()
+		{
+			targetValid = lookAtTarget != null;
+		}
+
+		public void Update()
+		{
+			if(!targetValid)
+				return;
+
+			var lookvec = ReversLookVector ? 
+			transform.position - lookAtTarget.position:
+			lookAtTarget.position - transform.position;
+
+			Quaternion targetRotation = Quaternion.LookRotation(lookvec, LookAtVector);
+
+			// 使用 slerp 插值平滑旋转
+			float step = RotateSpeed * Time.deltaTime;
+			transform.rotation = Quaternion.RotateTowards(transform.rotation, targetRotation, step);
+		}
+
+		#endregion
+	}
+}

Runtime/SpatialTransform/LookAtSomething.cs.meta

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

Runtime/Type/BatchProcessor.cs

@@ -16,7 +16,7 @@ namespace XericLibrary.Runtime.Type
 	/// 此举会使得编译器不再追踪及其细致的更新时间调用栈，谨慎使用。
     /// </code>
     /// </summary>
-    public abstract class BatchProcessor : SingleMonoBase<BatchProcessor>
+    public class BatchProcessor : SingleMonoBase<BatchProcessor>
 	{
 		#region 字段属性
 
@@ -34,13 +34,21 @@ namespace XericLibrary.Runtime.Type
 			remove => RemoveProcess(value);
 		}
 
-
+		/// <summary>
+		/// 每帧允许指定的流程数量
+		/// </summary>
+		public int ProcessorCountPerFrame = 100;
 
 		/// <summary>
 		/// 在更新时需要被移除的对象
 		/// </summary>
 		private List<ActionAttribution> needRemove = new List<ActionAttribution>();
 
+		/// <summary>
+		/// 上一次处理到的索引
+		/// </summary>
+		private int lastProcessorIndex = 0;
+
 		#endregion
 
 		#region 类内类
@@ -80,12 +88,20 @@ namespace XericLibrary.Runtime.Type
 		protected override void Awake()
 		{
 			base.Awake();
+			ProcessorList = new List<ActionAttribution>();
 		}
 
 		protected virtual void Update()
 		{
-			foreach(var processor in ProcessorList)
+			int ProcesInframe = ProcessorCountPerFrame;
+
+			if(lastProcessorIndex <= 0)
+				lastProcessorIndex = ProcessorList.Count;
+
+			while(0 <=-- ProcesInframe && 0 <=-- lastProcessorIndex)
 			{
+				var processor = ProcessorList[lastProcessorIndex];
+
 				if(ReferenceEquals(processor.TargetScript, null))
 					needRemove.Add(processor);
 
@@ -104,7 +120,7 @@ namespace XericLibrary.Runtime.Type
 		#region 方法
 
 		/// <summary>
-		/// 添加匿名处理器
+		/// 添加匿名处理器，需要由此处理器担保对象的生命周期大于等于处理器。
 		/// </summary>
 		/// <param name="actuator"></param>
 		protected internal void AddProcess(Action actuator)
@@ -137,7 +153,7 @@ namespace XericLibrary.Runtime.Type
 		/// <param name="actuator"></param>
 		public void RemoveProcess(MonoBehaviour script, Action actuator)
 		{
-			RemoveProcess(a => a.EventAction == actuator && a.TargetScript == script);
+			RemoveProcess(a => a.TargetScript == script && a.EventAction == actuator);
 		}
 
 		/// <summary>

Runtime/Type/EasingMode.cs

@@ -0,0 +1,43 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+
+namespace XericLibrary.Runtime.Type
+{
+	/// <summary>
+	/// »º¶¯Ä£Ê½
+	/// </summary>
+	public enum EasingMode
+	{
+		Linear,
+		QuadraticIn,
+		QuadraticOut,
+		QuadraticInOut,
+		CubicIn,
+		CubicOut,
+		CubicInOut,
+		QuarticIn,
+		QuarticOut,
+		QuarticInOut,
+		QuinticIn,
+		QuinticOut,
+		QuinticInOut,
+		SinusoidalIn,
+		SinusoidalOut,
+		SinusoidalInOut,
+		ExponentialIn,
+		ExponentialOut,
+		ExponentialInOut,
+		CircularIn,
+		CircularOut,
+		CircularInOut,
+		ElasticIn,
+		ElasticOut,
+		ElasticInOut,
+		BackIn,
+		BounceIn,
+		BounceOut,
+		BounceInOut,
+	}
+}

Runtime/Type/EasingMode.cs.meta

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

Runtime/Type/GradientWeight.cs

@@ -0,0 +1,358 @@
+using Sirenix.OdinInspector.Editor;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+using UnityEngine;
+
+namespace XericLibrary.Runtime.Type
+{
+	/// <summary>
+	/// 带有权重的梯度，要求其中的元素实现lerp；
+	/// lerp不属于接口，所以需要后续手动定义。
+	/// </summary>
+    [Serializable]
+	public abstract class GradientWeight<T> : IList<GradientPoint<T>>
+	{
+		#region 字段属性
+
+		/// <summary>
+		/// 梯度列表，默认其中的元素都是从小到大的，且数量不小于1
+		/// </summary>
+		private List<GradientPoint<T>> gradientList;
+
+		public int Count => gradientList.Count;
+
+		bool ICollection<GradientPoint<T>>.IsReadOnly => false;
+
+		GradientPoint<T> IList<GradientPoint<T>>.this[int index]
+		{
+			get => gradientList[index];
+			set => gradientList[index] = value;
+		}
+
+		#endregion
+
+		#region 构造方法
+
+		/// <summary>
+		/// 梯度权重
+		/// </summary>
+		public GradientWeight()
+		{
+			gradientList = new List<GradientPoint<T>>() { new GradientPoint<T>() };
+		}
+
+		#endregion
+
+		#region 接口
+
+		int IList<GradientPoint<T>>.IndexOf(GradientPoint<T> item)
+		{
+			return gradientList.IndexOf(item);
+		}
+
+		void IList<GradientPoint<T>>.Insert(int index, GradientPoint<T> item)
+		{
+			gradientList.Insert(index, item);
+		}
+
+		void IList<GradientPoint<T>>.RemoveAt(int index)
+		{
+			gradientList.RemoveAt(index);
+		}
+
+		public void Add(GradientPoint<T> item)
+		{
+			// 排队
+			if(gradientList[Math.Max(gradientList.Count - 1, 0)].x < item.x)
+			{
+				gradientList.Add(item);
+				return;
+			}
+			for(int i = 0; i < gradientList.Count; i++)
+			{
+				// 覆盖
+				if(Math.Abs(Math.Abs(gradientList[i].x) - Math.Abs(item.x)) <= float.MinValue)
+				{
+					gradientList[i] = item;
+					return;
+				}
+				// 插队
+				else if(gradientList[i].x > item.x)
+				{
+					gradientList.Insert(i, item);
+					return;
+				}
+				// todo 插队与排队需要移除默认0
+			}
+		}
+
+		public void Clear()
+		{
+			gradientList.Clear();
+			gradientList.Add(new GradientPoint<T>());
+		}
+
+		public bool Contains(GradientPoint<T> item)
+		{
+			return !gradientList
+			.Where(a => a.x == item.x)
+			.FirstOrDefault().Equals(null);
+			//return gradientList.Contains(item);
+		}
+
+		public void CopyTo(GradientPoint<T>[] array, int arrayIndex)
+		{
+			gradientList.CopyTo(array, arrayIndex);
+		}
+
+		public bool Remove(GradientPoint<T> item)
+		{
+			bool resualt = gradientList.Remove(item);
+			if(resualt && gradientList.Count <= 0)
+				gradientList.Add(new GradientPoint<T>());
+			return resualt;
+		}
+
+		public IEnumerator<GradientPoint<T>> GetEnumerator()
+		{
+			return gradientList.GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			return gradientList.GetEnumerator();
+		}
+
+		#endregion
+
+		#region 基本使用
+
+		/// <summary>
+		/// 获取在给定的值上的取值
+		/// </summary>
+		/// <param name="x"></param>
+		/// <returns></returns>
+		public T Get(float x)
+		{
+			if(x <= gradientList[0].x)
+				return gradientList[0].y;
+			if(x >= gradientList[gradientList.Count - 1].x)
+				return gradientList[gradientList.Count - 1].y;
+
+			int j = 0;
+			for(int i = 0; i < gradientList.Count; i++)
+			{
+				if(x > gradientList[i].x)
+				{
+					j = i;
+					continue;
+				}
+
+				if(j == i)
+					return default(T);
+
+				var mix = (x - gradientList[j].x) / (gradientList[i].x - gradientList[j].x);
+				return GetAdjacentGradientMixWithWeight(gradientList[j], gradientList[i], mix);
+			}
+			return default(T);
+		}
+
+		/// <summary>
+		/// 获取两个节点的梯度混合
+		/// </summary>
+		/// <param name="point1"></param>
+		/// <param name="point2"></param>
+		/// <returns></returns>
+		protected internal abstract T GetAdjacentGradientMixWithWeight(GradientPoint<T> point1, GradientPoint<T> point2, float value);
+
+		/// <summary>
+		/// 获取给定坐标的位置所处的索引
+		/// </summary>
+		/// <param name="value"></param>
+		/// <returns></returns>
+		public int GetIndex(float value)
+		{
+			for(int i = 0; i < gradientList.Count; i++)
+			{
+				if(value < gradientList[i].x)
+					return i;
+			}
+			return gradientList.Count - 1;
+		}
+
+		#endregion
+
+	}
+
+	/// <summary>
+	/// 梯度列表上的单点
+	/// </summary>
+	/// <typeparam name="K"></typeparam>
+	[Serializable]
+	public struct GradientPoint<K> : IComparable<float>
+	{
+		#region 字段属性
+
+		/// <summary>
+		/// 横轴坐标
+		/// </summary>
+		public float x;
+
+		/// <summary>
+		/// 纵轴取值
+		/// </summary>
+		public K y;
+
+		/// <summary>
+		/// 与上一个项目的权重
+		/// </summary>
+		public float WeightPrev;
+
+		/// <summary>
+		/// 与下一个项目的权重
+		/// </summary>
+		public float WeightNext;
+
+		#endregion
+
+		#region 基本函数
+
+		/// <summary>
+		/// 创建一个梯度结构点
+		/// </summary>
+		/// <param name="x"></param>
+		/// <param name="y"></param>
+		/// <param name="pWeight">最小只能表示0</param>
+		/// <param name="nWeight">最小只能表示0</param>
+		public GradientPoint(float x = 0, K y = default, float pWeight = 1, float nWeight = 1)
+		{
+			this.x = x;
+			this.y = y;
+			this.WeightPrev = Mathf.Max(0, pWeight);
+			this.WeightNext = Mathf.Max(0, nWeight);
+		}
+
+		public int CompareTo(float other)
+		{
+			return x.CompareTo(other);
+		}
+
+		#endregion
+
+		#region 方法
+
+		/// <summary>
+		/// 获取当前元素与相邻元素的有效权重；
+		/// 这里的有效权重是指对于双方来说，各自从0-1的权重。
+		/// </summary>
+		/// <param name="next">下一个梯度元素</param>
+		/// <param name="nextWeight">下一个梯度元素的权重</param>
+		/// <returns>当前梯度元素的权重</returns>
+		public float GetAdjacentRatioWeight(GradientPoint<K> next, out float nextWeight)
+		{
+			nextWeight = next.WeightPrev / Mathf.Max(this.WeightNext + next.WeightPrev, float.MinValue);
+			var thisWeight = 1 - nextWeight;
+			if(nextWeight > thisWeight)
+			{
+				thisWeight = thisWeight / nextWeight;
+				nextWeight = 1;
+			}
+			else if(thisWeight > nextWeight)
+			{
+				nextWeight = nextWeight / thisWeight;
+				thisWeight = 1;
+			}
+			else
+			{
+				thisWeight = 1;
+				nextWeight = 1;
+			}
+			return thisWeight;
+		}
+
+
+		#endregion
+	}
+
+	/// <summary>
+	/// 浮点梯度权重
+	/// </summary>
+	[Serializable]
+	public class FloatGradientWeight : GradientWeight<float>
+	{
+		protected internal override float GetAdjacentGradientMixWithWeight(GradientPoint<float> point1, GradientPoint<float> point2, float value)
+		{
+			var weight1 = point1.GetAdjacentRatioWeight(point2, out var weight2);
+			return Mathf.Lerp(point1.y * weight1, point2.y * weight2, value);
+		}
+	}
+
+	/// <summary>
+	/// 矢量梯度权重
+	/// </summary>
+	[Serializable]
+	public class Vector2GradientWeight : GradientWeight<UnityEngine.Vector2>
+	{
+		protected internal override Vector2 GetAdjacentGradientMixWithWeight(GradientPoint<Vector2> point1, GradientPoint<Vector2> point2, float value)
+		{
+			var weight1 = point1.GetAdjacentRatioWeight(point2, out var weight2);
+			return Vector2.Lerp(point1.y * weight1, point2.y * weight2, value);
+		}
+	}
+
+	/// <summary>
+	/// 矢量梯度权重
+	/// </summary>
+	[Serializable]
+	public class Vector3GradientWeight : GradientWeight<UnityEngine.Vector3>
+	{
+		protected internal override Vector3 GetAdjacentGradientMixWithWeight(GradientPoint<Vector3> point1, GradientPoint<Vector3> point2, float value)
+		{
+			var weight1 = point1.GetAdjacentRatioWeight(point2, out var weight2);
+			return Vector3.Lerp(point1.y * weight1, point2.y * weight2, value);
+		}
+	}
+
+	/// <summary>
+	/// 矢量梯度权重
+	/// </summary>
+	[Serializable]
+	public class Vector4GradientWeight : GradientWeight<UnityEngine.Vector4>
+	{
+		protected internal override Vector4 GetAdjacentGradientMixWithWeight(GradientPoint<Vector4> point1, GradientPoint<Vector4> point2, float value)
+		{
+			var weight1 = point1.GetAdjacentRatioWeight(point2, out var weight2);
+			return Vector4.Lerp(point1.y * weight1, point2.y * weight2, value);
+		}
+	}
+
+	/// <summary>
+	/// 颜色梯度权重
+	/// </summary>
+	[Serializable]
+	public class ColorGradientWeight : GradientWeight<UnityEngine.Color>
+	{
+		protected internal override Color GetAdjacentGradientMixWithWeight(GradientPoint<Color> point1, GradientPoint<Color> point2, float value)
+		{
+			var weight1 = point1.GetAdjacentRatioWeight(point2, out var weight2);
+			return Color.Lerp(point1.y * weight1, point2.y * weight2, value);
+		}
+	}
+
+	/// <summary>
+	/// 旋转梯度权重
+	/// </summary>
+	[Serializable]
+	public class QuaternionGradientWeight : GradientWeight<UnityEngine.Quaternion>
+	{
+		protected internal override Quaternion GetAdjacentGradientMixWithWeight(GradientPoint<Quaternion> point1, GradientPoint<Quaternion> point2, float value)
+		{
+			//var weight1 = point1.GetAdjacentRatioWeight(point2, out var weight2);
+			return Quaternion.Lerp(point1.y, point2.y, value);
+		}
+	}
+}

Runtime/Type/GradientWeight.cs.meta

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

Runtime/Type/MappingDiagram.cs

@@ -0,0 +1,140 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace XericLibrary.Runtime.Type
+{
+    public class MappingDiagram<T> : IList<T>
+	where T : struct
+	{
+		#region 字段属性
+
+		/// <summary>
+		/// 插值模式
+		/// </summary>
+		public EasingMode EasingMode = EasingMode.Linear;
+
+		public List<Dimensional1<T>> dimensionals;
+
+		int ICollection<T>.Count => dimensionals.Count;
+
+		bool ICollection<T>.IsReadOnly => false;
+
+		T IList<T>.this[int index]
+		{
+			get => dimensionals[index].y;
+			set => throw new Exception("插值不允许修改");
+		}
+
+		#endregion
+
+		#region 内类
+
+		/// <summary>
+		/// 维度定义与映射
+		/// </summary>
+		public struct Dimensional1<K>
+		where K : struct
+		{
+			public double x;
+
+			public K y;
+		}
+
+		#endregion
+
+		#region 构造方法
+
+		/// <summary>
+		/// 平滑多段插值
+		/// </summary>
+		public MappingDiagram(EasingMode mode = 0)
+		{
+			dimensionals = new List<Dimensional1<T>>();
+		}
+
+		#endregion
+
+		#region 方法
+
+		public T GetValue(float x)
+		{
+			if(dimensionals.Count <= 0)
+				return default;
+
+			int hi = 0;
+			int li = 0;
+			while(hi < dimensionals.Count)
+			{
+				if(x > dimensionals[hi].x)
+					hi++;
+				else
+					break;
+			}
+
+			if(hi <= 0)
+				return default(T);
+
+			if(hi >= dimensionals.Count)
+			{
+				hi -= 1;
+				li = Mathf.Max(hi - 1, 0);
+			}
+
+			return default;
+		}
+
+		int IList<T>.IndexOf(T item)
+		{
+			throw new NotImplementedException();
+		}
+
+		void IList<T>.Insert(int index, T item)
+		{
+			throw new NotImplementedException();
+		}
+
+		void IList<T>.RemoveAt(int index)
+		{
+			throw new NotImplementedException();
+		}
+
+		void ICollection<T>.Add(T item)
+		{
+			throw new NotImplementedException();
+		}
+
+		void ICollection<T>.Clear()
+		{
+			throw new NotImplementedException();
+		}
+
+		bool ICollection<T>.Contains(T item)
+		{
+			throw new NotImplementedException();
+		}
+
+		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
+		{
+			throw new NotImplementedException();
+		}
+
+		bool ICollection<T>.Remove(T item)
+		{
+			throw new NotImplementedException();
+		}
+
+		IEnumerator<T> IEnumerable<T>.GetEnumerator()
+		{
+			throw new NotImplementedException();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator()
+		{
+			throw new NotImplementedException();
+		}
+
+		#endregion
+	}
+}

Runtime/Type/MappingDiagram.cs.meta

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

Runtime/Type/SingleMonoBase.cs

@@ -1,5 +1,3 @@
-using OfficeOpenXml.FormulaParsing.Excel.Functions.Text;
-
 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
@@ -17,14 +15,14 @@ namespace XericLibrary.Runtime.Type
 		#region 字段属性
 
 		/// <summary>
-		/// 根节点名称
+		/// 空诞生时根节点名称
 		/// </summary>
-		internal static string rootNodeName = "DoNotDestroyThis";
+		internal static string rootNodeName = "GolbalStaticNode";
 
 		/// <summary>
 		/// 组件单例
 		/// </summary>
-		private static T inst;
+		private static T inst = null;
 
 		/// <summary>
 		/// 获取组件单例
@@ -34,7 +32,7 @@ namespace XericLibrary.Runtime.Type
 			get
 			{
 				if(inst == null)
-					InstanceLaunch();
+					return InstanceLaunch();
 				return inst;
 			}
 		}
@@ -42,7 +40,7 @@ namespace XericLibrary.Runtime.Type
 		/// <summary>
 		/// 所有没有指定的目标的单例脚本组件的挂载节点
 		/// </summary>
-		private static GameObject globalEmptyNode;
+		private static GameObject globalNode = null;
 
 		#endregion
 
@@ -82,21 +80,20 @@ namespace XericLibrary.Runtime.Type
 		/// <summary>
 		/// 实例在场景中无中生有时通过此过程进行初始化
 		/// </summary>
-		private static void InstanceLaunch()
+		private static T InstanceLaunch()
 		{
-			if(globalEmptyNode == null)
+			if(globalNode == null)
 			{
-#if UNITY_EDITOR
+				globalNode = GameObject.Find(rootNodeName);
-				globalEmptyNode = GameObject.Find(rootNodeName);
+				if(globalNode == null)
-				if(globalEmptyNode == null)
+				globalNode = new GameObject(rootNodeName);
-#endif
-				globalEmptyNode = new GameObject(rootNodeName);
 			}
 
-			globalEmptyNode.AddComponent<T>();
+			return globalNode.AddComponent<T>();
 		}
 
 		#endregion
 
 	}
+
 }

Runtime/Visual/ShaderFunc/Input.meta

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

Runtime/Visual/ShaderFunc/Input/DepthOfEdgeIntersection.shadersubgraph

@@ -0,0 +1,563 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "8a8b87c20e8845a4953be3e81a27d2e5",
+    "m_Properties": [],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "b94265496b5b454cb7309e54e1b0e747"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "4ad93c9e43784c43b8608713562aa8f4"
+        },
+        {
+            "m_Id": "9bda938a84c747d8a53ec21649b31b6d"
+        },
+        {
+            "m_Id": "8d6a91cae6c340159d55b542b3f5f17e"
+        },
+        {
+            "m_Id": "ed10db5d836e435b899e285b2ba70c5a"
+        },
+        {
+            "m_Id": "35f6bc757e0b433cb6c45199a7e34a4d"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "35f6bc757e0b433cb6c45199a7e34a4d"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "4ad93c9e43784c43b8608713562aa8f4"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "8d6a91cae6c340159d55b542b3f5f17e"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "ed10db5d836e435b899e285b2ba70c5a"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "9bda938a84c747d8a53ec21649b31b6d"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "35f6bc757e0b433cb6c45199a7e34a4d"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "ed10db5d836e435b899e285b2ba70c5a"
+                },
+                "m_SlotId": 4
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "35f6bc757e0b433cb6c45199a7e34a4d"
+                },
+                "m_SlotId": 1
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "Sub Graphs",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "4ad93c9e43784c43b8608713562aa8f4"
+    },
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "097f3ce25eaf4389a9f01eb5839554eb",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 1.0,
+        "y": 1.0,
+        "z": 1.0,
+        "w": 1.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubtractNode",
+    "m_ObjectId": "35f6bc757e0b433cb6c45199a7e34a4d",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Subtract",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -191.0,
+            "y": -6.0,
+            "width": 126.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "097f3ce25eaf4389a9f01eb5839554eb"
+        },
+        {
+            "m_Id": "db998236027d466f9648874ed6381f24"
+        },
+        {
+            "m_Id": "9da15aab4f994baaa4af7464e5d26437"
+        }
+    ],
+    "synonyms": [
+        "subtraction",
+        "remove",
+        "minus",
+        "take away"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "3755245c24dc4a64a77f8bbe28768508",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 2,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "4ad93c9e43784c43b8608713562aa8f4",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 0.0,
+            "y": 0.0,
+            "width": 0.0,
+            "height": 0.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "dbe27e3a2b5647428bea4b7256964ee2"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "6c9547581fb747829076c090df920979",
+    "m_Id": 4,
+    "m_DisplayName": "A",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.ScreenPositionNode",
+    "m_ObjectId": "8d6a91cae6c340159d55b542b3f5f17e",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Screen Position",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -576.0,
+            "y": 155.0,
+            "width": 145.0,
+            "height": 129.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "d1bf73d59301418bbf5abc87e1b538be"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_ScreenSpaceType": 1
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SceneDepthNode",
+    "m_ObjectId": "9bda938a84c747d8a53ec21649b31b6d",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Scene Depth",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -429.0,
+            "y": 0.0,
+            "width": 145.0,
+            "height": 112.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "b539d5ff94ee4b2fb711166e3c56fc21"
+        },
+        {
+            "m_Id": "3755245c24dc4a64a77f8bbe28768508"
+        }
+    ],
+    "synonyms": [
+        "zbuffer",
+        "zdepth"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_DepthSamplingMode": 2
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "9da15aab4f994baaa4af7464e5d26437",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "9f13af6f6baa495797030241915207ae",
+    "m_Id": 0,
+    "m_DisplayName": "In",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "In",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "a1f47eda9da14f61ae758884f9b29872",
+    "m_Id": 2,
+    "m_DisplayName": "G",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "G",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.ScreenPositionMaterialSlot",
+    "m_ObjectId": "b539d5ff94ee4b2fb711166e3c56fc21",
+    "m_Id": 0,
+    "m_DisplayName": "UV",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "UV",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_Labels": [],
+    "m_ScreenSpaceType": 0
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "b94265496b5b454cb7309e54e1b0e747",
+    "m_Name": "",
+    "m_ChildObjectList": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "cffe31dc6eba445b8b40397d85aee552",
+    "m_Id": 3,
+    "m_DisplayName": "B",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "d1bf73d59301418bbf5abc87e1b538be",
+    "m_Id": 0,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "db998236027d466f9648874ed6381f24",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 1.0,
+        "y": 1.0,
+        "z": 1.0,
+        "w": 1.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "dbe27e3a2b5647428bea4b7256964ee2",
+    "m_Id": 1,
+    "m_DisplayName": "Edge",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Edge",
+    "m_StageCapability": 2,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "eab48fed8c4f436a842be00aa354b178",
+    "m_Id": 1,
+    "m_DisplayName": "R",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "R",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SplitNode",
+    "m_ObjectId": "ed10db5d836e435b899e285b2ba70c5a",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Split",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -404.0,
+            "y": 155.0,
+            "width": 120.0,
+            "height": 149.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "9f13af6f6baa495797030241915207ae"
+        },
+        {
+            "m_Id": "eab48fed8c4f436a842be00aa354b178"
+        },
+        {
+            "m_Id": "a1f47eda9da14f61ae758884f9b29872"
+        },
+        {
+            "m_Id": "cffe31dc6eba445b8b40397d85aee552"
+        },
+        {
+            "m_Id": "6c9547581fb747829076c090df920979"
+        }
+    ],
+    "synonyms": [
+        "separate"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+

Runtime/Visual/ShaderFunc/Input/DepthOfEdgeIntersection.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: fd38b0ef5ee21d040bd54b4b782b247c
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Input/MyMainLightDirection.shadersubgraph

@@ -0,0 +1,262 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "daad105b100847aabd25f461eb15d79b",
+    "m_Properties": [],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "c22c9c427fc64e00acf91be053cb6ca3"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "bcf59baaf6084a3188a9bbb069dee991"
+        },
+        {
+            "m_Id": "3ebe3924340d4010bc361709e662f6d7"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "3ebe3924340d4010bc361709e662f6d7"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "bcf59baaf6084a3188a9bbb069dee991"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "3ebe3924340d4010bc361709e662f6d7"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "bcf59baaf6084a3188a9bbb069dee991"
+                },
+                "m_SlotId": 2
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "Sub Graphs",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "bcf59baaf6084a3188a9bbb069dee991"
+    },
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "02eec3befa5b4aa6973ac1772931b379",
+    "m_Id": 1,
+    "m_DisplayName": "Direction",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Direction",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "31e9d4509d1e49118179252c0f0b2baf",
+    "m_Id": 0,
+    "m_DisplayName": "Direction",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Direction",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode",
+    "m_ObjectId": "3ebe3924340d4010bc361709e662f6d7",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "MainLightDirection (Custom Function)",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -242.0,
+            "y": -31.0,
+            "width": 262.0,
+            "height": 302.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "31e9d4509d1e49118179252c0f0b2baf"
+        },
+        {
+            "m_Id": "4b93e834e3924299b8f5a18324290a34"
+        }
+    ],
+    "synonyms": [
+        "code",
+        "HLSL"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 2,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_SourceType": 1,
+    "m_FunctionName": "MainLightDirection",
+    "m_FunctionSource": "",
+    "m_FunctionBody": "#if SHADERGRAPH_PREVIEW\r\n    Direction = half3(0.5, 0.5, 0);\r\n    Color = half4(1, 0, 0, 1);\r\n#else\r\n    Light light = GetMainLight();\r\n    Direction = light.direction;\r\n    Color = light.color;\r\n#endif"
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "4b93e834e3924299b8f5a18324290a34",
+    "m_Id": 1,
+    "m_DisplayName": "Color",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Color",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "532f2a3c638b484da1d6e1f7ad2805a0",
+    "m_Id": 2,
+    "m_DisplayName": "Color",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Color",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "bcf59baaf6084a3188a9bbb069dee991",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 20.0,
+            "y": -31.0,
+            "width": 121.0,
+            "height": 77.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "02eec3befa5b4aa6973ac1772931b379"
+        },
+        {
+            "m_Id": "532f2a3c638b484da1d6e1f7ad2805a0"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "c22c9c427fc64e00acf91be053cb6ca3",
+    "m_Name": "",
+    "m_ChildObjectList": []
+}
+

Runtime/Visual/ShaderFunc/Input/MyMainLightDirection.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: bf05bc1a37217994d82ee5de90471651
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Input/UVDefinedBySizeRatioCenter.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: bfdafa2d5c56d0c4da767fbcd38f9314
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math.meta

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

Runtime/Visual/ShaderFunc/Math/PI.shadersubgraph

@@ -0,0 +1,180 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "84aa12ea8c7f4190973dab9a530ebb93",
+    "m_Properties": [],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "34bd486136d94eaf81c352e41e295c87"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "d275909a6cdc4ea18f6ac0e038906aae"
+        },
+        {
+            "m_Id": "16be8fb33dd44534a9395e2fe364b659"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "16be8fb33dd44534a9395e2fe364b659"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "d275909a6cdc4ea18f6ac0e038906aae"
+                },
+                "m_SlotId": 1
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "Sub Graphs",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 1,
+    "m_OutputNode": {
+        "m_Id": "d275909a6cdc4ea18f6ac0e038906aae"
+    },
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.CustomFunctionNode",
+    "m_ObjectId": "16be8fb33dd44534a9395e2fe364b659",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "PI (Custom Function)",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -199.0,
+            "y": 0.0,
+            "width": 166.0,
+            "height": 94.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "ce4fd33dc2304418a03a50dd2fadb5ea"
+        }
+    ],
+    "synonyms": [
+        "code",
+        "HLSL"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_SourceType": 1,
+    "m_FunctionName": "PI",
+    "m_FunctionSource": "",
+    "m_FunctionBody": "pi = 3.1415926535897932384626433832795;\n"
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "34bd486136d94eaf81c352e41e295c87",
+    "m_Name": "",
+    "m_ChildObjectList": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "ce4fd33dc2304418a03a50dd2fadb5ea",
+    "m_Id": 0,
+    "m_DisplayName": "pi",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "pi",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "d275909a6cdc4ea18f6ac0e038906aae",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 0.0,
+            "y": 0.0,
+            "width": 0.0,
+            "height": 0.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "e2abd78a1fc1471f95a4a4ba895d6d2e"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "e2abd78a1fc1471f95a4a4ba895d6d2e",
+    "m_Id": 1,
+    "m_DisplayName": "PI",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "PI",
+    "m_StageCapability": 3,
+    "m_Value": 3.1415927410125734,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+

Runtime/Visual/ShaderFunc/Math/PI.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 485490f1eea21ae4bada3113cfff1439
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/Rotate2.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7c3de367c330d1b41a617f62e6be3a51
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/ScaleUV.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: daf5b67320329a14588fdd2bd50230b4
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/Sphere2.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 3deca10a272297642a93b446727afa2e
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/UVSpiralProgress.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 961e544533359964cac7b044a4ae7f0a
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/ViewLength.shadersubgraph

@@ -0,0 +1,519 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "913bf919bcbc4a9aa08c2ea70d2b5bd9",
+    "m_Properties": [],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "94bbbede7d6a4ff78223decef5ecb230"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "37ca9058f79f4346afc7aef4e5b7455b"
+        },
+        {
+            "m_Id": "f6c9a6ff0fcb49c186100fc67de1a320"
+        },
+        {
+            "m_Id": "1e166a3ac82044a8b26b47a49a4f4b49"
+        },
+        {
+            "m_Id": "96ac27fda4bf4f8a9b82cf37bae07de8"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "1e166a3ac82044a8b26b47a49a4f4b49"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "96ac27fda4bf4f8a9b82cf37bae07de8"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "96ac27fda4bf4f8a9b82cf37bae07de8"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "37ca9058f79f4346afc7aef4e5b7455b"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "f6c9a6ff0fcb49c186100fc67de1a320"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "96ac27fda4bf4f8a9b82cf37bae07de8"
+                },
+                "m_SlotId": 0
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "Sub Graphs",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 1,
+    "m_OutputNode": {
+        "m_Id": "37ca9058f79f4346afc7aef4e5b7455b"
+    },
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "051e8c133dbd4979bcfd9f9e1ebd3b35",
+    "m_Id": 0,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "06a8bdd262424e3d8fd8cd2883fe6e32",
+    "m_Id": 7,
+    "m_DisplayName": "Height",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Height",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "0a13eff7e78344c7b64605d9092d5ed8",
+    "m_Id": 6,
+    "m_DisplayName": "Width",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Width",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CameraNode",
+    "m_ObjectId": "1e166a3ac82044a8b26b47a49a4f4b49",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Camera",
+    "m_DrawState": {
+        "m_Expanded": false,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -326.0,
+            "y": 0.0,
+            "width": 97.0,
+            "height": 76.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "39ab33f369174593a84e3814641d2bee"
+        },
+        {
+            "m_Id": "cffeab78cc6f42818a997c2b38070c0d"
+        },
+        {
+            "m_Id": "bba66bbbac304125bff9a1ad23a98aca"
+        },
+        {
+            "m_Id": "20c842d25a5040a2a8aa1e04dc973850"
+        },
+        {
+            "m_Id": "24fa7b844b9549518fa1821cc7e0e8c8"
+        },
+        {
+            "m_Id": "32e2070ed7484478b55d5da524fb04aa"
+        },
+        {
+            "m_Id": "0a13eff7e78344c7b64605d9092d5ed8"
+        },
+        {
+            "m_Id": "06a8bdd262424e3d8fd8cd2883fe6e32"
+        }
+    ],
+    "synonyms": [
+        "position",
+        "direction",
+        "orthographic",
+        "near plane",
+        "far plane",
+        "width",
+        "height"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "20c842d25a5040a2a8aa1e04dc973850",
+    "m_Id": 3,
+    "m_DisplayName": "Near Plane",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Near Plane",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "24fa7b844b9549518fa1821cc7e0e8c8",
+    "m_Id": 4,
+    "m_DisplayName": "Far Plane",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Far Plane",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "302bee369f7a4bacb31d706c98fc38af",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "32e2070ed7484478b55d5da524fb04aa",
+    "m_Id": 5,
+    "m_DisplayName": "Z Buffer Sign",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Z Buffer Sign",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "37ca9058f79f4346afc7aef4e5b7455b",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -101.0,
+            "y": 0.0,
+            "width": 86.0,
+            "height": 77.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "499388254bec4f7cb89ccb65bee8fd2a"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "39ab33f369174593a84e3814641d2bee",
+    "m_Id": 0,
+    "m_DisplayName": "Position",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Position",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "499388254bec4f7cb89ccb65bee8fd2a",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "5442cbd397f44cb7bfe0aa7a3ced3285",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "617697979f2b488d961a88f74321235f",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "94bbbede7d6a4ff78223decef5ecb230",
+    "m_Name": "",
+    "m_ChildObjectList": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DistanceNode",
+    "m_ObjectId": "96ac27fda4bf4f8a9b82cf37bae07de8",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Distance",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -229.0,
+            "y": 0.0,
+            "width": 128.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "302bee369f7a4bacb31d706c98fc38af"
+        },
+        {
+            "m_Id": "617697979f2b488d961a88f74321235f"
+        },
+        {
+            "m_Id": "5442cbd397f44cb7bfe0aa7a3ced3285"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "bba66bbbac304125bff9a1ad23a98aca",
+    "m_Id": 2,
+    "m_DisplayName": "Orthographic",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Orthographic",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "cffeab78cc6f42818a997c2b38070c0d",
+    "m_Id": 1,
+    "m_DisplayName": "Direction",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Direction",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.PositionNode",
+    "m_ObjectId": "f6c9a6ff0fcb49c186100fc67de1a320",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Position",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -532.0,
+            "y": 0.0,
+            "width": 206.0,
+            "height": 131.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "051e8c133dbd4979bcfd9f9e1ebd3b35"
+        }
+    ],
+    "synonyms": [
+        "location"
+    ],
+    "m_Precision": 1,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 2,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Space": 2,
+    "m_PositionSource": 0
+}
+

Runtime/Visual/ShaderFunc/Math/ViewLength.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 31e39c0352e7fa644bedc14a751f6f67
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/ViewScale.shadersubgraph

@@ -0,0 +1,719 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "1f6a19d74aa24589a951b891846d06bf",
+    "m_Properties": [
+        {
+            "m_Id": "4a0ccfe171ca4cbea0224df37bb4c106"
+        },
+        {
+            "m_Id": "246ae5a94d5946adb708c1df8cecb0b3"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "1b9e4b8c97bb4a6ca4dfcaa2bbcf6dcd"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "9bd69e69963242de9d3556ed293f164c"
+        },
+        {
+            "m_Id": "844e1fad213f489f9d9d53b61ceada1d"
+        },
+        {
+            "m_Id": "39752ee903e84cc3a3ed40a6210844e6"
+        },
+        {
+            "m_Id": "4c9979a9a0b942e8ad7a8516a25f1bc9"
+        },
+        {
+            "m_Id": "f87c1fd14eba4beb9fbabb59080de1c0"
+        },
+        {
+            "m_Id": "dde6006ead684a9999d0071cce122846"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "39752ee903e84cc3a3ed40a6210844e6"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "9bd69e69963242de9d3556ed293f164c"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "4c9979a9a0b942e8ad7a8516a25f1bc9"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "844e1fad213f489f9d9d53b61ceada1d"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "844e1fad213f489f9d9d53b61ceada1d"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "39752ee903e84cc3a3ed40a6210844e6"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "dde6006ead684a9999d0071cce122846"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "844e1fad213f489f9d9d53b61ceada1d"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "f87c1fd14eba4beb9fbabb59080de1c0"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "39752ee903e84cc3a3ed40a6210844e6"
+                },
+                "m_SlotId": 1
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "Sub Graphs",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "9bd69e69963242de9d3556ed293f164c"
+    },
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "1b9e4b8c97bb4a6ca4dfcaa2bbcf6dcd",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "4a0ccfe171ca4cbea0224df37bb4c106"
+        },
+        {
+            "m_Id": "246ae5a94d5946adb708c1df8cecb0b3"
+        }
+    ]
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty",
+    "m_ObjectId": "246ae5a94d5946adb708c1df8cecb0b3",
+    "m_Guid": {
+        "m_GuidSerialized": "fa3eeb73-bf96-4ffb-96d8-2ee14bf927dc"
+    },
+    "m_Name": "Scale",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "Scale",
+    "m_DefaultReferenceName": "_Scale",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_Value": 1.0,
+    "m_FloatType": 0,
+    "m_RangeValues": {
+        "x": 0.0,
+        "y": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.MultiplyNode",
+    "m_ObjectId": "39752ee903e84cc3a3ed40a6210844e6",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Multiply",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -228.99998474121095,
+            "y": 0.000002384185791015625,
+            "width": 126.00000762939453,
+            "height": 117.99999237060547
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "d7e6e17514114fa7bb58b3e3185470ae"
+        },
+        {
+            "m_Id": "dc0979a614ed45c0ac8138d162536217"
+        },
+        {
+            "m_Id": "7263456c448141239ff05a4f36632531"
+        }
+    ],
+    "synonyms": [
+        "multiplication",
+        "times",
+        "x"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "40499ee0cb974b1f9b75372b87ff8e0f",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "475bf8f65a4a4a2b8592d6e156fce533",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 64.0,
+        "y": 2.0,
+        "z": 2.0,
+        "w": 2.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty",
+    "m_ObjectId": "4a0ccfe171ca4cbea0224df37bb4c106",
+    "m_Guid": {
+        "m_GuidSerialized": "a863a593-cece-4105-8c79-443b13c52c0f"
+    },
+    "m_Name": "Base",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "Base",
+    "m_DefaultReferenceName": "_Base",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_Value": 64.0,
+    "m_FloatType": 0,
+    "m_RangeValues": {
+        "x": 0.0,
+        "y": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "4c9979a9a0b942e8ad7a8516a25f1bc9",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -355.0,
+            "y": -34.00000762939453,
+            "width": 101.00006103515625,
+            "height": 34.0000114440918
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "874a04a863804e5f9cd409ae062e6623"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "4a0ccfe171ca4cbea0224df37bb4c106"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "4e0ffdd46c0f4e6ca0a68b09ee3d6ec8",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "7263456c448141239ff05a4f36632531",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 0.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 0.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 0.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 0.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "7521d19cc1b44240893a97f2e71e486a",
+    "m_Id": 0,
+    "m_DisplayName": "Scale",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DivideNode",
+    "m_ObjectId": "844e1fad213f489f9d9d53b61ceada1d",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Divide",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -355.00006103515627,
+            "y": 0.0000050067901611328128,
+            "width": 126.0,
+            "height": 117.99998474121094
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "e5aa6abbb59e456bb0de521834df7c4b"
+        },
+        {
+            "m_Id": "475bf8f65a4a4a2b8592d6e156fce533"
+        },
+        {
+            "m_Id": "4e0ffdd46c0f4e6ca0a68b09ee3d6ec8"
+        }
+    ],
+    "synonyms": [
+        "division",
+        "divided by"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "874a04a863804e5f9cd409ae062e6623",
+    "m_Id": 0,
+    "m_DisplayName": "Base",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "9bd69e69963242de9d3556ed293f164c",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 0.0,
+            "y": 0.0,
+            "width": 0.0,
+            "height": 0.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "a00a38d02a84493d8359b29166382962"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "a00a38d02a84493d8359b29166382962",
+    "m_Id": 1,
+    "m_DisplayName": "Unit",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Unit",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "d7e6e17514114fa7bb58b3e3185470ae",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 0.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 0.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 0.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 0.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "dc0979a614ed45c0ac8138d162536217",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 2.0,
+        "e01": 2.0,
+        "e02": 2.0,
+        "e03": 2.0,
+        "e10": 2.0,
+        "e11": 2.0,
+        "e12": 2.0,
+        "e13": 2.0,
+        "e20": 2.0,
+        "e21": 2.0,
+        "e22": 2.0,
+        "e23": 2.0,
+        "e30": 2.0,
+        "e31": 2.0,
+        "e32": 2.0,
+        "e33": 2.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphNode",
+    "m_ObjectId": "dde6006ead684a9999d0071cce122846",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "ViewLength",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -469.0,
+            "y": 0.000022411346435546875,
+            "width": 114.0,
+            "height": 94.00001525878906
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "40499ee0cb974b1f9b75372b87ff8e0f"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_SerializedSubGraph": "{\n    \"subGraph\": {\n        \"fileID\": -5475051401550479605,\n        \"guid\": \"31e39c0352e7fa644bedc14a751f6f67\",\n        \"type\": 3\n    }\n}",
+    "m_PropertyGuids": [],
+    "m_PropertyIds": [],
+    "m_Dropdowns": [],
+    "m_DropdownSelectedEntries": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "e5aa6abbb59e456bb0de521834df7c4b",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "f87c1fd14eba4beb9fbabb59080de1c0",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -355.0,
+            "y": 117.99999237060547,
+            "width": 91.00003051757813,
+            "height": 34.00000762939453
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "7521d19cc1b44240893a97f2e71e486a"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "246ae5a94d5946adb708c1df8cecb0b3"
+    }
+}
+

Runtime/Visual/ShaderFunc/Math/ViewScale.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 9d90a3805d5077e448fca1be2f6a3ee4
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/WorldCoseAlpha.shadersubgraph

@@ -0,0 +1,769 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "21c835d1106748779a28a1b0f3fff62c",
+    "m_Properties": [],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "4e082843f4c449c7afbdec0ebceb5ecc"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "bfad33db198d4395b5309ec61636cdc0"
+        },
+        {
+            "m_Id": "51cde3b7103145b0b71abc430c3486e2"
+        },
+        {
+            "m_Id": "eacd41b10d314d0c8b3ca342c56b1722"
+        },
+        {
+            "m_Id": "7c46548b390d410c9a3c3dcb705ccb5f"
+        },
+        {
+            "m_Id": "72bb6be4fd594e3695b1d6a3bd640637"
+        },
+        {
+            "m_Id": "cc0a8f8969a9439199b2b3beec309397"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "51cde3b7103145b0b71abc430c3486e2"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "eacd41b10d314d0c8b3ca342c56b1722"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "72bb6be4fd594e3695b1d6a3bd640637"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "cc0a8f8969a9439199b2b3beec309397"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "7c46548b390d410c9a3c3dcb705ccb5f"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "eacd41b10d314d0c8b3ca342c56b1722"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "7c46548b390d410c9a3c3dcb705ccb5f"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "cc0a8f8969a9439199b2b3beec309397"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "cc0a8f8969a9439199b2b3beec309397"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "bfad33db198d4395b5309ec61636cdc0"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "eacd41b10d314d0c8b3ca342c56b1722"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "72bb6be4fd594e3695b1d6a3bd640637"
+                },
+                "m_SlotId": 0
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "Sub Graphs",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 2,
+    "m_OutputNode": {
+        "m_Id": "bfad33db198d4395b5309ec61636cdc0"
+    },
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "0a62990cc42a4b9095aaa26a2700514e",
+    "m_Id": 5,
+    "m_DisplayName": "Z Buffer Sign",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Z Buffer Sign",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "0a888b4e0972467f9af554ea5ff1bfc7",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 1.0,
+        "y": 1.0,
+        "z": 1.0,
+        "w": 1.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "1ae7ac2c0c3e4513b50a3efd56e5a877",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "217021a24f6a4d6abdc0b10b535d8e95",
+    "m_Id": 6,
+    "m_DisplayName": "Width",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Width",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "2883e49e97614690ae52918cc5578f2a",
+    "m_Id": 3,
+    "m_DisplayName": "Near Plane",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Near Plane",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "2cef2c0df4794b0e8fdfeeab95f48c94",
+    "m_Id": 0,
+    "m_DisplayName": "In",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "In",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "4e082843f4c449c7afbdec0ebceb5ecc",
+    "m_Name": "",
+    "m_ChildObjectList": []
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.PositionNode",
+    "m_ObjectId": "51cde3b7103145b0b71abc430c3486e2",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Position",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -624.0,
+            "y": 0.0,
+            "width": 206.0,
+            "height": 131.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "b533669952ac4fa192231ce05a268699"
+        }
+    ],
+    "synonyms": [
+        "location"
+    ],
+    "m_Precision": 1,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 2,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Space": 2,
+    "m_PositionSource": 0
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.NormalizeNode",
+    "m_ObjectId": "72bb6be4fd594e3695b1d6a3bd640637",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Normalize",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -288.0,
+            "y": 0.0,
+            "width": 132.0,
+            "height": 94.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "2cef2c0df4794b0e8fdfeeab95f48c94"
+        },
+        {
+            "m_Id": "91aef3cac94849a69dae7f4a4a244bcf"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "769f5dba071649f785bf6926e8da5af1",
+    "m_Id": 1,
+    "m_DisplayName": "Direction",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Direction",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CameraNode",
+    "m_ObjectId": "7c46548b390d410c9a3c3dcb705ccb5f",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Camera",
+    "m_DrawState": {
+        "m_Expanded": false,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -624.0,
+            "y": 131.0,
+            "width": 102.0,
+            "height": 100.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "f88014d1da354d13bccc13ef4f5c939c"
+        },
+        {
+            "m_Id": "769f5dba071649f785bf6926e8da5af1"
+        },
+        {
+            "m_Id": "7e415df3e73c4f46b193a94365772a6a"
+        },
+        {
+            "m_Id": "2883e49e97614690ae52918cc5578f2a"
+        },
+        {
+            "m_Id": "8895252e5dff44bba29549d1909f1956"
+        },
+        {
+            "m_Id": "0a62990cc42a4b9095aaa26a2700514e"
+        },
+        {
+            "m_Id": "217021a24f6a4d6abdc0b10b535d8e95"
+        },
+        {
+            "m_Id": "cc0d936f69e3446cb78f9b0dc9449e15"
+        }
+    ],
+    "synonyms": [
+        "position",
+        "direction",
+        "orthographic",
+        "near plane",
+        "far plane",
+        "width",
+        "height"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "7e415df3e73c4f46b193a94365772a6a",
+    "m_Id": 2,
+    "m_DisplayName": "Orthographic",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Orthographic",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "8895252e5dff44bba29549d1909f1956",
+    "m_Id": 4,
+    "m_DisplayName": "Far Plane",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Far Plane",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "91aef3cac94849a69dae7f4a4a244bcf",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "a6a9ded60b8a48deb72658adfa59f3d9",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "b08db34f64e349728ba84aca5f41cdb9",
+    "m_Id": 1,
+    "m_DisplayName": "Cos_Alpha",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Cos_Alpha",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "b533669952ac4fa192231ce05a268699",
+    "m_Id": 0,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "b77003064d594e359f8721191cce0873",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "bfad33db198d4395b5309ec61636cdc0",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": 0.0,
+            "y": 0.0,
+            "width": 0.0,
+            "height": 0.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "b08db34f64e349728ba84aca5f41cdb9"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "c060ef533c424896a777f023377a9793",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 1.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DotProductNode",
+    "m_ObjectId": "cc0a8f8969a9439199b2b3beec309397",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Dot Product",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -156.0,
+            "y": 0.0,
+            "width": 128.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "a6a9ded60b8a48deb72658adfa59f3d9"
+        },
+        {
+            "m_Id": "c060ef533c424896a777f023377a9793"
+        },
+        {
+            "m_Id": "b77003064d594e359f8721191cce0873"
+        }
+    ],
+    "synonyms": [
+        "scalar product"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "cc0d936f69e3446cb78f9b0dc9449e15",
+    "m_Id": 7,
+    "m_DisplayName": "Height",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Height",
+    "m_StageCapability": 3,
+    "m_Value": 1.0,
+    "m_DefaultValue": 1.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "dc559a6b8d264dfc991efc973ff7dd2f",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 1.0,
+        "y": 1.0,
+        "z": 1.0,
+        "w": 1.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubtractNode",
+    "m_ObjectId": "eacd41b10d314d0c8b3ca342c56b1722",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Subtract",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -418.0,
+            "y": 0.0,
+            "width": 130.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "dc559a6b8d264dfc991efc973ff7dd2f"
+        },
+        {
+            "m_Id": "0a888b4e0972467f9af554ea5ff1bfc7"
+        },
+        {
+            "m_Id": "1ae7ac2c0c3e4513b50a3efd56e5a877"
+        }
+    ],
+    "synonyms": [
+        "subtraction",
+        "remove",
+        "minus",
+        "take away"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector3MaterialSlot",
+    "m_ObjectId": "f88014d1da354d13bccc13ef4f5c939c",
+    "m_Id": 0,
+    "m_DisplayName": "Position",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Position",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0
+    },
+    "m_Labels": []
+}
+

Runtime/Visual/ShaderFunc/Math/WorldCoseAlpha.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 95d6cb39dd5a4b341a4dcabc668847ef
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/WouldRadiusUpPlaneSphereInWorld.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 4b2b0d5b31833b943bc72be0a3b83ffb
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/WouldRadiusUpPlaneSphereOnObject.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: ecc376d61bcddb44d9e7262fa0c709ed
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/Math/ZeroCrossingEdge.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 8651af11a25c7f148aee9759d820d7da
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/ProgramTexture.meta

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

Runtime/Visual/ShaderFunc/ProgramTexture/PT_SimpleWave.shadersubgraph

@@ -0,0 +1,913 @@
+{
+    "m_SGVersion": 3,
+    "m_Type": "UnityEditor.ShaderGraph.GraphData",
+    "m_ObjectId": "f6009b554fee4951a74ecdf3df1a8599",
+    "m_Properties": [
+        {
+            "m_Id": "6b9016b12b2146b4a401d48a09baa4b5"
+        },
+        {
+            "m_Id": "9c8588099df540698fb2eaa7be2190be"
+        }
+    ],
+    "m_Keywords": [],
+    "m_Dropdowns": [],
+    "m_CategoryData": [
+        {
+            "m_Id": "9af4922fa1b14dc49bd21f2cb94bff19"
+        }
+    ],
+    "m_Nodes": [
+        {
+            "m_Id": "dcf4610b5d9b49308eff1d78ad1e73be"
+        },
+        {
+            "m_Id": "0e4caf75fd6f4d709944b91a8ef6e6f6"
+        },
+        {
+            "m_Id": "d54a69dc773a49699403e69eee933b49"
+        },
+        {
+            "m_Id": "132ea70e984b4330ae91b743e3ff2d55"
+        },
+        {
+            "m_Id": "e7f3dc176709449a8051885fb0a3fae9"
+        },
+        {
+            "m_Id": "13242ac56a5746a3b87e17fbe94efedb"
+        },
+        {
+            "m_Id": "9b9fd8997c5d4413bba1f147332d26c6"
+        }
+    ],
+    "m_GroupDatas": [],
+    "m_StickyNoteDatas": [],
+    "m_Edges": [
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "0e4caf75fd6f4d709944b91a8ef6e6f6"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "132ea70e984b4330ae91b743e3ff2d55"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "13242ac56a5746a3b87e17fbe94efedb"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "132ea70e984b4330ae91b743e3ff2d55"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "132ea70e984b4330ae91b743e3ff2d55"
+                },
+                "m_SlotId": 2
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "d54a69dc773a49699403e69eee933b49"
+                },
+                "m_SlotId": 0
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "9b9fd8997c5d4413bba1f147332d26c6"
+                },
+                "m_SlotId": 0
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "13242ac56a5746a3b87e17fbe94efedb"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "d54a69dc773a49699403e69eee933b49"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "dcf4610b5d9b49308eff1d78ad1e73be"
+                },
+                "m_SlotId": 1
+            }
+        },
+        {
+            "m_OutputSlot": {
+                "m_Node": {
+                    "m_Id": "e7f3dc176709449a8051885fb0a3fae9"
+                },
+                "m_SlotId": 1
+            },
+            "m_InputSlot": {
+                "m_Node": {
+                    "m_Id": "13242ac56a5746a3b87e17fbe94efedb"
+                },
+                "m_SlotId": 0
+            }
+        }
+    ],
+    "m_VertexContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_FragmentContext": {
+        "m_Position": {
+            "x": 0.0,
+            "y": 0.0
+        },
+        "m_Blocks": []
+    },
+    "m_PreviewData": {
+        "serializedMesh": {
+            "m_SerializedMesh": "{\"mesh\":{\"instanceID\":0}}",
+            "m_Guid": ""
+        },
+        "preventRotation": false
+    },
+    "m_Path": "Sub Graphs",
+    "m_GraphPrecision": 1,
+    "m_PreviewMode": 1,
+    "m_OutputNode": {
+        "m_Id": "dcf4610b5d9b49308eff1d78ad1e73be"
+    },
+    "m_ActiveTargets": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "03dc826153b04fbd9f7903a06a7e2f49",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 2.0,
+        "e01": 2.0,
+        "e02": 2.0,
+        "e03": 2.0,
+        "e10": 2.0,
+        "e11": 2.0,
+        "e12": 2.0,
+        "e13": 2.0,
+        "e20": 2.0,
+        "e21": 2.0,
+        "e22": 2.0,
+        "e23": 2.0,
+        "e30": 2.0,
+        "e31": 2.0,
+        "e32": 2.0,
+        "e33": 2.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "0e4caf75fd6f4d709944b91a8ef6e6f6",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -1013.0001220703125,
+            "y": 155.00001525878907,
+            "width": 78.00006103515625,
+            "height": 34.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "950c9510cb554dfa84f6328b23e18555"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "6b9016b12b2146b4a401d48a09baa4b5"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.MultiplyNode",
+    "m_ObjectId": "13242ac56a5746a3b87e17fbe94efedb",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Multiply",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -898.0000610351563,
+            "y": 236.00003051757813,
+            "width": 126.0,
+            "height": 118.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "4e80226b83fb4fc28d3143fa9519154f"
+        },
+        {
+            "m_Id": "03dc826153b04fbd9f7903a06a7e2f49"
+        },
+        {
+            "m_Id": "9599143a448b47af9d03e260bb20807b"
+        }
+    ],
+    "synonyms": [
+        "multiplication",
+        "times",
+        "x"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.MultiplyNode",
+    "m_ObjectId": "132ea70e984b4330ae91b743e3ff2d55",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Multiply",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -772.0000610351563,
+            "y": 118.0,
+            "width": 129.99993896484376,
+            "height": 118.00003051757813
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "bb1d28dfdfbb4487b061c1a0ba0ca117"
+        },
+        {
+            "m_Id": "7bdf04563de84af98fb9288964b9a4b9"
+        },
+        {
+            "m_Id": "2a3be1f9393344958dec0efc0180255f"
+        }
+    ],
+    "synonyms": [
+        "multiplication",
+        "times",
+        "x"
+    ],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "2a3be1f9393344958dec0efc0180255f",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 0.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 0.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 0.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 0.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "4e80226b83fb4fc28d3143fa9519154f",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 0.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 0.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 0.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 0.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "6ab5412b07d74519a5029fed2e9f5b15",
+    "m_Id": 1,
+    "m_DisplayName": "wave",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "wave",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector4ShaderProperty",
+    "m_ObjectId": "6b9016b12b2146b4a401d48a09baa4b5",
+    "m_Guid": {
+        "m_GuidSerialized": "d36d134c-ac05-41b7-9cf5-23edfc9314d6"
+    },
+    "m_Name": "UV",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "UV",
+    "m_DefaultReferenceName": "_UV",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": true,
+    "m_CustomSlotLabel": "UV",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 2,
+    "m_Hidden": false,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "7bdf04563de84af98fb9288964b9a4b9",
+    "m_Id": 1,
+    "m_DisplayName": "B",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "B",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 3.140000104904175,
+        "e01": 2.0,
+        "e02": 2.0,
+        "e03": 2.0,
+        "e10": 2.0,
+        "e11": 2.0,
+        "e12": 2.0,
+        "e13": 2.0,
+        "e20": 2.0,
+        "e21": 2.0,
+        "e22": 2.0,
+        "e23": 2.0,
+        "e30": 2.0,
+        "e31": 2.0,
+        "e32": 2.0,
+        "e33": 2.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "814eafc70b064bcda5ea159877edfb33",
+    "m_Id": 0,
+    "m_DisplayName": "Scale",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector4MaterialSlot",
+    "m_ObjectId": "950c9510cb554dfa84f6328b23e18555",
+    "m_Id": 0,
+    "m_DisplayName": "UV",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "9599143a448b47af9d03e260bb20807b",
+    "m_Id": 2,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 0.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 0.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 0.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 0.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.CategoryData",
+    "m_ObjectId": "9af4922fa1b14dc49bd21f2cb94bff19",
+    "m_Name": "",
+    "m_ChildObjectList": [
+        {
+            "m_Id": "6b9016b12b2146b4a401d48a09baa4b5"
+        },
+        {
+            "m_Id": "9c8588099df540698fb2eaa7be2190be"
+        }
+    ]
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.PropertyNode",
+    "m_ObjectId": "9b9fd8997c5d4413bba1f147332d26c6",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Property",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -1013.0001220703125,
+            "y": 330.0,
+            "width": 91.00006103515625,
+            "height": 34.00006103515625
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "814eafc70b064bcda5ea159877edfb33"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_Property": {
+        "m_Id": "9c8588099df540698fb2eaa7be2190be"
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "9bfe8ccadd87410c8d7b497d5f4481ec",
+    "m_Id": 1,
+    "m_DisplayName": "Out",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "Out",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+
+{
+    "m_SGVersion": 1,
+    "m_Type": "UnityEditor.ShaderGraph.Internal.Vector1ShaderProperty",
+    "m_ObjectId": "9c8588099df540698fb2eaa7be2190be",
+    "m_Guid": {
+        "m_GuidSerialized": "42f21f26-bc0f-4424-9fd5-3d21bba322f2"
+    },
+    "m_Name": "Scale",
+    "m_DefaultRefNameVersion": 1,
+    "m_RefNameGeneratedByDisplayName": "Scale",
+    "m_DefaultReferenceName": "_Scale",
+    "m_OverrideReferenceName": "",
+    "m_GeneratePropertyBlock": true,
+    "m_UseCustomSlotLabel": false,
+    "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
+    "m_Precision": 0,
+    "overrideHLSLDeclaration": false,
+    "hlslDeclarationOverride": 0,
+    "m_Hidden": false,
+    "m_Value": 10.0,
+    "m_FloatType": 0,
+    "m_RangeValues": {
+        "x": 0.0,
+        "y": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.Vector1MaterialSlot",
+    "m_ObjectId": "a522c8e27c8742a097288334dbede725",
+    "m_Id": 1,
+    "m_DisplayName": "PI",
+    "m_SlotType": 1,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "PI",
+    "m_StageCapability": 3,
+    "m_Value": 0.0,
+    "m_DefaultValue": 0.0,
+    "m_Labels": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicValueMaterialSlot",
+    "m_ObjectId": "bb1d28dfdfbb4487b061c1a0ba0ca117",
+    "m_Id": 0,
+    "m_DisplayName": "A",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "A",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "e00": 0.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 0.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 0.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 0.0
+    },
+    "m_DefaultValue": {
+        "e00": 1.0,
+        "e01": 0.0,
+        "e02": 0.0,
+        "e03": 0.0,
+        "e10": 0.0,
+        "e11": 1.0,
+        "e12": 0.0,
+        "e13": 0.0,
+        "e20": 0.0,
+        "e21": 0.0,
+        "e22": 1.0,
+        "e23": 0.0,
+        "e30": 0.0,
+        "e31": 0.0,
+        "e32": 0.0,
+        "e33": 1.0
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SineNode",
+    "m_ObjectId": "d54a69dc773a49699403e69eee933b49",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Sine",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -642.0001220703125,
+            "y": 118.0,
+            "width": 132.00003051757813,
+            "height": 94.00001525878906
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "ef37639ea6544e04bac5e80e98cf63e1"
+        },
+        {
+            "m_Id": "9bfe8ccadd87410c8d7b497d5f4481ec"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    }
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphOutputNode",
+    "m_ObjectId": "dcf4610b5d9b49308eff1d78ad1e73be",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "Output",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -281.0,
+            "y": 118.0,
+            "width": 86.0,
+            "height": 77.0
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "6ab5412b07d74519a5029fed2e9f5b15"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "IsFirstSlotValid": true
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.SubGraphNode",
+    "m_ObjectId": "e7f3dc176709449a8051885fb0a3fae9",
+    "m_Group": {
+        "m_Id": ""
+    },
+    "m_Name": "PI",
+    "m_DrawState": {
+        "m_Expanded": true,
+        "m_Position": {
+            "serializedVersion": "2",
+            "x": -1013.0000610351563,
+            "y": 236.00001525878907,
+            "width": 64.0,
+            "height": 93.99998474121094
+        }
+    },
+    "m_Slots": [
+        {
+            "m_Id": "a522c8e27c8742a097288334dbede725"
+        }
+    ],
+    "synonyms": [],
+    "m_Precision": 0,
+    "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
+    "m_PreviewMode": 0,
+    "m_CustomColors": {
+        "m_SerializableColors": []
+    },
+    "m_SerializedSubGraph": "{\n    \"subGraph\": {\n        \"fileID\": -5475051401550479605,\n        \"guid\": \"485490f1eea21ae4bada3113cfff1439\",\n        \"type\": 3\n    }\n}",
+    "m_PropertyGuids": [],
+    "m_PropertyIds": [],
+    "m_Dropdowns": [],
+    "m_DropdownSelectedEntries": []
+}
+
+{
+    "m_SGVersion": 0,
+    "m_Type": "UnityEditor.ShaderGraph.DynamicVectorMaterialSlot",
+    "m_ObjectId": "ef37639ea6544e04bac5e80e98cf63e1",
+    "m_Id": 0,
+    "m_DisplayName": "In",
+    "m_SlotType": 0,
+    "m_Hidden": false,
+    "m_ShaderOutputName": "In",
+    "m_StageCapability": 3,
+    "m_Value": {
+        "x": 0.5,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    },
+    "m_DefaultValue": {
+        "x": 0.0,
+        "y": 0.0,
+        "z": 0.0,
+        "w": 0.0
+    }
+}
+

Runtime/Visual/ShaderFunc/ProgramTexture/PT_SimpleWave.shadersubgraph.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: 7a7568d4203466444a748b58b2431650
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 60072b568d64c40a485e0fc55012dc9f, type: 3}

Runtime/Visual/ShaderFunc/UV/UVTrIangle.shadersubgraph

@@ -643,6 +643,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -721,6 +722,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -772,6 +774,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -1058,6 +1061,7 @@
     "m_GeneratePropertyBlock": true,
     "m_UseCustomSlotLabel": false,
     "m_CustomSlotLabel": "",
+    "m_DismissedVersion": 0,
     "m_Precision": 0,
     "overrideHLSLDeclaration": false,
     "hlslDeclarationOverride": 0,
@@ -1193,6 +1197,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -1291,6 +1296,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -1384,6 +1390,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -1763,6 +1770,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -1849,6 +1857,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -1939,6 +1948,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -1981,6 +1991,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2027,6 +2038,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2161,6 +2173,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2269,6 +2282,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2311,6 +2325,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2394,6 +2409,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2492,6 +2508,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2910,6 +2927,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2951,6 +2969,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -2991,6 +3010,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3183,6 +3203,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3218,6 +3239,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3259,6 +3281,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3306,6 +3329,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3609,6 +3633,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3662,6 +3687,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3777,6 +3803,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": false,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3817,6 +3844,7 @@
     ],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []
@@ -3933,6 +3961,7 @@
     "synonyms": [],
     "m_Precision": 0,
     "m_PreviewExpanded": true,
+    "m_DismissedVersion": 0,
     "m_PreviewMode": 0,
     "m_CustomColors": {
         "m_SerializableColors": []

package.json

@@ -1,7 +1,7 @@
 {
   "name": "com.lrss3.xericlibrary",
   "displayName": "Xeric Library",
-  "version": "0.2.2",
+  "version": "0.2.410",
   "unity": "2021.3",
   "description": "\u901a\u7528\u5e93\u63d2\u4ef6\u3002"
 }