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

MaterialGraphProject/Assets/Matt/Examples/Anisotropy.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Anisotropy
-  m_Shader: {fileID: 4800000, guid: 9ab5e16c2083a4fe689209a8c1ae425e, type: 3}
+  m_Shader: {fileID: 4800000, guid: 01a19a2c08481994c87ec502a371225e, type: 3}
   m_ShaderKeywords: 
   m_LightmapFlags: 0
   m_EnableInstancingVariants: 0
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
+    - Texture_25f557fd_e8c0_4423_81b1_854877e54145_Uniform:
+        m_Texture: {fileID: 2800000, guid: f147ecc73752dd84c862347627c2506c, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
     - 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}
     m_Floats:
     - Vector1_3c037cd0_a4ae_48b0_8e8c_e1507ff6f738_Uniform: 1
+    - Vector1_5c761f75_773e_42ed_b242_72e6b25acebd_Uniform: 0.896
+    - Vector1_8272d735_22ca_40c5_a082_1c40f63ad50b_Uniform: 0.415
+    - Vector1_91e780ac_52c0_4e9a_bd0e_974f5805854d_Uniform: 0.546
     - Vector1_da8ece50_8bc4_4e14_b77a_24dfc74c32da_Uniform: 0.817
     - _BumpScale: 1
     - _Cutoff: 0.5

MaterialGraphProject/Assets/NewNodes/WIP/AACheckerBoardNode.cs

                     };
                 }
             }
+            public ShaderGlobal[] globals { get { return new ShaderGlobal[] { }; } }
 
             public string hlsl
             {

MaterialGraphProject/Assets/NewNodes/WIP/AnyNode.cs

 
 namespace UnityEngine.MaterialGraph
 {
+    public enum ShaderGlobal
+    {
+        UV0,
+        UV1,
+        UV2,
+        UV3,
+        WorldSpaceNormal,
+        WorldSpaceBitangent,
+        WorldSpaceTangent,
+        WorldSpacePosition,
+        WorldSpaceViewDirection,
+        TangentSpaceViewDirection,
+        ScreenPosition,
+        VertexColor,
+    }
+
     [Serializable]
     public class AnyNodeSlot
     {
         string name { get; }
         AnyNodeProperty[] properties { get; }
         AnyNodeSlot[] outputs { get; }
+        ShaderGlobal[] globals { get; }
         string hlsl { get; }
     }
 
 
         [SerializeField]
         protected AnyNodeSlot[] m_outputSlots;
+
+        [SerializeField]
+        protected ShaderGlobal[] m_globals;
 
         public IEnumerable<AnyNodeProperty> properties
         {
         AnyNodeBase
 		, IGeneratesBodyCode
 		, IGeneratesFunction
+//        , IMayRequireMeshUV
+//        , IMayRequireNormal             // TODO
+//        , IMayRequireTangent
+//        , IMayRequireBitangent
+//        , IMayRequireScreenPosition
+//        , IMayRequireViewDirection
+//        , IMayRequireWorldPosition
+//        , IMayRequireVertexColor
+        , IMayRequireViewDirectionTangentSpace 
-        /*      , IMayRequireMeshUV
-                , IOnAssetEnabled               // TODO
-                , IMayRequireNormal             // TODO
-                , IMayRequireTangent
-                , IMayRequireBitangent
-                , IMayRequireScreenPosition
-                , IMayRequireViewDirection
-                , IMayRequireWorldPosition
-                , IMayRequireVertexColor
-                , IMayRequireViewDirectionTangentSpace 
-        */
         where DEFINITION : IAnyNodeDefinition, new()
     {
         private DEFINITION m_definition;
 
             m_outputSlots = m_definition.outputs;
 
+            m_globals = m_definition.globals;
+
             UpdateNodeAfterDeserialization();
 		}
 
             // now that we've copied the old data into the new properties, start using the new properties
             m_properties = new_properties;
             m_outputSlots = new_outputs;
+            m_globals = m_definition.globals;
 
             List<int> validSlotIds = new List<int>();
 
             }
         }
 
+        public bool RequiresViewDirectionTangentSpace()
+        {
+            return (Array.FindIndex(m_globals, x => x == ShaderGlobal.TangentSpaceViewDirection) >= 0);
+        }
+
-
-            //		properties.AddRange(subGraph.GetPreviewProperties());       // ???
-
                 switch (p.propertyType)
                 {
                     case PropertyType.Float:
             return "unity_any_" + node_name + "_" + precision;
         }
 
+        private string GetShaderGlobalName(ShaderGlobal g)
+        {
+            string globalname = null;
+            switch (g)
+            {
+                case ShaderGlobal.UV0:
+                    globalname = ShaderGeneratorNames.GetUVName(UVChannel.uv0);
+                    break;
+                case ShaderGlobal.UV1:
+                    globalname = ShaderGeneratorNames.GetUVName(UVChannel.uv1);
+                    break;
+                case ShaderGlobal.UV2:
+                    globalname = ShaderGeneratorNames.GetUVName(UVChannel.uv2);
+                    break;
+                case ShaderGlobal.UV3:
+                    globalname = ShaderGeneratorNames.GetUVName(UVChannel.uv3);
+                    break;
+                case ShaderGlobal.WorldSpaceNormal:
+                    globalname = ShaderGeneratorNames.WorldSpaceNormal;
+                    break;
+                case ShaderGlobal.WorldSpaceBitangent:
+                    globalname = ShaderGeneratorNames.WorldSpaceBitangent;
+                    break;
+                case ShaderGlobal.WorldSpaceTangent:
+                    globalname = ShaderGeneratorNames.WorldSpaceTangent;
+                    break;
+                case ShaderGlobal.WorldSpacePosition:
+                    globalname = ShaderGeneratorNames.WorldSpacePosition;
+                    break;
+                case ShaderGlobal.WorldSpaceViewDirection:
+                    globalname = ShaderGeneratorNames.WorldSpaceViewDirection;
+                    break;
+                case ShaderGlobal.TangentSpaceViewDirection:
+                    globalname = ShaderGeneratorNames.TangentSpaceViewDirection;
+                    break;
+                case ShaderGlobal.ScreenPosition:
+                    globalname = ShaderGeneratorNames.ScreenPosition;
+                    break;
+                case ShaderGlobal.VertexColor:
+                    globalname = ShaderGeneratorNames.VertexColor;
+                    break;
+            }
+            return globalname;
+        }
+
+        private string GetShaderGlobalTypeDecl(ShaderGlobal g)
+        {
+            string typeDecl = null;
+            switch (g)
+            {
+                case ShaderGlobal.UV0:
+                case ShaderGlobal.UV1:
+                case ShaderGlobal.UV2:
+                case ShaderGlobal.UV3:
+                    typeDecl = "float4";
+                    break;
+                case ShaderGlobal.WorldSpaceNormal:
+                case ShaderGlobal.WorldSpaceBitangent:
+                case ShaderGlobal.WorldSpaceTangent:
+                case ShaderGlobal.WorldSpacePosition:
+                case ShaderGlobal.WorldSpaceViewDirection:
+                case ShaderGlobal.TangentSpaceViewDirection:
+                    typeDecl = "float3";
+                    break;
+                case ShaderGlobal.ScreenPosition:
+                    typeDecl = "float2";
+                    break;
+                case ShaderGlobal.VertexColor:
+                    typeDecl = "float4";
+                    break;
+            }
+
+            return typeDecl;
+        }
+
         protected virtual string GetFunctionPrototype()
         {
             string result = "inline void " + GetFunctionName() + "(";
             }
 
             // then 'globals'
-            // TODO
+            foreach (ShaderGlobal g in m_globals)
+            {
+                result += "in " + GetShaderGlobalTypeDecl(g) + " " + GetShaderGlobalName(g) + ", ";
+            }
 
             // then outputs
             foreach (AnyNodeSlot s in m_outputSlots)
                         inputVariableName = p.name;
                     }
                     outputString.AddShaderChunk((first ? "" : ",") + inputVariableName, false);
+                    first = false;
+                }
+
+                outputString.AddShaderChunk("// global parameters", false);
+                foreach (ShaderGlobal g in m_globals)
+                {
+                    outputString.AddShaderChunk((first ? "" : ",") + GetShaderGlobalName(g), false);
                     first = false;
                 }
 

MaterialGraphProject/Assets/NewNodes/WIP/RadialShearNode.cs

                     };
                 }
             }
+            public ShaderGlobal[] globals { get { return new ShaderGlobal[] { }; } }
 
             public string hlsl
             {

MaterialGraphProject/Assets/NewNodes/WIP/ScaleOffsetNode.cs

                 }
             }
 
+            public ShaderGlobal[] globals { get { return new ShaderGlobal[] { }; } }
+
             public string hlsl
             {
                 get

MaterialGraphProject/Assets/NewNodes/WIP/SphereWarpNode.cs

                 }
             }
 
+            public ShaderGlobal[] globals { get { return new ShaderGlobal[]{ };  } }
+
             public string hlsl
             {
                 get

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

             typeMapper[typeof(ScaleOffsetNode)] = typeof(AnyNodePresenter);         // anything derived from AnyNode should use the AnyNodePresenter
             typeMapper[typeof(RadialShearNode)] = typeof(AnyNodePresenter);         // anything derived from AnyNode should use the AnyNodePresenter
             typeMapper[typeof(SphereWarpNode)] = typeof(AnyNodePresenter);          // anything derived from AnyNode should use the AnyNodePresenter
+            typeMapper[typeof(SphericalIndentationNode)] = typeof(AnyNodePresenter);          // anything derived from AnyNode should use the AnyNodePresenter
             typeMapper[typeof(AACheckerboardNode)] = typeof(AnyNodePresenter);         // anything derived from AnyNode should use the AnyNodePresenter
             typeMapper[typeof(SubGraphNode)] = typeof(SubgraphNodePresenter);
             typeMapper[typeof(RemapMasterNode)] = typeof(RemapMasterNodePresenter);

MaterialGraphProject/Assets/Matt/Examples/Anisotropy.shader

+Shader "Examples/Anisotropy"
+{
+	Properties
+	{
+		Vector1_5c761f75_773e_42ed_b242_72e6b25acebd_Uniform("Metallic", Range(0, 1)) = 0.278
+		Vector1_91e780ac_52c0_4e9a_bd0e_974f5805854d_Uniform("Smoothness", Range(0, 1)) = 0.59
+		[NonModifiableTextureData] Texture_3db1140f_b814_4ba5_a49c_d40499367921_Uniform("Texture", 2D) = "white" {}
+	Vector1_8272d735_22ca_40c5_a082_1c40f63ad50b_Uniform("Anisotropy", Range(0, 1)) = 1
+
+	}
+
+		SubShader
+	{
+		Tags
+	{
+		"RenderType" = "Opaque"
+		"Queue" = "Geometry"
+	}
+
+		Blend One Zero
+
+		Cull Back
+
+		ZTest LEqual
+
+		ZWrite On
+
+
+		LOD 200
+
+		CGPROGRAM
+#include "UnityCG.cginc"
+		//#include "AdvancedBRDF.cginc"
+		//#include "AdvancedShading.cginc"
+		//#include "AdvancedLighting.cginc"
+
+#define SHADINGMODELID_STANDARD
+
+
+		// ------------------------------------------------------------------
+		//  Diffuse
+
+		// From UE4 - Used for Cloth (Deprecated)
+		float3 Diffuse_Lambert(float3 DiffuseColor)
+	{
+		return DiffuseColor * (1 / UNITY_PI);
+	}
+
+	// ------------------------------------------------------------------
+	//  Fresnel
+
+	// From UE4 - Used for Cloth
+	// [Schlick 1994, "An Inexpensive BRDF Model for Physically-Based Rendering"]
+	float3 F_Schlick(float3 SpecularColor, float VoH)
+	{
+		float Fc = Pow5(1 - VoH);					// 1 sub, 3 mul
+													//return Fc + (1 - Fc) * SpecularColor;		// 1 add, 3 mad
+													// Anything less than 2% is physically impossible and is instead considered to be shadowing
+		return saturate(50.0 * SpecularColor.g) * Fc + (1 - Fc) * SpecularColor;
+	}
+
+	// ------------------------------------------------------------------
+	//  Distribution
+
+	// From UE4 - USed for Cloth
+	// GGX / Trowbridge-Reitz
+	// [Walter et al. 2007, "Microfacet models for refraction through rough surfaces"]
+	float D_GGX(float roughness, float NdotH)
+	{
+		float a = roughness * roughness;
+		float a2 = a * a;
+		float d = (NdotH * a2 - NdotH) * NdotH + 1;	// 2 mad
+		return a2 / (UNITY_PI*d*d);					// 4 mul, 1 rcp
+	}
+
+	// Anisotropic GGX
+	// Taken from HDRenderPipeline
+	float D_GGXAnisotropic(float TdotH, float BdotH, float NdotH, float roughnessT, float roughnessB)
+	{
+		float f = TdotH * TdotH / (roughnessT * roughnessT) + BdotH * BdotH / (roughnessB * roughnessB) + NdotH * NdotH;
+		return 1.0 / (roughnessT * roughnessB * f * f);
+	}
+
+	// From UE4 - Used for Cloth
+	float D_InvGGX(float roughness, float NdotH)
+	{
+		float a = roughness * roughness;
+		float a2 = a * a;
+		float A = 4;
+		float d = (NdotH - a2 * NdotH) * NdotH + a2;
+		return 1 / (UNITY_PI * (1 + A*a2)) * (1 + 4 * a2*a2 / (d*d)); //RCP
+	}
+
+	// ------------------------------------------------------------------
+	//  Visibility
+
+	// From UE4 - Used for Cloth
+	// Appoximation of joint Smith term for GGX
+	// [Heitz 2014, "Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs"]
+	float Vis_SmithJointApprox(float Roughness, float NoV, float NoL)
+	{
+		float a = (Roughness*Roughness);
+		float Vis_SmithV = NoL * (NoV * (1 - a) + a);
+		float Vis_SmithL = NoV * (NoL * (1 - a) + a);
+		// Note: will generate NaNs with Roughness = 0.  MinRoughness is used to prevent this
+		return 0.5 * 1 / (Vis_SmithV + Vis_SmithL); //RCP
+	}
+
+	// From UE4 - Used for Cloth
+	float Vis_Cloth(float NoV, float NoL)
+	{
+		return 1 / (4 * (NoL + NoV - NoL * NoV)); //RCP
+	}
+
+	// ------------------------------------------------------------------
+	//  SORT THESE
+
+	// Smith Joint GGX Anisotropic Visibility
+	// Taken from https://cedec.cesa.or.jp/2015/session/ENG/14698.html
+	float SmithJointGGXAnisotropic(float TdotV, float BdotV, float NdotV, float TdotL, float BdotL, float NdotL, float roughnessT, float roughnessB)
+	{
+		float aT = roughnessT;
+		float aT2 = aT * aT;
+		float aB = roughnessB;
+		float aB2 = aB * aB;
+
+		float lambdaV = NdotL * sqrt(aT2 * TdotV * TdotV + aB2 * BdotV * BdotV + NdotV * NdotV);
+		float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);
+
+		return 0.5 / (lambdaV + lambdaL);
+	}
+
+	// Convert Anistropy to roughness
+	void ConvertAnisotropyToRoughness(float roughness, float anisotropy, out float roughnessT, out float roughnessB)
+	{
+		// (0 <= anisotropy <= 1), therefore (0 <= anisoAspect <= 1)
+		// The 0.9 factor limits the aspect ratio to 10:1.
+		float anisoAspect = sqrt(1.0 - 0.9 * anisotropy);
+		roughnessT = roughness / anisoAspect; // Distort along tangent (rougher)
+		roughnessB = roughness * anisoAspect; // Straighten along bitangent (smoother)
+	}
+
+	// Schlick Fresnel
+	float FresnelSchlick(float f0, float f90, float u)
+	{
+		float x = 1.0 - u;
+		float x5 = x * x;
+		x5 = x5 * x5 * x;
+		return (f90 - f0) * x5 + f0; // sub mul mul mul sub mad
+	}
+
+	//Clamp roughness
+	float ClampRoughnessForAnalyticalLights(float roughness)
+	{
+		return max(roughness, 0.000001);
+	}
+
+	//Calculate tangent warp for IBL (Reference Version - not used)
+	float3 SpecularGGXIBLRef(float3 viewDir, float3 normalDir, float3 tangentDir, float3 bitangentDir, float roughnessT, float roughnessB)
+	{
+		return float3(1, 1, 1);
+		//Hidden in UnityAnisotropicLighting.cginc
+	}
+
+	// Sample Anisotropic Direction for IBL (Reference Version - not used)
+	void SampleAnisoGGXDir(float2 u, float3 viewDir, float3 normalDir, float3 tangent, float3 bitangent, float roughnessT, float roughnessB, out float3 halfDir, out float3 lightDir)
+	{
+		// AnisoGGX NDF sampling
+		halfDir = sqrt(u.x / (1.0 - u.x)) * (roughnessT * cos((UNITY_PI * 2) * u.y) * tangent + roughnessB * sin((UNITY_PI * 2) * u.y) * bitangent) + normalDir;
+		halfDir = normalize(halfDir);
+
+		// Convert sample from half angle to incident angle
+		lightDir = 2.0 * saturate(dot(viewDir, halfDir)) * halfDir - viewDir;
+	}
+
+	// Ref: Donald Revie - Implementing Fur Using Deferred Shading (GPU Pro 2)
+	// The grain direction (e.g. hair or brush direction) is assumed to be orthogonal to the normal.
+	// The returned normal is NOT normalized.
+	float3 ComputeGrainNormal(float3 grainDir, float3 V)
+	{
+		float3 B = cross(-V, grainDir);
+		return cross(B, grainDir);
+	}
+
+	//Modify Normal for Anisotropic IBL (Realtime version)
+	// Fake anisotropic by distorting the normal.
+	// The grain direction (e.g. hair or brush direction) is assumed to be orthogonal to N.
+	// Anisotropic ratio (0->no isotropic; 1->full anisotropy in tangent direction)
+	float3 GetAnisotropicModifiedNormal(float3 grainDir, float3 N, float3 V, float anisotropy)
+	{
+		float3 grainNormal = ComputeGrainNormal(grainDir, V);
+		// TODO: test whether normalizing 'grainNormal' is worth it.
+		return normalize(lerp(N, grainNormal, anisotropy));
+	}
+
+	/// REGION END - ANISOTROPY
+
+	/// REGION START - SUBSURFACE SCATTERING
+
+	half Fresnel(half3 H, half3 V, half F0)
+	{
+		half base = 1.0 - dot(V, H);
+		half exponential = pow(base, 5.0);
+		return exponential + F0 * (1.0 - exponential);
+	}
+	/*
+	inline half3 KelemenSzirmayKalosSpecular(half3 normal, half3 lightDir, half3 viewDir, float roughness, float rho_s)
+	{
+	half3 result = half3(0, 0, 0);
+	half NdotL = dot(normal, lightDir);
+	if (NdotL > 0.0)
+	{
+	half3 h = lightDir + viewDir;
+	half3 H = normalize(h);
+	half NdotH = dot(normal, H);
+	half PH = pow(2.0 * tex2D(_BeckmannPrecomputedTex, half2(NdotH, roughness)).r, 10.0);
+	half F = Fresnel(H, viewDir, 0.028);
+	half frSpec = max(PH * F / dot(h, h), 0);
+	half term = NdotL * rho_s * frSpec;
+	result = half3(term, term, term);
+	}
+	return result;
+	}*/
+	/*
+	half3 SkinDiffuse(float curv, float3 NdotL)
+	{
+	float3 lookup = NdotL * 0.5 + 0.5;
+	float3 diffuse;
+
+	diffuse.r = tex2D(_DiffusionProfileTexture, float2(lookup.r, curv)).r;
+	diffuse.g = tex2D(_DiffusionProfileTexture, float2(lookup.g, curv)).g;
+	diffuse.b = tex2D(_DiffusionProfileTexture, float2(lookup.b, curv)).b;
+
+	return diffuse;
+	}*/
+
+	/// REGION END - SUBSURFACE SCATTERING
+
+	// Upgrade NOTE: replaced 'defined SHADINGMODELID_CLEARCOAT' with 'defined (SHADINGMODELID_CLEARCOAT)'
+	// Upgrade NOTE: replaced 'defined SHADINGMODELID_CLOTH' with 'defined (SHADINGMODELID_CLOTH)'
+	// Upgrade NOTE: replaced 'defined SHADINGMODELID_EYE' with 'defined (SHADINGMODELID_EYE)'
+	// Upgrade NOTE: replaced 'defined SHADINGMODELID_FOLIAGE' with 'defined (SHADINGMODELID_FOLIAGE)'
+	// Upgrade NOTE: replaced 'defined SHADINGMODELID_HAIR' with 'defined (SHADINGMODELID_HAIR)'
+	// Upgrade NOTE: replaced 'defined SHADINGMODELID_SKIN' with 'defined (SHADINGMODELID_SKIN)'
+	// Upgrade NOTE: replaced 'defined SHADINGMODELID_SUBSURFACE' with 'defined (SHADINGMODELID_SUBSURFACE)'
+
+	// ------------------------------------------------------------------
+	// Shading models
+
+	//#pragma multi_compile SHADINGMODELID_UNLIT SHADINGMODELID_STANDARD SHADINGMODELID_SUBSURFACE SHADINGMODELID_SKIN SHADINGMODELID_FOLIAGE SHADINGMODELID_CLEARCOAT SHADINGMODELID_CLOTH SHADINGMODELID_EYE			
+
+	// ------------------------------------------------------------------
+	//  Input
+
+	half		_ShadingModel;
+
+	sampler2D	_AnisotropyMap;
+	half		_Anisotropy;
+	sampler2D	_TangentMap;
+
+	half4 		_TranslucentColor;
+	sampler2D	_TranslucencyMap;
+
+	sampler2D	_FuzzTex;
+	half3		_FuzzColor;
+	half		_Cloth;
+
+	sampler2D	_IrisNormal;
+	sampler2D	_IrisMask;
+	half		_IrisDistance;
+
+	half _TDistortion;
+	half _TScale;
+	half _TAmbient;
+	half _TPower;
+	half _TAttenuation;
+	half _TransmissionOverallStrength;
+
+	// ------------------------------------------------------------------
+	//  Maths helpers
+
+	// Octahedron Normal Vectors
+	// [Cigolle 2014, "A Survey of Efficient Representations for Independent Unit Vectors"]
+	//						Mean	Max
+	// oct		8:8			0.33709 0.94424
+	// snorm	8:8:8		0.17015 0.38588
+	// oct		10:10		0.08380 0.23467
+	// snorm	10:10:10	0.04228 0.09598
+	// oct		12:12		0.02091 0.05874
+
+	float2 UnitVectorToOctahedron(float3 N)
+	{
+		N.xy /= dot(float3(1,1,1), abs(N));
+		if (N.z <= 0)
+		{
+			N.xy = (1 - abs(N.yx)) * (N.xy >= 0 ? float2(1, 1) : float2(-1, -1));
+		}
+		return N.xy;
+	}
+
+	float3 OctahedronToUnitVector(float2 Oct)
+	{
+		float3 N = float3(Oct, 1 - dot(float2(1,1), abs(Oct)));
+		if (N.z < 0)
+		{
+			N.xy = (1 - abs(N.yx)) * (N.xy >= 0 ? float2(1, 1) : float2(-1, -1));
+		}
+		return float3(1, 1, 1);
+		return normalize(N);
+	}
+
+	// ------------------------------------------------------------------
+	//  Surface helpers
+
+	half Anisotropy(float2 uv)
+	{
+		return tex2D(_AnisotropyMap, uv) * _Anisotropy;
+	}
+
+	half3 Fuzz(float2 uv)
+	{
+		return tex2D(_FuzzTex, uv) * _FuzzColor;
+	}
+
+	half Cloth()
+	{
+		return _Cloth;
+	}
+
+	half4 Iris(float2 uv)
+	{
+		float2 n = UnitVectorToOctahedron(normalize(UnpackNormal(tex2D(_IrisNormal, uv)).rgb)) * 0.5 + 0.5;
+		float m = saturate(tex2D(_IrisMask, uv).r);	// Iris Mask
+		float d = saturate(_IrisDistance);				// Iris Distance
+		return float4(n.x, n.y, m, d);
+	}
+
+	half3 Translucency(float2 uv)
+	{
+		return tex2D(_TranslucencyMap, uv).rgb * _TranslucentColor.rgb;
+	}
+
+	// ------------------------------------------------------------------
+	//  Unlit Shading Function
+
+	float4 UnlitShading(float3 diffColor)
+	{
+		return half4(diffColor, 1);
+	}
+
+	// ------------------------------------------------------------------
+	//  Standard Shading Function
+
+	float4 StandardShading(float3 diffColor, float3 specColor, float oneMinusReflectivity, float smoothness, float3 normal, float3x3 worldVectors,
+		float anisotropy, float metallic, float3 viewDir, UnityLight light, UnityIndirect gi)
+	{
+		//Unpack world vectors
+		float3 tangent = worldVectors[0];
+		float3 bitangent = worldVectors[1];
+		//Normal shift
+		float shiftAmount = dot(normal, viewDir);
+		normal = shiftAmount < 0.0f ? normal + viewDir * (-shiftAmount + 1e-5f) : normal;
+		//Regular vectors
+		float NdotL = saturate(dot(normal, light.dir)); //sat?
+		float NdotV = abs(dot(normal, viewDir)); //abs?
+		float LdotV = dot(light.dir, viewDir);
+		float3 H = Unity_SafeNormalize(light.dir + viewDir);
+		float invLenLV = rsqrt(abs(2 + 2 * normalize(LdotV)));
+		//float invLenLV = rsqrt(abs(2 + 2 * LdotV));
+		//float NdotH = (NdotL + normalize(NdotV)) * invLenLV;
+		float NdotH = saturate(dot(normal, H));
+		//float NdotH = saturate((NdotL + normalize(NdotV)) * invLenLV);
+		//float H = (light.dir + viewDir) * invLenLV;
+		float LdotH = saturate(dot(light.dir, H));
+		//Tangent vectors
+		float TdotH = dot(tangent, H);
+		float TdotL = dot(tangent, light.dir);
+		float BdotH = dot(bitangent, H);
+		float BdotL = dot(bitangent, light.dir);
+		float TdotV = dot(viewDir, tangent);
+		float BdotV = dot(viewDir, bitangent);
+		//Fresnels
+		half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
+		float3 F = FresnelLerp(specColor, grazingTerm, NdotV); //Original Schlick - Replace from SRP?
+															   //float3 fresnel0 = lerp(specColor, diffColor, metallic);
+															   //float3 F = FresnelSchlick(fresnel0, 1.0, LdotH);
+															   //Calculate roughness
+		float roughnessT;
+		float roughnessB;
+		float perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
+		float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+		ConvertAnisotropyToRoughness(roughness, anisotropy, roughnessT, roughnessB);
+		//Clamp roughness
+		//roughness = ClampRoughnessForAnalyticalLights(roughness);
+		roughnessT = ClampRoughnessForAnalyticalLights(roughnessT);
+		roughnessB = ClampRoughnessForAnalyticalLights(roughnessB);
+		//Visibility & Distribution terms
+		float V = SmithJointGGXAnisotropic(TdotV, BdotV, NdotV, TdotL, BdotL, NdotL, roughnessT, roughnessB);
+		float D = D_GGXAnisotropic(TdotH, BdotH, NdotH, roughnessT, roughnessB);
+		//Specular term
+		float3 specularTerm = V * D; //*UNITY_PI;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		specularTerm = sqrt(max(1e-4h, specularTerm));
+#	endif
+		// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
+		specularTerm = max(0, specularTerm * NdotL);
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+		specularTerm = 0.0;
+#endif
+		//Diffuse term
+		float diffuseTerm = DisneyDiffuse(NdotV, NdotL, LdotH, perceptualRoughness) * NdotL;// - Need this NdotL multiply?
+																							//Reduction
+		half surfaceReduction;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		surfaceReduction = 1.0 - 0.28*roughness*perceptualRoughness;		// 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
+#	else
+		surfaceReduction = 1.0 / (roughness*roughness + 1.0);			// fade \in [0.5;1]
+#	endif
+																		//Final
+		half3 color = (diffColor * (gi.diffuse + light.color * diffuseTerm))
+			+ specularTerm * light.color * FresnelTerm(specColor, LdotH)
+			+ surfaceReduction * gi.specular * FresnelLerp(specColor, grazingTerm, NdotV);
+		return half4(color, 1);
+	}
+
+	// ------------------------------------------------------------------
+	//  Cloth Shading Function
+
+	//float3 ClothShading(FGBufferData GBuffer, float3 LobeRoughness, float3 LobeEnergy, float3 L, float3 V, half3 N)
+	float4 ClothShading(float3 diffColor, float3 specColor, float3 fuzzColor, float cloth, float oneMinusReflectivity, float smoothness, float3 normal, float3 viewDir, UnityLight light, UnityIndirect gi, float3x3 worldVectors, float anisotropy)
+	{
+		const float3 FuzzColor = saturate(fuzzColor);
+		const float  Cloth = saturate(cloth);
+
+		//Regular vectors
+		float NdotL = saturate(dot(normal, light.dir)); //sat?
+		float NdotV = abs(dot(normal, viewDir)); //abs?
+		float LdotV = dot(light.dir, viewDir);
+		//float invLenLV = rsqrt(abs(2 + 2 * normalize(LdotV)));
+		////float invLenLV = rsqrt(abs(2 + 2 * LdotV));
+		//float NdotH = (NdotL + normalize(NdotV)) * invLenLV;
+		//float NdotH = saturate((NdotL + normalize(NdotV)) * invLenLV);
+		float3 H = Unity_SafeNormalize(light.dir + viewDir);
+		//float H = (light.dir + viewDir) * invLenLV;
+		float LdotH = saturate(dot(light.dir, H));
+
+		//float3 H = normalize(viewDir + light.dir);
+		//float NdotL = saturate(dot(normal, light.dir));
+		//float NdotV = saturate(abs(dot(normal, viewDir)) + 1e-5);
+		float NdotH = saturate(dot(normal, H));
+		float VdotH = saturate(dot(viewDir, H));
+		//float LdotH = saturate(dot(light.dir, H));
+
+		half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
+
+		// Diffuse
+		float perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
+		float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+		float diffuseTerm = DisneyDiffuse(NdotV, NdotL, LdotH, perceptualRoughness) * NdotL;// - Need this NdotL multiply?
+
+																							// Cloth - Asperity Scattering - Inverse Beckmann Layer	
+		float3 F1 = FresnelTerm(fuzzColor, LdotH);// FresnelLerp(fuzzColor, grazingTerm, NdotV);// FresnelTerm(FuzzColor, LdotH);// F_Schlick(FuzzColor, VdotH);
+		float  D1 = D_InvGGX(roughness, NdotH);
+		float  V1 = Vis_Cloth(NdotV, NdotL);
+		//Specular term
+		float3 specularTerm1 = V1 * D1; //*UNITY_PI;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		specularTerm1 = sqrt(max(1e-4h, specularTerm1));
+#	endif
+		// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
+		// specularTerm1 = max(0, specularTerm1 * NdotL);
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+		specularTerm1 = 0.0;
+#endif
+		float3 Spec1 = specularTerm1 * light.color * FresnelTerm(fuzzColor, LdotH);
+
+		// Generalized microfacet specular
+		/*float3 F2 = F_Schlick(specColor, VdotH);
+		float  D2 = D_GGX(roughness, NdotH);
+		float  V2 = Vis_SmithJointApprox(roughness, NdotV, NdotL);
+		float3 Spec2 = D2 * V2 * F2 * light.color;*/
+
+		//Unpack world vectors
+		float3 tangent = worldVectors[0];
+		float3 bitangent = worldVectors[1];
+		//Tangent vectors
+		float TdotH = dot(tangent, H);
+		float TdotL = dot(tangent, light.dir);
+		float BdotH = dot(bitangent, H);
+		float BdotL = dot(bitangent, light.dir);
+		float TdotV = dot(viewDir, tangent);
+		float BdotV = dot(viewDir, bitangent);
+		//Fresnels
+		float3 F2 = FresnelLerp(specColor, grazingTerm, NdotV);// FresnelTerm(specColor, LdotH);// FresnelLerp(specColor, grazingTerm, NdotV); //Original Schlick - Replace from SRP?
+		float roughnessT;
+		float roughnessB;
+		//float perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
+		//float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+		ConvertAnisotropyToRoughness(roughness, anisotropy, roughnessT, roughnessB);
+		//Clamp roughness
+		//roughness = ClampRoughnessForAnalyticalLights(roughness);
+		roughnessT = ClampRoughnessForAnalyticalLights(roughnessT);
+		roughnessB = ClampRoughnessForAnalyticalLights(roughnessB);
+		//Visibility & Distribution terms
+		float V2 = SmithJointGGXAnisotropic(TdotV, BdotV, NdotV, TdotL, BdotL, NdotL, roughnessT, roughnessB);
+		float D2 = D_GGXAnisotropic(TdotH, BdotH, NdotH, roughnessT, roughnessB);
+		//Specular term
+		float3 specularTerm2 = V2 * D2; //*UNITY_PI;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		specularTerm2 = sqrt(max(1e-4h, specularTerm2));
+#	endif
+		// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
+		specularTerm2 = max(0, specularTerm2 * NdotL);
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+		specularTerm2 = 0.0;
+#endif
+		float3 Spec2 = specularTerm2 * light.color * FresnelTerm(specColor, LdotH);
+
+		float3 Spec = lerp(Spec2, Spec1, Cloth);
+
+		//Reduction
+		half surfaceReduction;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		surfaceReduction = 1.0 - 0.28*roughness*perceptualRoughness;		// 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
+#	else
+		surfaceReduction = 1.0 / (roughness*roughness + 1.0);			// fade \in [0.5;1]
+#	endif
+																		//Final
+																		//half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
+		half3 color = (diffColor * (gi.diffuse + light.color * diffuseTerm))
+			+ Spec
+			+ surfaceReduction * gi.specular * FresnelLerp(specColor, grazingTerm, NdotV);
+		return half4(color, 1);
+	}
+
+	// ------------------------------------------------------------------
+	//  Eye Shading Function
+
+	//float3 EyeShading(FGBufferData GBuffer, float3 LobeRoughness, float3 LobeEnergy, float3 L, float3 V, half3 N)
+	float4 EyeShading(float3 diffColor, float3 specColor, float3 viewDir, half3 normal, float smoothness, float oneMinusReflectivity, UnityLight light, UnityIndirect gi)
+	{
+		float3 H = normalize(viewDir + light.dir);
+		float NdotL = saturate(dot(normal, light.dir));
+		float NdotV = saturate(abs(dot(normal, viewDir)) + 1e-5);
+		float NdotH = saturate(dot(normal, H));
+		float VdotH = saturate(dot(viewDir, H));
+		float LdotH = saturate(dot(light.dir, H));
+
+		// Generalized microfacet specular
+		float perceptualRoughness = SmoothnessToPerceptualRoughness(smoothness);
+		float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+
+		float D = D_GGX(roughness, NdotH);// *LobeEnergy[1];
+		float V = Vis_SmithJointApprox(roughness, NdotV, NdotL);
+		float3 F = F_Schlick(specColor, VdotH);
+
+		float3 specularTerm = V * D; //*UNITY_PI;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		specularTerm = sqrt(max(1e-4h, specularTerm));
+#	endif
+		// specularTerm * nl can be NaN on Metal in some cases, use max() to make sure it's a sane value
+		specularTerm = max(0, specularTerm * NdotL);
+#if defined(_SPECULARHIGHLIGHTS_OFF)
+		specularTerm = 0.0;
+#endif
+		half grazingTerm = saturate(smoothness + (1 - oneMinusReflectivity));
+		half surfaceReduction;
+#	ifdef UNITY_COLORSPACE_GAMMA
+		surfaceReduction = 1.0 - 0.28*roughness*perceptualRoughness;		// 1-0.28*x^3 as approximation for (1/(x^4+1))^(1/2.2) on the domain [0;1]
+#	else
+		surfaceReduction = 1.0 / (roughness*roughness + 1.0);			// fade \in [0.5;1]
+#	endif
+
+		float diffuseTerm = DisneyDiffuse(NdotV, NdotL, LdotH, perceptualRoughness) * NdotL; // TODO - Unreal does not apply diffuse in Shading function
+																							 //Final
+		half3 color = (diffColor * (gi.diffuse + light.color * diffuseTerm))
+			+ specularTerm * light.color * FresnelTerm(specColor, LdotH)
+			+ surfaceReduction * gi.specular * FresnelLerp(specColor, grazingTerm, NdotV);
+		return half4(color, 1);
+	}
+
+	// ------------------------------------------------------------------
+	//  Subsurface Shading Function
+
+	float3 SubsurfaceShadingSimple(float3 diffColor, float3 normal, float3 viewDir, float3 thickness, UnityLight light)
+	{
+		half3 vLTLight = light.dir + normal * 1;
+		half  fLTDot = pow(saturate(dot(viewDir, -vLTLight)), 3.5) * 1.5;
+		half3 fLT = 1 * (fLTDot + 1.2) * (thickness);
+		return diffColor * ((light.color * fLT) * 0.4);
+	}
+
+	// ------------------------------------------------------------------
+	//  Eye Subsurface Shading Function
+
+	//float3 EyeSubsurfaceShading(FGBufferData GBuffer, float3 L, float3 V, half3 N)
+	float3 EyeSubsurfaceShading(float3 diffColor, float3 specColor, float3 viewDir, half3 normal, float smoothness, float4 iris, UnityLight light)
+	{
+		float2 irisNormal = iris.rg;
+		float irisMask = iris.z;
+		float irisDistance = iris.w;
+
+		float3 H = normalize(viewDir + light.dir);
+		float VdotH = saturate(dot(viewDir, H));
+		float NdotV = saturate(abs(dot(normal, viewDir)) + 1e-5);
+		float LdotH = saturate(dot(light.dir, H));
+
+		// F_Schlick
+		//float F0 = GBuffer.Specular * 0.08;
+		//float Fc = Pow5(1 - VoH);
+		//float F = Fc + (1 - Fc) * F0;
+		float3 fresnel0 = lerp(specColor, diffColor, smoothness);
+		float3 F = FresnelSchlick(fresnel0, 1.0, LdotH);
+
+		//float  IrisDistance = GBuffer.CustomData.w;
+		//float  IrisMask = GBuffer.CustomData.z;
+
+		float3 IrisNormal;
+		IrisNormal = OctahedronToUnitVector(irisNormal * 2 - 1);
+
+		// Blend in the negative intersection normal to create some concavity
+		// Not great as it ties the concavity to the convexity of the cornea surface
+		// No good justification for that. On the other hand, if we're just looking to
+		// introduce some concavity, this does the job.
+		float3 CausticNormal = normalize(lerp(IrisNormal, -normal, irisMask*irisDistance));
+
+		float NdotL = saturate(dot(IrisNormal, light.dir));
+		float Power = lerp(12, 1, NdotL);
+		float Caustic = 0.6 + 0.2 * (Power + 1) * pow(saturate(dot(CausticNormal, light.dir)), Power);
+		float Iris = NdotL * Caustic;
+
+		// http://blog.stevemcauley.com/2011/12/03/energy-conserving-wrapped-diffuse/
+		float Wrap = 0.15;
+		float Sclera = saturate((dot(normal, light.dir) + Wrap) / (1 + Wrap) * (1 + Wrap));
+
+		return (1 - F) * lerp(Sclera, Iris, irisMask) * diffColor / UNITY_PI;
+	}
+
+	// ------------------------------------------------------------------
+	//  Shading function selectors
+
+	//float3 SurfaceShading(/*FGBufferData GBuffer,*/ float3 LobeRoughness, float3 LobeEnergy, float3 L, float3 V, half3 N, uint2 Random)
+	float4 SurfaceShading(float3 diffColor, float3 specColor, float oneMinusReflectivity, float smoothness, float3 normal,
+		float3x3 worldVectors, float anisotropy, float4 customData, float metallic, float3 viewDir, UnityLight light, UnityIndirect gi)
+	{
+#if defined(SHADINGMODELID_UNLIT)
+		{
+			return UnlitShading(diffColor);
+		}
+#elif defined(SHADINGMODELID_STANDARD) || defined(SHADINGMODELID_SUBSURFACE) || defined(SHADINGMODELID_SKIN) || defined(SHADINGMODELID_FOLIAGE)
+		{
+			return StandardShading(diffColor, specColor, oneMinusReflectivity, smoothness,
+				normal, worldVectors, anisotropy, metallic, viewDir, light, gi);
+		}
+#elif defined (SHADINGMODELID_CLEARCOAT)
+		{
+			return float4(1, 1, 1, 1); //ClearCoatShading(GBuffer, LobeRoughness, LobeEnergy, L, V, N);
+		}
+#elif defined (SHADINGMODELID_CLOTH)
+		{
+			return ClothShading(diffColor, specColor, customData.rgb, customData.a, oneMinusReflectivity, smoothness, normal, viewDir, light, gi, worldVectors, anisotropy);
+		}
+#elif defined (SHADINGMODELID_EYE)
+		{
+			return EyeShading(diffColor, specColor, viewDir, normal, smoothness, oneMinusReflectivity, light, gi); //EyeShading(GBuffer, LobeRoughness, LobeEnergy, L, V, N);
+		}
+#endif
+		return float4(0, 0, 0, 0);
+	}
+
+	//float3 SubsurfaceShading(/*FGBufferData GBuffer,*/ float3 L, float3 V, half3 N, float Shadow, uint2 Random)
+	float3 SubsurfaceShading(float3 diffColor, float3 specColor, float3 normal, float smoothness, float3 viewDir, float4 customData, UnityLight light)
+	{
+#if defined (SHADINGMODELID_SUBSURFACE)
+		{
+			return SubsurfaceShadingSimple(diffColor, normal, viewDir, customData.rgb, light);
+		}
+#elif defined (SHADINGMODELID_SKIN)
+		{
+			return float3(0, 0, 0); //SubsurfaceShadingPreintegratedSkin(GBuffer, L, V, N);
+		}
+#elif defined (SHADINGMODELID_FOLIAGE)
+		{
+			return float3(0, 0, 0); //SubsurfaceShadingTwoSided(SubsurfaceColor, L, V, N);
+		}
+#elif defined (SHADINGMODELID_HAIR)
+		{
+			return float3(0, 0, 0); //HairShading(GBuffer, L, V, N, Shadow, 1, 0, Random);
+		}
+#elif defined (SHADINGMODELID_EYE)
+		{
+			return EyeSubsurfaceShading(diffColor, specColor, viewDir, normal, smoothness, customData, light); //EyeSubsurfaceShading(GBuffer, L, V, N);
+		}
+#endif
+		return float3(0, 0, 0);
+	}
+
+	//#endif UNITY_ADVANCED_SHADINGMODELS_INCLUDED
+
+	//-------------------------------------------------------------------------------------
+	// Lighting Helpers
+
+	// Glossy Environment
+	half3 Unity_AnisotropicGlossyEnvironment(UNITY_ARGS_TEXCUBE(tex), half4 hdr, Unity_GlossyEnvironmentData glossIn, half anisotropy) //Reference IBL from HD Pipe (Add half3 L input and replace R)
+	{
+		half perceptualRoughness = glossIn.roughness /* perceptualRoughness */;
+
+		// TODO: CAUTION: remap from Morten may work only with offline convolution, see impact with runtime convolution!
+		// For now disabled
+#if 0
+		float m = PerceptualRoughnessToRoughness(perceptualRoughness); // m is the real roughness parameter
+		const float fEps = 1.192092896e-07F;        // smallest such that 1.0+FLT_EPSILON != 1.0  (+1e-4h is NOT good here. is visibly very wrong)
+		float n = (2.0 / max(fEps, m*m)) - 2.0;        // remap to spec power. See eq. 21 in --> https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
+
+		n /= 4;                                     // remap from n_dot_h formulatino to n_dot_r. See section "Pre-convolved Cube Maps vs Path Tracers" --> https://s3.amazonaws.com/docs.knaldtech.com/knald/1.0.0/lys_power_drops.html
+
+		perceptualRoughness = pow(2 / (n + 2), 0.25);      // remap back to square root of real roughness (0.25 include both the sqrt root of the conversion and sqrt for going from roughness to perceptualRoughness)
+#else
+		// MM: came up with a surprisingly close approximation to what the #if 0'ed out code above does.
+		perceptualRoughness = perceptualRoughness*(1.7 - 0.7*perceptualRoughness);
+#endif
+
+
+		half mip = perceptualRoughnessToMipmapLevel(perceptualRoughness);
+		half3 R = glossIn.reflUVW;// -half3(anisotropy, 0, 0);
+		half4 rgbm = UNITY_SAMPLE_TEXCUBE_LOD(tex, R, mip);
+
+		return DecodeHDR(rgbm, hdr);
+	}
+
+	// Indirect Specular
+	inline half3 UnityGI_AnisotropicIndirectSpecular(UnityGIInput data, half occlusion, Unity_GlossyEnvironmentData glossIn, half anisotropy, half3x3 worldVectors)
+	{
+		half3 specular;
+		float3 tangentX = worldVectors[0];
+		float3 tangentY = worldVectors[1];
+		float3 N = worldVectors[2];
+		float3 V = data.worldViewDir;
+		float3 iblNormalWS = GetAnisotropicModifiedNormal(tangentY, N, V, anisotropy);
+		float3 iblR = reflect(-V, iblNormalWS);
+
+#ifdef UNITY_SPECCUBE_BOX_PROJECTION
+		// we will tweak reflUVW in glossIn directly (as we pass it to Unity_GlossyEnvironment twice for probe0 and probe1), so keep original to pass into BoxProjectedCubemapDirection
+
+		half3 originalReflUVW = glossIn.reflUVW;
+		glossIn.reflUVW = BoxProjectedCubemapDirection(iblR, data.worldPos, data.probePosition[0], data.boxMin[0], data.boxMax[0]);
+#endif
+
+#ifdef _GLOSSYREFLECTIONS_OFF
+		specular = unity_IndirectSpecColor.rgb;
+#else
+		half3 env0 = Unity_AnisotropicGlossyEnvironment(UNITY_PASS_TEXCUBE(unity_SpecCube0), data.probeHDR[0], glossIn, anisotropy);
+		//half3 env0 = Unity_AnisotropicGlossyEnvironment(UNITY_PASS_TEXCUBE(unity_SpecCube0), data.probeHDR[0], glossIn, anisotropy, L); //Reference IBL from HD Pipe
+#ifdef UNITY_SPECCUBE_BLENDING
+		const float kBlendFactor = 0.99999;
+		float blendLerp = data.boxMin[0].w;
+		UNITY_BRANCH
+			if (blendLerp < kBlendFactor)
+			{
+#ifdef UNITY_SPECCUBE_BOX_PROJECTION
+				glossIn.reflUVW = BoxProjectedCubemapDirection(iblR, data.worldPos, data.probePosition[1], data.boxMin[1], data.boxMax[1]);
+#endif
+				half3 env1 = Unity_AnisotropicGlossyEnvironment(UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), data.probeHDR[1], glossIn, anisotropy);
+				//half3 env1 = Unity_AnisotropicGlossyEnvironment(UNITY_PASS_TEXCUBE_SAMPLER(unity_SpecCube1, unity_SpecCube0), data.probeHDR[1], glossIn, anisotropy, L); //Reference IBL from HD Pipe
+				specular = lerp(env1, env0, blendLerp);
+			}
+			else
+			{
+				specular = env0;
+			}
+#else
+		specular = env0;
+#endif
+#endif
+
+		return specular * occlusion;// *weightOverPdf; //Reference IBL from HD Pipe
+									//return specular * occlusion * weightOverPdf; //Reference IBL from HD Pipe
+	}
+
+	// Global Illumination
+	inline UnityGI UnityAnisotropicGlobalIllumination(UnityGIInput data, half occlusion, half3 normalWorld, Unity_GlossyEnvironmentData glossIn, half anisotropy, half3x3 worldVectors)
+	{
+		UnityGI o_gi = UnityGI_Base(data, occlusion, normalWorld);
+		o_gi.indirect.specular = UnityGI_AnisotropicIndirectSpecular(data, occlusion, glossIn, anisotropy, worldVectors);
+		return o_gi;
+	}
+
+	//-------------------------------------------------------------------------------------
+	// Lighting Functions
+
+	//Surface Description
+	struct SurfaceOutputAdvanced
+	{
+		fixed3 Albedo;		// base (diffuse or specular) color
+		fixed3 Normal;		// tangent space normal, if written
+		half3 Emission;
+		half Metallic;		// 0=non-metal, 1=metal
+							// Smoothness is the user facing name, it should be perceptual smoothness but user should not have to deal with it.
+							// Everywhere in the code you meet smoothness it is perceptual smoothness
+		half Smoothness;	// 0=rough, 1=smooth
+		half Occlusion;		// occlusion (default 1)
+		fixed Alpha;		// alpha for transparencies
+		half3 Tangent;
+		half Anisotropy;
+		half4 CustomData;
+		float3x3 WorldVectors;
+		//half ShadingModel;
+	};
+
+	inline half4 LightingAdvanced(SurfaceOutputAdvanced s, half3 viewDir, UnityGI gi)
+	{
+		s.Normal = normalize(s.Normal);
+
+		half oneMinusReflectivity;
+		half3 specColor;
+		s.Albedo = DiffuseAndSpecularFromMetallic(s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
+
+		// shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+		// this is necessary to handle transparency in physically correct way - only diffuse component gets affected by alpha
+		half outputAlpha;
+		s.Albedo = PreMultiplyAlpha(s.Albedo, s.Alpha, oneMinusReflectivity, /*out*/ outputAlpha);
+
+		half4 c = SurfaceShading(s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, s.WorldVectors, s.Anisotropy, s.CustomData, s.Metallic, viewDir, gi.light, gi.indirect);
+		c.rgb += SubsurfaceShading(s.Albedo, specColor, s.Normal, s.Smoothness, viewDir, s.CustomData, gi.light);
+
+		//c.rgb += UNITY_BRDF_GI(s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, viewDir, s.Occlusion, gi);
+		c.a = outputAlpha;
+		return c;
+	}
+
+	//This is pointless as always forward?
+	inline half4 LightingAdvanced_Deferred(SurfaceOutputAdvanced s, half3 viewDir, UnityGI gi, out half4 outGBuffer0, out half4 outGBuffer1, out half4 outGBuffer2)
+	{
+		half oneMinusReflectivity;
+		half3 specColor;
+		s.Albedo = DiffuseAndSpecularFromMetallic(s.Albedo, s.Metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
+
+		half4 c = SurfaceShading(s.Albedo, specColor, oneMinusReflectivity, s.Smoothness, s.Normal, s.WorldVectors, s.Anisotropy, s.CustomData, s.Metallic, viewDir, gi.light, gi.indirect);
+		c.rgb += SubsurfaceShading(s.Albedo, specColor, s.Normal, s.Smoothness, viewDir, s.CustomData, gi.light);
+
+		UnityStandardData data;
+		data.diffuseColor = s.Albedo;
+		data.occlusion = s.Occlusion;
+		data.specularColor = specColor;
+		data.smoothness = s.Smoothness;
+		data.normalWorld = s.Normal;
+
+		UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
+
+		half4 emission = half4(s.Emission + c.rgb, 1);
+		return emission;
+	}
+
+	inline void LightingAdvanced_GI(SurfaceOutputAdvanced s, UnityGIInput data, inout UnityGI gi)
+	{
+#if defined(UNITY_PASS_DEFERRED) && UNITY_ENABLE_REFLECTION_BUFFERS
+		gi = UnityGlobalIllumination(data, s.Occlusion, s.Normal);
+#else
+		Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(s.Smoothness, data.worldViewDir, s.Normal, lerp(unity_ColorSpaceDielectricSpec.rgb, s.Albedo, s.Metallic));
+		gi = UnityAnisotropicGlobalIllumination(data, s.Occlusion, s.Normal, g, s.Anisotropy, s.WorldVectors);
+#endif
+	}
+
+
+	///END
+
+
+	//#pragma target 5.0
+#pragma surface surf Advanced vertex:vert
+#pragma glsl
+#pragma debug
+
+	inline float4 unity_multiply_float(float4 arg1, float4 arg2)
+	{
+		return arg1 * arg2;
+	}
+	inline float4 unity_uvrotator_float(float4 arg1, float arg2)
+	{
+		arg1.xy -= 0.5;
+		float s = sin(arg2);
+		float c = cos(arg2);
+		float2x2 rMatrix = float2x2(c, -s, s, c);
+		rMatrix *= 0.5;
+		rMatrix += 0.5;
+		rMatrix = rMatrix * 2 - 1;
+		arg1.xy = mul(arg1.xy, rMatrix);
+		arg1.xy += 0.5;
+		return arg1;
+	}
+	inline float4 unity_add_float(float4 arg1, float4 arg2)
+	{
+		return arg1 + arg2;
+	}
+	inline float3 unity_saturation_float(float3 arg1, float arg2)
+	{
+		float luma = dot(arg1, float3(0.2126729, 0.7151522, 0.0721750));
+		return luma.xxx + arg2.xxx * (arg1 - luma.xxx);
+	}
+
+	float Vector1_5c761f75_773e_42ed_b242_72e6b25acebd_Uniform;
+	float Vector1_91e780ac_52c0_4e9a_bd0e_974f5805854d_Uniform;
+	sampler2D Texture_3db1140f_b814_4ba5_a49c_d40499367921_Uniform;
+	float Vector1_8272d735_22ca_40c5_a082_1c40f63ad50b_Uniform;
+
+
+	struct Input
+	{
+		float4 color : COLOR;
+		half4 meshUV0;
+		float4 worldTangent;
+		float3 worldNormal;
+
+	};
+
+	void vert(inout appdata_full v, out Input o)
+	{
+		UNITY_INITIALIZE_OUTPUT(Input,o);
+		o.meshUV0 = v.texcoord;
+		o.worldTangent = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
+
+	}
+
+	void surf(Input IN, inout SurfaceOutputAdvanced o)
+	{
+		half4 uv0 = IN.meshUV0;
+		float3 worldSpaceTangent = normalize(IN.worldTangent.xyz);
+		float3 worldSpaceNormal = normalize(IN.worldNormal);
+		float3 worldSpaceBitangent = cross(worldSpaceNormal, worldSpaceTangent) * IN.worldTangent.w;
+		float4 Color_60e5aa92_5827_4655_88ef_824edebc611c_Uniform = float4 (1, 1, 1, 0);
+		float4 UV_5469bdac_9fb3_4be1_99d3_b33dd79bde38_UV = uv0;
+		float Vector1_eba0cdd0_45b4_4538_9e0b_cea4c7422396_Uniform = 10;
+		float4 Multiply_4812768f_5378_4eb3_9ce3_7b7b373bf5af_Output = unity_multiply_float(UV_5469bdac_9fb3_4be1_99d3_b33dd79bde38_UV, Vector1_eba0cdd0_45b4_4538_9e0b_cea4c7422396_Uniform);
+		float4 Fraction_5d78144e_c212_4560_a9ac_8a1cfa2d8998_Output = frac(Multiply_4812768f_5378_4eb3_9ce3_7b7b373bf5af_Output);
+		float4 Texture_3db1140f_b814_4ba5_a49c_d40499367921 = tex2D(Texture_3db1140f_b814_4ba5_a49c_d40499367921_Uniform, (Fraction_5d78144e_c212_4560_a9ac_8a1cfa2d8998_Output.xy));
+		float4 Swizzle_8fa020a1_1e6e_4a73_8319_f9403f55481f_Output = float4(Texture_3db1140f_b814_4ba5_a49c_d40499367921.rbga).rgba;
+		float4 UVRotator_33524407_d6a4_4e64_995b_84ca0117ce56_Output = unity_uvrotator_float(Swizzle_8fa020a1_1e6e_4a73_8319_f9403f55481f_Output, _Time.y);
+		float4 Swizzle_518dd051_97b1_4f9d_b388_4db28346054e_Output = float4(UVRotator_33524407_d6a4_4e64_995b_84ca0117ce56_Output.rbga).rgba;
+		float4 Add_204f3b90_9101_429f_acf1_8fdace08eb17_Output = unity_add_float(Swizzle_518dd051_97b1_4f9d_b388_4db28346054e_Output, float4 (0,0,0,0));
+		float3 Saturation_96e26331_ca74_4d63_aacd_f34516700ae6_Output = unity_saturation_float(Add_204f3b90_9101_429f_acf1_8fdace08eb17_Output, 0);
+		o.Albedo = Color_60e5aa92_5827_4655_88ef_824edebc611c_Uniform;
+		o.Metallic = Vector1_5c761f75_773e_42ed_b242_72e6b25acebd_Uniform;
+		o.Smoothness = Vector1_91e780ac_52c0_4e9a_bd0e_974f5805854d_Uniform;
+		o.Occlusion = Saturation_96e26331_ca74_4d63_aacd_f34516700ae6_Output;
+		o.Tangent = Add_204f3b90_9101_429f_acf1_8fdace08eb17_Output;
+		float3x3 worldToTangent;
+		worldToTangent[0] = float3(1, 0, 0);
+		worldToTangent[1] = float3(0, 1, 0);
+		worldToTangent[2] = float3(0, 0, 1);
+		float3 tangentTWS = mul(o.Tangent, worldToTangent);
+		o.WorldVectors = float3x3(tangentTWS, worldSpaceBitangent, worldSpaceNormal);
+		o.Anisotropy = Vector1_8272d735_22ca_40c5_a082_1c40f63ad50b_Uniform;
+
+	}
+	ENDCG
+	}
+
+
+		FallBack "Diffuse"
+		CustomEditor "LegacyIlluminShaderGUI"
+}

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

+fileFormatVersion: 2
+guid: 01a19a2c08481994c87ec502a371225e
+timeCreated: 1495754850
+licenseType: Pro
+ShaderImporter:
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/Matt/Examples/Anisotropy.unity

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 8
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0.15402943, g: 0.17526728, b: 0.18618384, a: 1}
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 9
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_TextureWidth: 1024
+    m_TextureHeight: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFiltering: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousColorSigma: 1
+    m_PVRFilteringAtrousNormalSigma: 1
+    m_PVRFilteringAtrousPositionSigma: 1
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1 &1175244166
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1175244170}
+  - component: {fileID: 1175244169}
+  - component: {fileID: 1175244168}
+  - component: {fileID: 1175244167}
+  m_Layer: 0
+  m_Name: Cube
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &1175244167
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1175244166}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: b691b84f941db2740ba393773c55e10e, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 1
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!65 &1175244168
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1175244166}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!33 &1175244169
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1175244166}
+  m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1175244170
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1175244166}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -0.6726772, y: 1.891152, z: 1.7966161}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1268097406
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1268097408}
+  - component: {fileID: 1268097407}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!108 &1268097407
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1268097406}
+  m_Enabled: 1
+  serializedVersion: 8
+  m_Type: 1
+  m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 2
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_FalloffTable:
+    m_Table[0]: 0
+    m_Table[1]: 0
+    m_Table[2]: 0
+    m_Table[3]: 0
+    m_Table[4]: 0
+    m_Table[5]: 0
+    m_Table[6]: 0
+    m_Table[7]: 0
+    m_Table[8]: 0
+    m_Table[9]: 0
+    m_Table[10]: 0
+    m_Table[11]: 0
+    m_Table[12]: 0
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &1268097408
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1268097406}
+  m_LocalRotation: {x: 0.2754269, y: -0.6067653, z: -0.25753763, w: 0.6997502}
+  m_LocalPosition: {x: -2.93, y: 3, z: -0.69}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 4.182, y: -83.555, z: -44.148003}
+--- !u!1 &1652373340
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1652373345}
+  - component: {fileID: 1652373344}
+  - component: {fileID: 1652373343}
+  - component: {fileID: 1652373342}
+  - component: {fileID: 1652373341}
+  m_Layer: 0
+  m_Name: Main Camera
+  m_TagString: MainCamera
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!81 &1652373341
+AudioListener:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1652373340}
+  m_Enabled: 1
+--- !u!124 &1652373342
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1652373340}
+  m_Enabled: 1
+--- !u!92 &1652373343
+Behaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1652373340}
+  m_Enabled: 1
+--- !u!20 &1652373344
+Camera:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1652373340}
+  m_Enabled: 1
+  serializedVersion: 2
+  m_ClearFlags: 1
+  m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
+  m_NormalizedViewPortRect:
+    serializedVersion: 2
+    x: 0
+    y: 0
+    width: 1
+    height: 1
+  near clip plane: 0.3
+  far clip plane: 1000
+  field of view: 60
+  orthographic: 0
+  orthographic size: 5
+  m_Depth: -1
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_RenderingPath: -1
+  m_TargetTexture: {fileID: 0}
+  m_TargetDisplay: 0
+  m_TargetEye: 3
+  m_HDR: 1
+  m_AllowMSAA: 1
+  m_ForceIntoRT: 0
+  m_OcclusionCulling: 1
+  m_StereoConvergence: 10
+  m_StereoSeparation: 0.022
+  m_StereoMirrorMode: 0
+--- !u!4 &1652373345
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1652373340}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 1, z: -10}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

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

+fileFormatVersion: 2
+guid: e62816a8b56c9964d9d512ec8496d304
+timeCreated: 1495753720
+licenseType: Pro
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

MaterialGraphProject/Assets/NewNodes/WIP/SphericalIndentationNode.cs

+using UnityEngine.Graphing;
+
+
+namespace UnityEngine.MaterialGraph
+{
+	[Title("UV/SphericalIndentation")]
+	public class SphericalIndentationNode : AnyNode<SphericalIndentationNode.Definition>
+	{
+		public class Definition : IAnyNodeDefinition
+		{
+			public string name { get { return "SphericalIndentation"; } }
+
+			public AnyNodeProperty[] properties
+			{
+				get
+				{
+					return new AnyNodeProperty[]
+					{
+                           // slotId is the 'immutable' value we used to connect things
+                            new AnyNodeProperty { slotId= 0,    name = "inUVs",       description = "Input UV coords",          propertyType = PropertyType.Vector2,    value = Vector4.zero,                       state = AnyNodePropertyState.Slot },
+							new AnyNodeProperty { slotId= 1,    name = "center",      description = "UV center point",          propertyType = PropertyType.Vector2,    value= new Vector4(0.5f, 0.5f, 0.5f, 0.5f), state = AnyNodePropertyState.Constant },
+							new AnyNodeProperty { slotId= 2,    name = "height",      description = "Height off surface",       propertyType = PropertyType.Float,      value= Vector4.zero,                        state = AnyNodePropertyState.Constant },
+							new AnyNodeProperty { slotId= 3,    name = "radius",      description = "Radius",                   propertyType = PropertyType.Float,      value= Vector4.one,                         state = AnyNodePropertyState.Constant },
+					};
+				}
+			}
+
+			public AnyNodeSlot[] outputs
+			{
+				get
+				{
+					return new AnyNodeSlot[]
+					{
+							new AnyNodeSlot { slotId= 4,    name = "outUVs",   description = "Output UV texture coordinates", slotValueType = SlotValueType.Vector2, value = Vector4.zero  },
+							new AnyNodeSlot { slotId= 5,    name = "outNormal", description = "Output Normal in tangent space", slotValueType = SlotValueType.Vector3, value = Vector4.zero  }
+					};
+				}
+			}
+
+			public ShaderGlobal[] globals { get { return new ShaderGlobal[] { ShaderGlobal.TangentSpaceViewDirection }; } }
+
+			public string hlsl
+			{
+				get
+				{
+					return
+						"float radius2= radius*radius;\n" +
+						"float3 cur= float3(inUVs.xy, 0.0f);\n" +
+						"float3 sphereCenter = float3(center, height);\n" +
+						"float3 edgeA = sphereCenter - cur;\n" +
+						"float a2 = dot(edgeA, edgeA);\n" +
+						"outUVs= inUVs;\n" +
+                        "outNormal= float3(0.0f, 0.0f, 1.0f);\n" +
+						"if (a2 < radius2)\n" +
+						"{\n" +
+						"   float a = sqrt(a2);\n" +
+						"   edgeA = edgeA / a;\n" +
+						"   float cosineR = dot(edgeA, tangentSpaceViewDirection.xyz);\n" +
+						"   float x = cosineR * a - sqrt(-a2 + radius2 + a2 * cosineR * cosineR);\n" +
+						"   float3 intersectedEdge = cur + tangentSpaceViewDirection * x;\n" +
+                        "   outNormal= normalize(sphereCenter - intersectedEdge);\n" +
+						"   outUVs = intersectedEdge.xy;\n" +
+						"}\n";
+
+				}
+			}
+		}
+	}
+}

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

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

MaterialGraphProject/Assets/SphereDent.ShaderGraph.meta

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