Merge branch 'hackweek2017' of https://github.com/stramit/MaterialGraph into hackweek2017

MaterialGraphProject/Assets/Andre/Materials/Mat.mat

   disabledShaderPasses: []
   m_SavedProperties:
     serializedVersion: 3
-    m_TexEnvs:
-    - Cubemap_181b280a_a8b7_461e_bbeb_30fa23931a56_Uniform:
-        m_Texture: {fileID: 8900000, guid: f7111c407ddfe4109af9703cb740eaf9, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Cubemap_cfafd4ef_c0b8_4ca3_9f3c_7068e7916d3e_Uniform:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Cubemap_dc3182b8_fe99_45ed_8c1d_67fb354034bd_Uniform:
-        m_Texture: {fileID: 8900000, guid: f7111c407ddfe4109af9703cb740eaf9, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Cubemap_ee09e335_3be2_46ee_9d59_ce2673aeedf9_Uniform:
-        m_Texture: {fileID: 8900000, guid: f7111c407ddfe4109af9703cb740eaf9, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - TextureAsset_ebbe75eb_728a_4e6c_b8a1_994df86c74ad_Uniform:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_02e4013b_5c99_456a_a8d8_cafbb1dfc0da_Uniform:
-        m_Texture: {fileID: 2800000, guid: 5a5e07ee958edbd468227e1d9ac4726a, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_401188ed_6e9e_4a8a_9f5c_a7853502ba40_Uniform:
-        m_Texture: {fileID: 2800000, guid: aa460a2956f927d4ab684aa4970bf76a, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_5537060b_db74_4900_8f2b_178ba97b7f11_Uniform:
-        m_Texture: {fileID: 10305, guid: 0000000000000000f000000000000000, type: 0}
-        m_Scale: {x: 1, y: 2}
-        m_Offset: {x: 0, y: 0}
-    - Texture_6df69ae7_cb4c_435c_a029_13f370817e4c_Uniform:
-        m_Texture: {fileID: 2800000, guid: 84462bdfeee9d694bbebf34e5f3faa74, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_73d7755c_9da7_46d2_90c6_35c2a880d380_Uniform:
-        m_Texture: {fileID: 2800000, guid: 5a5e07ee958edbd468227e1d9ac4726a, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_7e044bc6_b639_4457_83f6_752bfaedcb11_Uniform:
-        m_Texture: {fileID: 2800000, guid: 330f42016073a97418a4aae5517e32c8, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_8304e17f_0ca3_45b8_9081_4e083e4ffba7_Uniform:
-        m_Texture: {fileID: 2800000, guid: 330f42016073a97418a4aae5517e32c8, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_aa489395_d5b1_4bce_a08c_71ce4329894d_Uniform:
-        m_Texture: {fileID: 2800000, guid: 330f42016073a97418a4aae5517e32c8, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_bac51ec0_c299_4919_8bbd_573b26865795_Uniform:
-        m_Texture: {fileID: 2800000, guid: 556373d2abe91394795e2c7b920330f0, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_c007d40f_e93f_40ea_9867_1b70cebcd3fd_Uniform:
-        m_Texture: {fileID: 2800000, guid: aa460a2956f927d4ab684aa4970bf76a, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_cfc1ad3f_b7ac_495b_a5d4_bbf5e525f27c_Uniform:
-        m_Texture: {fileID: 2800000, guid: 46dd7a1d84b1ee64ca65752c24cfd890, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_d48530d7_5921_4987_918e_46411222e797_Uniform:
-        m_Texture: {fileID: 2800000, guid: 5b01c9e873ba169449186e98e1483a23, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_d6d1ed65_5575_444c_8f92_38740ace2353_Uniform:
-        m_Texture: {fileID: 2800000, guid: 5a5e07ee958edbd468227e1d9ac4726a, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_f6eb7ab6_0df6_4d1f_a833_847f9eefa1ce_Uniform:
-        m_Texture: {fileID: 2800000, guid: 915047e45d68d412f9e6857db8439117, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - Texture_fd9422b7_6255_4b8e_b616_78346d444d21_Uniform:
-        m_Texture: {fileID: 2800000, guid: 84462bdfeee9d694bbebf34e5f3faa74, type: 3}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _BumpMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailAlbedoMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailMask:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _DetailNormalMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _EmissionMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MainTex:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _MetallicGlossMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _OcclusionMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
-    - _ParallaxMap:
-        m_Texture: {fileID: 0}
-        m_Scale: {x: 1, y: 1}
-        m_Offset: {x: 0, y: 0}
+    m_TexEnvs: []
-    - Toggle_bda28932_b1ab_4b0b_ba54_ca5db612047a_Uniform: 0.6
-    - Vector1_15d5efb3_faea_4990_90ce_629f350a50cb_Uniform: 0
-    - Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform: 0.05
-    - Vector1_36d8f7c7_3ada_4604_9149_df2ba1745b80_Uniform: 8
-    - Vector1_48a064e9_29c4_4cdd_8bf7_34902bb50605_Uniform: 3
-    - Vector1_681e693a_7812_42ab_a37b_8a1edc00d63e_Uniform: 0.005
-    - Vector1_bc1392c9_f4d7_47a8_8add_f4f4b00fdfe5_Uniform: 0
-    - _BumpScale: 1
-    - _Cutoff: 0.5
-    - _DetailNormalMapScale: 1
-    - _DstBlend: 0
-    - _GlossMapScale: 1
-    - _Glossiness: 0.5
-    - _GlossyReflections: 1
-    - _Metallic: 0
-    - _Mode: 0
-    - _OcclusionStrength: 1
-    - _Parallax: 0.02
-    - _SmoothnessTextureChannel: 0
-    - _SpecularHighlights: 1
-    - _SrcBlend: 1
-    - _UVSec: 0
-    - _ZWrite: 1
-    m_Colors:
-    - _Color: {r: 1, g: 1, b: 1, a: 1}
-    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - Vector1_a2ac4923_bc39_4a5c_924e_e77bd500d4f3_Uniform: 1
+    m_Colors: []

MaterialGraphProject/Assets/Andre/Nodes/Editor/TransformNodePresenter.cs

             if (tNode == null)
                 return;
 
-			//tNode.floatType = (FloatPropertyChunk.FloatType)EditorGUILayout.EnumPopup ("Float", tNode.floatType);
-
+			//EditorGUILayout.BeginHorizontal ();
+			tNode.spaceFrom = (SimpleMatrixType)EditorGUILayout.EnumPopup ("From", tNode.spaceFrom);
+			tNode.spaceTo = (SimpleMatrixType)EditorGUILayout.EnumPopup ("To", tNode.spaceTo);
+			//EditorGUILayout.BeginHorizontal ();
-			return (EditorGUIUtility.singleLineHeight + 16 * EditorGUIUtility.standardVerticalSpacing) + EditorGUIUtility.standardVerticalSpacing;
+			return (EditorGUIUtility.singleLineHeight + 6 * EditorGUIUtility.standardVerticalSpacing) + EditorGUIUtility.standardVerticalSpacing;
         }
     }
 

MaterialGraphProject/Assets/Andre/Nodes/ToggleNode.cs

     public class ToggleNode : PropertyNode, IGeneratesBodyCode
     {
         [SerializeField]
-        private float m_Float;
+        //private float m_Float;
 		private bool m_ToggleState;
 
         private const int kOutputSlotId = 0;

MaterialGraphProject/Assets/Andre/Nodes/TransformNode.cs

-namespace UnityEngine.MaterialGraph
+using UnityEngine.Graphing;
+using System.Collections.Generic;
+
+namespace UnityEngine.MaterialGraph
-	public class TransformNode : Function1Input
+	public class TransformNode : AbstractMaterialNode, IGeneratesBodyCode, IMayRequireTangent, IMayRequireBitangent, IMayRequireNormal
+		[SerializeField]
+		private SimpleMatrixType m_spaceListFrom;
+		[SerializeField]
+		private SimpleMatrixType m_spaceListTo;
+
+		private const int InputSlotId = 0;
+		private const int OutputSlotId = 1;
+		private const string kInputSlotName = "Input";
+		private const string kOutputSlotName = "Output";
+
+		public SimpleMatrixType spaceFrom
+		{
+			get { return m_spaceListFrom; }
+			set
+			{
+				if (m_spaceListFrom == value)
+					return;
+
+				m_spaceListFrom = value;
+				if (onModified != null)
+				{
+					onModified(this, ModificationScope.Graph);
+				}
+			}
+		}
+
+		public override bool hasPreview
+		{
+			get { return false; }
+		}
+
+		public SimpleMatrixType spaceTo
+		{
+			get { return m_spaceListTo; }
+			set
+			{
+				if (m_spaceListTo == value)
+					return;
+
+				m_spaceListTo = value;
+				if (onModified != null)
+				{
+					onModified(this, ModificationScope.Graph);
+				}
+			}
+		}
+
+			UpdateNodeAfterDeserialization ();
-		protected override string GetFunctionName ()
+		public sealed override void UpdateNodeAfterDeserialization()
+			AddSlot(GetInputSlot());
+			AddSlot(GetOutputSlot());
+			RemoveSlotsNameNotMatching(validSlots);
+		}
-			//mul(unity_WorldToObject, float4(i.posWorld.rgb,0) ).xyz - world to local
-			//mul( tangentTransform, i.posWorld.rgb ).xyz - world to tangent
-			//mul( UNITY_MATRIX_V, float4(i.posWorld.rgb,0) ).xyz - world to view
+		protected int[] validSlots
+		{
+			get { return new[] {InputSlotId, OutputSlotId}; }
+		}
-			//mul( unity_ObjectToWorld, float4(i.posWorld.rgb,0) ).xyz - local to world
-			//mul( tangentTransform, mul( unity_ObjectToWorld, float4(i.posWorld.rgb,0) ).xyz - local to tangent
-			//mul( UNITY_MATRIX_MV, float4(i.posWorld.rgb,0) ).xyz - local to view
+		protected virtual MaterialSlot GetInputSlot()
+		{
+			return new MaterialSlot(InputSlotId, GetInputSlotName(), kInputSlotName, SlotType.Input, SlotValueType.Vector3, Vector3.zero);
+		}
-			//mul( i.posWorld.rgb, tangentTransform ).xyz - tangent to world
-			//mul( unity_WorldToObject, float4(mul( i.posWorld.rgb, tangentTransform ),0) ).xyz - tangent to local
-			//mul( UNITY_MATRIX_V, float4(mul( i.posWorld.rgb, tangentTransform ),0) ).xyz - tangent to view
+		protected virtual MaterialSlot GetOutputSlot()
+		{
+			return new MaterialSlot(OutputSlotId, GetOutputSlotName(), kOutputSlotName, SlotType.Output, SlotValueType.Vector3, Vector4.zero);
+		}
-			//mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_V ).xyz - view to world
-			//mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_MV ).xyz - view to local
-			//mul( tangentTransform, mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_V ).xyz ).xyz - view to tangent
+		protected virtual string GetInputSlotName()
+		{
+			return "Input";
+		}
-			return "exp";
+		protected virtual string GetOutputSlotName()
+		{
+			return "Output";
+		}
+
+		public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+		{
+			NodeUtils.SlotConfigurationExceptionIfBadConfiguration(this, new[] { InputSlotId }, new[] { OutputSlotId });
+			string inputValue = GetSlotValue(InputSlotId, generationMode);
+			string transformString = "";
+			bool requiresTangentTransform = false;
+
+			if(spaceFrom == SimpleMatrixType.World){
+				if (spaceTo == SimpleMatrixType.World) {
+					transformString = inputValue;
+				} else if (spaceTo == SimpleMatrixType.Local) {
+					transformString = "mul(unity_WorldToObject, float4(" + inputValue + ", 0)).xyz";
+				} else if (spaceTo == SimpleMatrixType.Tangent) {
+					requiresTangentTransform = true;
+					transformString = "mul(tangentTransform, " + inputValue + ").xyz";
+				} else if (spaceTo == SimpleMatrixType.View) {
+					transformString = "mul( UNITY_MATRIX_V, float4(" + inputValue + ", 0)).xyz";
+				}
+			}else if(spaceFrom == SimpleMatrixType.Local){
+				if (spaceTo == SimpleMatrixType.World) {
+					transformString = "mul(unity_ObjectToWorld, float4(" + inputValue + ", 0)).xyz";
+				} else if (spaceTo == SimpleMatrixType.Local) {
+					transformString = inputValue;
+				} else if (spaceTo == SimpleMatrixType.Tangent) {
+					requiresTangentTransform = true;
+					transformString = "mul( tangentTransform, mul( unity_ObjectToWorld, float4(" + inputValue + ", 0) ).xyz).xyz";
+				} else if (spaceTo == SimpleMatrixType.View) {
+					transformString = "mul( UNITY_MATRIX_MV, float4(" + inputValue + ", 0)).xyz";
+				}
+			}else if(spaceFrom == SimpleMatrixType.Tangent){
+				requiresTangentTransform = true;
+				if (spaceTo == SimpleMatrixType.World) {
+					transformString = "mul( " + inputValue + ", tangentTransform ).xyz";
+				} else if (spaceTo == SimpleMatrixType.Local) {
+					transformString = "mul( unity_WorldToObject, float4(mul(" + inputValue + ", tangentTransform ),0) ).xyz";
+				} else if (spaceTo == SimpleMatrixType.Tangent) {
+					transformString = inputValue;
+				} else if (spaceTo == SimpleMatrixType.View) {
+					transformString = "mul( UNITY_MATRIX_V, float4(mul(" + inputValue + ", tangentTransform ),0) ).xyz";
+				}
+			}else if(spaceFrom == SimpleMatrixType.View){
+				if (spaceTo == SimpleMatrixType.World) {
+					transformString = "mul( float4(" + inputValue + ", 0), UNITY_MATRIX_V ).xyz";
+				} else if (spaceTo == SimpleMatrixType.Local) {
+					transformString = "mul( float4(" + inputValue + ", 0), UNITY_MATRIX_MV ).xyz";
+				} else if (spaceTo == SimpleMatrixType.Tangent) {
+					requiresTangentTransform = true;
+					transformString = "mul( tangentTransform, mul( float4(" + inputValue + ", 0), UNITY_MATRIX_V ).xyz ).xyz";
+				} else if (spaceTo == SimpleMatrixType.View) {
+					transformString = inputValue;
+				}
+			}
+
+			if(requiresTangentTransform)
+				visitor.AddShaderChunk ("float3x3 tangentTransform = float3x3( worldSpaceTangent, worldSpaceBitangent, worldSpaceNormal);", false);
+
+			visitor.AddShaderChunk(precision + outputDimension + " " + GetVariableNameForSlot(OutputSlotId) + " = " + transformString + ";", true);
+		}
+
+		//float3x3 tangentTransform = float3x3( i.tangentDir, i.bitangentDir, i.normalDir);------
+
+		//mul(unity_WorldToObject, float4(i.posWorld.rgb,0) ).xyz - world to local---------
+		//mul( tangentTransform, i.posWorld.rgb ).xyz - world to tangent-----------------
+		//mul( UNITY_MATRIX_V, float4(i.posWorld.rgb,0) ).xyz - world to view-------------
+
+		//mul( unity_ObjectToWorld, float4(i.posWorld.rgb,0) ).xyz - local to world--------
+		//mul( tangentTransform, mul( unity_ObjectToWorld, float4(i.posWorld.rgb,0) ).xyz - local to tangent------------
+		//mul( UNITY_MATRIX_MV, float4(i.posWorld.rgb,0) ).xyz - local to view--------------
+
+		//mul( i.posWorld.rgb, tangentTransform ).xyz - tangent to world---------
+		//mul( unity_WorldToObject, float4(mul( i.posWorld.rgb, tangentTransform ),0) ).xyz - tangent to local-----
+		//mul( UNITY_MATRIX_V, float4(mul( i.posWorld.rgb, tangentTransform ),0) ).xyz - tangent to view-------
+
+		//mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_V ).xyz - view to world
+		//mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_MV ).xyz - view to local
+		//mul( tangentTransform, mul( float4(i.posWorld.rgb,0), UNITY_MATRIX_V ).xyz ).xyz - view to tangent
+
+
+		public string outputDimension
+		{
+			get { return ConvertConcreteSlotValueTypeToString(FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType); }
+		}
+		private string inputDimension
+		{
+			get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlotId).concreteValueType); }
+		}
+
+		public bool RequiresTangent()
+		{
+			return true;
+		}
+
+		public bool RequiresBitangent()
+		{
+			return true;
+		}
+
+		public bool RequiresNormal(){
+			return true;
 		}
 	}
 }

MaterialGraphProject/Assets/Eduardo/FunctionNInNOut.cs

             else
                 nextSlotId = GetInputSlots<MaterialSlot>().Count() + 1;
 
-            bool useDefaultValue = (valueType != SlotValueType.sampler2D);
+            bool useDefaultValue = (valueType != SlotValueType.Texture2D);
             AddSlot(new MaterialSlot(nextSlotId, displayName, nameInShader, slotType, valueType, defaultValue, useDefaultValue));
             return nextSlotId;
         }
         public string GetSlotTypeName(int slotId)
         {
             return ConvertConcreteSlotValueTypeToString(FindSlot<MaterialSlot>(slotId).concreteValueType);
+        }
+
+        public ConcreteSlotValueType GetSlotValueType(int slotId)
+        {
+            return FindSlot<MaterialSlot>(slotId).concreteValueType;
         }
 
         protected string GetShaderOutputName(int slotId)
                 if (inSlot.isOutputSlot)
                     param += "out ";
 
-                if (FindSlot<MaterialSlot>(inSlot.id).concreteValueType != ConcreteSlotValueType.sampler2D)
+                if (FindSlot<MaterialSlot>(inSlot.id).concreteValueType != ConcreteSlotValueType.Texture2D
+                    && FindSlot<MaterialSlot>(inSlot.id).concreteValueType != ConcreteSlotValueType.SamplerState
+                    )
                     param += precision;
                 param += GetSlotTypeName(inSlot.id) + " ";
                 param += GetShaderOutputName(inSlot.id);
             int remainingParams = GetSlots<ISlot>().Count();
             foreach (ISlot inSlot in GetSlots<ISlot>())
             {
-                param += GetSlotValue(inSlot.id, generationMode);
+
+                if (FindSlot<MaterialSlot>(inSlot.id).concreteValueType == ConcreteSlotValueType.SamplerState)
+                    param += GetSamplerInput(inSlot.id);
+                else
+                    param += GetSlotValue(inSlot.id, generationMode);
 
                 if (remainingParams > 1)
                     param += ", ";
 
         private string GetFunctionCall(GenerationMode generationMode)
         {
-            return GetFunctionName() +
+            string prefix = "";
+            string sufix = "";
+            foreach (ISlot slot in GetInputSlots<MaterialSlot>())
+            {
+                if (GetSlotValueType(slot.id) == ConcreteSlotValueType.Texture2D || GetSlotValueType(slot.id) == ConcreteSlotValueType.SamplerState)
+                {
+                    prefix = "#ifdef UNITY_COMPILER_HLSL \n";
+                    sufix = "\n #endif";
+                }
+            }
+            return prefix + GetFunctionName() +
-               ");";
+               ");" + sufix;
         }
 
         private string GetOutputDeclaration()
             outputString.AddShaderChunk(GetFunctionCall(generationMode), false);
 
             visitor.AddShaderChunk(outputString.GetShaderString(0), true);
+        }
+
+        public string GetSamplerInput(int slotID)
+        {
+            //default sampler if no input is provided
+            var samplerName = "my_linear_repeat_sampler";
+
+            //Sampler input slot
+            var samplerSlot = FindInputSlot<MaterialSlot>(slotID);
+
+            if (samplerSlot != null)
+            {
+                var edgesSampler = owner.GetEdges(samplerSlot.slotReference).ToList();
+
+                if (edgesSampler.Count > 0)
+                {
+                    var edge = edgesSampler[0];
+                    var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                    samplerName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.SamplerState, true);
+                }
+            }
+
+            return samplerName;
         }
     }
 }

MaterialGraphProject/Assets/Eduardo/HeightToNormalNode.cs

 namespace UnityEngine.MaterialGraph
 {
     [Title("Utility/Heightmap To Normalmap")]
-    public class HeightToNormalNode : FunctionNInNOut, IGeneratesFunction
+    public class HeightToNormalNode : FunctionNInNOut, IGeneratesFunction, IGenerateProperties
-            AddSlot("HeightMap", "heightmap", Graphing.SlotType.Input, SlotValueType.sampler2D, Vector4.zero);
+            AddSlot("HeightMap", "heightmap", Graphing.SlotType.Input, SlotValueType.Texture2D, Vector4.zero);
             AddSlot("UV", "texCoord", Graphing.SlotType.Input, SlotValueType.Vector2, Vector4.zero);
             AddSlot("Offset", "texOffset", Graphing.SlotType.Input, SlotValueType.Vector1, new Vector4(0.005f, 0,0,0));
             AddSlot("Strength", "strength", Graphing.SlotType.Input, SlotValueType.Vector1, new Vector4(8,0,0,0));
             get { return true; }
         }
 
+        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            base.GeneratePropertyUsages(visitor, generationMode);
+
+            visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+            visitor.AddShaderChunk("SamplerState my_linear_repeat_sampler;", false);
+            visitor.AddShaderChunk("#endif", false);
+        }
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();
             outputString.AddShaderChunk("float2 offsetV = float2(texCoord.x, texCoord.y + texOffset);", false);
 
-            outputString.AddShaderChunk("float normalSample = tex2D(heightmap, texCoord).r;", false);
-            outputString.AddShaderChunk("float uSample = tex2D(heightmap, offsetU).r;", false);
-            outputString.AddShaderChunk("float vSample = tex2D(heightmap, offsetV).r;", false);
+            outputString.AddShaderChunk("float normalSample = 0;", false);
+            outputString.AddShaderChunk("float uSample = 0;", false);
+            outputString.AddShaderChunk("float vSample = 0;", false);
+
+            visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+
+            outputString.AddShaderChunk("normalSample = heightmap.Sample(my_linear_repeat_sampler, texCoord).r;", false);
+            outputString.AddShaderChunk("uSample = heightmap.Sample(my_linear_repeat_sampler, offsetU).r;", false);
+            outputString.AddShaderChunk("vSample = heightmap.Sample(my_linear_repeat_sampler, offsetV).r;", false);
+
+            visitor.AddShaderChunk("#endif", false);
 
             outputString.AddShaderChunk("float uMinusNormal = uSample - normalSample;", false);
             outputString.AddShaderChunk("float vMinusNormal = vSample - normalSample;", false);

MaterialGraphProject/Assets/GeneratedShader.shader

-Shader "Hidden/PreviewShader/Posterize_f232fbec_5ce8_4ba5_8491_a7a66291d45f_Output" {
-	Properties {
-		Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform("", Float) = 0.1
+Shader "Graph/Generated.MetallicMasterNode554b91b5-7a00-4f5f-b71a-f7729fcbdee8" 
+{
+	Properties 
+	{
+		[NonModifiableTextureData] TextureAsset_8f4a8771_6c8f_4107_9c0b_83da34d57a9b_Uniform("TextureAsset", 2D) = "white" {}
-	SubShader {
-		// inside SubShader
+SubShader 
+{
-			"Queue"="Geometry"
-			"IgnoreProjector"="True"
+			"Queue"="Geometry"
-		// inside Pass
+		Blend One Zero
+
+		Cull Back
+
+		ZTest LEqual
+
-		Blend One Zero
-		
-		Pass {
-			CGPROGRAM
-			#pragma vertex vert
-			#pragma fragment frag
-			#include "UnityCG.cginc"
+	LOD 200
+	
+	CGPROGRAM
+	#pragma target 3.0
+	#pragma surface surf Standard vertex:vert
+	#pragma glsl
+	#pragma debug
-			float3 ReflectionProbe_4f8cb744_19c5_4a6e_9bc1_172200f2fa25_normalDir;
-			float Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform;
+		#ifdef UNITY_COMPILER_HLSL
+		Texture2D TextureAsset_8f4a8771_6c8f_4107_9c0b_83da34d57a9b_Uniform;
+		#endif
+		float HeightToNormal_81cdd9a9_500d_41e2_9771_df274a2363bd_texOffset;
+		float HeightToNormal_81cdd9a9_500d_41e2_9771_df274a2363bd_strength;
+		#ifdef UNITY_COMPILER_HLSL
+		SamplerState my_linear_repeat_sampler;
+		#endif
+		#ifdef UNITY_COMPILER_HLSL
+		#endif
+		inline void unity_HeightToNormal (Texture2D heightmap, float2 texCoord, float texOffset, float strength, out float3 normalRes)
+		{
+		float2 offsetU = float2(texCoord.x + texOffset, texCoord.y);
+		float2 offsetV = float2(texCoord.x, texCoord.y + texOffset);
+		float normalSample = 0;
+		float uSample = 0;
+		float vSample = 0;
+		normalSample = heightmap.Sample(my_linear_repeat_sampler, texCoord).r;
+		uSample = heightmap.Sample(my_linear_repeat_sampler, offsetU).r;
+		vSample = heightmap.Sample(my_linear_repeat_sampler, offsetV).r;
+		float uMinusNormal = uSample - normalSample;
+		float vMinusNormal = vSample - normalSample;
+		uMinusNormal = uMinusNormal * strength;
+		vMinusNormal = vMinusNormal * strength;
+		float3 va = float3(1, 0, uMinusNormal);
+		float3 vb = float3(0, 1, vMinusNormal);
+		normalRes = cross(va, vb);
+		}
-			struct v2f 
-			{
-				float4 pos : SV_POSITION;
-				float4 color : COLOR;
-				float3 worldNormal : TEXCOORD1;
-			};
+	struct Input 
+	{
+			float4 color : COLOR;
+			half4 meshUV0;
-			inline float unity_posterize_float (float input, float stepsize)
-			{
-				return floor(input / stepsize) * stepsize;
-			}
+	};
+	void vert (inout appdata_full v, out Input o)
+	{
+		UNITY_INITIALIZE_OUTPUT(Input,o);
+			o.meshUV0 = v.texcoord;
-			v2f vert (appdata_full v) 
-			{
-				v2f o = (v2f)0;
-				o.pos = UnityObjectToClipPos(v.vertex);;
-				float3 worldPos = mul(unity_ObjectToWorld, v.vertex).xyz;
-				float3 viewDir = UnityWorldSpaceViewDir(worldPos);
-				float4 screenPos = ComputeScreenPos(UnityObjectToClipPos(v.vertex));
-				float3 worldNormal = UnityObjectToWorldNormal(v.normal);
-				o.worldNormal = worldNormal;
+	}
+  
+	void surf (Input IN, inout SurfaceOutputStandard o) 
+	{
+			half4 uv0 = IN.meshUV0;
+			float4 UV_de8d7b89_7b50_499d_aa73_0f2a725356e6_UV = uv0;
+			 float3 HeightToNormal_81cdd9a9_500d_41e2_9771_df274a2363bd_normalRes;
+			#ifdef UNITY_COMPILER_HLSL 
+			unity_HeightToNormal (TextureAsset_8f4a8771_6c8f_4107_9c0b_83da34d57a9b_Uniform, UV_de8d7b89_7b50_499d_aa73_0f2a725356e6_UV, HeightToNormal_81cdd9a9_500d_41e2_9771_df274a2363bd_texOffset, HeightToNormal_81cdd9a9_500d_41e2_9771_df274a2363bd_strength, HeightToNormal_81cdd9a9_500d_41e2_9771_df274a2363bd_normalRes);
+			 #endif
+			o.Normal = HeightToNormal_81cdd9a9_500d_41e2_9771_df274a2363bd_normalRes;
+			o.Normal += 1e-6;
-				return o;
-			}
+	}
+	ENDCG
+}
-			half4 frag (v2f IN) : COLOR
-			{
-				float3 worldSpaceNormal = normalize(IN.worldNormal);
-				float3 ReflectionProbe_4f8cb744_19c5_4a6e_9bc1_172200f2fa25 = ShadeSH9(float4(worldSpaceNormal.xyz , 1));
-				float4 Split_f630c862_c9a4_4765_b085_f9b01dd46061 = float4(ReflectionProbe_4f8cb744_19c5_4a6e_9bc1_172200f2fa25, 1.0);
-				float Posterize_f232fbec_5ce8_4ba5_8491_a7a66291d45f_Output = unity_posterize_float (Split_f630c862_c9a4_4765_b085_f9b01dd46061.r, Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform);
-				return half4(Posterize_f232fbec_5ce8_4ba5_8491_a7a66291d45f_Output, Posterize_f232fbec_5ce8_4ba5_8491_a7a66291d45f_Output, Posterize_f232fbec_5ce8_4ba5_8491_a7a66291d45f_Output, 1.0);
-			}
-			ENDCG
-		}
-	}
-	Fallback Off
-}
+	FallBack "Diffuse"
+	CustomEditor "LegacyIlluminShaderGUI"
+}

MaterialGraphProject/Assets/GraphView/Editor.meta

 fileFormatVersion: 2
-guid: 7a91bd168256a4fecb2d532dc2f38d8a
+guid: 9635695807dafd94992e8eb6a9346b63
-timeCreated: 1495668355
+timeCreated: 1485805545
 licenseType: Pro
 DefaultImporter:
   userData: 

MaterialGraphProject/Assets/Matt/CommonMatrixType.cs

         ObjectToWorld,
         WorldToObject
     };
+
+	public enum SimpleMatrixType
+	{
+		World,
+		Local,
+		Tangent,
+		View
+	};
 }

MaterialGraphProject/Assets/NewNodes/WIP/MultiLayerParallaxNode.cs

 
         protected virtual MaterialSlot GetTextureSlot()
         {
-            return new MaterialSlot(TextureSlotId, GetTextureSlotName(), kTextureSlotShaderName, SlotType.Input, SlotValueType.sampler2D, Vector4.zero);
+            return new MaterialSlot(TextureSlotId, GetTextureSlotName(), kTextureSlotShaderName, SlotType.Input, SlotValueType.Texture2D, Vector4.zero);
         }
 
         protected virtual MaterialSlot GetOutputSlot()

MaterialGraphProject/Assets/TestAssets/Materials/Default.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Default
-  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_Shader: {fileID: 4800000, guid: 9ab5e16c2083a4fe689209a8c1ae425e, type: 3}
-  m_LightmapFlags: 4
+  m_LightmapFlags: 0
   m_EnableInstancingVariants: 0
   m_CustomRenderQueue: -1
   stringTagMap: {}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
     m_Floats:
+    - Vector1_a2ac4923_bc39_4a5c_924e_e77bd500d4f3_Uniform: 1
     - _BumpScale: 1
     - _Cutoff: 0.5
     - _DetailNormalMapScale: 1

MaterialGraphProject/Assets/TestAssets/Teapot.fbx.meta

     useFileScale: 1
   tangentSpace:
     normalSmoothAngle: 60
-    normalImportMode: 0
+    normalImportMode: 1
     tangentImportMode: 3
     normalCalculationMode: 4
   importAnimation: 1

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/MaterialGraphPresenter.cs

 using UnityEditor.Graphing.Drawing;
 using UnityEngine.MaterialGraph;
+using System.Collections.Generic;
+using System.Linq;
+using RMGUI.GraphView;
 
 namespace UnityEditor.MaterialGraph.Drawing
 {
             typeMapper[typeof(GradientNode)] = typeof(GradientNodePresenter);
             typeMapper[typeof(ScatterNode)] = typeof(ScatterNodePresenter);
             typeMapper[typeof(TextureNode)] = typeof(TextureNodePresenter);
+            typeMapper[typeof(TextureSamplerNode)] = typeof(TextureSamplerNodePresenter);
+            typeMapper[typeof(SamplerStateNode)] = typeof(SamplerStateNodePresenter);
             typeMapper[typeof(CubemapNode)] = typeof(CubeNodePresenter);
 			typeMapper[typeof(ToggleNode)] = typeof(ToggleNodePresenter);
             typeMapper[typeof(UVNode)] = typeof(UVNodePresenter);
             typeMapper[typeof(Matrix4Node)] = typeof(Matrix4NodePresenter);
             typeMapper[typeof(MatrixCommonNode)] = typeof(MatrixCommonNodePresenter);
 			typeMapper[typeof(TransformNode)] = typeof(TransformNodePresenter);
+            typeMapper[typeof(ConvolutionFilterNode)] = typeof(ConvolutionFilterNodePresenter);
+        }
+
+		public override List<NodeAnchorPresenter> GetCompatibleAnchors(NodeAnchorPresenter startAnchor, NodeAdapter nodeAdapter)
+        {
+			return allChildren.OfType<NodeAnchorPresenter>()
+                              .Where(nap => nap.IsConnectable() &&
+                                     nap.orientation == startAnchor.orientation &&
+                                     nap.direction != startAnchor.direction &&
+                                     nodeAdapter.GetAdapter(nap.source, startAnchor.source) != null && 
+									(startAnchor is GraphAnchorPresenter && ((GraphAnchorPresenter)nap).slot is MaterialSlot && 
+									((MaterialSlot)((GraphAnchorPresenter)startAnchor).slot).IsCompatibleWithInputSlotType(((MaterialSlot)((GraphAnchorPresenter)nap).slot).valueType)))
+                              .ToList();
         }
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Editor/HelperShader.shader

-Shader "Graph/UnityEngine.MaterialGraph.MetallicMasterNode0dd415f6-2593-4617-b37c-c9d9dd315a4c" 
+Shader "Graph/UnityEngine.MaterialGraph.MetallicMasterNode68c240e8-1bfd-46d4-86b7-3459bc630675" 
-		Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform("", Float) = 0.1
 
 	}	
 	
 	#pragma glsl
 	#pragma debug
 
-		inline float unity_posterize_float (float input, float stepsize)
-		{
-			return floor(input / stepsize) * stepsize;
-		}
-		float Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform;
-			float3 worldNormal;
 
 	};
 
   
 	void surf (Input IN, inout SurfaceOutputStandard o) 
 	{
-			float3 worldSpaceNormal = normalize(IN.worldNormal);
-			float3 ReflectionProbe_4f8cb744_19c5_4a6e_9bc1_172200f2fa25 = ShadeSH9(float4(worldSpaceNormal.xyz , 1));
-			float4 Split_f630c862_c9a4_4765_b085_f9b01dd46061 = float4(ReflectionProbe_4f8cb744_19c5_4a6e_9bc1_172200f2fa25, 1.0);
-			float Posterize_f232fbec_5ce8_4ba5_8491_a7a66291d45f_Output = unity_posterize_float (Split_f630c862_c9a4_4765_b085_f9b01dd46061.r, Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform);
-			float Posterize_3187d243_6c53_430c_9d5e_fa7a1561872c_Output = unity_posterize_float (Split_f630c862_c9a4_4765_b085_f9b01dd46061.g, Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform);
-			float Posterize_c83cc006_d2b4_4a06_8f45_52c85f6e2a73_Output = unity_posterize_float (Split_f630c862_c9a4_4765_b085_f9b01dd46061.b, Vector1_20d0d38d_52d0_4444_8ef4_da01a311590e_Uniform);
-			float4 Combine_2e6d43a4_be04_453e_a0f2_a0520f41fea5_Output = float4(Posterize_f232fbec_5ce8_4ba5_8491_a7a66291d45f_Output,Posterize_3187d243_6c53_430c_9d5e_fa7a1561872c_Output,Posterize_c83cc006_d2b4_4a06_8f45_52c85f6e2a73_Output,0.0);
-			o.Emission = Combine_2e6d43a4_be04_453e_a0f2_a0520f41fea5_Output;
 
 	}
 	ENDCG

MaterialGraphProject/Assets/UnityShaderEditor/Editor/HelperShader.shader.meta

 fileFormatVersion: 2
 guid: 9ab5e16c2083a4fe689209a8c1ae425e
-timeCreated: 1495643268
+timeCreated: 1495720140
 licenseType: Pro
 ShaderImporter:
   defaultTextures: []

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/subshader.template

 	#pragma glsl
 	#pragma debug
 
+${ShaderPropertyUsages}
-${ShaderPropertyUsages}
+
 
 	struct Input 
 	{

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/AbstractMaterialNode.cs

                 if (edges.Any())
                     continue;
 
-                inputSlot.GeneratePropertyUsages(visitor, generationMode);
+                if (inputSlot.valueType == SlotValueType.SamplerState)
+                {
+                    visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+                    visitor.AddShaderChunk(inputSlot.valueType + " my_linear_repeat_sampler;", false);
+                    visitor.AddShaderChunk("#endif", false);
+                }
+                else
+                    inputSlot.GeneratePropertyUsages(visitor, generationMode);
             }
         }
 
                     return ConcreteSlotValueType.Vector3;
                 case SlotValueType.Vector4:
                     return ConcreteSlotValueType.Vector4;
-                case SlotValueType.sampler2D:
-                    return ConcreteSlotValueType.sampler2D;
+                case SlotValueType.Texture2D:
+                    return ConcreteSlotValueType.Texture2D;
                 case SlotValueType.Matrix2:
                     return ConcreteSlotValueType.Matrix2;
                 case SlotValueType.Matrix3:
+				case SlotValueType.SamplerState:
+                    return ConcreteSlotValueType.SamplerState;
             }
             return ConcreteSlotValueType.Error;
         }
                     return "3";
                 case ConcreteSlotValueType.Vector4:
                     return "4";
-                case ConcreteSlotValueType.sampler2D:
-                    return "sampler2D";
+                case ConcreteSlotValueType.Texture2D:
+                    return "Texture2D";
                 case ConcreteSlotValueType.Matrix2:
                     return "2x2";
                 case ConcreteSlotValueType.Matrix3:
+				case ConcreteSlotValueType.SamplerState:
+                    return "SamplerState";
+                case ConcreteSlotValueType.Sampler2D:
+                    return "sampler2D";
                 default:
                     return "Error";
             }
         {
             switch (slotValue)
             {
-                case ConcreteSlotValueType.sampler2D:
+                case ConcreteSlotValueType.Texture2D:
                     return PropertyType.Texture;
                 case ConcreteSlotValueType.Vector1:
                     return PropertyType.Float;
                     return PropertyType.Matrix3;
                 case ConcreteSlotValueType.Matrix4:
                     return PropertyType.Matrix4;
+				case ConcreteSlotValueType.SamplerState:
+                    return PropertyType.SamplerState;
+                case ConcreteSlotValueType.Sampler2D:
+                    return PropertyType.Texture;
                 default:
                     return PropertyType.Vector4;
             }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Function2Input.cs

                    + precision + input2Dimension + " " + arg2Name + ")";
         }
 
-        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
         {
             NodeUtils.SlotConfigurationExceptionIfBadConfiguration(this, new[] { InputSlot1Id, InputSlot2Id }, new[] { OutputSlotId });
             string input1Value = GetSlotValue(InputSlot1Id, generationMode);
             get { return ConvertConcreteSlotValueTypeToString(FindOutputSlot<MaterialSlot>(OutputSlotId).concreteValueType); }
         }
 
-        private string input1Dimension
+        protected string input1Dimension
-        private string input2Dimension
+        protected string input2Dimension
         {
             get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(InputSlot2Id).concreteValueType); }
         }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/MaterialSlot.cs

                     return "(3x3)";
                 case ConcreteSlotValueType.Matrix4:
                     return "(4x4)";
+                case ConcreteSlotValueType.SamplerState:
+                    return "(SS)";
+                case ConcreteSlotValueType.Texture2D:
+                    return "(T)";
+                case ConcreteSlotValueType.Sampler2D:
+                    return "(S)";
                 default:
                     return "(E)";
             }
                     case SlotValueType.Matrix4:
                         concreteValueType = ConcreteSlotValueType.Matrix4;
                         break;
+					case SlotValueType.Texture2D:
+                        concreteValueType = ConcreteSlotValueType.Texture2D;
+                        break;
+                    case SlotValueType.SamplerState:
+                        concreteValueType = ConcreteSlotValueType.SamplerState;
+                        break;
+                    case SlotValueType.Sampler2D:
+                        concreteValueType = ConcreteSlotValueType.Sampler2D;
+                        break;
                     default:
                         concreteValueType = ConcreteSlotValueType.Vector4;
                         break;
 
             visitor.AddShaderChunk(matOwner.precision + AbstractMaterialNode.ConvertConcreteSlotValueTypeToString(concreteValueType) + " " + matOwner.GetVariableNameForSlot(id) + ";", true);
         }
+
+		public bool IsCompatibleWithInputSlotType(SlotValueType inputType)
+		{
+			return (inputType == SlotValueType.Dynamic || valueType == SlotValueType.Vector1 || valueType <= inputType);
+		}
 
         public string GetDefaultValue(GenerationMode generationMode)
         {

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Procedural/CheckerboardNode.cs

 
         protected override MaterialSlot GetInputSlot2()
         {
-            return new MaterialSlot(InputSlot2Id, GetInputSlot2Name(), kInputSlot2ShaderName, UnityEngine.Graphing.SlotType.Input, SlotValueType.Vector1, Vector4.zero);
+            return new MaterialSlot(InputSlot2Id, GetInputSlot2Name(), kInputSlot2ShaderName, UnityEngine.Graphing.SlotType.Input, SlotValueType.Vector1, new Vector4(10,0,0,0));
-            return new MaterialSlot(InputSlot3Id, GetInputSlot3Name(), kInputSlot3ShaderName, UnityEngine.Graphing.SlotType.Input, SlotValueType.Vector1, Vector4.zero);
+            return new MaterialSlot(InputSlot3Id, GetInputSlot3Name(), kInputSlot3ShaderName, UnityEngine.Graphing.SlotType.Input, SlotValueType.Vector1, new Vector4(10, 0, 0, 0));
         }
         protected override MaterialSlot GetOutputSlot()
         {

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/PropertyType.cs

         Vector4,
         Matrix2,
         Matrix3,
-        Matrix4
+        Matrix4,
+		SamplerState
     }
 }

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/SlotValue.cs

     [Serializable]
     public enum SlotValueType
     {
+        Sampler2D,
+		SamplerState,
-        sampler2D,
+        Texture2D,
         Dynamic,
         Vector4,
         Vector3,
 
     public enum ConcreteSlotValueType
     {
+        Sampler2D = 10,
+		SamplerState = 9,
-        sampler2D = 5,
+        Texture2D = 5,
         Vector4 = 4,
         Vector3 = 3,
         Vector2 = 2,

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/UV/UVTileNode.cs

 
         protected override MaterialSlot GetInputSlot2()
         {
-            return new MaterialSlot(InputSlot2Id, GetInputSlot2Name(), kInputSlot2ShaderName, UnityEngine.Graphing.SlotType.Input, SlotValueType.Vector2, Vector2.zero);
+            return new MaterialSlot(InputSlot2Id, GetInputSlot2Name(), kInputSlot2ShaderName, UnityEngine.Graphing.SlotType.Input, SlotValueType.Vector2, new Vector2(2,2));
         }
 
         protected override MaterialSlot GetOutputSlot()

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/SurfaceModel/AbstractSurfaceMasterNode.cs

 
             foreach (var node in activeNodeList.OfType<AbstractMaterialNode>())
             {
+                string prefix = "";
+                string sufix = "";
+                foreach (ISlot slot in node.GetInputSlots<MaterialSlot>())
+                {
+                    SlotValueType slotValueType = FindSlot<MaterialSlot>(slot.id).valueType;
+                    if (slotValueType == SlotValueType.Texture2D || slotValueType == SlotValueType.SamplerState)
+                    {
+                        prefix = "#ifdef UNITY_COMPILER_HLSL \n";
+                        sufix = "\n #endif";
+                    }
+                }
+
+                {
+                    nodeFunction.AddShaderChunk(prefix, false);
+                    nodeFunction.AddShaderChunk(sufix, false);
+                }
 
                 node.GeneratePropertyUsages(propertyUsages, mode);
             }

MaterialGraphProject/Assets/Vlad/TextureAssetNode.cs

 
         public sealed override void UpdateNodeAfterDeserialization()
         {
-            AddSlot(new MaterialSlot(OutputSlotRgbaId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, SlotValueType.sampler2D, Vector4.zero, false));
+            AddSlot(new MaterialSlot(OutputSlotRgbaId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, SlotValueType.Texture2D, Vector4.zero, false));
             RemoveSlotsNameNotMatching(validSlots);
         }
 
         
         public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
         {
-            visitor.AddShaderChunk("sampler2D " + propertyName + ";", true);
+            visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", true);
+            visitor.AddShaderChunk("Texture2D " + propertyName + ";", true);
+            visitor.AddShaderChunk("#endif", true);
-        
+
 
 
         public override PreviewProperty GetPreviewProperty()

MaterialGraphProject/Assets/Vlad/UVTriPlanar.cs

 namespace UnityEngine.MaterialGraph
 {
     [Title("UV/Tri-Planar Mapping")]
-    public class UVTriPlanar : Function3Input, IGeneratesFunction, IMayRequireNormal, IMayRequireWorldPosition
+    public class UVTriPlanar : FunctionNInNOut, IGeneratesFunction, IMayRequireNormal, IMayRequireWorldPosition
+        private int slot0, slot1, slot2, slot3, slot4, slot5, slot6 = 0;
-        private const string kTextureSlotName = "Texture";
-        private const string kTileSlotName = "Tile";
-        private const string kBlendSlotName = "Blend";
+        private string slot0Name = "texRef";
+        private string slot1Name = "tileFactor";
+        private string slot2Name = "blendFactor";
+        private string slot3Name = "samplerRef";
+        private string slot4Name = "normalRef";
+        private string slot5Name = "posRef";
+        private string slot6Name = "outputRef";
 
         protected override string GetFunctionName()
         {
-        protected override MaterialSlot GetInputSlot1()
+        public UVTriPlanar()
-            return new MaterialSlot(InputSlot1Id, kTextureSlotName, kTextureSlotName, SlotType.Input, SlotValueType.sampler2D, Vector4.zero, false);
-        }
+            name = "UVTriPlanar";
-        protected override MaterialSlot GetInputSlot2()
-        {
-            return new MaterialSlot(InputSlot2Id, kTileSlotName, kTileSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.one);
-        }
+            slot0 = AddSlot("Texture", slot0Name, Graphing.SlotType.Input, SlotValueType.Texture2D, Vector4.zero);
+            slot1 = AddSlot("Tile", slot1Name, Graphing.SlotType.Input, SlotValueType.Vector1, Vector4.zero);
+            slot2 = AddSlot("Blend", slot2Name, Graphing.SlotType.Input, SlotValueType.Vector1, Vector4.zero);
+            slot3 = AddSlot("Sampler", slot3Name, Graphing.SlotType.Input, SlotValueType.SamplerState, Vector4.zero);
+            slot4 = AddSlot("Normals", slot4Name, Graphing.SlotType.Input, SlotValueType.Vector3, Vector3.one);
+            slot5 = AddSlot("Position", slot5Name, Graphing.SlotType.Input, SlotValueType.Vector3, Vector3.one);
+            slot6 = AddSlot("RGBA ", slot6Name, Graphing.SlotType.Output, SlotValueType.Vector4, Vector4.zero);
-        protected override MaterialSlot GetInputSlot3()
-        {
-            return new MaterialSlot(InputSlot3Id, kBlendSlotName, kBlendSlotName, SlotType.Input, SlotValueType.Vector1, Vector4.one);
-        }
-
-        protected override MaterialSlot GetOutputSlot()
-        {
-            return new MaterialSlot(OutputSlotId, kTextureSlotName, kOutputSlotShaderName, SlotType.Output, SlotValueType.Vector4, Vector4.zero);
-        }
-
-        public UVTriPlanar()
-        {
-            name = "UVTriPlanar";
             UpdateNodeAfterDeserialization();
         }
 
 			}
 		}
 
-		protected override string GetFunctionPrototype(string arg1Name, string arg2Name, string arg3Name)
-        {
-            return "inline " + precision + outputDimension + " " + GetFunctionName() + " ("
-                   + "sampler2D " + arg1Name + ", " 
-                   + precision + " " + arg2Name + ", " 
-                   + precision + " " + arg3Name + 
-                   ", float3 normal, float3 pos)";
-        }
-        protected override string GetFunctionCallBody(string input1Value, string input2Value, string input3Value)
-        {
-            return GetFunctionName() + " (" + input1Value + ", " + input2Value + ", " + input3Value + ", IN.worldNormal, IN.worldPos)";
-        }
-
-        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
-        {
-            base.GeneratePropertyUsages(visitor, generationMode);
-        }
 
         //TODO:Externalize
         //Reference code from:http://www.chilliant.com/rgb2hsv.html
-
-            var textureSlot = FindInputSlot<MaterialSlot>(InputSlot1Id);
-            if (textureSlot == null)
-                return;
-
-            var textureName = "";
+            //Sampler input
+            var samplerName = GetSamplerInput(3);
+            outputString.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
-            var edges = owner.GetEdges(textureSlot.slotReference).ToList();
-            if (edges.Count > 0)
-            {
-                var edge = edges[0];
-                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
-                textureName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.sampler2D, true);
-            }
-              
-
-            outputString.AddShaderChunk(GetFunctionPrototype("arg1", "arg2", "arg3"), false);
+           // outputString.AddShaderChunk(GetFunctionPrototype("arg1", "arg2", "arg3", samplerName), false);
+            outputString.AddShaderChunk(GetFunctionPrototype(), false);
+            outputString.Indent();
-            outputString.Indent();
-
-            outputString.AddShaderChunk("fixed3 uvs = pos * arg2;", false);
+            outputString.AddShaderChunk("float3 uvs = " + slot5Name + "*" + slot1Name + ";", false);
-            outputString.AddShaderChunk("half3 blend = pow(abs(normal), arg3);", false);
+            outputString.AddShaderChunk("half3 blend = pow(abs(" + slot4Name + ")," + slot2Name + ");", false);
-            outputString.AddShaderChunk("fixed4 cx = tex2D(arg1, uvs.yz);", false);
-            outputString.AddShaderChunk("fixed4 cy = tex2D(arg1, uvs.xz);", false);
-            outputString.AddShaderChunk("fixed4 cz = tex2D(arg1, uvs.xy);", false);
+            outputString.AddShaderChunk("float4 cx = " + slot0Name + ".Sample(" + slot3Name + ", uvs.yz);", false);
+            outputString.AddShaderChunk("float4 cy = " + slot0Name + ".Sample(" + slot3Name + ", uvs.xz);", false);
+            outputString.AddShaderChunk("float4 cz = " + slot0Name + ".Sample(" + slot3Name + ", uvs.xy);", false);
-            outputString.AddShaderChunk("fixed4 c = cx * blend.x + cy * blend.y + cz * blend.z;", false);
-            
-            outputString.AddShaderChunk("return " + "c;", false);
+            outputString.AddShaderChunk(slot6Name + " = cx * blend.x + cy * blend.y + cz * blend.z;", false);
+
+            //outputString.AddShaderChunk("return " + "c;", false);
-
+            outputString.AddShaderChunk("#endif", true);
+        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            
+    //Sampler input slot
+            
+            base.GeneratePropertyUsages(visitor, generationMode);
+            var samplerSlot = FindInputSlot<MaterialSlot>(slot3);
+
+            if (samplerSlot != null)
+            {
+                var samplerName = GetSamplerInput(slot3);
+
+                visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+                visitor.AddShaderChunk("SamplerState " + samplerName + ";", true);
+                visitor.AddShaderChunk("#endif", false);
+            }
+        }
+
+
-            var slot = FindInputSlot<MaterialSlot>(InputSlot1Id);
+            var slot = FindInputSlot<MaterialSlot>(0);
             if (slot == null)
                 return;
 

MaterialGraphProject/Assets/_MingWai/ColorBalanceNode.cs

 namespace UnityEngine.MaterialGraph
 {
-    [Title("ColorBalance")]
+    [Title("Art/Adjustments/ColorBalance")]
     public class ColorBalanceNode : FunctionNInNOut, IGeneratesFunction
     {
         public ColorBalanceNode()

MaterialGraphProject/Assets/_MingWai/ScatterNode.cs

         public ScatterNode()
         {
             name = "Scatter";
-            AddSlot("Texture", "inputTex", Graphing.SlotType.Input, SlotValueType.sampler2D, Vector4.zero);
+            AddSlot("TextureAsset", "inputTex", Graphing.SlotType.Input, SlotValueType.Texture2D, Vector4.zero);
+            AddSlot("SamplerState", "inputSampler", Graphing.SlotType.Input, SlotValueType.SamplerState, Vector4.zero);
             AddSlot("UV", "inputUV", Graphing.SlotType.Input, SlotValueType.Vector2, Vector2.one);
             AddSlot("Seed", "seed", Graphing.SlotType.Input, SlotValueType.Vector2, Vector2.one);
             AddSlot("PositionRange", "p_range", Graphing.SlotType.Input, SlotValueType.Vector2, Vector2.zero);
             get { return true; }
         }
 
+        public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+
+            //Sampler input slot
+
+            base.GeneratePropertyUsages(visitor, generationMode);
+            var samplerSlot = FindInputSlot<MaterialSlot>(2);
+
+            if (samplerSlot != null)
+            {
+                var samplerName = GetSamplerInput(2);
+
+                visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+                visitor.AddShaderChunk("SamplerState " + samplerName + ";", true);
+                visitor.AddShaderChunk("#endif", false);
+            }
+        }
+
         public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
         {
             var outputString = new ShaderGenerator();
             outputString.AddShaderChunk("{", false);
             outputString.Indent();
             outputString.AddShaderChunk("float randomno =  frac(sin(dot(randomseed, float2(12.9898, 78.233)))*43758.5453);", false);
-            outputString.AddShaderChunk("return floor(randomno * (max - min + 1)) + min;", false);
+            outputString.AddShaderChunk("return lerp(min,max,abs(frac(randomno)));", false);
+            //outputString.AddShaderChunk("return floor(randomno * (max - min + 1)) + min;", false);
             outputString.Deindent();
             outputString.AddShaderChunk("}", false);
 
             outputString.Indent();
 
             outputString.AddShaderChunk("finalColor = float4(0,0,0,0);", false);
-            outputString.AddShaderChunk("float2 newuv = inputUV;", false);
-            outputString.AddShaderChunk("float4 tex = tex2D(inputTex,newuv);", false);
-            
+            outputString.AddShaderChunk("float2 newuv;", false);
+            outputString.AddShaderChunk("float4 tex = finalColor;", false);
+
+            outputString.AddShaderChunk("float scale;", false);
+            outputString.AddShaderChunk("float rotation;", false);
+            outputString.AddShaderChunk("float2 position;", false);
+            outputString.AddShaderChunk("float j;", false);
+
+
-                outputString.AddShaderChunk("newuv *= randomrange(seed,s_range.x,s_range.y);", false); //Scale
-                outputString.AddShaderChunk("newuv = rotateUV(newuv,randomrange(seed,r_range.x,r_range.y));", false); //Rotate
-                outputString.AddShaderChunk("newuv += randomrange(seed,p_range.x,p_range.y));", false); //Position
+
+                outputString.AddShaderChunk("newuv = inputUV;", false);
+                outputString.AddShaderChunk("j = "+i+"+0.001f;", false);
-                //seamless
+                outputString.AddShaderChunk("scale = randomrange(seed+j,s_range.x,s_range.y);", false); //Random Scale
+                outputString.AddShaderChunk("newuv *= scale;", false); //Scale
+                outputString.AddShaderChunk("newuv -= (scale-1)*0.5f;", false); //Move to Center After Scale
+                outputString.AddShaderChunk("rotation = randomrange(seed+j,r_range.x,r_range.y);", false); //Random rotation
+                outputString.AddShaderChunk("newuv = rotateUV(newuv,rotation);", false); //Rotate
+
+                outputString.AddShaderChunk("position.x = randomrange(seed.x+j,p_range.x,p_range.y);", false); //Random position
+                outputString.AddShaderChunk("position.y = randomrange(seed.y+j,p_range.x,p_range.y);", false); //Random position
+                outputString.AddShaderChunk("newuv += position*scale;", false); //Position
-                outputString.AddShaderChunk("tex = tex2D(inputTex,newuv);", false);
+                outputString.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+                outputString.AddShaderChunk("tex = inputTex.Sample(inputSampler, newuv);", false);
+                outputString.AddShaderChunk("#endif",false);
-                outputString.AddShaderChunk("finalColor += tex/"+m_num+";", false);
+                outputString.AddShaderChunk("finalColor = lerp(finalColor,tex, tex.a);", false);
+
+                //seamless
+                outputString.AddShaderChunk("newuv = 1-newuv;", false);
+                outputString.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+                outputString.AddShaderChunk("tex = inputTex.Sample(inputSampler, newuv);", false);
+                outputString.AddShaderChunk("#endif", false);
+                //blend seamless
+                outputString.AddShaderChunk("finalColor = lerp(finalColor,tex, tex.a);", false);
+
             }
 
             outputString.Deindent();

MaterialGraphProject/ProjectSettings/ProjectSettings.asset

   webGLUseEmbeddedResources: 0
   webGLUseWasm: 0
   webGLCompressionFormat: 1
-  scriptingDefineSymbols: {}
+  scriptingDefineSymbols:
+    1: CROSS_PLATFORM_INPUT
+    4: CROSS_PLATFORM_INPUT;MOBILE_INPUT
+    7: CROSS_PLATFORM_INPUT;MOBILE_INPUT
+    14: CROSS_PLATFORM_INPUT;MOBILE_INPUT
+    17: MOBILE_INPUT
+    20: MOBILE_INPUT
+    22: MOBILE_INPUT
   platformArchitecture: {}
   scriptingBackend:
     Android: 0

MaterialGraphProject/ProjectSettings/QualitySettings.asset

     shadowProjection: 1
     shadowCascades: 1
     shadowDistance: 15
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
     blendWeights: 1
     textureQuality: 1
     anisotropicTextures: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
-    lodBias: .300000012
+    lodBias: 0.3
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
     excludedTargetPlatforms: []
   - serializedVersion: 2
     name: Fast
     shadowProjection: 1
     shadowCascades: 1
     shadowDistance: 20
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
     blendWeights: 2
     textureQuality: 0
     anisotropicTextures: 0
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
-    lodBias: .400000006
+    lodBias: 0.4
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
     excludedTargetPlatforms: []
   - serializedVersion: 2
     name: Simple
     shadowProjection: 1
     shadowCascades: 1
     shadowDistance: 20
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 0
     blendWeights: 2
     textureQuality: 0
     anisotropicTextures: 1
+    realtimeReflectionProbes: 0
+    billboardsFaceCameraPosition: 0
-    lodBias: .699999988
+    lodBias: 0.7
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
     excludedTargetPlatforms: []
   - serializedVersion: 2
     name: Good
     shadowProjection: 1
-    shadowCascades: 2
-    shadowDistance: 40
+    shadowCascades: 4
+    shadowDistance: 80
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.074709564, y: 0.15174267, z: 0.2816801}
+    shadowmaskMode: 1
     blendWeights: 2
     textureQuality: 0
     anisotropicTextures: 1
+    realtimeReflectionProbes: 1
+    billboardsFaceCameraPosition: 1
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
     excludedTargetPlatforms: []
   - serializedVersion: 2
     name: Beautiful
     shadowProjection: 1
     shadowCascades: 2
     shadowDistance: 70
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
     blendWeights: 4
     textureQuality: 0
     anisotropicTextures: 2
+    realtimeReflectionProbes: 1
+    billboardsFaceCameraPosition: 1
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
     excludedTargetPlatforms: []
   - serializedVersion: 2
     name: Fantastic
     shadowProjection: 1
     shadowCascades: 4
     shadowDistance: 150
+    shadowNearPlaneOffset: 3
+    shadowCascade2Split: 0.33333334
+    shadowCascade4Split: {x: 0.06666667, y: 0.2, z: 0.46666667}
+    shadowmaskMode: 1
     blendWeights: 4
     textureQuality: 0
     anisotropicTextures: 2
+    realtimeReflectionProbes: 1
+    billboardsFaceCameraPosition: 1
+    asyncUploadTimeSlice: 2
+    asyncUploadBufferSize: 4
+    resolutionScalingFixedDPIFactor: 1
-  m_PerPlatformDefaultQuality: {}
+  m_PerPlatformDefaultQuality:
+    Standalone: 0

MaterialGraphProject/Assets/Florent.meta

+fileFormatVersion: 2
+guid: e9dab59e587c7f244adde1add29b34fc
+folderAsset: yes
+timeCreated: 1495531757
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Matt/Examples/Anisotropy.ShaderGraph.meta

+fileFormatVersion: 2
+guid: 85377c065145c6f4380b09435f049950
+timeCreated: 1495721666
+licenseType: Pro
+ScriptedImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}

MaterialGraphProject/Assets/Matt/Examples/Anisotropy.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Anisotropy
+  m_Shader: {fileID: 4800000, guid: 9ab5e16c2083a4fe689209a8c1ae425e, type: 3}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 0
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - Texture_3db1140f_b814_4ba5_a49c_d40499367921_Uniform:
+        m_Texture: {fileID: 2800000, guid: cbf25f5368b2350408963109a1c8f22d, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - Vector1_3c037cd0_a4ae_48b0_8e8c_e1507ff6f738_Uniform: 1
+    - Vector1_da8ece50_8bc4_4e14_b77a_24dfc74c32da_Uniform: 0.817
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

MaterialGraphProject/Assets/Matt/Examples/Anisotropy.mat.meta

+fileFormatVersion: 2
+guid: b691b84f941db2740ba393773c55e10e
+timeCreated: 1495722255
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Matt/Examples/Grain.ShaderGraph.meta

+fileFormatVersion: 2
+guid: 778b0a6ad2007a14e8beec62e3904ba4
+timeCreated: 1495717986
+licenseType: Pro
+ScriptedImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}

MaterialGraphProject/Assets/NewNodes/WIP/POMNode.cs

+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("UV/ParallaxOcclusionMapping")]
+    public class ParallaxOcclusionMappingNode : 
+        AbstractMaterialNode, 
+        IGeneratesBodyCode, 
+        IGeneratesFunction, 
+        IMayRequireMeshUV,
+        IMayRequireViewDirection,
+        IMayRequireNormal,
+        IMayRequireViewDirectionTangentSpace
+    {
+        protected const string kInputHeightScaleShaderName = "HeightScale";
+        protected const string kTextureSlotShaderName = "Texture";
+        protected const string kOutputSlotShaderName = "UV";
+
+        public const int HeightScaleSlotId = 0;         // 'height_scale'
+        public const int TextureSlotId = 1;             // 'tex'
+        public const int OutputSlotId = 2;
+
+        public override bool hasPreview
+        {
+            get { return true; }
+        }
+
+        public override PreviewMode previewMode
+        {
+            get
+            {
+                return PreviewMode.Preview3D;
+            }
+        }
+
+        public ParallaxOcclusionMappingNode()
+        {
+            name = "ParallaxOcclusionMapping";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public string GetFunctionName()
+        {
+            return "unity_parallax_occlusion_mapping_" + precision;
+        }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(GetInputHeightScaleSlot());
+            AddSlot(GetTextureSlot());
+            AddSlot(GetOutputSlot());
+
+            RemoveSlotsNameNotMatching(validSlots);
+        }
+
+        protected int[] validSlots
+        {
+            get { return new[] { HeightScaleSlotId, TextureSlotId, OutputSlotId }; }
+        }
+        protected virtual string GetInputHeightScaleName()
+        {
+            return kInputHeightScaleShaderName;
+        }
+        protected virtual MaterialSlot GetInputHeightScaleSlot()
+        {
+            return new MaterialSlot(
+                HeightScaleSlotId, GetInputHeightScaleName(), kInputHeightScaleShaderName, SlotType.Input, SlotValueType.Vector1, Vector4.zero);
+        }
+        protected virtual MaterialSlot GetTextureSlot()
+        {
+            return new MaterialSlot(TextureSlotId, GetTextureSlotName(), kTextureSlotShaderName, SlotType.Input, SlotValueType.Texture2D, Vector4.zero);
+        }
+
+        protected virtual MaterialSlot GetOutputSlot()
+        {
+            return new MaterialSlot(OutputSlotId, GetOutputSlotName(), kOutputSlotShaderName, SlotType.Output, SlotValueType.Vector2, Vector4.zero);
+        }
+
+        protected virtual string GetTextureSlotName()
+        {
+            return kTextureSlotShaderName;
+        }
+        
+        protected virtual string GetOutputSlotName()
+        {
+            return kOutputSlotShaderName;
+        }
+
+        private string inputHeightScaleDimension
+        {
+            get { return ConvertConcreteSlotValueTypeToString(FindInputSlot<MaterialSlot>(HeightScaleSlotId).concreteValueType); }
+        }
+
+        protected virtual string GetFunctionPrototype(
+            string heightScale, string tex, string UVs, string viewTangentSpace, string worldSpaceNormal, string worldSpaceViewDirection)
+        {
+            return "inline " + precision + "2 " + GetFunctionName() + " (" +
+                precision + inputHeightScaleDimension + " " + heightScale + ", " + 
+                "sampler2D " + tex + ", " +
+                precision + "2 " + UVs + ", " +
+                precision + "3 " + viewTangentSpace + ", " +
+                precision + "3 " + worldSpaceNormal + ", " +
+                precision + "3 " + worldSpaceViewDirection + ")";
+        }
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            NodeUtils.SlotConfigurationExceptionIfBadConfiguration(
+                this, 
+                new[] { HeightScaleSlotId, TextureSlotId }, 
+                new[] { OutputSlotId });
+            string heightScaleValue = GetSlotValue(HeightScaleSlotId, generationMode);
+            string textureValue = GetSlotValue(TextureSlotId, generationMode);
+
+            visitor.AddShaderChunk(precision + "2 " + GetVariableNameForSlot(OutputSlotId) + " = " + 
+                GetFunctionCallBody(heightScaleValue, textureValue) + ";", true);
+        }
+
+        public void GenerateNodeFunction(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+            var outputString = new ShaderGenerator();
+            outputString.AddShaderChunk(
+                    GetFunctionPrototype("heightScale", "tex", "UVs", "viewTangentSpace", "worldSpaceNormal", "worldSpaceViewDirection" ), 
+                    false);
+            
+            outputString.AddShaderChunk("{", false);
+            outputString.Indent();
+
+            outputString.AddShaderChunk(precision + "2 " + "height_map_dimensions = " + precision + "2" + "(256.0f, 256.0f);      //HARDCODE", false);
+            //height_map.tex.GetDimensions(height_map_dimensions.x, height_map_dimensions.y);
+
+            outputString.AddShaderChunk(precision + "2 texcoord= UVs;", false);
+
+            // Compute the current gradients:
+            outputString.AddShaderChunk(precision + "2 " + " texcoords_per_size = texcoord * height_map_dimensions;", false);
+
+            // Compute all 4 derivatives in x and y in a single instruction to optimize:
+            outputString.AddShaderChunk("float2 dx, dy;", false);
+
+            outputString.AddShaderChunk(" float4 temp_ddx = ddx(float4(texcoords_per_size, texcoord));", false);
+
+            outputString.AddShaderChunk("dx.xy = temp_ddx.zw;", false);
+
+            outputString.AddShaderChunk("float4 temp_ddy = ddy(float4(texcoords_per_size, texcoord));", false);
+
+            outputString.AddShaderChunk("dy.xy = temp_ddy.zw;", false);
+
+            // Start the current sample located at the input texture coordinate, which would correspond
+            // to computing a bump mapping result:
+            outputString.AddShaderChunk(precision + "2 " + "result_texcoord = texcoord;", false);
+
+            outputString.AddShaderChunk("float height_scale_value = heightScale;", false);
+            outputString.AddShaderChunk("float height_scale_adjust = height_scale_value;", false);
+
+
+            outputString.AddShaderChunk("float per_pixel_height_scale_value = height_scale_value * heightScale;", false);
+            
+            // Parallax occlusion mapping offset computation 
+            //--------------
+
+            // Utilize dynamic flow control to change the number of samples per ray 
+            // depending on the viewing angle for the surface. Oblique angles require 
+            // smaller step sizes to achieve more accurate precision for computing displacement.
+            // We express the sampling rate as a linear function of the angle between 
+            // the geometric normal and the view direction ray:
+            outputString.AddShaderChunk("float max_samples = 30.0f;", false);
+            outputString.AddShaderChunk("float min_samples = 4.0f;", false);
+
+            outputString.AddShaderChunk("float view_dot_normal= dot(worldSpaceNormal, worldSpaceViewDirection);", false);
+
+            outputString.AddShaderChunk("int number_of_steps = (int)lerp(max_samples, min_samples, saturate(view_dot_normal));", false);
+
+            // Intersect the view ray with the height field profile along the direction of
+            // the parallax offset ray (computed in the vertex shader. Note that the code is
+            // designed specifically to take advantage of the dynamic flow control constructs
+            // in HLSL and is very sensitive to specific syntax. When converting to other examples,
+            // if still want to use dynamic flow control in the resulting assembly shader,
+            // care must be applied.
+            // 
+            // In the below steps we approximate the height field profile as piecewise linear
+            // curve. We find the pair of endpoints between which the intersection between the 
+            // height field profile and the view ray is found and then compute line segment
+            // intersection for the view ray and the line segment formed by the two endpoints.
+            // This intersection is the displacement offset from the original texture coordinate.
+            // See the above SI3D 06 paper for more details about the process and derivation.
+            //
+
+            outputString.AddShaderChunk("float current_height = 0.0;", false);
+            outputString.AddShaderChunk("float step_size = 1.0 / (float)number_of_steps;", false);
+
+            outputString.AddShaderChunk("float previous_height = 1.0;", false);
+            outputString.AddShaderChunk("float next_height = 0.0;", false);
+
+
+            outputString.AddShaderChunk("int step_index = 0;", false);
+
+            // Optimization: this should move to vertex shader, however, we compute it here for simplicity of
+            // integration into our shaders for now.
+            outputString.AddShaderChunk("float3 normalized_view_dir_in_tangent_space = normalize(viewTangentSpace.xyz);", false);
+
+            // Compute initial parallax displacement direction:
+            outputString.AddShaderChunk("float2 parallax_direction = normalize(viewTangentSpace.xy);", false);
+
+            // The length of this vector determines the furthest amount of displacement:
+            outputString.AddShaderChunk("float parallax_direction_length = length(normalized_view_dir_in_tangent_space);", false);
+
+            outputString.AddShaderChunk(
+                "float max_parallax_amount = sqrt(parallax_direction_length * parallax_direction_length - viewTangentSpace.z * viewTangentSpace.z) / viewTangentSpace.z;", false);
+
+            // Compute the actual reverse parallax displacement vector:
+            outputString.AddShaderChunk("float2 parallax_offset_in_tangent_space = parallax_direction * max_parallax_amount;", false);
+
+            // Need to scale the amount of displacement to account for different height ranges
+            // in height maps. This is controlled by an artist-editable parameter:
+            outputString.AddShaderChunk("parallax_offset_in_tangent_space *= saturate(heightScale);", false); 
+
+            outputString.AddShaderChunk("float2 texcoord_offset_per_step = step_size * parallax_offset_in_tangent_space;", false);
+
+            outputString.AddShaderChunk(precision + "2 " + "current_texcoord_offset = texcoord;", false);
+            outputString.AddShaderChunk("float current_bound = 1.0;", false);
+
+            outputString.AddShaderChunk("float current_parallax_amount = 0.0;", false);
+
+            outputString.AddShaderChunk("float2 pt1 = 0;", false);
+            outputString.AddShaderChunk("float2 pt2 = 0;", false);
+
+
+            outputString.AddShaderChunk(precision + "2 " + "temp_texcoord_offset = 0;", false);
+
+            outputString.AddShaderChunk("while (step_index < number_of_steps)", false);
+            outputString.AddShaderChunk("{", false);
+            outputString.Indent();
+
+            outputString.AddShaderChunk("current_texcoord_offset -= texcoord_offset_per_step;", false);
+
+            // Sample height map which in this case is stored in the alpha channel of the normal map:
+            outputString.AddShaderChunk("current_height = tex2Dgrad(tex, current_texcoord_offset, dx, dy).r;", false);
+
+            outputString.AddShaderChunk("current_bound -= step_size;", false);
+
+            outputString.AddShaderChunk("if (current_height > current_bound)", false);
+            outputString.AddShaderChunk("{", false);
+            outputString.Indent();
+
+            outputString.AddShaderChunk("pt1 = float2(current_bound, current_height);", false);
+
+            outputString.AddShaderChunk("pt2 = float2(current_bound + step_size, previous_height);", false);
+
+
+            outputString.AddShaderChunk("temp_texcoord_offset = current_texcoord_offset - texcoord_offset_per_step;", false);
+            
+            outputString.AddShaderChunk("step_index = number_of_steps + 1;", false);
+
+            outputString.Deindent();
+            outputString.AddShaderChunk("}", false);
+            outputString.AddShaderChunk("else", false);
+
+            outputString.AddShaderChunk("{", false);
+            outputString.Indent();
+
+            outputString.AddShaderChunk("step_index++;", false);
+            outputString.AddShaderChunk("previous_height = current_height;", false);
+
+            outputString.Deindent();
+            outputString.AddShaderChunk("}", false);
+
+            outputString.Deindent();
+            outputString.AddShaderChunk("}   // End of while ( step_index < number_of_steps)", false);
+
+
+            outputString.AddShaderChunk("float delta2 = pt2.x - pt2.y;", false);
+            outputString.AddShaderChunk("float delta1 = pt1.x - pt1.y;", false);
+
+            outputString.AddShaderChunk("float denominator = delta2 - delta1;", false);
+
+            // SM 3.0 and above requires a check for divide by zero since that operation
+            // will generate an 'Inf' number instead of 0
+            outputString.AddShaderChunk("if (denominator== 0.0f) ", false);
+            outputString.AddShaderChunk("{", false);
+            outputString.Indent();
+            outputString.AddShaderChunk("current_parallax_amount= 0.0f;", false);
+            outputString.Deindent();
+            outputString.AddShaderChunk("}", false);
+            outputString.AddShaderChunk("else", false);
+            outputString.AddShaderChunk("{", false);
+            outputString.Indent();
+            outputString.AddShaderChunk("current_parallax_amount= (pt1.x* delta2 - pt2.x* delta1) / denominator;", false);
+            outputString.Deindent();
+            outputString.AddShaderChunk("}", false);
+
+            outputString.AddShaderChunk("float2 parallax_offset = parallax_offset_in_tangent_space * (1.0f - current_parallax_amount);", false);
+
+            // The computed texture offset for the displaced point on the pseudo-extruded surface:
+            outputString.AddShaderChunk("float2 parallaxed_texcoord = texcoord - parallax_offset;", false);
+
+            outputString.AddShaderChunk("return parallaxed_texcoord;", false);
+
+            outputString.Deindent();
+            outputString.AddShaderChunk("}", false);
+
+            visitor.AddShaderChunk(outputString.GetShaderString(0), true);
+        }
+
+        protected virtual string GetFunctionCallBody(string heightScale, string texValue)
+        {
+            var channel = UVChannel.uv0;
+            
+            return GetFunctionName() + " (" +
+                heightScale + ", " + 
+                texValue + ", " +
+                channel.GetUVName() + ", " +
+                ShaderGeneratorNames.TangentSpaceViewDirection + ", " +
+                ShaderGeneratorNames.WorldSpaceNormal + ", " +
+                ShaderGeneratorNames.WorldSpaceViewDirection + ")";
+        }
+
+        public bool RequiresMeshUV(UVChannel channel)
+        {
+            return channel == UVChannel.uv0;
+        }
+        public bool RequiresViewDirectionTangentSpace()
+        {
+            return true;
+        }
+        public bool RequiresNormal()
+        {
+            return true;
+        }
+        public bool RequiresViewDirection()
+        {
+            return true;
+        }
+    }
+}
+

MaterialGraphProject/Assets/NewNodes/WIP/POMNode.cs.meta

+fileFormatVersion: 2
+guid: daac036bc09be70438149124ccd0a11b
+timeCreated: 1495700896
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/POM_Graph.ShaderGraph.meta

+fileFormatVersion: 2
+guid: 96bf971901c0d7c468d21e8511ced163
+timeCreated: 1495479560
+licenseType: Pro
+ScriptedImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 11500000, guid: 625f186215c104763be7675aa2d941aa, type: 3}

MaterialGraphProject/Assets/Rinaldo/DemoScene.meta

+fileFormatVersion: 2
+guid: f413b728b2f6460418512648f4132898
+folderAsset: yes
+timeCreated: 1495695266
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/TestAssets/ColorTransparent.tif.meta

+fileFormatVersion: 2
+guid: 75446046af0bacb4eac0858374f720b5
+timeCreated: 1490800222
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 2
+  alphaIsTransparency: 1
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  - buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/TestAssets/TangentMap1.jpg.meta

+fileFormatVersion: 2
+guid: fd9dcc0042b460046917799942414fe0
+timeCreated: 1495721640
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/TestAssets/TangentMap2.jpg.meta

+fileFormatVersion: 2
+guid: ff1fa8d5d8b0945499c7785f1b0f2a4f
+timeCreated: 1495721640
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/TestAssets/TangentMap3.jpg.meta

+fileFormatVersion: 2
+guid: cbf25f5368b2350408963109a1c8f22d
+timeCreated: 1495721640
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/ConvolutionFilterNodePresenter.cs

+using System;
+using System.Collections.Generic;
+using RMGUI.GraphView;
+using UnityEditor.Graphing.Drawing;
+using UnityEngine.MaterialGraph;
+using UnityEngine;
+
+namespace UnityEditor.MaterialGraph.Drawing
+{
+    class ConvolutionFilterControlPresenter : GraphControlPresenter
+    {
+        enum KernelPresets
+        {
+            Presets,
+            BoxBlur,
+            GaussianBlur,
+            EdgesDetection,
+            EnhanceEdges,
+            Sharpen,
+            Emboss,
+        };
+
+        private void ApplyPreset(KernelPresets preset, ref float[,] values, ref float divisor)
+        {
+            if (preset == KernelPresets.BoxBlur)
+            {
+                values = new float[,] { {1,1,1,1,1},
+                                        {1,1,1,1,1},
+                                        {1,1,1,1,1},
+                                        {1,1,1,1,1},
+                                        {1,1,1,1,1} };
+                divisor = 25;
+            }
+            if (preset == KernelPresets.GaussianBlur)
+            {
+                values = new float[,] { { 1, 4, 6, 4, 1},
+                                        { 4,16,24,16, 4},
+                                        { 6,24,36,24, 6},
+                                        { 4,16,24,16, 4},
+                                        { 1, 4, 6, 4, 1} };
+                divisor = 256;
+            }
+            if (preset == KernelPresets.EdgesDetection)
+            {
+                values = new float[,] { {-1,-1,-1, -1,-1},
+                                        {-1,-2,-2, -2,-1},
+                                        {-1,-2, 33,-2,-1},
+                                        {-1,-2,-2, -2,-1},
+                                        {-1,-1,-1, -1,-1} };
+                divisor = 1;
+            }
+            if (preset == KernelPresets.EnhanceEdges)
+            {
+                values = new float[,] { { 0, 0, 0, 0, 0},
+                                        { 0, 1, 1, 1, 0},
+                                        { 0, 1,-7, 1, 0},
+                                        { 0, 1, 1, 1, 0},
+                                        { 0, 0, 0, 0, 0} };
+                divisor = 1;
+            }
+            if (preset == KernelPresets.Sharpen)
+            {
+                values = new float[,] { {-1,-1,-1, -1,-1},
+                                        {-1, 2, 2,  2,-1},
+                                        {-1, 2, 8,  2,-1},
+                                        {-1, 2, 2,  2,-1},
+                                        {-1,-1,-1, -1,-1} };
+                divisor = 8;
+            }
+            if (preset == KernelPresets.Emboss)
+            {
+                values = new float[,] { {-1,-1,-1,-1, 0},
+                                        {-1,-1,-1, 0, 1},
+                                        {-1,-1, 0, 1, 1},
+                                        {-1, 0, 1, 1, 1},
+                                        { 0, 1, 1, 1, 1} };
+                divisor = 1;
+            }
+        }
+
+        public override void OnGUIHandler()
+        {
+            base.OnGUIHandler();
+
+            var tNode = node as ConvolutionFilterNode;
+            if (tNode == null)
+                return;
+
+            float divisor = tNode.GetConvolutionDivisor();
+            float[,] values = new float[5,5];
+            for (int row = 0; row < 5; ++row)
+            {
+                for (int col = 0; col < 5; ++col)
+                {
+                    values[row,col] = tNode.GetConvolutionWeight(row,col);
+                }
+            }
+
+            EditorGUILayout.BeginVertical();
+            EditorGUI.BeginChangeCheck();
+
+            EditorGUILayout.LabelField("Kernel");
+            KernelPresets kernelPresets = KernelPresets.Presets;
+            kernelPresets = (KernelPresets)EditorGUILayout.EnumPopup(kernelPresets);
+            ApplyPreset(kernelPresets, ref values, ref divisor);
+
+            for (int col = 0; col < 5; ++col)
+            {
+                EditorGUILayout.BeginHorizontal();
+                for (int row = 0; row < 5; ++row)
+                {
+                    values[row, col] = EditorGUILayout.FloatField(values[row, col], GUILayout.Width(35));
+                }
+                EditorGUILayout.EndHorizontal();
+            }
+            EditorGUILayout.Space();
+
+            divisor = EditorGUILayout.FloatField("Divisor", divisor);
+
+            EditorGUILayout.EndVertical();
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                tNode.SetConvolutionDivisor(divisor);
+                for (int row = 0; row < 5; ++row)
+                {
+                    for (int col = 0; col < 5; ++col)
+                    {
+                         tNode.SetConvolutionWeight(row, col, values[row, col]);
+                    }
+                }
+            }
+        }
+
+        public override float GetHeight()
+        {
+            return (EditorGUIUtility.singleLineHeight * 10 + EditorGUIUtility.standardVerticalSpacing) + EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+
+    [Serializable]
+    public class ConvolutionFilterNodePresenter : PropertyNodePresenter
+    {
+        protected override IEnumerable<GraphElementPresenter> GetControlData()
+        {
+            var instance = CreateInstance<ConvolutionFilterControlPresenter>();
+            instance.Initialize(node);
+            return new List<GraphElementPresenter>(base.GetControlData()) { instance };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/ConvolutionFilterNodePresenter.cs.meta

+fileFormatVersion: 2
+guid: f3a416c372d21b6479241e837d4257da
+timeCreated: 1495705790
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/SamplerStatePresenter.cs

+using System;
+using System.Collections.Generic;
+using UnityEngine.MaterialGraph;
+using RMGUI.GraphView;
+using UnityEditor.Graphing.Drawing;
+
+namespace UnityEditor.MaterialGraph.Drawing
+{
+    [Serializable]
+    class SamplerStateControlPresenter : GraphControlPresenter
+    {
+       
+        private string[] samplerFilterMode;
+        private string[] samplerWrapMode;
+
+        private string[] _samplerFilterMode
+        {
+            get
+            {
+                if (samplerFilterMode == null)
+                    samplerFilterMode = Enum.GetNames(typeof(SamplerStateNode.FilterMode));
+                return samplerFilterMode;
+            }
+        }
+
+        private string[] _samplerWrapMode
+        {
+            get
+            {
+                if (samplerWrapMode == null)
+                    samplerWrapMode = Enum.GetNames(typeof(SamplerStateNode.WrapMode));
+                return samplerWrapMode;
+            }
+        }
+
+        public override void OnGUIHandler()
+        {
+            base.OnGUIHandler();
+
+            var cNode = node as UnityEngine.MaterialGraph.SamplerStateNode;
+            if (cNode == null)
+                return;
+
+            cNode.filter = (SamplerStateNode.FilterMode)EditorGUILayout.Popup((int)cNode.filter, _samplerFilterMode, EditorStyles.popup);
+            cNode.wrap = (SamplerStateNode.WrapMode)EditorGUILayout.Popup((int)cNode.wrap, _samplerWrapMode, EditorStyles.popup);
+        }
+
+        public override float GetHeight()
+        {
+            return EditorGUIUtility.singleLineHeight + EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+
+    [Serializable]
+    public class SamplerStateNodePresenter : MaterialNodePresenter
+    {
+        protected override IEnumerable<GraphElementPresenter> GetControlData()
+        {
+            var instance = CreateInstance<SamplerStateControlPresenter>();
+            instance.Initialize(node);
+            return new List<GraphElementPresenter> { instance };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/SamplerStatePresenter.cs.meta

+fileFormatVersion: 2
+guid: 8ffcc48ccff1aea44b90acb362bc0dfc
+timeCreated: 1495659152
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/TextureSamplerPresenter.cs

+using System;
+using System.Collections.Generic;
+using RMGUI.GraphView;
+using UnityEditor.Graphing.Drawing;
+using UnityEngine;
+using UnityEngine.MaterialGraph;
+
+namespace UnityEditor.MaterialGraph.Drawing
+{
+    class TextureSamplerContolPresenter : GraphControlPresenter
+    {
+        private string[] m_TextureTypeNames;
+        private string[] textureTypeNames
+        {
+            get
+            {
+                if (m_TextureTypeNames == null)
+                    m_TextureTypeNames = Enum.GetNames(typeof(TextureType));
+                return m_TextureTypeNames;
+            }
+        }
+
+        public override void OnGUIHandler()
+        {
+            base.OnGUIHandler();
+
+            var tNode = node as UnityEngine.MaterialGraph.TextureAssetNode;
+            if (tNode == null)
+                return;
+
+            tNode.exposedState = (PropertyNode.ExposedState)EditorGUILayout.EnumPopup(new GUIContent("Exposed"), tNode.exposedState);
+            tNode.defaultTexture = EditorGUILayout.MiniThumbnailObjectField(new GUIContent("Texture"), tNode.defaultTexture, typeof(Texture), null) as Texture;
+            tNode.textureType = (TextureType)EditorGUILayout.Popup((int)tNode.textureType, textureTypeNames, EditorStyles.popup);
+        }
+
+        public override float GetHeight()
+        {
+            return 3 * (EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing) + EditorGUIUtility.standardVerticalSpacing;
+        }
+    }
+
+    [Serializable]
+    public class TextureSamplerNodePresenter : MaterialNodePresenter
+    {
+        protected override IEnumerable<GraphElementPresenter> GetControlData()
+        {
+            var instance = CreateInstance<TextureSamplerContolPresenter>();
+            instance.Initialize(node);
+            return new List<GraphElementPresenter> { instance };
+        }
+    }
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/TextureSamplerPresenter.cs.meta

+fileFormatVersion: 2
+guid: 86fe3d2371b24d34399f4b116a238d45
+timeCreated: 1495638407
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/bricks_height.png.meta

+fileFormatVersion: 2
+guid: 5d84e1086e00e3347aaa0bbba206bb80
+timeCreated: 1495717214
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/bricks_normal.tga.meta

+fileFormatVersion: 2
+guid: e017404169662f041a969b0a924cc2ed
+timeCreated: 1495717224
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Drawing/Presenters/mur_Ambiant.bmp.meta

+fileFormatVersion: 2
+guid: b5a88303611082242a4eb08e645752d2
+timeCreated: 1495717081
+licenseType: Pro
+TextureImporter:
+  fileIDToRecycleName: {}
+  serializedVersion: 4
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/tesselationSubshader.template

+SubShader 
+{
+${Tags}
+${Blending}
+${Culling}
+${ZTest}
+${ZWrite}
+
+	LOD ${LOD}
+	
+	CGPROGRAM
+	#include "Tessellation.cginc"
+	#pragma target 4.6
+	#pragma surface surf ${LightingFunctionName} ${VertexShaderDecl} vertex:Displacement tessellate:tessEdge tessphong:_Phong
+	#pragma glsl
+	#pragma debug
+
+	
+	//Tessellation Edge Function
+float4 tessEdge(appdata v0, appdata v1, appdata v2)
+{
+	float quality = 20-(_Subdivision * 2);
+	return UnityEdgeLengthBasedTess(v0.vertex, v1.vertex, v2.vertex, quality);
+}
+
+//Tessellation Vertex Function
+void Displacement (inout appdata v)
+{
+	float d = tex2Dlod(_DisplacementTex, float4(v.texcoord.xy * (_DisplacementTex_ST.xy * float2(_WeaveScale*25, _WeaveScale*25)) + _DisplacementTex_ST.zw, 0, 0)).r * _Displacement*0.1;
+	v.vertex.xyz += v.normal * (d * 0.5);
+}
+
+${ShaderFunctions}
+${ShaderPropertyUsages}
+
+	struct Input 
+	{
+${ShaderInputs}
+	};
+
+	void vert (inout appdata_full v, out Input o)
+	{
+		UNITY_INITIALIZE_OUTPUT(Input,o);
+${VertexShaderBody}
+	}
+  
+	void surf (Input IN, inout ${SurfaceOutputStructureName} o) 
+	{
+${PixelShaderBody}
+	}
+	ENDCG
+}

MaterialGraphProject/Assets/UnityShaderEditor/Editor/Templates/tesselationSubshader.template.meta

+fileFormatVersion: 2
+guid: 71a3d46ddb1693340a7de3973be90309
+timeCreated: 1481194716
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/UnityShaderEditor/Runtime/Nodes/Art/Filters.meta

+fileFormatVersion: 2
+guid: 7ed888a282fe7b54e968311cd68c4862
+folderAsset: yes
+timeCreated: 1495638073
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Vlad/SamplerStateNode.cs

+using System.Collections.Generic;
+using UnityEngine.MaterialGraph;
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+{
+    [Title("Input/Sampler State")]
+    public class SamplerStateNode : AbstractMaterialNode, IGeneratesBodyCode
+    {
+
+        public enum FilterMode
+        {
+            Linear,
+            Point
+        }
+
+        public enum WrapMode
+        {
+            Repeat,
+            Clamp
+        }
+
+        static Dictionary<FilterMode, string> filterMode = new Dictionary<FilterMode, string>
+        {
+            {FilterMode.Linear, "_linear"},
+            {FilterMode.Point, "_point"},
+        };
+
+        static Dictionary<WrapMode, string> wrapMode = new Dictionary<WrapMode, string>
+        {
+            {WrapMode.Repeat, "_repeat"},
+            {WrapMode.Clamp, "_clamp"},
+        };
+
+
+        [SerializeField]
+        private FilterMode m_filter = FilterMode.Linear;
+
+ 
+        public FilterMode filter
+        {
+            get { return m_filter; }
+            set
+            {
+                if (m_filter == value)
+                    return;
+
+                m_filter = value;
+                if (onModified != null)
+                {
+                    onModified(this, ModificationScope.Graph);
+                }
+            }
+        }
+
+        [SerializeField]
+        private WrapMode m_wrap = WrapMode.Repeat;
+
+
+        public WrapMode wrap
+        {
+            get { return m_wrap; }
+            set
+            {
+                if (m_wrap == value)
+                    return;
+
+                m_wrap = value;
+                if (onModified != null)
+                {
+                    onModified(this, ModificationScope.Graph);
+                }
+            }
+        }
+
+        public SamplerStateNode()
+        {
+            name = "SamplerState";
+            UpdateNodeAfterDeserialization();
+        }
+
+        public override bool hasPreview { get { return false; } }
+
+        private const int kOutputSlotId = 0;
+        private const string kOutputSlotName = "Sampler Output";
+
+        public sealed override void UpdateNodeAfterDeserialization()
+        {
+            AddSlot(new MaterialSlot(kOutputSlotId, kOutputSlotName, kOutputSlotName, SlotType.Output, SlotValueType.SamplerState, Vector4.zero, false));
+            RemoveSlotsNameNotMatching(new[] { kOutputSlotId });
+        }
+
+        /*
+        public override PropertyType propertyType
+        {
+            get { return PropertyType.SamplerState; }
+        }
+
+        public override PreviewProperty GetPreviewProperty()
+        {
+            return new PreviewProperty
+            {
+                m_Name = propertyName + "HEEEEEEYYYYY",
+                m_PropType = PropertyType.Float,
+               // m_Float = filterMode[filter];
+            };
+        }
+
+        */
+
+
+
+        public void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+        {
+           // GetVariableNameForSlot();
+        }
+
+        public override string GetVariableNameForSlot(int slotId)
+        {
+           // var slot = FindSlot<MaterialSlot>(slotId);
+            //if (slot == null)
+              //  throw new ArgumentException(string.Format("Attempting to use MaterialSlot({0}) on node of type {1} where this slot can not be found", slotId, this), "slotId");
+
+            return GetVariableNameForNode();
+        }
+
+        //my_linear_repeat_sampler
+        public override string GetVariableNameForNode()
+        {
+            return "my" + filterMode[filter] + wrapMode[wrap] + "_sampler";           
+        }
+    }
+}

MaterialGraphProject/Assets/Vlad/SamplerStateNode.cs.meta

+fileFormatVersion: 2
+guid: 5fe2c333e043511478cc507ee61a8c21
+timeCreated: 1495658099
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Vlad/TextureSamplerNode.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+#if UNITY_EDITOR
+using UnityEditor;
+#endif
+using UnityEngine.Graphing;
+
+namespace UnityEngine.MaterialGraph
+    {
+        [Title("Input/Texture/Texture Sampler")]
+        public class TextureSamplerNode : PropertyNode, IGeneratesBodyCode, IMayRequireMeshUV
+        {
+            private const string kTextureAssetName = "Texture Asset";
+            private const string kUVSlotName = "UV";
+            private const string kSamplerName = "Sampler";
+            protected const string kOutputSlotRGBAName = "RGBA";
+
+            public const int TextureAssetSlotId = 0;
+            public const int UVSlotId = 1;
+            public const int SamplerSlotId = 2;
+            public const int OutputSlotRGBAId = 3;
+
+            [SerializeField]
+            private string m_SerializedTexture;
+
+            [SerializeField]
+            private TextureType m_TextureType;
+
+            [Serializable]
+            private class TextureHelper
+            {
+                public Texture2D texture;
+            }
+
+            public override bool hasPreview { get { return true; } }
+
+#if UNITY_EDITOR
+            public Texture2D defaultTexture
+            {
+                get
+                {
+                    if (string.IsNullOrEmpty(m_SerializedTexture))
+                        return null;
+
+                    var tex = new TextureHelper();
+                    EditorJsonUtility.FromJsonOverwrite(m_SerializedTexture, tex);
+                    return tex.texture;
+                }
+                set
+                {
+                    if (defaultTexture == value)
+                        return;
+
+                    var tex = new TextureHelper();
+                    tex.texture = value;
+                    m_SerializedTexture = EditorJsonUtility.ToJson(tex, true);
+
+                    if (onModified != null)
+                    {
+                        onModified(this, ModificationScope.Node);
+                    }
+                }
+            }
+#else
+        public Texture2D defaultTexture {get; set; }
+#endif
+
+            public TextureType textureType
+            {
+                get { return m_TextureType; }
+                set
+                {
+                    if (m_TextureType == value)
+                        return;
+
+
+                    m_TextureType = value;
+                    if (onModified != null)
+                    {
+                        onModified(this, ModificationScope.Graph);
+                    }
+                }
+            }
+
+            public TextureSamplerNode()
+            {
+                name = "TextureSamplerNode";
+                UpdateNodeAfterDeserialization();
+            }
+
+        public sealed override void UpdateNodeAfterDeserialization()
+            {
+            AddSlot(new MaterialSlot(TextureAssetSlotId, kTextureAssetName, kTextureAssetName, SlotType.Input, SlotValueType.Texture2D, Vector4.zero, false));
+            AddSlot(new MaterialSlot(UVSlotId, kUVSlotName, kUVSlotName, SlotType.Input, SlotValueType.Vector2, Vector4.zero, false));
+            AddSlot(new MaterialSlot(SamplerSlotId, kSamplerName, kSamplerName, SlotType.Input, SlotValueType.SamplerState, Vector4.zero, false));
+            AddSlot(new MaterialSlot(OutputSlotRGBAId, kOutputSlotRGBAName, kOutputSlotRGBAName, SlotType.Output, SlotValueType.Vector4, Vector4.zero));
+            RemoveSlotsNameNotMatching(validSlots);
+            }
+
+            protected int[] validSlots
+            {
+                get { return new[] { OutputSlotRGBAId, SamplerSlotId, UVSlotId, TextureAssetSlotId }; }
+            }
+
+            // Node generations
+            public virtual void GenerateNodeCode(ShaderGenerator visitor, GenerationMode generationMode)
+            {
+
+                //Texture input slot
+                var textureSlot = FindInputSlot<MaterialSlot>(TextureAssetSlotId);
+                var textureAssetName = "";
+                var edgesTexture = owner.GetEdges(textureSlot.slotReference).ToList();
+
+                if (edgesTexture.Count > 0)
+                {
+                    var edge = edgesTexture[0];
+                    var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                    textureAssetName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Texture2D, true);
+                }
+
+                //UV input slot
+                var uvSlot = FindInputSlot<MaterialSlot>(UVSlotId);
+                var uvName = string.Format("{0}.xy", UVChannel.uv0.GetUVName());
+                if (uvSlot == null)
+                return;
+
+                var edgesUV = owner.GetEdges(uvSlot.slotReference).ToList();
+
+                if (edgesUV.Count > 0)
+                {
+                    var edge = edgesUV[0];
+                    var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                    uvName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.Vector2, true);
+                }
+
+
+                //Sampler input slot
+                var samplerSlot = FindInputSlot<MaterialSlot>(SamplerSlotId);
+                var samplerName = "my_linear_repeat_sampler";
+
+                if (samplerSlot == null)
+                    return;
+
+                var edgesSampler = owner.GetEdges(samplerSlot.slotReference).ToList();
+
+                if (edgesSampler.Count > 0)
+                {
+                    var edge = edgesSampler[0];
+                    var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                    samplerName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.SamplerState, true);
+                }
+
+            visitor.AddShaderChunk(precision + "4 " + GetVariableNameForNode() + "_Uniform = " + precision + "4(0,0,0,0);", true);
+            visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", true);
+            string body = textureAssetName + ".Sample(" + samplerName + ", " + uvName + ");";
+                if (m_TextureType == TextureType.Bump)
+                    body = precision + "4(UnpackNormal(" + body + "), 0)";
+            
+                 visitor.AddShaderChunk(GetVariableNameForNode() + "_Uniform" + " = " + body, true);
+
+            visitor.AddShaderChunk("#endif", true);
+        }
+       
+            // Properties
+            public override void GeneratePropertyBlock(PropertyGenerator visitor, GenerationMode generationMode)
+            {   /*
+                visitor.AddShaderProperty(
+                    new TexturePropertyChunk(
+                        propertyName,
+                        description,
+                        defaultTexture, m_TextureType,
+                        PropertyChunk.HideState.Visible,
+                        exposedState == ExposedState.Exposed ?
+                            TexturePropertyChunk.ModifiableState.Modifiable
+                            : TexturePropertyChunk.ModifiableState.NonModifiable));
+                */
+            }
+
+            public override void GeneratePropertyUsages(ShaderGenerator visitor, GenerationMode generationMode)
+            {
+
+            //Sampler input slot
+            var samplerSlot = FindInputSlot<MaterialSlot>(SamplerSlotId);
+            var samplerName = "my_linear_repeat_sampler";
+
+            if (samplerSlot == null)
+                return;
+
+            var edgesSampler = owner.GetEdges(samplerSlot.slotReference).ToList();
+
+            if (edgesSampler.Count > 0)
+            {
+                var edge = edgesSampler[0];
+                var fromNode = owner.GetNodeFromGuid<AbstractMaterialNode>(edge.outputSlot.nodeGuid);
+                samplerName = ShaderGenerator.AdaptNodeOutput(fromNode, edge.outputSlot.slotId, ConcreteSlotValueType.SamplerState, true);
+            }
+            
+            visitor.AddShaderChunk("#ifdef UNITY_COMPILER_HLSL", false);
+            visitor.AddShaderChunk(samplerSlot.valueType + " " + samplerName + ";", true);
+            visitor.AddShaderChunk("#endif", false);
+        }
+        
+        
+            public override PreviewProperty GetPreviewProperty()
+            {
+                return new PreviewProperty
+                {
+                    m_Name = propertyName,
+                    m_PropType = PropertyType.Texture,
+                    m_Texture = defaultTexture
+                };
+            }
+        
+            public override PropertyType propertyType { get { return PropertyType.Texture; } }
+
+            public bool RequiresMeshUV(UVChannel channel)
+            {
+                if (channel != UVChannel.uv0)
+                {
+                    return false;
+                }
+
+                var uvSlot = FindInputSlot<MaterialSlot>(UVSlotId);
+                if (uvSlot == null)
+                    return true;
+
+                var edges = owner.GetEdges(uvSlot.slotReference).ToList();
+                return edges.Count == 0;
+            }
+
+        //prevent validation errors when a sampler2D input is missing
+        //use on any input requiring a TextureAssetNode
+        public override void ValidateNode()
+        {
+            base.ValidateNode();
+            var slot = FindInputSlot<MaterialSlot>(TextureAssetSlotId);
+            if (slot == null)
+                return;
+
+            var edges = owner.GetEdges(slot.slotReference).ToList();
+            hasError |= edges.Count == 0;
+        }
+
+    }
+    }

MaterialGraphProject/Assets/Vlad/TextureSamplerNode.cs.meta

+fileFormatVersion: 2
+guid: 5ca9d434229e11f44888abcbf66062a5
+timeCreated: 1495637741
+licenseType: Pro
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/_MingWai/Scatter.ShaderGraph.meta

+fileFormatVersion: 2
+guid: 0e5edf7e3bc2bbc47bdb6b74107cc104
+timeCreated: 1495479560
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Florent/GeneratedTexture.meta

+guid: fbb15485f0112484eaa58e88a4ac393f

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh.meta

+fileFormatVersion: 2
+guid: 11cce0c6b8f60b94eb9d075bbb367f18
+folderAsset: yes
+timeCreated: 1495695267
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/CylinderShowcase.FBX.meta

+fileFormatVersion: 2
+guid: d9b9a09db9199a146bea1ac6d01fe99f
+timeCreated: 1495724507
+licenseType: Pro
+ModelImporter:
+  serializedVersion: 21
+  fileIDToRecycleName:
+    100000: Cylinder005
+    100002: Cylinder006
+    100004: Cylinder007
+    100006: Cylinder008
+    100008: Cylinder009
+    100010: Cylinder010
+    100012: Cylinder011
+    100014: Cylinder012
+    100016: Cylinder013
+    100018: Cylinder014
+    100020: Cylinder015
+    100022: Cylinder016
+    100024: //RootNode
+    400000: Cylinder005
+    400002: Cylinder006
+    400004: Cylinder007
+    400006: Cylinder008
+    400008: Cylinder009
+    400010: Cylinder010
+    400012: Cylinder011
+    400014: Cylinder012
+    400016: Cylinder013
+    400018: Cylinder014
+    400020: Cylinder015
+    400022: Cylinder016
+    400024: //RootNode
+    2300000: Cylinder005
+    2300002: Cylinder006
+    2300004: Cylinder007
+    2300006: Cylinder008
+    2300008: Cylinder009
+    2300010: Cylinder010
+    2300012: Cylinder011
+    2300014: Cylinder012
+    2300016: Cylinder013
+    2300018: Cylinder014
+    2300020: Cylinder015
+    2300022: Cylinder016
+    3300000: Cylinder005
+    3300002: Cylinder006
+    3300004: Cylinder007
+    3300006: Cylinder008
+    3300008: Cylinder009
+    3300010: Cylinder010
+    3300012: Cylinder011
+    3300014: Cylinder012
+    3300016: Cylinder013
+    3300018: Cylinder014
+    3300020: Cylinder015
+    3300022: Cylinder016
+    4300000: Cylinder005
+    4300002: Cylinder006
+    4300004: Cylinder007
+    4300006: Cylinder008
+    4300008: Cylinder009
+    4300010: Cylinder010
+    4300012: Cylinder011
+    4300014: Cylinder012
+    4300016: Cylinder013
+    4300018: Cylinder014
+    4300020: Cylinder015
+    4300022: Cylinder016
+    9500000: //RootNode
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    rootMotionBoneRotation: {x: 0, y: 0, z: 0, w: 1}
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 2
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/MaterialGallery_2018.max.meta

+fileFormatVersion: 2
+guid: 1cfd683a88f02ad4dbb67853f7a88c95
+timeCreated: 1495705349
+licenseType: Pro
+ModelImporter:
+  serializedVersion: 21
+  fileIDToRecycleName:
+    100000: BendBox
+    100002: BendBox001
+    100004: BendBox002
+    100006: BendBox003
+    100008: BendBox004
+    100010: BendBox005
+    100012: BendBox006
+    100014: BendBox007
+    100016: BendBox008
+    100018: BendBox009
+    100020: BendBox010
+    100022: BendBox011
+    100024: BendBox012
+    100026: BendBox013
+    100028: BendBox014
+    100030: BendBox015
+    100032: BendBox016
+    100034: BendBox017
+    100036: BendBox018
+    100038: BendBox019
+    100040: BendBox020
+    100042: BendBox021
+    100044: BendBox022
+    100046: BendBox023
+    100048: BendBox024
+    100050: BendBox025
+    100052: BendBox026
+    100054: BendBox027
+    100056: BendBox028
+    100058: BendBox029
+    100060: BendBox030
+    100062: BendBox031
+    100064: BendBox032
+    100066: BendBox033
+    100068: BendBox034
+    100070: BendBox035
+    100072: BendBox036
+    100074: BendBox037
+    100076: BendBox038
+    100078: BendBox039
+    100080: BendBox040
+    100082: BendBox041
+    100084: BendBox042
+    100086: BendBox043
+    100088: BendBox044
+    100090: BendBox045
+    100092: BendBox046
+    100094: BendBox047
+    100096: BendBox048
+    100098: BendBox049
+    100100: BendBox050
+    100102: BendBox051
+    100104: BendBox052
+    100106: BendBox053
+    100108: BendBox054
+    100110: BendBox055
+    100112: BendBox056
+    100114: BendBox057
+    100116: BendBox058
+    100118: BendBox059
+    100120: BendBox060
+    100122: BendBox061
+    100124: BendBox062
+    100126: BendBox063
+    100128: BendBox064
+    100130: BendBox065
+    100132: BendBox066
+    100134: Bottom_Circle
+    100136: Box001
+    100138: Box002
+    100140: Box003
+    100142: Box004
+    100144: Box005
+    100146: Box006
+    100148: Box007
+    100150: Box009
+    100152: Box010
+    100154: Box011
+    100156: Box012
+    100158: Box013
+    100160: CeilingCutter
+    100162: Cylinder001
+    100164: Cylinder002
+    100166: Cylinder003
+    100168: Cylinder004
+    100170: Exterior_EdgeDecor
+    100172: Exterior_EdgeDecor001
+    100174: Exterior_EdgeDecor002
+    100176: Exterior_EdgeDecor003
+    100178: Exterior_EdgeDecor004
+    100180: Exterior_EdgeDecor005
+    100182: Exterior_EdgeDecor006
+    100184: Exterior_EdgeDecor007
+    100186: Exterior_EdgeDecor008
+    100188: Exterior_EdgeDecor009
+    100190: Exterior_EdgeDecor010
+    100192: Exterior_EdgeDecor011
+    100194: Exterior_EdgeDecor012
+    100196: Exterior_EdgeDecor013
+    100198: Exterior_EdgeDecor014
+    100200: Exterior_EdgeDecor015
+    100202: Exterior_EdgeDecor016
+    100204: Exterior_EdgeDecor017
+    100206: Exterior_EdgeDecor018
+    100208: Exterior_EdgeDecor019
+    100210: Exterior_EdgeDecor020
+    100212: Exterior_EdgeDecor021
+    100214: Exterior_EdgeDecor022
+    100216: Exterior_EdgeDecor023
+    100218: Exterior_EdgeDecor024
+    100220: Exterior_EdgeDecor025
+    100222: Exterior_EdgeDecor026
+    100224: Exterior_EdgeDecor027
+    100226: Exterior_EdgeDecor028
+    100228: Exterior_EdgeDecor029
+    100230: Exterior_EdgeDecor030
+    100232: Exterior_EdgeDecor031
+    100234: Exterior_EdgeDecor032
+    100236: Exterior_EdgeDecor033
+    100238: Exterior_EdgeDecor034
+    100240: Exterior_EdgeDecor035
+    100242: Exterior_EdgeDecor036
+    100244: Exterior_EdgeDecor037
+    100246: Exterior_EdgeDecor038
+    100248: Exterior_EdgeDecor039
+    100250: Exterior_EdgeDecor040
+    100252: Exterior_EdgeDecor041
+    100254: Exterior_Pie
+    100256: Exterior_Pie001
+    100258: Exterior_Pie002
+    100260: Exterior_Pie003
+    100262: Exterior_Pie004
+    100264: Exterior_Pie005
+    100266: Inner_Template
+    100268: Inner_Wall
+    100270: Inner_Wall001
+    100272: Inner_Wall002
+    100274: Inner_Wall003
+    100276: Inner_Wall004
+    100278: Inner_Wall005
+    100280: InnerPie
+    100282: InnerPie001
+    100284: InnerPie002
+    100286: InnerPie003
+    100288: InnerPie004
+    100290: InnerPie005
+    100292: //RootNode
+    100294: OriginalCircle
+    100296: OriginalCircle001
+    100298: Template
+    100300: Wall
+    100302: Wall001
+    100304: Wall002
+    100306: Wall003
+    100308: WoodPillar
+    100310: Exterior_Pie006_Backup
+    100312: InnerPie006_Backup
+    100314: ShaderGlobe_Unity
+    100316: Cylinder005
+    100318: Cylinder006
+    100320: Cylinder007
+    100322: Cylinder008
+    100324: Cylinder009
+    100326: Cylinder010
+    100328: Cylinder011
+    100330: Cylinder012
+    100332: Cylinder013
+    100334: Cylinder014
+    100336: Cylinder015
+    100338: Cylinder016
+    400000: BendBox
+    400002: BendBox001
+    400004: BendBox002
+    400006: BendBox003
+    400008: BendBox004
+    400010: BendBox005
+    400012: BendBox006
+    400014: BendBox007
+    400016: BendBox008
+    400018: BendBox009
+    400020: BendBox010
+    400022: BendBox011
+    400024: BendBox012
+    400026: BendBox013
+    400028: BendBox014
+    400030: BendBox015
+    400032: BendBox016
+    400034: BendBox017
+    400036: BendBox018
+    400038: BendBox019
+    400040: BendBox020
+    400042: BendBox021
+    400044: BendBox022
+    400046: BendBox023
+    400048: BendBox024
+    400050: BendBox025
+    400052: BendBox026
+    400054: BendBox027
+    400056: BendBox028
+    400058: BendBox029
+    400060: BendBox030
+    400062: BendBox031
+    400064: BendBox032
+    400066: BendBox033
+    400068: BendBox034
+    400070: BendBox035
+    400072: BendBox036
+    400074: BendBox037
+    400076: BendBox038
+    400078: BendBox039
+    400080: BendBox040
+    400082: BendBox041
+    400084: BendBox042
+    400086: BendBox043
+    400088: BendBox044
+    400090: BendBox045
+    400092: BendBox046
+    400094: BendBox047
+    400096: BendBox048
+    400098: BendBox049
+    400100: BendBox050
+    400102: BendBox051
+    400104: BendBox052
+    400106: BendBox053
+    400108: BendBox054
+    400110: BendBox055
+    400112: BendBox056
+    400114: BendBox057
+    400116: BendBox058
+    400118: BendBox059
+    400120: BendBox060
+    400122: BendBox061
+    400124: BendBox062
+    400126: BendBox063
+    400128: BendBox064
+    400130: BendBox065
+    400132: BendBox066
+    400134: Bottom_Circle
+    400136: Box001
+    400138: Box002
+    400140: Box003
+    400142: Box004
+    400144: Box005
+    400146: Box006
+    400148: Box007
+    400150: Box009
+    400152: Box010
+    400154: Box011
+    400156: Box012
+    400158: Box013
+    400160: CeilingCutter
+    400162: Cylinder001
+    400164: Cylinder002
+    400166: Cylinder003
+    400168: Cylinder004
+    400170: Exterior_EdgeDecor
+    400172: Exterior_EdgeDecor001
+    400174: Exterior_EdgeDecor002
+    400176: Exterior_EdgeDecor003
+    400178: Exterior_EdgeDecor004
+    400180: Exterior_EdgeDecor005
+    400182: Exterior_EdgeDecor006
+    400184: Exterior_EdgeDecor007
+    400186: Exterior_EdgeDecor008
+    400188: Exterior_EdgeDecor009
+    400190: Exterior_EdgeDecor010
+    400192: Exterior_EdgeDecor011
+    400194: Exterior_EdgeDecor012
+    400196: Exterior_EdgeDecor013
+    400198: Exterior_EdgeDecor014
+    400200: Exterior_EdgeDecor015
+    400202: Exterior_EdgeDecor016
+    400204: Exterior_EdgeDecor017
+    400206: Exterior_EdgeDecor018
+    400208: Exterior_EdgeDecor019
+    400210: Exterior_EdgeDecor020
+    400212: Exterior_EdgeDecor021
+    400214: Exterior_EdgeDecor022
+    400216: Exterior_EdgeDecor023
+    400218: Exterior_EdgeDecor024
+    400220: Exterior_EdgeDecor025
+    400222: Exterior_EdgeDecor026
+    400224: Exterior_EdgeDecor027
+    400226: Exterior_EdgeDecor028
+    400228: Exterior_EdgeDecor029
+    400230: Exterior_EdgeDecor030
+    400232: Exterior_EdgeDecor031
+    400234: Exterior_EdgeDecor032
+    400236: Exterior_EdgeDecor033
+    400238: Exterior_EdgeDecor034
+    400240: Exterior_EdgeDecor035
+    400242: Exterior_EdgeDecor036
+    400244: Exterior_EdgeDecor037
+    400246: Exterior_EdgeDecor038
+    400248: Exterior_EdgeDecor039
+    400250: Exterior_EdgeDecor040
+    400252: Exterior_EdgeDecor041
+    400254: Exterior_Pie
+    400256: Exterior_Pie001
+    400258: Exterior_Pie002
+    400260: Exterior_Pie003
+    400262: Exterior_Pie004
+    400264: Exterior_Pie005
+    400266: Inner_Template
+    400268: Inner_Wall
+    400270: Inner_Wall001
+    400272: Inner_Wall002
+    400274: Inner_Wall003
+    400276: Inner_Wall004
+    400278: Inner_Wall005
+    400280: InnerPie
+    400282: InnerPie001
+    400284: InnerPie002
+    400286: InnerPie003
+    400288: InnerPie004
+    400290: InnerPie005
+    400292: //RootNode
+    400294: OriginalCircle
+    400296: OriginalCircle001
+    400298: Template
+    400300: Wall
+    400302: Wall001
+    400304: Wall002
+    400306: Wall003
+    400308: WoodPillar
+    400310: Exterior_Pie006_Backup
+    400312: InnerPie006_Backup
+    400314: ShaderGlobe_Unity
+    400316: Cylinder005
+    400318: Cylinder006
+    400320: Cylinder007
+    400322: Cylinder008
+    400324: Cylinder009
+    400326: Cylinder010
+    400328: Cylinder011
+    400330: Cylinder012
+    400332: Cylinder013
+    400334: Cylinder014
+    400336: Cylinder015
+    400338: Cylinder016
+    2300000: BendBox
+    2300002: BendBox001
+    2300004: BendBox002
+    2300006: BendBox003
+    2300008: BendBox004
+    2300010: BendBox005
+    2300012: BendBox006
+    2300014: BendBox007
+    2300016: BendBox008
+    2300018: BendBox009
+    2300020: BendBox010
+    2300022: BendBox011
+    2300024: BendBox012
+    2300026: BendBox013
+    2300028: BendBox014
+    2300030: BendBox015
+    2300032: BendBox016
+    2300034: BendBox017
+    2300036: BendBox018
+    2300038: BendBox019
+    2300040: BendBox020
+    2300042: BendBox021
+    2300044: BendBox022
+    2300046: BendBox023
+    2300048: BendBox024
+    2300050: BendBox025
+    2300052: BendBox026
+    2300054: BendBox027
+    2300056: BendBox028
+    2300058: BendBox029
+    2300060: BendBox030
+    2300062: BendBox031
+    2300064: BendBox032
+    2300066: BendBox033
+    2300068: BendBox034
+    2300070: BendBox035
+    2300072: BendBox036
+    2300074: BendBox037
+    2300076: BendBox038
+    2300078: BendBox039
+    2300080: BendBox040
+    2300082: BendBox041
+    2300084: BendBox042
+    2300086: BendBox043
+    2300088: BendBox044
+    2300090: BendBox045
+    2300092: BendBox046
+    2300094: BendBox047
+    2300096: BendBox048
+    2300098: BendBox049
+    2300100: BendBox050
+    2300102: BendBox051
+    2300104: BendBox052
+    2300106: BendBox053
+    2300108: BendBox054
+    2300110: BendBox055
+    2300112: BendBox056
+    2300114: BendBox057
+    2300116: BendBox058
+    2300118: BendBox059
+    2300120: BendBox060
+    2300122: BendBox061
+    2300124: BendBox062
+    2300126: BendBox063
+    2300128: BendBox064
+    2300130: BendBox065
+    2300132: BendBox066
+    2300134: Bottom_Circle
+    2300136: Box001
+    2300138: Box002
+    2300140: Box003
+    2300142: Box004
+    2300144: Box005
+    2300146: Box006
+    2300148: Box007
+    2300150: Box009
+    2300152: Box010
+    2300154: Box011
+    2300156: Box012
+    2300158: Box013
+    2300160: CeilingCutter
+    2300162: Cylinder001
+    2300164: Cylinder002
+    2300166: Cylinder003
+    2300168: Cylinder004
+    2300170: Exterior_EdgeDecor
+    2300172: Exterior_EdgeDecor001
+    2300174: Exterior_EdgeDecor002
+    2300176: Exterior_EdgeDecor003
+    2300178: Exterior_EdgeDecor004
+    2300180: Exterior_EdgeDecor005
+    2300182: Exterior_EdgeDecor006
+    2300184: Exterior_EdgeDecor007
+    2300186: Exterior_EdgeDecor008
+    2300188: Exterior_EdgeDecor009
+    2300190: Exterior_EdgeDecor010
+    2300192: Exterior_EdgeDecor011
+    2300194: Exterior_EdgeDecor012
+    2300196: Exterior_EdgeDecor013
+    2300198: Exterior_EdgeDecor014
+    2300200: Exterior_EdgeDecor015
+    2300202: Exterior_EdgeDecor016
+    2300204: Exterior_EdgeDecor017
+    2300206: Exterior_EdgeDecor018
+    2300208: Exterior_EdgeDecor019
+    2300210: Exterior_EdgeDecor020
+    2300212: Exterior_EdgeDecor021
+    2300214: Exterior_EdgeDecor022
+    2300216: Exterior_EdgeDecor023
+    2300218: Exterior_EdgeDecor024
+    2300220: Exterior_EdgeDecor025
+    2300222: Exterior_EdgeDecor026
+    2300224: Exterior_EdgeDecor027
+    2300226: Exterior_EdgeDecor028
+    2300228: Exterior_EdgeDecor029
+    2300230: Exterior_EdgeDecor030
+    2300232: Exterior_EdgeDecor031
+    2300234: Exterior_EdgeDecor032
+    2300236: Exterior_EdgeDecor033
+    2300238: Exterior_EdgeDecor034
+    2300240: Exterior_EdgeDecor035
+    2300242: Exterior_EdgeDecor036
+    2300244: Exterior_EdgeDecor037
+    2300246: Exterior_EdgeDecor038
+    2300248: Exterior_EdgeDecor039
+    2300250: Exterior_EdgeDecor040
+    2300252: Exterior_EdgeDecor041
+    2300254: Exterior_Pie
+    2300256: Exterior_Pie001
+    2300258: Exterior_Pie002
+    2300260: Exterior_Pie003
+    2300262: Exterior_Pie004
+    2300264: Exterior_Pie005
+    2300266: Inner_Template
+    2300268: Inner_Wall
+    2300270: Inner_Wall001
+    2300272: Inner_Wall002
+    2300274: Inner_Wall003
+    2300276: Inner_Wall004
+    2300278: Inner_Wall005
+    2300280: InnerPie
+    2300282: InnerPie001
+    2300284: InnerPie002
+    2300286: InnerPie003
+    2300288: InnerPie004
+    2300290: InnerPie005
+    2300292: OriginalCircle
+    2300294: OriginalCircle001
+    2300296: Template
+    2300298: Wall
+    2300300: Wall001
+    2300302: Wall002
+    2300304: Wall003
+    2300306: WoodPillar
+    2300308: Exterior_Pie006_Backup
+    2300310: InnerPie006_Backup
+    2300312: ShaderGlobe_Unity
+    2300314: Cylinder005
+    2300316: Cylinder006
+    2300318: Cylinder007
+    2300320: Cylinder008
+    2300322: Cylinder009
+    2300324: Cylinder010
+    2300326: Cylinder011
+    2300328: Cylinder012
+    2300330: Cylinder013
+    2300332: Cylinder014
+    2300334: Cylinder015
+    2300336: Cylinder016
+    3300000: BendBox
+    3300002: BendBox001
+    3300004: BendBox002
+    3300006: BendBox003
+    3300008: BendBox004
+    3300010: BendBox005
+    3300012: BendBox006
+    3300014: BendBox007
+    3300016: BendBox008
+    3300018: BendBox009
+    3300020: BendBox010
+    3300022: BendBox011
+    3300024: BendBox012
+    3300026: BendBox013
+    3300028: BendBox014
+    3300030: BendBox015
+    3300032: BendBox016
+    3300034: BendBox017
+    3300036: BendBox018
+    3300038: BendBox019
+    3300040: BendBox020
+    3300042: BendBox021
+    3300044: BendBox022
+    3300046: BendBox023
+    3300048: BendBox024
+    3300050: BendBox025
+    3300052: BendBox026
+    3300054: BendBox027
+    3300056: BendBox028
+    3300058: BendBox029
+    3300060: BendBox030
+    3300062: BendBox031
+    3300064: BendBox032
+    3300066: BendBox033
+    3300068: BendBox034
+    3300070: BendBox035
+    3300072: BendBox036
+    3300074: BendBox037
+    3300076: BendBox038
+    3300078: BendBox039
+    3300080: BendBox040
+    3300082: BendBox041
+    3300084: BendBox042
+    3300086: BendBox043
+    3300088: BendBox044
+    3300090: BendBox045
+    3300092: BendBox046
+    3300094: BendBox047
+    3300096: BendBox048
+    3300098: BendBox049
+    3300100: BendBox050
+    3300102: BendBox051
+    3300104: BendBox052
+    3300106: BendBox053
+    3300108: BendBox054
+    3300110: BendBox055
+    3300112: BendBox056
+    3300114: BendBox057
+    3300116: BendBox058
+    3300118: BendBox059
+    3300120: BendBox060
+    3300122: BendBox061
+    3300124: BendBox062
+    3300126: BendBox063
+    3300128: BendBox064
+    3300130: BendBox065
+    3300132: BendBox066
+    3300134: Bottom_Circle
+    3300136: Box001
+    3300138: Box002
+    3300140: Box003
+    3300142: Box004
+    3300144: Box005
+    3300146: Box006
+    3300148: Box007
+    3300150: Box009
+    3300152: Box010
+    3300154: Box011
+    3300156: Box012
+    3300158: Box013
+    3300160: CeilingCutter
+    3300162: Cylinder001
+    3300164: Cylinder002
+    3300166: Cylinder003
+    3300168: Cylinder004
+    3300170: Exterior_EdgeDecor
+    3300172: Exterior_EdgeDecor001
+    3300174: Exterior_EdgeDecor002
+    3300176: Exterior_EdgeDecor003
+    3300178: Exterior_EdgeDecor004
+    3300180: Exterior_EdgeDecor005
+    3300182: Exterior_EdgeDecor006
+    3300184: Exterior_EdgeDecor007
+    3300186: Exterior_EdgeDecor008
+    3300188: Exterior_EdgeDecor009
+    3300190: Exterior_EdgeDecor010
+    3300192: Exterior_EdgeDecor011
+    3300194: Exterior_EdgeDecor012
+    3300196: Exterior_EdgeDecor013
+    3300198: Exterior_EdgeDecor014
+    3300200: Exterior_EdgeDecor015
+    3300202: Exterior_EdgeDecor016
+    3300204: Exterior_EdgeDecor017
+    3300206: Exterior_EdgeDecor018
+    3300208: Exterior_EdgeDecor019
+    3300210: Exterior_EdgeDecor020
+    3300212: Exterior_EdgeDecor021
+    3300214: Exterior_EdgeDecor022
+    3300216: Exterior_EdgeDecor023
+    3300218: Exterior_EdgeDecor024
+    3300220: Exterior_EdgeDecor025
+    3300222: Exterior_EdgeDecor026
+    3300224: Exterior_EdgeDecor027
+    3300226: Exterior_EdgeDecor028
+    3300228: Exterior_EdgeDecor029
+    3300230: Exterior_EdgeDecor030
+    3300232: Exterior_EdgeDecor031
+    3300234: Exterior_EdgeDecor032
+    3300236: Exterior_EdgeDecor033
+    3300238: Exterior_EdgeDecor034
+    3300240: Exterior_EdgeDecor035
+    3300242: Exterior_EdgeDecor036
+    3300244: Exterior_EdgeDecor037
+    3300246: Exterior_EdgeDecor038
+    3300248: Exterior_EdgeDecor039
+    3300250: Exterior_EdgeDecor040
+    3300252: Exterior_EdgeDecor041
+    3300254: Exterior_Pie
+    3300256: Exterior_Pie001
+    3300258: Exterior_Pie002
+    3300260: Exterior_Pie003
+    3300262: Exterior_Pie004
+    3300264: Exterior_Pie005
+    3300266: Inner_Template
+    3300268: Inner_Wall
+    3300270: Inner_Wall001
+    3300272: Inner_Wall002
+    3300274: Inner_Wall003
+    3300276: Inner_Wall004
+    3300278: Inner_Wall005
+    3300280: InnerPie
+    3300282: InnerPie001
+    3300284: InnerPie002
+    3300286: InnerPie003
+    3300288: InnerPie004
+    3300290: InnerPie005
+    3300292: OriginalCircle
+    3300294: OriginalCircle001
+    3300296: Template
+    3300298: Wall
+    3300300: Wall001
+    3300302: Wall002
+    3300304: Wall003
+    3300306: WoodPillar
+    3300308: Exterior_Pie006_Backup
+    3300310: InnerPie006_Backup
+    3300312: ShaderGlobe_Unity
+    3300314: Cylinder005
+    3300316: Cylinder006
+    3300318: Cylinder007
+    3300320: Cylinder008
+    3300322: Cylinder009
+    3300324: Cylinder010
+    3300326: Cylinder011
+    3300328: Cylinder012
+    3300330: Cylinder013
+    3300332: Cylinder014
+    3300334: Cylinder015
+    3300336: Cylinder016
+    4300000: Cylinder001
+    4300002: Box001
+    4300004: Box002
+    4300006: Cylinder002
+    4300008: Box003
+    4300010: Cylinder003
+    4300012: Cylinder004
+    4300014: Template
+    4300016: OriginalCircle
+    4300018: OriginalCircle001
+    4300020: Box004
+    4300022: Exterior_Pie
+    4300024: Box005
+    4300026: Inner_Wall
+    4300028: Box006
+    4300030: Box007
+    4300032: CeilingCutter
+    4300034: InnerPie
+    4300036: InnerPie001
+    4300038: InnerPie002
+    4300040: InnerPie003
+    4300042: InnerPie004
+    4300044: InnerPie005
+    4300046: Wall
+    4300048: Exterior_Pie001
+    4300050: Exterior_Pie002
+    4300052: Exterior_Pie003
+    4300054: Exterior_Pie004
+    4300056: Exterior_Pie005
+    4300058: Inner_Wall001
+    4300060: Inner_Wall002
+    4300062: Inner_Wall003
+    4300064: Inner_Wall004
+    4300066: Inner_Wall005
+    4300068: Exterior_EdgeDecor
+    4300070: Exterior_EdgeDecor001
+    4300072: Exterior_EdgeDecor002
+    4300074: Exterior_EdgeDecor003
+    4300076: Exterior_EdgeDecor004
+    4300078: Exterior_EdgeDecor005
+    4300080: Exterior_EdgeDecor006
+    4300082: Bottom_Circle
+    4300084: WoodPillar
+    4300086: BendBox
+    4300088: BendBox001
+    4300090: BendBox002
+    4300092: BendBox003
+    4300094: BendBox004
+    4300096: BendBox005
+    4300098: BendBox006
+    4300100: BendBox007
+    4300102: BendBox008
+    4300104: BendBox009
+    4300106: BendBox010
+    4300108: BendBox011
+    4300110: BendBox012
+    4300112: BendBox013
+    4300114: BendBox014
+    4300116: BendBox015
+    4300118: BendBox016
+    4300120: BendBox017
+    4300122: BendBox018
+    4300124: BendBox019
+    4300126: BendBox020
+    4300128: BendBox021
+    4300130: BendBox022
+    4300132: BendBox023
+    4300134: BendBox024
+    4300136: BendBox025
+    4300138: BendBox026
+    4300140: BendBox027
+    4300142: BendBox028
+    4300144: BendBox029
+    4300146: BendBox030
+    4300148: BendBox031
+    4300150: BendBox032
+    4300152: BendBox033
+    4300154: BendBox034
+    4300156: BendBox035
+    4300158: BendBox036
+    4300160: BendBox037
+    4300162: BendBox038
+    4300164: BendBox039
+    4300166: BendBox040
+    4300168: BendBox041
+    4300170: BendBox042
+    4300172: BendBox043
+    4300174: BendBox044
+    4300176: BendBox045
+    4300178: BendBox046
+    4300180: BendBox047
+    4300182: BendBox048
+    4300184: BendBox049
+    4300186: BendBox050
+    4300188: BendBox051
+    4300190: BendBox052
+    4300192: BendBox053
+    4300194: BendBox054
+    4300196: BendBox055
+    4300198: BendBox056
+    4300200: BendBox057
+    4300202: BendBox058
+    4300204: BendBox059
+    4300206: BendBox060
+    4300208: BendBox061
+    4300210: BendBox062
+    4300212: BendBox063
+    4300214: BendBox064
+    4300216: BendBox065
+    4300218: BendBox066
+    4300220: Exterior_EdgeDecor007
+    4300222: Exterior_EdgeDecor008
+    4300224: Exterior_EdgeDecor009
+    4300226: Exterior_EdgeDecor010
+    4300228: Exterior_EdgeDecor011
+    4300230: Exterior_EdgeDecor012
+    4300232: Exterior_EdgeDecor013
+    4300234: Exterior_EdgeDecor014
+    4300236: Exterior_EdgeDecor015
+    4300238: Exterior_EdgeDecor016
+    4300240: Exterior_EdgeDecor017
+    4300242: Exterior_EdgeDecor018
+    4300244: Exterior_EdgeDecor019
+    4300246: Exterior_EdgeDecor020
+    4300248: Exterior_EdgeDecor021
+    4300250: Exterior_EdgeDecor022
+    4300252: Exterior_EdgeDecor023
+    4300254: Exterior_EdgeDecor024
+    4300256: Exterior_EdgeDecor025
+    4300258: Exterior_EdgeDecor026
+    4300260: Exterior_EdgeDecor027
+    4300262: Exterior_EdgeDecor028
+    4300264: Exterior_EdgeDecor029
+    4300266: Exterior_EdgeDecor030
+    4300268: Exterior_EdgeDecor031
+    4300270: Exterior_EdgeDecor032
+    4300272: Exterior_EdgeDecor033
+    4300274: Exterior_EdgeDecor034
+    4300276: Exterior_EdgeDecor035
+    4300278: Exterior_EdgeDecor036
+    4300280: Exterior_EdgeDecor037
+    4300282: Exterior_EdgeDecor038
+    4300284: Exterior_EdgeDecor039
+    4300286: Exterior_EdgeDecor040
+    4300288: Exterior_EdgeDecor041
+    4300290: Box009
+    4300292: Box010
+    4300294: Box011
+    4300296: Box012
+    4300298: Box013
+    4300300: Inner_Template
+    4300302: Wall001
+    4300304: Wall002
+    4300306: Wall003
+    4300308: InnerPie006_Backup
+    4300310: Exterior_Pie006_Backup
+    4300312: ShaderGlobe_Unity
+    4300314: Cylinder005
+    4300316: Cylinder006
+    4300318: Cylinder007
+    4300320: Cylinder008
+    4300322: Cylinder009
+    4300324: Cylinder010
+    4300326: Cylinder011
+    4300328: Cylinder012
+    4300330: Cylinder013
+    4300332: Cylinder014
+    4300334: Cylinder015
+    4300336: Cylinder016
+    9500000: //RootNode
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    rootMotionBoneRotation: {x: 0, y: 0, z: 0, w: 1}
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 2
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/MaterialGallery_Export_2018.FBX.meta

+fileFormatVersion: 2
+guid: 6533677ca066bb141b4bc872197c4451
+timeCreated: 1495705351
+licenseType: Pro
+ModelImporter:
+  serializedVersion: 21
+  fileIDToRecycleName:
+    100000: BendBox
+    100002: BendBox001
+    100004: BendBox002
+    100006: BendBox003
+    100008: BendBox004
+    100010: BendBox005
+    100012: BendBox006
+    100014: BendBox007
+    100016: BendBox008
+    100018: BendBox009
+    100020: BendBox010
+    100022: BendBox011
+    100024: BendBox012
+    100026: BendBox013
+    100028: BendBox014
+    100030: BendBox015
+    100032: BendBox016
+    100034: BendBox017
+    100036: BendBox018
+    100038: BendBox019
+    100040: BendBox020
+    100042: BendBox021
+    100044: BendBox022
+    100046: BendBox023
+    100048: BendBox024
+    100050: BendBox025
+    100052: BendBox026
+    100054: BendBox027
+    100056: BendBox028
+    100058: BendBox029
+    100060: BendBox030
+    100062: BendBox031
+    100064: BendBox032
+    100066: BendBox033
+    100068: BendBox034
+    100070: BendBox035
+    100072: BendBox036
+    100074: BendBox037
+    100076: BendBox038
+    100078: BendBox039
+    100080: BendBox040
+    100082: BendBox041
+    100084: BendBox042
+    100086: BendBox043
+    100088: BendBox044
+    100090: BendBox045
+    100092: BendBox046
+    100094: BendBox047
+    100096: BendBox048
+    100098: BendBox049
+    100100: BendBox050
+    100102: BendBox051
+    100104: BendBox052
+    100106: BendBox053
+    100108: BendBox054
+    100110: BendBox055
+    100112: BendBox056
+    100114: BendBox057
+    100116: BendBox058
+    100118: BendBox059
+    100120: BendBox060
+    100122: BendBox061
+    100124: BendBox062
+    100126: BendBox063
+    100128: BendBox064
+    100130: BendBox065
+    100132: BendBox066
+    100134: Bottom_Circle
+    100136: Box009
+    100138: Box010
+    100140: Box011
+    100142: Box012
+    100144: Box013
+    100146: Exterior_EdgeDecor
+    100148: Exterior_EdgeDecor001
+    100150: Exterior_EdgeDecor002
+    100152: Exterior_EdgeDecor003
+    100154: Exterior_EdgeDecor004
+    100156: Exterior_EdgeDecor005
+    100158: Exterior_EdgeDecor006
+    100160: Exterior_EdgeDecor007
+    100162: Exterior_EdgeDecor008
+    100164: Exterior_EdgeDecor009
+    100166: Exterior_EdgeDecor010
+    100168: Exterior_EdgeDecor011
+    100170: Exterior_EdgeDecor012
+    100172: Exterior_EdgeDecor013
+    100174: Exterior_EdgeDecor014
+    100176: Exterior_EdgeDecor015
+    100178: Exterior_EdgeDecor016
+    100180: Exterior_EdgeDecor017
+    100182: Exterior_EdgeDecor018
+    100184: Exterior_EdgeDecor019
+    100186: Exterior_EdgeDecor020
+    100188: Exterior_EdgeDecor021
+    100190: Exterior_EdgeDecor022
+    100192: Exterior_EdgeDecor023
+    100194: Exterior_EdgeDecor024
+    100196: Exterior_EdgeDecor025
+    100198: Exterior_EdgeDecor026
+    100200: Exterior_EdgeDecor027
+    100202: Exterior_EdgeDecor028
+    100204: Exterior_EdgeDecor029
+    100206: Exterior_EdgeDecor030
+    100208: Exterior_EdgeDecor031
+    100210: Exterior_EdgeDecor032
+    100212: Exterior_EdgeDecor033
+    100214: Exterior_EdgeDecor034
+    100216: Exterior_EdgeDecor035
+    100218: Exterior_EdgeDecor036
+    100220: Exterior_EdgeDecor037
+    100222: Exterior_EdgeDecor038
+    100224: Exterior_EdgeDecor039
+    100226: Exterior_EdgeDecor040
+    100228: Exterior_EdgeDecor041
+    100230: Exterior_Pie
+    100232: Exterior_Pie001
+    100234: Exterior_Pie002
+    100236: Exterior_Pie003
+    100238: Exterior_Pie004
+    100240: Exterior_Pie005
+    100242: Inner_Wall
+    100244: Inner_Wall001
+    100246: Inner_Wall002
+    100248: Inner_Wall003
+    100250: Inner_Wall004
+    100252: Inner_Wall005
+    100254: InnerPie
+    100256: InnerPie001
+    100258: InnerPie002
+    100260: InnerPie003
+    100262: InnerPie004
+    100264: InnerPie005
+    100266: //RootNode
+    100268: Wall
+    100270: Wall001
+    100272: Wall002
+    100274: Wall003
+    100276: WoodPillar
+    100278: 1Meter
+    400000: BendBox
+    400002: BendBox001
+    400004: BendBox002
+    400006: BendBox003
+    400008: BendBox004
+    400010: BendBox005
+    400012: BendBox006
+    400014: BendBox007
+    400016: BendBox008
+    400018: BendBox009
+    400020: BendBox010
+    400022: BendBox011
+    400024: BendBox012
+    400026: BendBox013
+    400028: BendBox014
+    400030: BendBox015
+    400032: BendBox016
+    400034: BendBox017
+    400036: BendBox018
+    400038: BendBox019
+    400040: BendBox020
+    400042: BendBox021
+    400044: BendBox022
+    400046: BendBox023
+    400048: BendBox024
+    400050: BendBox025
+    400052: BendBox026
+    400054: BendBox027
+    400056: BendBox028
+    400058: BendBox029
+    400060: BendBox030
+    400062: BendBox031
+    400064: BendBox032
+    400066: BendBox033
+    400068: BendBox034
+    400070: BendBox035
+    400072: BendBox036
+    400074: BendBox037
+    400076: BendBox038
+    400078: BendBox039
+    400080: BendBox040
+    400082: BendBox041
+    400084: BendBox042
+    400086: BendBox043
+    400088: BendBox044
+    400090: BendBox045
+    400092: BendBox046
+    400094: BendBox047
+    400096: BendBox048
+    400098: BendBox049
+    400100: BendBox050
+    400102: BendBox051
+    400104: BendBox052
+    400106: BendBox053
+    400108: BendBox054
+    400110: BendBox055
+    400112: BendBox056
+    400114: BendBox057
+    400116: BendBox058
+    400118: BendBox059
+    400120: BendBox060
+    400122: BendBox061
+    400124: BendBox062
+    400126: BendBox063
+    400128: BendBox064
+    400130: BendBox065
+    400132: BendBox066
+    400134: Bottom_Circle
+    400136: Box009
+    400138: Box010
+    400140: Box011
+    400142: Box012
+    400144: Box013
+    400146: Exterior_EdgeDecor
+    400148: Exterior_EdgeDecor001
+    400150: Exterior_EdgeDecor002
+    400152: Exterior_EdgeDecor003
+    400154: Exterior_EdgeDecor004
+    400156: Exterior_EdgeDecor005
+    400158: Exterior_EdgeDecor006
+    400160: Exterior_EdgeDecor007
+    400162: Exterior_EdgeDecor008
+    400164: Exterior_EdgeDecor009
+    400166: Exterior_EdgeDecor010
+    400168: Exterior_EdgeDecor011
+    400170: Exterior_EdgeDecor012
+    400172: Exterior_EdgeDecor013
+    400174: Exterior_EdgeDecor014
+    400176: Exterior_EdgeDecor015
+    400178: Exterior_EdgeDecor016
+    400180: Exterior_EdgeDecor017
+    400182: Exterior_EdgeDecor018
+    400184: Exterior_EdgeDecor019
+    400186: Exterior_EdgeDecor020
+    400188: Exterior_EdgeDecor021
+    400190: Exterior_EdgeDecor022
+    400192: Exterior_EdgeDecor023
+    400194: Exterior_EdgeDecor024
+    400196: Exterior_EdgeDecor025
+    400198: Exterior_EdgeDecor026
+    400200: Exterior_EdgeDecor027
+    400202: Exterior_EdgeDecor028
+    400204: Exterior_EdgeDecor029
+    400206: Exterior_EdgeDecor030
+    400208: Exterior_EdgeDecor031
+    400210: Exterior_EdgeDecor032
+    400212: Exterior_EdgeDecor033
+    400214: Exterior_EdgeDecor034
+    400216: Exterior_EdgeDecor035
+    400218: Exterior_EdgeDecor036
+    400220: Exterior_EdgeDecor037
+    400222: Exterior_EdgeDecor038
+    400224: Exterior_EdgeDecor039
+    400226: Exterior_EdgeDecor040
+    400228: Exterior_EdgeDecor041
+    400230: Exterior_Pie
+    400232: Exterior_Pie001
+    400234: Exterior_Pie002
+    400236: Exterior_Pie003
+    400238: Exterior_Pie004
+    400240: Exterior_Pie005
+    400242: Inner_Wall
+    400244: Inner_Wall001
+    400246: Inner_Wall002
+    400248: Inner_Wall003
+    400250: Inner_Wall004
+    400252: Inner_Wall005
+    400254: InnerPie
+    400256: InnerPie001
+    400258: InnerPie002
+    400260: InnerPie003
+    400262: InnerPie004
+    400264: InnerPie005
+    400266: //RootNode
+    400268: Wall
+    400270: Wall001
+    400272: Wall002
+    400274: Wall003
+    400276: WoodPillar
+    400278: 1Meter
+    2300000: BendBox
+    2300002: BendBox001
+    2300004: BendBox002
+    2300006: BendBox003
+    2300008: BendBox004
+    2300010: BendBox005
+    2300012: BendBox006
+    2300014: BendBox007
+    2300016: BendBox008
+    2300018: BendBox009
+    2300020: BendBox010
+    2300022: BendBox011
+    2300024: BendBox012
+    2300026: BendBox013
+    2300028: BendBox014
+    2300030: BendBox015
+    2300032: BendBox016
+    2300034: BendBox017
+    2300036: BendBox018
+    2300038: BendBox019
+    2300040: BendBox020
+    2300042: BendBox021
+    2300044: BendBox022
+    2300046: BendBox023
+    2300048: BendBox024
+    2300050: BendBox025
+    2300052: BendBox026
+    2300054: BendBox027
+    2300056: BendBox028
+    2300058: BendBox029
+    2300060: BendBox030
+    2300062: BendBox031
+    2300064: BendBox032
+    2300066: BendBox033
+    2300068: BendBox034
+    2300070: BendBox035
+    2300072: BendBox036
+    2300074: BendBox037
+    2300076: BendBox038
+    2300078: BendBox039
+    2300080: BendBox040
+    2300082: BendBox041
+    2300084: BendBox042
+    2300086: BendBox043
+    2300088: BendBox044
+    2300090: BendBox045
+    2300092: BendBox046
+    2300094: BendBox047
+    2300096: BendBox048
+    2300098: BendBox049
+    2300100: BendBox050
+    2300102: BendBox051
+    2300104: BendBox052
+    2300106: BendBox053
+    2300108: BendBox054
+    2300110: BendBox055
+    2300112: BendBox056
+    2300114: BendBox057
+    2300116: BendBox058
+    2300118: BendBox059
+    2300120: BendBox060
+    2300122: BendBox061
+    2300124: BendBox062
+    2300126: BendBox063
+    2300128: BendBox064
+    2300130: BendBox065
+    2300132: BendBox066
+    2300134: Bottom_Circle
+    2300136: Box009
+    2300138: Box010
+    2300140: Box011
+    2300142: Box012
+    2300144: Box013
+    2300146: Exterior_EdgeDecor
+    2300148: Exterior_EdgeDecor001
+    2300150: Exterior_EdgeDecor002
+    2300152: Exterior_EdgeDecor003
+    2300154: Exterior_EdgeDecor004
+    2300156: Exterior_EdgeDecor005
+    2300158: Exterior_EdgeDecor006
+    2300160: Exterior_EdgeDecor007
+    2300162: Exterior_EdgeDecor008
+    2300164: Exterior_EdgeDecor009
+    2300166: Exterior_EdgeDecor010
+    2300168: Exterior_EdgeDecor011
+    2300170: Exterior_EdgeDecor012
+    2300172: Exterior_EdgeDecor013
+    2300174: Exterior_EdgeDecor014
+    2300176: Exterior_EdgeDecor015
+    2300178: Exterior_EdgeDecor016
+    2300180: Exterior_EdgeDecor017
+    2300182: Exterior_EdgeDecor018
+    2300184: Exterior_EdgeDecor019
+    2300186: Exterior_EdgeDecor020
+    2300188: Exterior_EdgeDecor021
+    2300190: Exterior_EdgeDecor022
+    2300192: Exterior_EdgeDecor023
+    2300194: Exterior_EdgeDecor024
+    2300196: Exterior_EdgeDecor025
+    2300198: Exterior_EdgeDecor026
+    2300200: Exterior_EdgeDecor027
+    2300202: Exterior_EdgeDecor028
+    2300204: Exterior_EdgeDecor029
+    2300206: Exterior_EdgeDecor030
+    2300208: Exterior_EdgeDecor031
+    2300210: Exterior_EdgeDecor032
+    2300212: Exterior_EdgeDecor033
+    2300214: Exterior_EdgeDecor034
+    2300216: Exterior_EdgeDecor035
+    2300218: Exterior_EdgeDecor036
+    2300220: Exterior_EdgeDecor037
+    2300222: Exterior_EdgeDecor038
+    2300224: Exterior_EdgeDecor039
+    2300226: Exterior_EdgeDecor040
+    2300228: Exterior_EdgeDecor041
+    2300230: Exterior_Pie
+    2300232: Exterior_Pie001
+    2300234: Exterior_Pie002
+    2300236: Exterior_Pie003
+    2300238: Exterior_Pie004
+    2300240: Exterior_Pie005
+    2300242: Inner_Wall
+    2300244: Inner_Wall001
+    2300246: Inner_Wall002
+    2300248: Inner_Wall003
+    2300250: Inner_Wall004
+    2300252: Inner_Wall005
+    2300254: InnerPie
+    2300256: InnerPie001
+    2300258: InnerPie002
+    2300260: InnerPie003
+    2300262: InnerPie004
+    2300264: InnerPie005
+    2300266: Wall
+    2300268: Wall001
+    2300270: Wall002
+    2300272: Wall003
+    2300274: WoodPillar
+    2300276: 1Meter
+    2300278: //RootNode
+    3300000: BendBox
+    3300002: BendBox001
+    3300004: BendBox002
+    3300006: BendBox003
+    3300008: BendBox004
+    3300010: BendBox005
+    3300012: BendBox006
+    3300014: BendBox007
+    3300016: BendBox008
+    3300018: BendBox009
+    3300020: BendBox010
+    3300022: BendBox011
+    3300024: BendBox012
+    3300026: BendBox013
+    3300028: BendBox014
+    3300030: BendBox015
+    3300032: BendBox016
+    3300034: BendBox017
+    3300036: BendBox018
+    3300038: BendBox019
+    3300040: BendBox020
+    3300042: BendBox021
+    3300044: BendBox022
+    3300046: BendBox023
+    3300048: BendBox024
+    3300050: BendBox025
+    3300052: BendBox026
+    3300054: BendBox027
+    3300056: BendBox028
+    3300058: BendBox029
+    3300060: BendBox030
+    3300062: BendBox031
+    3300064: BendBox032
+    3300066: BendBox033
+    3300068: BendBox034
+    3300070: BendBox035
+    3300072: BendBox036
+    3300074: BendBox037
+    3300076: BendBox038
+    3300078: BendBox039
+    3300080: BendBox040
+    3300082: BendBox041
+    3300084: BendBox042
+    3300086: BendBox043
+    3300088: BendBox044
+    3300090: BendBox045
+    3300092: BendBox046
+    3300094: BendBox047
+    3300096: BendBox048
+    3300098: BendBox049
+    3300100: BendBox050
+    3300102: BendBox051
+    3300104: BendBox052
+    3300106: BendBox053
+    3300108: BendBox054
+    3300110: BendBox055
+    3300112: BendBox056
+    3300114: BendBox057
+    3300116: BendBox058
+    3300118: BendBox059
+    3300120: BendBox060
+    3300122: BendBox061
+    3300124: BendBox062
+    3300126: BendBox063
+    3300128: BendBox064
+    3300130: BendBox065
+    3300132: BendBox066
+    3300134: Bottom_Circle
+    3300136: Box009
+    3300138: Box010
+    3300140: Box011
+    3300142: Box012
+    3300144: Box013
+    3300146: Exterior_EdgeDecor
+    3300148: Exterior_EdgeDecor001
+    3300150: Exterior_EdgeDecor002
+    3300152: Exterior_EdgeDecor003
+    3300154: Exterior_EdgeDecor004
+    3300156: Exterior_EdgeDecor005
+    3300158: Exterior_EdgeDecor006
+    3300160: Exterior_EdgeDecor007
+    3300162: Exterior_EdgeDecor008
+    3300164: Exterior_EdgeDecor009
+    3300166: Exterior_EdgeDecor010
+    3300168: Exterior_EdgeDecor011
+    3300170: Exterior_EdgeDecor012
+    3300172: Exterior_EdgeDecor013
+    3300174: Exterior_EdgeDecor014
+    3300176: Exterior_EdgeDecor015
+    3300178: Exterior_EdgeDecor016
+    3300180: Exterior_EdgeDecor017
+    3300182: Exterior_EdgeDecor018
+    3300184: Exterior_EdgeDecor019
+    3300186: Exterior_EdgeDecor020
+    3300188: Exterior_EdgeDecor021
+    3300190: Exterior_EdgeDecor022
+    3300192: Exterior_EdgeDecor023
+    3300194: Exterior_EdgeDecor024
+    3300196: Exterior_EdgeDecor025
+    3300198: Exterior_EdgeDecor026
+    3300200: Exterior_EdgeDecor027
+    3300202: Exterior_EdgeDecor028
+    3300204: Exterior_EdgeDecor029
+    3300206: Exterior_EdgeDecor030
+    3300208: Exterior_EdgeDecor031
+    3300210: Exterior_EdgeDecor032
+    3300212: Exterior_EdgeDecor033
+    3300214: Exterior_EdgeDecor034
+    3300216: Exterior_EdgeDecor035
+    3300218: Exterior_EdgeDecor036
+    3300220: Exterior_EdgeDecor037
+    3300222: Exterior_EdgeDecor038
+    3300224: Exterior_EdgeDecor039
+    3300226: Exterior_EdgeDecor040
+    3300228: Exterior_EdgeDecor041
+    3300230: Exterior_Pie
+    3300232: Exterior_Pie001
+    3300234: Exterior_Pie002
+    3300236: Exterior_Pie003
+    3300238: Exterior_Pie004
+    3300240: Exterior_Pie005
+    3300242: Inner_Wall
+    3300244: Inner_Wall001
+    3300246: Inner_Wall002
+    3300248: Inner_Wall003
+    3300250: Inner_Wall004
+    3300252: Inner_Wall005
+    3300254: InnerPie
+    3300256: InnerPie001
+    3300258: InnerPie002
+    3300260: InnerPie003
+    3300262: InnerPie004
+    3300264: InnerPie005
+    3300266: Wall
+    3300268: Wall001
+    3300270: Wall002
+    3300272: Wall003
+    3300274: WoodPillar
+    3300276: 1Meter
+    3300278: //RootNode
+    4300000: Exterior_Pie
+    4300002: Inner_Wall
+    4300004: InnerPie
+    4300006: InnerPie001
+    4300008: InnerPie002
+    4300010: InnerPie003
+    4300012: InnerPie004
+    4300014: InnerPie005
+    4300016: Wall
+    4300018: Exterior_Pie001
+    4300020: Exterior_Pie002
+    4300022: Exterior_Pie003
+    4300024: Exterior_Pie004
+    4300026: Exterior_Pie005
+    4300028: Inner_Wall001
+    4300030: Inner_Wall002
+    4300032: Inner_Wall003
+    4300034: Inner_Wall004
+    4300036: Inner_Wall005
+    4300038: Exterior_EdgeDecor
+    4300040: Exterior_EdgeDecor001
+    4300042: Exterior_EdgeDecor002
+    4300044: Exterior_EdgeDecor003
+    4300046: Exterior_EdgeDecor004
+    4300048: Exterior_EdgeDecor005
+    4300050: Exterior_EdgeDecor006
+    4300052: Bottom_Circle
+    4300054: WoodPillar
+    4300056: BendBox
+    4300058: BendBox001
+    4300060: BendBox002
+    4300062: BendBox003
+    4300064: BendBox004
+    4300066: BendBox005
+    4300068: BendBox006
+    4300070: BendBox007
+    4300072: BendBox008
+    4300074: BendBox009
+    4300076: BendBox010
+    4300078: BendBox011
+    4300080: BendBox012
+    4300082: BendBox013
+    4300084: BendBox014
+    4300086: BendBox015
+    4300088: BendBox016
+    4300090: BendBox017
+    4300092: BendBox018
+    4300094: BendBox019
+    4300096: BendBox020
+    4300098: BendBox021
+    4300100: BendBox022
+    4300102: BendBox023
+    4300104: BendBox024
+    4300106: BendBox025
+    4300108: BendBox026
+    4300110: BendBox027
+    4300112: BendBox028
+    4300114: BendBox029
+    4300116: BendBox030
+    4300118: BendBox031
+    4300120: BendBox032
+    4300122: BendBox033
+    4300124: BendBox034
+    4300126: BendBox035
+    4300128: BendBox036
+    4300130: BendBox037
+    4300132: BendBox038
+    4300134: BendBox039
+    4300136: BendBox040
+    4300138: BendBox041
+    4300140: BendBox042
+    4300142: BendBox043
+    4300144: BendBox044
+    4300146: BendBox045
+    4300148: BendBox046
+    4300150: BendBox047
+    4300152: BendBox048
+    4300154: BendBox049
+    4300156: BendBox050
+    4300158: BendBox051
+    4300160: BendBox052
+    4300162: BendBox053
+    4300164: BendBox054
+    4300166: BendBox055
+    4300168: BendBox056
+    4300170: BendBox057
+    4300172: BendBox058
+    4300174: BendBox059
+    4300176: BendBox060
+    4300178: BendBox061
+    4300180: BendBox062
+    4300182: BendBox063
+    4300184: BendBox064
+    4300186: BendBox065
+    4300188: BendBox066
+    4300190: Exterior_EdgeDecor007
+    4300192: Exterior_EdgeDecor008
+    4300194: Exterior_EdgeDecor009
+    4300196: Exterior_EdgeDecor010
+    4300198: Exterior_EdgeDecor011
+    4300200: Exterior_EdgeDecor012
+    4300202: Exterior_EdgeDecor013
+    4300204: Exterior_EdgeDecor014
+    4300206: Exterior_EdgeDecor015
+    4300208: Exterior_EdgeDecor016
+    4300210: Exterior_EdgeDecor017
+    4300212: Exterior_EdgeDecor018
+    4300214: Exterior_EdgeDecor019
+    4300216: Exterior_EdgeDecor020
+    4300218: Exterior_EdgeDecor021
+    4300220: Exterior_EdgeDecor022
+    4300222: Exterior_EdgeDecor023
+    4300224: Exterior_EdgeDecor024
+    4300226: Exterior_EdgeDecor025
+    4300228: Exterior_EdgeDecor026
+    4300230: Exterior_EdgeDecor027
+    4300232: Exterior_EdgeDecor028
+    4300234: Exterior_EdgeDecor029
+    4300236: Exterior_EdgeDecor030
+    4300238: Exterior_EdgeDecor031
+    4300240: Exterior_EdgeDecor032
+    4300242: Exterior_EdgeDecor033
+    4300244: Exterior_EdgeDecor034
+    4300246: Exterior_EdgeDecor035
+    4300248: Exterior_EdgeDecor036
+    4300250: Exterior_EdgeDecor037
+    4300252: Exterior_EdgeDecor038
+    4300254: Exterior_EdgeDecor039
+    4300256: Exterior_EdgeDecor040
+    4300258: Exterior_EdgeDecor041
+    4300260: Box009
+    4300262: Box010
+    4300264: Box011
+    4300266: Box012
+    4300268: Box013
+    4300270: Wall001
+    4300272: Wall002
+    4300274: Wall003
+    4300276: 1Meter
+    4300278: Box014
+    9500000: //RootNode
+  materials:
+    importMaterials: 1
+    materialName: 0
+    materialSearch: 1
+  animations:
+    legacyGenerateAnimations: 4
+    bakeSimulation: 0
+    resampleCurves: 1
+    optimizeGameObjects: 0
+    motionNodeName: 
+    rigImportErrors: 
+    rigImportWarnings: 
+    animationImportErrors: 
+    animationImportWarnings: 
+    animationRetargetingWarnings: 
+    animationDoRetargetingWarnings: 0
+    importAnimatedCustomProperties: 0
+    animationCompression: 1
+    animationRotationError: 0.5
+    animationPositionError: 0.5
+    animationScaleError: 0.5
+    animationWrapMode: 0
+    extraExposedTransformPaths: []
+    extraUserProperties: []
+    clipAnimations: []
+    isReadable: 1
+  meshes:
+    lODScreenPercentages: []
+    globalScale: 1
+    meshCompression: 0
+    addColliders: 0
+    importVisibility: 1
+    importBlendShapes: 1
+    importCameras: 1
+    importLights: 1
+    swapUVChannels: 0
+    generateSecondaryUV: 0
+    useFileUnits: 1
+    optimizeMeshForGPU: 1
+    keepQuads: 0
+    weldVertices: 1
+    secondaryUVAngleDistortion: 8
+    secondaryUVAreaDistortion: 15.000001
+    secondaryUVHardAngle: 88
+    secondaryUVPackMargin: 4
+    useFileScale: 1
+  tangentSpace:
+    normalSmoothAngle: 60
+    normalImportMode: 0
+    tangentImportMode: 3
+    normalCalculationMode: 4
+  importAnimation: 1
+  copyAvatar: 0
+  humanDescription:
+    serializedVersion: 2
+    human: []
+    skeleton: []
+    armTwist: 0.5
+    foreArmTwist: 0.5
+    upperLegTwist: 0.5
+    legTwist: 0.5
+    armStretch: 0.05
+    legStretch: 0.05
+    feetSpacing: 0
+    rootMotionBoneName: 
+    rootMotionBoneRotation: {x: 0, y: 0, z: 0, w: 1}
+    hasTranslationDoF: 0
+    hasExtraRoot: 0
+    skeletonHasParents: 1
+  lastHumanDescriptionAvatarSource: {instanceID: 0}
+  animationType: 2
+  humanoidOversampling: 1
+  additionalBone: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials.meta

+fileFormatVersion: 2
+guid: caf559e15b19eec42b3a1e3e01e95e52
+folderAsset: yes
+timeCreated: 1495695296
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/BlackMetal.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: BlackMetal
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.327
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.2941176, g: 0.2941176, b: 0.2941176, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/BlackMetal.mat.meta

+fileFormatVersion: 2
+guid: 24b76de0640d4db458f7f010e5060d56
+timeCreated: 1495707977
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/CheckerBoard.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: CheckerBoard
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 7b7a978dade3d3543aeaa728573901ee, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.588, g: 0.588, b: 0.588, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/CheckerBoard.mat.meta

+fileFormatVersion: 2
+guid: 4215aaf0439387d4793fa9e1ad500985
+timeCreated: 1495719198
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/EmissiveStrip_D.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: EmissiveStrip_D
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _EMISSION
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 2800000, guid: 0b5a8e8e6081495418ad02992a4201cb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 0b5a8e8e6081495418ad02992a4201cb, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.899
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 1.1, g: 0.9536308, b: 0.84117645, a: 1}

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/EmissiveStrip_D.mat.meta

+fileFormatVersion: 2
+guid: 26d3db59021d80e41ba74c33172098a4
+timeCreated: 1495707977
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/No Name.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: No Name
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/No Name.mat.meta

+fileFormatVersion: 2
+guid: ea719810bcad1694c8a5f5855b737eff
+timeCreated: 1495723949
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/Painted_Surface_D.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: Painted_Surface_D
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _NORMALMAP
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 2800000, guid: 86c62b53c903a1047a9406838a9241bd, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 0.5
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.219
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 0.6985294, g: 0.6697666, b: 0.62662196, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/Painted_Surface_D.mat.meta

+fileFormatVersion: 2
+guid: 69b0c5833ef79da49ba267480698f50f
+timeCreated: 1495707977
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Rinaldo/DemoScene/Mesh/Materials/UnityLogoPBR.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: UnityLogoPBR
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: ad78029cb3832214ca442896e68ae18f, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.77
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 1
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}