Airboarder is now More Recolorable! (#889)

- Added the ability to recolor the floor and clouds in Airboarder - also did a few minor visual touchups (clouds look much better, turns out i had them set to the wrong shader whoopsies)
2025-06-12 12:17:37 +02:00 · 2024-04-22 07:22:15 -05:00
parent 92c40166e8
commit d9f466c7f8
51 changed files with 3568 additions and 58 deletions
--- a/Assets/ColorMask/Shaders/ColorMaskStandard.shader
+++ b/Assets/ColorMask/Shaders/ColorMaskStandard.shader
@ -0,0 +1,342 @@
+Shader "ColorMask/Standard"
+{
+	Properties
+	{
+		_Color("Color", Color) = (1,1,1,1)
+		_MainTex("Albedo", 2D) = "white" {}
+		
+		_Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+		
+		_ColorMaskTex("Color Mask", 2D) = "black" {}
+		_RedColor("Red Color", Color) = (1,1,1,1)
+		_GreenColor("Green Color", Color) = (1,1,1,1)
+		_BlueColor("Blue Color", Color) = (1,1,1,1)
+		_AlphaColor("Alpha Color", Color) = (1,1,1,1)
+
+		_Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
+		_GlossMapScale("Smoothness Scale", Range(0.0, 1.0)) = 1.0
+		[Enum(Metallic Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0
+
+		[Gamma] _Metallic("Metallic", Range(0.0, 1.0)) = 0.0
+		_MetallicGlossMap("Metallic", 2D) = "white" {}
+
+		[ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
+		[ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0
+
+		_BumpScale("Scale", Float) = 1.0
+		_BumpMap("Normal Map", 2D) = "bump" {}
+
+		_Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02
+		_ParallaxMap ("Height Map", 2D) = "black" {}
+
+		_OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0
+		_OcclusionMap("Occlusion", 2D) = "white" {}
+
+		_EmissionColor("Color", Color) = (0,0,0)
+		_EmissionMap("Emission", 2D) = "white" {}
+		
+		_DetailMask("Detail Mask", 2D) = "white" {}
+
+		_DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {}
+		_DetailNormalMapScale("Scale", Float) = 1.0
+		_DetailNormalMap("Normal Map", 2D) = "bump" {}
+
+		[Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0
+
+
+		// Blending state
+		[HideInInspector] _Mode ("__mode", Float) = 0.0
+		[HideInInspector] _SrcBlend ("__src", Float) = 1.0
+		[HideInInspector] _DstBlend ("__dst", Float) = 0.0
+		[HideInInspector] _ZWrite ("__zw", Float) = 1.0
+	}
+
+	CGINCLUDE
+		#define UNITY_SETUP_BRDF_INPUT MetallicSetup
+	ENDCG
+
+	SubShader
+	{
+		Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
+		LOD 300
+	
+
+		// ------------------------------------------------------------------
+		//  Base forward pass (directional light, emission, lightmaps, ...)
+		Pass
+		{
+			Name "FORWARD" 
+			Tags { "LightMode" = "ForwardBase" }
+
+			Blend [_SrcBlend] [_DstBlend]
+			ZWrite [_ZWrite]
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile_fwdbase
+			#pragma multi_compile_fog
+
+			#pragma vertex vertBase
+			#pragma fragment fragBase
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Additive forward pass (one light per pass)
+		Pass
+		{
+			Name "FORWARD_DELTA"
+			Tags { "LightMode" = "ForwardAdd" }
+			Blend [_SrcBlend] One
+			Fog { Color (0,0,0,0) } // in additive pass fog should be black
+			ZWrite Off
+			ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile_fwdadd_fullshadows
+			#pragma multi_compile_fog
+
+
+			#pragma vertex vertAdd
+			#pragma fragment fragAdd
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Shadow rendering pass
+		Pass {
+			Name "ShadowCaster"
+			Tags { "LightMode" = "ShadowCaster" }
+
+			ZWrite On ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma multi_compile_shadowcaster
+
+			#pragma vertex vertShadowCaster
+			#pragma fragment fragShadowCaster
+
+			#include "UnityStandardShadow.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Deferred pass
+		Pass
+		{
+			Name "DEFERRED"
+			Tags { "LightMode" = "Deferred" }
+
+			CGPROGRAM
+			#pragma target 3.0
+			#pragma exclude_renderers nomrt
+
+
+			// -------------------------------------
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile ___ UNITY_HDR_ON
+			#pragma multi_compile LIGHTMAP_OFF LIGHTMAP_ON
+			#pragma multi_compile ___ DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
+			#pragma multi_compile DYNAMICLIGHTMAP_OFF DYNAMICLIGHTMAP_ON
+
+			#pragma vertex vertDeferred
+			#pragma fragment fragDeferred
+
+			#include "ColorMaskStandardCore.cginc"
+
+			ENDCG
+		}
+
+		// ------------------------------------------------------------------
+		// Extracts information for lightmapping, GI (emission, albedo, ...)
+		// This pass it not used during regular rendering.
+		Pass
+		{
+			Name "META" 
+			Tags { "LightMode"="Meta" }
+
+			Cull Off
+
+			CGPROGRAM
+			#pragma target 2.5
+			
+			#pragma vertex vert_meta
+			#pragma fragment frag_meta
+
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature ___ _DETAIL_MULX2
+
+			#include "ColorMaskStandardMeta.cginc"
+			ENDCG
+		}
+	}
+
+	SubShader
+	{
+		Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
+		LOD 150
+
+		// ------------------------------------------------------------------
+		//  Base forward pass (directional light, emission, lightmaps, ...)
+		Pass
+		{
+			Name "FORWARD" 
+			Tags { "LightMode" = "ForwardBase" }
+
+			Blend [_SrcBlend] [_DstBlend]
+			ZWrite [_ZWrite]
+
+			CGPROGRAM
+			#pragma target 2.5
+			
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _EMISSION 
+			#pragma shader_feature _METALLICGLOSSMAP 
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
+			// SM2.0: NOT SUPPORTED shader_feature ___ _DETAIL_MULX2
+			// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP
+
+			#pragma skip_variants SHADOWS_SOFT DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
+
+			#pragma multi_compile_fwdbase
+			#pragma multi_compile_fog
+
+			#pragma vertex vertBase
+			#pragma fragment fragBase
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Additive forward pass (one light per pass)
+		Pass
+		{
+			Name "FORWARD_DELTA"
+			Tags { "LightMode" = "ForwardAdd" }
+			Blend [_SrcBlend] One
+			Fog { Color (0,0,0,0) } // in additive pass fog should be black
+			ZWrite Off
+			ZTest LEqual
+			
+			CGPROGRAM
+			#pragma target 2.5
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP
+			#pragma skip_variants SHADOWS_SOFT
+			
+			#pragma multi_compile_fwdadd_fullshadows
+			#pragma multi_compile_fog
+			
+			#pragma vertex vertAdd
+			#pragma fragment fragAdd
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Shadow rendering pass
+		Pass {
+			Name "ShadowCaster"
+			Tags { "LightMode" = "ShadowCaster" }
+			
+			ZWrite On ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 2.0
+
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma skip_variants SHADOWS_SOFT
+			#pragma multi_compile_shadowcaster
+
+			#pragma vertex vertShadowCaster
+			#pragma fragment fragShadowCaster
+
+			#include "UnityStandardShadow.cginc"
+
+			ENDCG
+		}
+
+		// ------------------------------------------------------------------
+		// Extracts information for lightmapping, GI (emission, albedo, ...)
+		// This pass it not used during regular rendering.
+		Pass
+		{
+			Name "META" 
+			Tags { "LightMode"="Meta" }
+
+			Cull Off
+
+			CGPROGRAM
+			#pragma target 2.5
+			
+			#pragma vertex vert_meta
+			#pragma fragment frag_meta
+
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _METALLICGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature ___ _DETAIL_MULX2
+
+			#include "ColorMaskStandardMeta.cginc"
+			ENDCG
+		}
+	}
+
+
+	FallBack "VertexLit"
+	CustomEditor "ColorMaskStandardShaderGUI"
+}
--- a/Assets/ColorMask/Shaders/ColorMaskStandard.shader.meta
+++ b/Assets/ColorMask/Shaders/ColorMaskStandard.shader.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 0179f1693b517f3428e6d259da489c15
+timeCreated: 1435093425
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/ColorMaskStandardCore.cginc
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardCore.cginc
@ -0,0 +1,694 @@
+#ifndef UNITY_STANDARD_CORE_INCLUDED
+#define UNITY_STANDARD_CORE_INCLUDED
+
+#include "UnityCG.cginc"
+#include "UnityShaderVariables.cginc"
+#include "UnityInstancing.cginc"
+#include "UnityStandardConfig.cginc"
+#include "ColorMaskStandardInput.cginc"
+#include "UnityPBSLighting.cginc"
+#include "UnityStandardUtils.cginc"
+#include "UnityGBuffer.cginc"
+#include "UnityStandardBRDF.cginc"
+
+#include "AutoLight.cginc"
+//-------------------------------------------------------------------------------------
+// counterpart for NormalizePerPixelNormal
+// skips normalization per-vertex and expects normalization to happen per-pixel
+half3 NormalizePerVertexNormal (float3 n) // takes float to avoid overflow
+{
+    #if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
+        return normalize(n);
+    #else
+        return n; // will normalize per-pixel instead
+    #endif
+}
+
+half3 NormalizePerPixelNormal (half3 n)
+{
+	#if (SHADER_TARGET < 30) || UNITY_STANDARD_SIMPLE
+		return n;
+	#else
+		return normalize(n);
+	#endif
+}
+
+//-------------------------------------------------------------------------------------
+UnityLight MainLight ()
+{
+	UnityLight l;
+	#if !defined(LIGHTMAP_ON)
+		l.color = _LightColor0.rgb;
+		l.dir = _WorldSpaceLightPos0.xyz;
+		l.ndotl = 0; // Not used
+	#else
+		// no light specified by the engine
+		// analytical light might be extracted from Lightmap data later on in the shader depending on the Lightmap type
+		// Should be ResetUnityLight() call but can't move the function to a UnityLightingCommon.cginc header because it break UBER shader on asset store...
+		l.color = half3(0, 0, 0);
+		l.dir = half3(0, 1, 0); // Irrelevant direction, just not null
+		l.ndotl = 0; // Not used
+	#endif
+
+	return l;
+}
+
+UnityLight AdditiveLight (half3 lightDir, half atten)
+{
+	UnityLight l;
+
+	l.color = _LightColor0.rgb;
+	l.dir = lightDir;
+	#ifndef USING_DIRECTIONAL_LIGHT
+		l.dir = NormalizePerPixelNormal(l.dir);
+	#endif
+
+	// shadow the light
+	l.color *= atten;
+	return l;
+}
+
+UnityLight DummyLight ()
+{
+	UnityLight l;
+	l.color = 0;
+	l.dir = half3 (0,1,0);
+	return l;
+}
+
+UnityIndirect ZeroIndirect ()
+{
+	UnityIndirect ind;
+	ind.diffuse = 0;
+	ind.specular = 0;
+	return ind;
+}
+
+//-------------------------------------------------------------------------------------
+// Common fragment setup
+
+// deprecated
+half3 WorldNormal(half4 tan2world[3])
+{
+	return normalize(tan2world[2].xyz);
+}
+
+// deprecated
+#ifdef _TANGENT_TO_WORLD
+	half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3])
+	{
+		half3 t = tan2world[0].xyz;
+		half3 b = tan2world[1].xyz;
+		half3 n = tan2world[2].xyz;
+
+	#if UNITY_TANGENT_ORTHONORMALIZE
+		n = NormalizePerPixelNormal(n);
+
+		// ortho-normalize Tangent
+		t = normalize (t - n * dot(t, n));
+
+		// recalculate Binormal
+		half3 newB = cross(n, t);
+		b = newB * sign (dot (newB, b));
+	#endif
+
+		return half3x3(t, b, n);
+	}
+#else
+	half3x3 ExtractTangentToWorldPerPixel(half4 tan2world[3])
+	{
+		return half3x3(0,0,0,0,0,0,0,0,0);
+	}
+#endif
+
+half3 PerPixelWorldNormal(float4 i_tex, half4 tangentToWorld[3])
+{
+#ifdef _NORMALMAP
+	half3 tangent = tangentToWorld[0].xyz;
+	half3 binormal = tangentToWorld[1].xyz;
+	half3 normal = tangentToWorld[2].xyz;
+
+	#if UNITY_TANGENT_ORTHONORMALIZE
+		normal = NormalizePerPixelNormal(normal);
+
+		// ortho-normalize Tangent
+		tangent = normalize (tangent - normal * dot(tangent, normal));
+
+		// recalculate Binormal
+		half3 newB = cross(normal, tangent);
+		binormal = newB * sign (dot (newB, binormal));
+	#endif
+
+	half3 normalTangent = NormalInTangentSpace(i_tex);
+	half3 normalWorld = NormalizePerPixelNormal(tangent * normalTangent.x + binormal * normalTangent.y + normal * normalTangent.z); // @TODO: see if we can squeeze this normalize on SM2.0 as well
+#else
+	half3 normalWorld = normalize(tangentToWorld[2].xyz);
+#endif
+	return normalWorld;
+}
+
+#ifdef _PARALLAXMAP
+	#define IN_VIEWDIR4PARALLAX(i) NormalizePerPixelNormal(half3(i.tangentToWorldAndParallax[0].w,i.tangentToWorldAndParallax[1].w,i.tangentToWorldAndParallax[2].w))
+	#define IN_VIEWDIR4PARALLAX_FWDADD(i) NormalizePerPixelNormal(i.viewDirForParallax.xyz)
+#else
+	#define IN_VIEWDIR4PARALLAX(i) half3(0,0,0)
+	#define IN_VIEWDIR4PARALLAX_FWDADD(i) half3(0,0,0)
+#endif
+
+#if UNITY_REQUIRE_FRAG_WORLDPOS
+	#define IN_WORLDPOS(i) i.posWorld
+#else
+	#define IN_WORLDPOS(i) half3(0,0,0)
+#endif
+
+#define IN_LIGHTDIR_FWDADD(i) half3(i.tangentToWorldAndLightDir[0].w, i.tangentToWorldAndLightDir[1].w, i.tangentToWorldAndLightDir[2].w)
+
+#define FRAGMENT_SETUP(x) FragmentCommonData x = \
+	FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX(i), i.tangentToWorldAndParallax, IN_WORLDPOS(i));
+
+#define FRAGMENT_SETUP_FWDADD(x) FragmentCommonData x = \
+	FragmentSetup(i.tex, i.eyeVec, IN_VIEWDIR4PARALLAX_FWDADD(i), i.tangentToWorldAndLightDir, half3(0,0,0));
+
+struct FragmentCommonData
+{
+	half3 diffColor, specColor;
+	// Note: smoothness & oneMinusReflectivity for optimization purposes, mostly for DX9 SM2.0 level.
+	// Most of the math is being done on these (1-x) values, and that saves a few precious ALU slots.
+	half oneMinusReflectivity, smoothness;
+	half3 normalWorld, eyeVec, posWorld;
+	half alpha;
+
+#if UNITY_OPTIMIZE_TEXCUBELOD || UNITY_STANDARD_SIMPLE
+	half3 reflUVW;
+#endif
+
+#if UNITY_STANDARD_SIMPLE
+	half3 tangentSpaceNormal;
+#endif
+};
+
+#ifndef UNITY_SETUP_BRDF_INPUT
+	#define UNITY_SETUP_BRDF_INPUT SpecularSetup
+#endif
+
+inline FragmentCommonData SpecularSetup (float4 i_tex)
+{
+	half4 specGloss = SpecularGloss(i_tex.xy);
+	half3 specColor = specGloss.rgb;
+	half smoothness = specGloss.a;
+
+	half oneMinusReflectivity;
+	half3 diffColor = EnergyConservationBetweenDiffuseAndSpecular (Albedo(i_tex), specColor, /*out*/ oneMinusReflectivity);
+	
+	FragmentCommonData o = (FragmentCommonData)0;
+	o.diffColor = diffColor;
+	o.specColor = specColor;
+	o.oneMinusReflectivity = oneMinusReflectivity;
+	o.smoothness = smoothness;
+	return o;
+}
+
+inline FragmentCommonData MetallicSetup (float4 i_tex)
+{
+	half2 metallicGloss = MetallicGloss(i_tex.xy);
+	half metallic = metallicGloss.x;
+	half smoothness = metallicGloss.y; // this is 1 minus the square root of real roughness m.
+
+	half oneMinusReflectivity;
+	half3 specColor;
+	half3 diffColor = DiffuseAndSpecularFromMetallic (Albedo(i_tex), metallic, /*out*/ specColor, /*out*/ oneMinusReflectivity);
+
+	FragmentCommonData o = (FragmentCommonData)0;
+	o.diffColor = diffColor;
+	o.specColor = specColor;
+	o.oneMinusReflectivity = oneMinusReflectivity;
+	o.smoothness = smoothness;
+	return o;
+} 
+
+inline FragmentCommonData FragmentSetup (float4 i_tex, half3 i_eyeVec, half3 i_viewDirForParallax, half4 tangentToWorld[3], half3 i_posWorld)
+{
+	i_tex = Parallax(i_tex, i_viewDirForParallax);
+
+	half alpha = Alpha(i_tex.xy);
+	#if defined(_ALPHATEST_ON)
+		clip (alpha - _Cutoff);
+	#endif
+
+	FragmentCommonData o = UNITY_SETUP_BRDF_INPUT (i_tex);
+	o.normalWorld = PerPixelWorldNormal(i_tex, tangentToWorld);
+	o.eyeVec = NormalizePerPixelNormal(i_eyeVec);
+	o.posWorld = i_posWorld;
+
+	// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+	o.diffColor = PreMultiplyAlpha (o.diffColor, alpha, o.oneMinusReflectivity, /*out*/ o.alpha);
+	return o;
+}
+
+inline UnityGI FragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light, bool reflections)
+{
+	UnityGIInput d;
+	d.light = light;
+	d.worldPos = s.posWorld;
+	d.worldViewDir = -s.eyeVec;
+	d.atten = atten;
+	#if defined(LIGHTMAP_ON) || defined(DYNAMICLIGHTMAP_ON)
+		d.ambient = 0;
+		d.lightmapUV = i_ambientOrLightmapUV;
+	#else
+		d.ambient = i_ambientOrLightmapUV.rgb;
+		d.lightmapUV = 0;
+	#endif
+
+
+	d.probeHDR[0] = unity_SpecCube0_HDR;
+	d.probeHDR[1] = unity_SpecCube1_HDR;
+	#if UNITY_SPECCUBE_BLENDING || UNITY_SPECCUBE_BOX_PROJECTION
+	  d.boxMin[0] = unity_SpecCube0_BoxMin; // .w holds lerp value for blending
+	#endif
+	#if UNITY_SPECCUBE_BOX_PROJECTION
+	  d.boxMax[0] = unity_SpecCube0_BoxMax;
+	  d.probePosition[0] = unity_SpecCube0_ProbePosition;
+	  d.boxMax[1] = unity_SpecCube1_BoxMax;
+	  d.boxMin[1] = unity_SpecCube1_BoxMin;
+	  d.probePosition[1] = unity_SpecCube1_ProbePosition;
+	#endif
+
+	if(reflections)
+	{
+		Unity_GlossyEnvironmentData g = UnityGlossyEnvironmentSetup(s.smoothness, -s.eyeVec, s.normalWorld, s.specColor);
+		// Replace the reflUVW if it has been compute in Vertex shader. Note: the compiler will optimize the calcul in UnityGlossyEnvironmentSetup itself
+		#if UNITY_OPTIMIZE_TEXCUBELOD || UNITY_STANDARD_SIMPLE
+			g.reflUVW = s.reflUVW;
+		#endif
+
+		return UnityGlobalIllumination (d, occlusion, s.normalWorld, g);
+	}
+	else
+	{
+		return UnityGlobalIllumination (d, occlusion, s.normalWorld);
+	}
+}
+
+inline UnityGI FragmentGI (FragmentCommonData s, half occlusion, half4 i_ambientOrLightmapUV, half atten, UnityLight light)
+{
+	return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, true);
+}
+
+
+//-------------------------------------------------------------------------------------
+half4 OutputForward (half4 output, half alphaFromSurface)
+{
+	#if defined(_ALPHABLEND_ON) || defined(_ALPHAPREMULTIPLY_ON)
+		output.a = alphaFromSurface;
+	#else
+		UNITY_OPAQUE_ALPHA(output.a);
+	#endif
+	return output;
+}
+
+inline half4 VertexGIForward(VertexInput v, float3 posWorld, half3 normalWorld)
+{
+	half4 ambientOrLightmapUV = 0;
+	// Static lightmaps
+	#ifdef LIGHTMAP_ON
+		ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
+		ambientOrLightmapUV.zw = 0;
+	// Sample light probe for Dynamic objects only (no static or dynamic lightmaps)
+	#elif UNITY_SHOULD_SAMPLE_SH
+		#ifdef VERTEXLIGHT_ON
+			// Approximated illumination from non-important point lights
+			ambientOrLightmapUV.rgb = Shade4PointLights (
+				unity_4LightPosX0, unity_4LightPosY0, unity_4LightPosZ0,
+				unity_LightColor[0].rgb, unity_LightColor[1].rgb, unity_LightColor[2].rgb, unity_LightColor[3].rgb,
+				unity_4LightAtten0, posWorld, normalWorld);
+		#endif
+
+		ambientOrLightmapUV.rgb = ShadeSHPerVertex (normalWorld, ambientOrLightmapUV.rgb);		
+	#endif
+
+	#ifdef DYNAMICLIGHTMAP_ON
+		ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
+	#endif
+
+	return ambientOrLightmapUV;
+}
+
+// ------------------------------------------------------------------
+//  Base forward pass (directional light, emission, lightmaps, ...)
+
+struct VertexOutputForwardBase
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half3 eyeVec 						: TEXCOORD1;
+	half4 tangentToWorldAndParallax[3]	: TEXCOORD2;	// [3x3:tangentToWorld | 1x3:viewDirForParallax]
+	half4 ambientOrLightmapUV			: TEXCOORD5;	// SH or Lightmap UV
+	SHADOW_COORDS(6)
+	UNITY_FOG_COORDS(7)
+
+	// next ones would not fit into SM2.0 limits, but they are always for SM3.0+
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		float3 posWorld					: TEXCOORD8;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		#if UNITY_REQUIRE_FRAG_WORLDPOS
+			half3 reflUVW				: TEXCOORD9;
+		#else
+			half3 reflUVW				: TEXCOORD8;
+		#endif
+	#endif
+
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+VertexOutputForwardBase vertForwardBase (VertexInput v)
+{
+	UNITY_SETUP_INSTANCE_ID(v);
+	VertexOutputForwardBase o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputForwardBase, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		o.posWorld = posWorld.xyz;
+	#endif
+	o.pos = UnityObjectToClipPos(v.vertex);
+		
+	o.tex = TexCoords(v);
+	o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
+	float3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	#ifdef _TANGENT_TO_WORLD
+		float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
+
+		float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
+		o.tangentToWorldAndParallax[0].xyz = tangentToWorld[0];
+		o.tangentToWorldAndParallax[1].xyz = tangentToWorld[1];
+		o.tangentToWorldAndParallax[2].xyz = tangentToWorld[2];
+	#else
+		o.tangentToWorldAndParallax[0].xyz = 0;
+		o.tangentToWorldAndParallax[1].xyz = 0;
+		o.tangentToWorldAndParallax[2].xyz = normalWorld;
+	#endif
+	//We need this for shadow receving
+	TRANSFER_SHADOW(o);
+
+	o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld);
+	
+	#ifdef _PARALLAXMAP
+		TANGENT_SPACE_ROTATION;
+		half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
+		o.tangentToWorldAndParallax[0].w = viewDirForParallax.x;
+		o.tangentToWorldAndParallax[1].w = viewDirForParallax.y;
+		o.tangentToWorldAndParallax[2].w = viewDirForParallax.z;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		o.reflUVW 		= reflect(o.eyeVec, normalWorld);
+	#endif
+
+	UNITY_TRANSFER_FOG(o,o.pos);
+	return o;
+}
+
+half4 fragForwardBaseInternal (VertexOutputForwardBase i)
+{
+	FRAGMENT_SETUP(s)
+#if UNITY_OPTIMIZE_TEXCUBELOD
+	s.reflUVW		= i.reflUVW;
+#endif
+
+	UnityLight mainLight = MainLight ();
+	half atten = SHADOW_ATTENUATION(i);
+
+
+	half occlusion = Occlusion(i.tex.xy);
+	UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, mainLight);
+
+	half4 c = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect);
+	c.rgb += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
+	c.rgb += Emission(i.tex.xy);
+
+	UNITY_APPLY_FOG(i.fogCoord, c.rgb);
+	return OutputForward (c, s.alpha);
+}
+
+half4 fragForwardBase (VertexOutputForwardBase i) : SV_Target	// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardBaseInternal(i);
+}
+
+// ------------------------------------------------------------------
+//  Additive forward pass (one light per pass)
+
+struct VertexOutputForwardAdd
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half3 eyeVec 						: TEXCOORD1;
+	half4 tangentToWorldAndLightDir[3]	: TEXCOORD2;	// [3x3:tangentToWorld | 1x3:lightDir]
+	LIGHTING_COORDS(5,6)
+	UNITY_FOG_COORDS(7)
+
+	// next ones would not fit into SM2.0 limits, but they are always for SM3.0+
+#if defined(_PARALLAXMAP)
+	half3 viewDirForParallax			: TEXCOORD8;
+#endif
+
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+VertexOutputForwardAdd vertForwardAdd (VertexInput v)
+{
+	VertexOutputForwardAdd o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputForwardAdd, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	o.pos = UnityObjectToClipPos(v.vertex);
+
+	o.tex = TexCoords(v);
+	o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
+	float3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	#ifdef _TANGENT_TO_WORLD
+		float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
+
+		float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
+		o.tangentToWorldAndLightDir[0].xyz = tangentToWorld[0];
+		o.tangentToWorldAndLightDir[1].xyz = tangentToWorld[1];
+		o.tangentToWorldAndLightDir[2].xyz = tangentToWorld[2];
+	#else
+		o.tangentToWorldAndLightDir[0].xyz = 0;
+		o.tangentToWorldAndLightDir[1].xyz = 0;
+		o.tangentToWorldAndLightDir[2].xyz = normalWorld;
+	#endif
+	//We need this for shadow receiving
+	TRANSFER_VERTEX_TO_FRAGMENT(o);
+
+	float3 lightDir = _WorldSpaceLightPos0.xyz - posWorld.xyz * _WorldSpaceLightPos0.w;
+	#ifndef USING_DIRECTIONAL_LIGHT
+		lightDir = NormalizePerVertexNormal(lightDir);
+	#endif
+	o.tangentToWorldAndLightDir[0].w = lightDir.x;
+	o.tangentToWorldAndLightDir[1].w = lightDir.y;
+	o.tangentToWorldAndLightDir[2].w = lightDir.z;
+
+	#ifdef _PARALLAXMAP
+		TANGENT_SPACE_ROTATION;
+		o.viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
+	#endif
+	
+	UNITY_TRANSFER_FOG(o,o.pos);
+	return o;
+}
+
+half4 fragForwardAddInternal (VertexOutputForwardAdd i)
+{
+	FRAGMENT_SETUP_FWDADD(s)
+
+	UnityLight light = AdditiveLight (IN_LIGHTDIR_FWDADD(i), LIGHT_ATTENUATION(i));
+	UnityIndirect noIndirect = ZeroIndirect ();
+
+	half4 c = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, light, noIndirect);
+	
+	UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass
+	return OutputForward (c, s.alpha);
+}
+
+half4 fragForwardAdd (VertexOutputForwardAdd i) : SV_Target		// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardAddInternal(i);
+}
+
+// ------------------------------------------------------------------
+//  Deferred pass
+
+struct VertexOutputDeferred
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half3 eyeVec 						: TEXCOORD1;
+	half4 tangentToWorldAndParallax[3]	: TEXCOORD2;	// [3x3:tangentToWorld | 1x3:viewDirForParallax]
+	half4 ambientOrLightmapUV			: TEXCOORD5;	// SH or Lightmap UVs
+
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		float3 posWorld						: TEXCOORD6;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		#if UNITY_REQUIRE_FRAG_WORLDPOS
+			half3 reflUVW				: TEXCOORD7;
+		#else
+			half3 reflUVW				: TEXCOORD6;
+		#endif
+	#endif
+
+	UNITY_VERTEX_OUTPUT_STEREO
+};
+
+
+VertexOutputDeferred vertDeferred (VertexInput v)
+{
+	UNITY_SETUP_INSTANCE_ID(v);
+	VertexOutputDeferred o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputDeferred, o);
+	UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	#if UNITY_REQUIRE_FRAG_WORLDPOS
+		o.posWorld = posWorld;
+	#endif
+	o.pos = UnityObjectToClipPos(v.vertex);
+
+	o.tex = TexCoords(v);
+	o.eyeVec = NormalizePerVertexNormal(posWorld.xyz - _WorldSpaceCameraPos);
+	float3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	#ifdef _TANGENT_TO_WORLD
+		float4 tangentWorld = float4(UnityObjectToWorldDir(v.tangent.xyz), v.tangent.w);
+
+		float3x3 tangentToWorld = CreateTangentToWorldPerVertex(normalWorld, tangentWorld.xyz, tangentWorld.w);
+		o.tangentToWorldAndParallax[0].xyz = tangentToWorld[0];
+		o.tangentToWorldAndParallax[1].xyz = tangentToWorld[1];
+		o.tangentToWorldAndParallax[2].xyz = tangentToWorld[2];
+	#else
+		o.tangentToWorldAndParallax[0].xyz = 0;
+		o.tangentToWorldAndParallax[1].xyz = 0;
+		o.tangentToWorldAndParallax[2].xyz = normalWorld;
+	#endif
+
+	o.ambientOrLightmapUV = 0;
+	#ifdef LIGHTMAP_ON
+		o.ambientOrLightmapUV.xy = v.uv1.xy * unity_LightmapST.xy + unity_LightmapST.zw;
+	#elif UNITY_SHOULD_SAMPLE_SH
+		o.ambientOrLightmapUV.rgb = ShadeSHPerVertex (normalWorld, o.ambientOrLightmapUV.rgb);
+	#endif
+	#ifdef DYNAMICLIGHTMAP_ON
+		o.ambientOrLightmapUV.zw = v.uv2.xy * unity_DynamicLightmapST.xy + unity_DynamicLightmapST.zw;
+	#endif
+	
+	#ifdef _PARALLAXMAP
+		TANGENT_SPACE_ROTATION;
+		half3 viewDirForParallax = mul (rotation, ObjSpaceViewDir(v.vertex));
+		o.tangentToWorldAndParallax[0].w = viewDirForParallax.x;
+		o.tangentToWorldAndParallax[1].w = viewDirForParallax.y;
+		o.tangentToWorldAndParallax[2].w = viewDirForParallax.z;
+	#endif
+
+	#if UNITY_OPTIMIZE_TEXCUBELOD
+		o.reflUVW		= reflect(o.eyeVec, normalWorld);
+	#endif
+
+	return o;
+}
+
+void fragDeferred (
+	VertexOutputDeferred i,
+	out half4 outGBuffer0 : SV_Target0,
+	out half4 outGBuffer1 : SV_Target1,
+	out half4 outGBuffer2 : SV_Target2,
+	out half4 outEmission : SV_Target3			// RT3: emission (rgb), --unused-- (a)
+)
+{
+	#if (SHADER_TARGET < 30)
+		outGBuffer0 = 1;
+		outGBuffer1 = 1;
+		outGBuffer2 = 0;
+		outEmission = 0;
+		return;
+	#endif
+
+	FRAGMENT_SETUP(s)
+#if UNITY_OPTIMIZE_TEXCUBELOD
+	s.reflUVW		= i.reflUVW;
+#endif
+
+	// no analytic lights in this pass
+	UnityLight dummyLight = DummyLight ();
+	half atten = 1;
+
+	// only GI
+	half occlusion = Occlusion(i.tex.xy);
+#if UNITY_ENABLE_REFLECTION_BUFFERS
+	bool sampleReflectionsInDeferred = false;
+#else
+	bool sampleReflectionsInDeferred = true;
+#endif
+
+	UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, dummyLight, sampleReflectionsInDeferred);
+
+	half3 emissiveColor = UNITY_BRDF_PBS (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, gi.light, gi.indirect).rgb;
+	emissiveColor += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
+
+	#ifdef _EMISSION
+		emissiveColor += Emission (i.tex.xy);
+	#endif
+
+	#ifndef UNITY_HDR_ON
+		emissiveColor.rgb = exp2(-emissiveColor.rgb);
+	#endif
+
+	UnityStandardData data;
+	data.diffuseColor	= s.diffColor;
+	data.occlusion		= occlusion;		
+	data.specularColor	= s.specColor;
+	data.smoothness		= s.smoothness;	
+	data.normalWorld	= s.normalWorld;
+
+	UnityStandardDataToGbuffer(data, outGBuffer0, outGBuffer1, outGBuffer2);
+
+	// Emisive lighting buffer
+	outEmission = half4(emissiveColor, 1);
+}
+
+
+//
+// Old FragmentGI signature. Kept only for backward compatibility and will be removed soon
+//
+
+inline UnityGI FragmentGI(
+	float3 posWorld,
+	half occlusion, half4 i_ambientOrLightmapUV, half atten, half smoothness, half3 normalWorld, half3 eyeVec,
+	UnityLight light,
+	bool reflections)
+{
+	// we init only fields actually used
+	FragmentCommonData s = (FragmentCommonData)0;
+	s.smoothness = smoothness;
+	s.normalWorld = normalWorld;
+	s.eyeVec = eyeVec;
+	s.posWorld = posWorld;
+#if UNITY_OPTIMIZE_TEXCUBELOD
+	s.reflUVW = reflect(eyeVec, normalWorld);
+#endif
+	return FragmentGI(s, occlusion, i_ambientOrLightmapUV, atten, light, reflections);
+}
+inline UnityGI FragmentGI (
+	float3 posWorld,
+	half occlusion, half4 i_ambientOrLightmapUV, half atten, half smoothness, half3 normalWorld, half3 eyeVec,
+	UnityLight light)
+{
+	return FragmentGI (posWorld, occlusion, i_ambientOrLightmapUV, atten, smoothness, normalWorld, eyeVec, light, true);
+}
+
+#endif // UNITY_STANDARD_CORE_INCLUDED
--- a/Assets/ColorMask/Shaders/ColorMaskStandardCore.cginc.meta
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardCore.cginc.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: e5dca6b2da6837042a45e61fa0082255
+timeCreated: 1435093423
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/ColorMaskStandardCoreForward.cginc
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardCoreForward.cginc
@ -0,0 +1,24 @@
+#ifndef UNITY_STANDARD_CORE_FORWARD_INCLUDED
+#define UNITY_STANDARD_CORE_FORWARD_INCLUDED
+
+#if defined(UNITY_NO_FULL_STANDARD_SHADER)
+#	define UNITY_STANDARD_SIMPLE 1
+#endif
+
+#include "UnityStandardConfig.cginc"
+
+#if UNITY_STANDARD_SIMPLE
+	#include "ColorMaskStandardCoreForwardSimple.cginc"
+	VertexOutputBaseSimple vertBase (VertexInput v) { return vertForwardBaseSimple(v); }
+	VertexOutputForwardAddSimple vertAdd (VertexInput v) { return vertForwardAddSimple(v); }
+	half4 fragBase (VertexOutputBaseSimple i) : SV_Target { return fragForwardBaseSimpleInternal(i); }
+	half4 fragAdd (VertexOutputForwardAddSimple i) : SV_Target { return fragForwardAddSimpleInternal(i); }
+#else
+	#include "ColorMaskStandardCore.cginc"
+	VertexOutputForwardBase vertBase (VertexInput v) { return vertForwardBase(v); }
+	VertexOutputForwardAdd vertAdd (VertexInput v) { return vertForwardAdd(v); }
+	half4 fragBase (VertexOutputForwardBase i) : SV_Target { return fragForwardBaseInternal(i); }
+	half4 fragAdd (VertexOutputForwardAdd i) : SV_Target { return fragForwardAddInternal(i); }
+#endif
+
+#endif // UNITY_STANDARD_CORE_FORWARD_INCLUDED
--- a/Assets/ColorMask/Shaders/ColorMaskStandardCoreForward.cginc.meta
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardCoreForward.cginc.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 62e4b8006c4d41942b2c870f78dd9402
+timeCreated: 1454275320
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/ColorMaskStandardCoreForwardSimple.cginc
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardCoreForwardSimple.cginc
@ -0,0 +1,354 @@
+#ifndef UNITY_STANDARD_CORE_FORWARD_SIMPLE_INCLUDED
+#define UNITY_STANDARD_CORE_FORWARD_SIMPLE_INCLUDED
+
+#include "ColorMaskStandardCore.cginc"
+
+//  Does not support: _PARALLAXMAP, DIRLIGHTMAP_COMBINED, DIRLIGHTMAP_SEPARATE
+#define GLOSSMAP (defined(_SPECGLOSSMAP) || defined(_METALLICGLOSSMAP))
+
+#ifndef SPECULAR_HIGHLIGHTS
+	#define SPECULAR_HIGHLIGHTS (!defined(_SPECULAR_HIGHLIGHTS_OFF))
+#endif
+
+struct VertexOutputBaseSimple
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+	half4 eyeVec 						: TEXCOORD1; // w: grazingTerm
+
+	half4 ambientOrLightmapUV			: TEXCOORD2; // SH or Lightmap UV
+	SHADOW_COORDS(3)
+	UNITY_FOG_COORDS_PACKED(4, half4) // x: fogCoord, yzw: reflectVec
+
+	half4 normalWorld					: TEXCOORD5; // w: fresnelTerm
+
+#ifdef _NORMALMAP
+	half3 tangentSpaceLightDir			: TEXCOORD6;
+	#if SPECULAR_HIGHLIGHTS
+		half3 tangentSpaceEyeVec		: TEXCOORD7;
+	#endif
+#endif
+#if UNITY_REQUIRE_FRAG_WORLDPOS
+	float3 posWorld						: TEXCOORD8;
+#endif
+};
+
+// UNIFORM_REFLECTIVITY(): workaround to get (uniform) reflecivity based on UNITY_SETUP_BRDF_INPUT
+half MetallicSetup_Reflectivity()
+{
+	return 1.0h - OneMinusReflectivityFromMetallic(_Metallic);
+}
+
+half SpecularSetup_Reflectivity()
+{
+	return SpecularStrength(_SpecColor.rgb);
+}
+
+#define JOIN2(a, b) a##b
+#define JOIN(a, b) JOIN2(a,b)
+#define UNIFORM_REFLECTIVITY JOIN(UNITY_SETUP_BRDF_INPUT, _Reflectivity)
+
+
+#ifdef _NORMALMAP
+
+half3 TransformToTangentSpace(half3 tangent, half3 binormal, half3 normal, half3 v)
+{
+	// Mali400 shader compiler prefers explicit dot product over using a half3x3 matrix
+	return half3(dot(tangent, v), dot(binormal, v), dot(normal, v));
+}
+
+void TangentSpaceLightingInput(half3 normalWorld, half4 vTangent, half3 lightDirWorld, half3 eyeVecWorld, out half3 tangentSpaceLightDir, out half3 tangentSpaceEyeVec)
+{
+	half3 tangentWorld = UnityObjectToWorldDir(vTangent.xyz);
+	half sign = half(vTangent.w) * half(unity_WorldTransformParams.w);
+	half3 binormalWorld = cross(normalWorld, tangentWorld) * sign;
+	tangentSpaceLightDir = TransformToTangentSpace(tangentWorld, binormalWorld, normalWorld, lightDirWorld);
+	#if SPECULAR_HIGHLIGHTS
+		tangentSpaceEyeVec = normalize(TransformToTangentSpace(tangentWorld, binormalWorld, normalWorld, eyeVecWorld));
+	#else
+		tangentSpaceEyeVec = 0;
+	#endif
+}
+
+#endif // _NORMALMAP
+
+VertexOutputBaseSimple vertForwardBaseSimple (VertexInput v)
+{
+	UNITY_SETUP_INSTANCE_ID(v);
+	VertexOutputBaseSimple o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputBaseSimple, o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+#if UNITY_REQUIRE_FRAG_WORLDPOS
+	o.posWorld = posWorld.xyz;
+#endif
+	o.pos = UnityObjectToClipPos(v.vertex);
+	o.tex = TexCoords(v);
+	
+	half3 eyeVec = normalize(posWorld.xyz - _WorldSpaceCameraPos);
+	half3 normalWorld = UnityObjectToWorldNormal(v.normal);
+	
+	o.normalWorld.xyz = normalWorld;
+	o.eyeVec.xyz = eyeVec;
+
+	#ifdef _NORMALMAP
+		half3 tangentSpaceEyeVec;
+		TangentSpaceLightingInput(normalWorld, v.tangent, _WorldSpaceLightPos0.xyz, eyeVec, o.tangentSpaceLightDir, tangentSpaceEyeVec);
+		#if SPECULAR_HIGHLIGHTS
+			o.tangentSpaceEyeVec = tangentSpaceEyeVec;
+		#endif
+	#endif
+
+	//We need this for shadow receiving
+	TRANSFER_SHADOW(o);
+
+	o.ambientOrLightmapUV = VertexGIForward(v, posWorld, normalWorld);
+
+	o.fogCoord.yzw = reflect(eyeVec, normalWorld);
+
+	o.normalWorld.w = Pow4(1 - saturate(dot(normalWorld, -eyeVec))); // fresnel term
+	#if !GLOSSMAP
+		o.eyeVec.w = saturate(_Glossiness + UNIFORM_REFLECTIVITY()); // grazing term
+	#endif
+
+	UNITY_TRANSFER_FOG(o, o.pos);
+	return o;
+}
+
+
+FragmentCommonData FragmentSetupSimple(VertexOutputBaseSimple i)
+{
+	half alpha = Alpha(i.tex.xy);
+	#if defined(_ALPHATEST_ON)
+		clip (alpha - _Cutoff);
+	#endif
+
+	FragmentCommonData s = UNITY_SETUP_BRDF_INPUT (i.tex);
+
+	// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+	s.diffColor = PreMultiplyAlpha (s.diffColor, alpha, s.oneMinusReflectivity, /*out*/ s.alpha);
+
+	s.normalWorld = i.normalWorld.xyz;
+	s.eyeVec = i.eyeVec.xyz;
+	s.posWorld = IN_WORLDPOS(i);
+	s.reflUVW = i.fogCoord.yzw;
+
+	#ifdef _NORMALMAP
+		s.tangentSpaceNormal =  NormalInTangentSpace(i.tex);
+	#else
+		s.tangentSpaceNormal =  0;
+	#endif
+
+	return s;
+}
+
+UnityLight MainLightSimple(VertexOutputBaseSimple i, FragmentCommonData s)
+{
+	UnityLight mainLight = MainLight();
+	return mainLight;
+}
+
+half PerVertexGrazingTerm(VertexOutputBaseSimple i, FragmentCommonData s)
+{
+	#if GLOSSMAP
+		return saturate(s.smoothness + (1-s.oneMinusReflectivity));
+	#else
+		return i.eyeVec.w;
+	#endif
+}
+
+half PerVertexFresnelTerm(VertexOutputBaseSimple i)
+{
+	return i.normalWorld.w;
+}
+
+#if !SPECULAR_HIGHLIGHTS
+#	define REFLECTVEC_FOR_SPECULAR(i, s) half3(0, 0, 0)
+#elif defined(_NORMALMAP)
+#	define REFLECTVEC_FOR_SPECULAR(i, s) reflect(i.tangentSpaceEyeVec, s.tangentSpaceNormal)
+#else
+#	define REFLECTVEC_FOR_SPECULAR(i, s) s.reflUVW
+#endif
+
+half3 LightDirForSpecular(VertexOutputBaseSimple i, UnityLight mainLight)
+{
+	#if SPECULAR_HIGHLIGHTS && defined(_NORMALMAP)
+		return i.tangentSpaceLightDir;
+	#else
+		return mainLight.dir;
+	#endif
+}
+
+half3 BRDF3DirectSimple(half3 diffColor, half3 specColor, half smoothness, half rl)
+{
+	#if SPECULAR_HIGHLIGHTS
+		return BRDF3_Direct(diffColor, specColor, Pow4(rl), smoothness);
+	#else
+		return diffColor;
+	#endif
+}
+
+half4 fragForwardBaseSimpleInternal (VertexOutputBaseSimple i)
+{
+	FragmentCommonData s = FragmentSetupSimple(i);
+
+	UnityLight mainLight = MainLightSimple(i, s);
+	
+	#if !defined(LIGHTMAP_ON) && defined(_NORMALMAP)
+	half ndotl = saturate(dot(s.tangentSpaceNormal, i.tangentSpaceLightDir));
+	#else
+	half ndotl = saturate(dot(s.normalWorld, mainLight.dir));
+	#endif
+	
+	half atten = SHADOW_ATTENUATION(i);
+	
+	half occlusion = Occlusion(i.tex.xy);
+	half rl = dot(REFLECTVEC_FOR_SPECULAR(i, s), LightDirForSpecular(i, mainLight));
+	
+	UnityGI gi = FragmentGI (s, occlusion, i.ambientOrLightmapUV, atten, mainLight);
+	half3 attenuatedLightColor = gi.light.color * ndotl;
+
+	half3 c = BRDF3_Indirect(s.diffColor, s.specColor, gi.indirect, PerVertexGrazingTerm(i, s), PerVertexFresnelTerm(i));
+	c += BRDF3DirectSimple(s.diffColor, s.specColor, s.smoothness, rl) * attenuatedLightColor;
+	c += UNITY_BRDF_GI (s.diffColor, s.specColor, s.oneMinusReflectivity, s.smoothness, s.normalWorld, -s.eyeVec, occlusion, gi);
+	c += Emission(i.tex.xy);
+
+	UNITY_APPLY_FOG(i.fogCoord, c);
+	
+	return OutputForward (half4(c, 1), s.alpha);
+}
+
+half4 fragForwardBaseSimple (VertexOutputBaseSimple i) : SV_Target	// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardBaseSimpleInternal(i);
+}
+
+struct VertexOutputForwardAddSimple
+{
+	float4 pos							: SV_POSITION;
+	float4 tex							: TEXCOORD0;
+
+	LIGHTING_COORDS(1,2)
+
+#if !defined(_NORMALMAP) && SPECULAR_HIGHLIGHTS
+	UNITY_FOG_COORDS_PACKED(3, half4) // x: fogCoord, yzw: reflectVec
+#else
+	UNITY_FOG_COORDS_PACKED(3, half1)
+#endif
+
+	half3 lightDir						: TEXCOORD4;
+
+#if defined(_NORMALMAP)
+	#if SPECULAR_HIGHLIGHTS
+		half3 tangentSpaceEyeVec		: TEXCOORD5;
+	#endif
+#else
+	half3 normalWorld					: TEXCOORD5;
+#endif
+};
+
+VertexOutputForwardAddSimple vertForwardAddSimple (VertexInput v)
+{
+	VertexOutputForwardAddSimple o;
+	UNITY_INITIALIZE_OUTPUT(VertexOutputForwardAddSimple, o);
+
+	float4 posWorld = mul(unity_ObjectToWorld, v.vertex);
+	o.pos = UnityObjectToClipPos(v.vertex);
+	o.tex = TexCoords(v);
+
+	//We need this for shadow receiving
+	TRANSFER_VERTEX_TO_FRAGMENT(o);
+
+	half3 lightDir = _WorldSpaceLightPos0.xyz - posWorld.xyz * _WorldSpaceLightPos0.w;
+	#ifndef USING_DIRECTIONAL_LIGHT
+		lightDir = NormalizePerVertexNormal(lightDir);
+	#endif
+
+	#if SPECULAR_HIGHLIGHTS
+		half3 eyeVec = normalize(posWorld.xyz - _WorldSpaceCameraPos);
+	#endif
+
+	half3 normalWorld = UnityObjectToWorldNormal(v.normal);
+
+	#ifdef _NORMALMAP
+		#if SPECULAR_HIGHLIGHTS
+			TangentSpaceLightingInput(normalWorld, v.tangent, lightDir, eyeVec, o.lightDir, o.tangentSpaceEyeVec);
+		#else
+			half3 ignore;
+			TangentSpaceLightingInput(normalWorld, v.tangent, lightDir, 0, o.lightDir, ignore);
+		#endif
+	#else
+		o.lightDir = lightDir;
+		o.normalWorld = normalWorld;
+		#if SPECULAR_HIGHLIGHTS
+			o.fogCoord.yzw = reflect(eyeVec, normalWorld);
+		#endif
+	#endif
+
+	UNITY_TRANSFER_FOG(o,o.pos);
+	return o;
+}
+
+FragmentCommonData FragmentSetupSimpleAdd(VertexOutputForwardAddSimple i)
+{
+	half alpha = Alpha(i.tex.xy);
+	#if defined(_ALPHATEST_ON)
+		clip (alpha - _Cutoff);
+	#endif
+
+	FragmentCommonData s = UNITY_SETUP_BRDF_INPUT (i.tex);
+
+	// NOTE: shader relies on pre-multiply alpha-blend (_SrcBlend = One, _DstBlend = OneMinusSrcAlpha)
+	s.diffColor = PreMultiplyAlpha (s.diffColor, alpha, s.oneMinusReflectivity, /*out*/ s.alpha);
+
+	s.eyeVec = 0;
+	s.posWorld = 0;
+
+	#ifdef _NORMALMAP
+		s.tangentSpaceNormal = NormalInTangentSpace(i.tex);
+		s.normalWorld = 0;
+	#else
+		s.tangentSpaceNormal = 0;
+		s.normalWorld = i.normalWorld;
+	#endif
+
+	#if SPECULAR_HIGHLIGHTS && !defined(_NORMALMAP)
+		s.reflUVW = i.fogCoord.yzw;
+	#else
+		s.reflUVW = 0;
+	#endif
+
+	return s;
+}
+
+half3 LightSpaceNormal(VertexOutputForwardAddSimple i, FragmentCommonData s)
+{
+	#ifdef _NORMALMAP
+		return s.tangentSpaceNormal;
+	#else
+		return i.normalWorld;
+	#endif
+}
+
+half4 fragForwardAddSimpleInternal (VertexOutputForwardAddSimple i)
+{
+	FragmentCommonData s = FragmentSetupSimpleAdd(i);
+
+	half3 c = BRDF3DirectSimple(s.diffColor, s.specColor, s.smoothness, dot(REFLECTVEC_FOR_SPECULAR(i, s), i.lightDir));
+
+	#if SPECULAR_HIGHLIGHTS // else diffColor has premultiplied light color
+		c *= _LightColor0.rgb;
+	#endif
+
+	c *= LIGHT_ATTENUATION(i) * saturate(dot(LightSpaceNormal(i, s), i.lightDir));
+	
+	UNITY_APPLY_FOG_COLOR(i.fogCoord, c.rgb, half4(0,0,0,0)); // fog towards black in additive pass
+	return OutputForward (half4(c, 1), s.alpha);
+}
+
+half4 fragForwardAddSimple (VertexOutputForwardAddSimple i) : SV_Target	// backward compatibility (this used to be the fragment entry function)
+{
+	return fragForwardAddSimpleInternal(i);
+}
+
+#endif // UNITY_STANDARD_CORE_FORWARD_SIMPLE_INCLUDED
--- a/Assets/ColorMask/Shaders/ColorMaskStandardCoreForwardSimple.cginc.meta
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardCoreForwardSimple.cginc.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: c2b809316d7becd45948832df9d72af5
+timeCreated: 1454275320
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/ColorMaskStandardInput.cginc
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardInput.cginc
@ -0,0 +1,249 @@
+#ifndef UNITY_STANDARD_INPUT_INCLUDED
+#define UNITY_STANDARD_INPUT_INCLUDED
+
+#include "UnityCG.cginc"
+#include "UnityShaderVariables.cginc"
+#include "UnityInstancing.cginc"
+#include "UnityStandardConfig.cginc"
+#include "UnityPBSLighting.cginc" // TBD: remove
+#include "UnityStandardUtils.cginc"
+
+//---------------------------------------
+// Directional lightmaps & Parallax require tangent space too
+#if (_NORMALMAP || DIRLIGHTMAP_COMBINED || DIRLIGHTMAP_SEPARATE || _PARALLAXMAP)
+	#define _TANGENT_TO_WORLD 1 
+#endif
+
+#if (_DETAIL_MULX2 || _DETAIL_MUL || _DETAIL_ADD || _DETAIL_LERP)
+	#define _DETAIL 1
+#endif
+
+//---------------------------------------
+half4		_Color;
+half		_Cutoff;
+
+sampler2D	_MainTex;
+float4		_MainTex_ST;
+
+sampler2D	_ColorMaskTex;
+float4		_ColorMaskTex_ST;
+
+half4		_RedColor;
+half4		_GreenColor;
+half4		_BlueColor;
+half4		_AlphaColor;
+
+sampler2D	_DetailAlbedoMap;
+float4		_DetailAlbedoMap_ST;
+
+sampler2D	_BumpMap;
+half		_BumpScale;
+
+sampler2D	_DetailMask;
+sampler2D	_DetailNormalMap;
+half		_DetailNormalMapScale;
+
+sampler2D	_SpecGlossMap;
+sampler2D	_MetallicGlossMap;
+half		_Metallic;
+half		_Glossiness;
+half		_GlossMapScale;
+
+sampler2D	_OcclusionMap;
+half		_OcclusionStrength;
+
+sampler2D	_ParallaxMap;
+half		_Parallax;
+half		_UVSec;
+
+half4 		_EmissionColor;
+sampler2D	_EmissionMap;
+
+//-------------------------------------------------------------------------------------
+// Input functions
+
+struct VertexInput
+{
+	float4 vertex	: POSITION;
+	half3 normal	: NORMAL;
+	float2 uv0		: TEXCOORD0;
+	float2 uv1		: TEXCOORD1;
+#if defined(DYNAMICLIGHTMAP_ON) || defined(UNITY_PASS_META)
+	float2 uv2		: TEXCOORD2;
+#endif
+#ifdef _TANGENT_TO_WORLD
+	half4 tangent	: TANGENT;
+#endif
+	UNITY_VERTEX_INPUT_INSTANCE_ID
+};
+
+float4 TexCoords(VertexInput v)
+{
+	float4 texcoord;
+	texcoord.xy = TRANSFORM_TEX(v.uv0, _MainTex); // Always source from uv0
+	texcoord.zw = TRANSFORM_TEX(((_UVSec == 0) ? v.uv0 : v.uv1), _DetailAlbedoMap);
+	return texcoord;
+}		
+
+half DetailMask(float2 uv)
+{
+	return tex2D (_DetailMask, uv).a;
+}
+
+half3 Albedo(float4 texcoords)
+{
+	
+	half3 albedo = tex2D (_MainTex, texcoords.xy).rgb;
+	
+	//4 channel color mask - Blend the albedo texture with the user defined colors using the color mask (rgba), then multiply the default color.
+	half4 cM = tex2D (_ColorMaskTex, texcoords.xy);
+	half total = cM.r + cM.g + cM.b + cM.a;
+	half mT = max(total, 0.002);
+	half4 blendColor = _RedColor * cM.r / mT + _GreenColor * cM.g / mT + _BlueColor * cM.b / mT + _AlphaColor * cM.a / mT;
+	//half4 blendColor = _RedColor * cM.r / mT + _GreenColor * cM.g / mT;
+	//half4 blendColor = cM;
+	albedo = lerp(albedo, blendColor.rgb, min(total, 1) * blendColor.a ) * _Color.rgb;
+	//albedo = cM.b + cM.a;
+	
+#if _DETAIL
+	#if (SHADER_TARGET < 30)
+		// SM20: instruction count limitation
+		// SM20: no detail mask
+		half mask = 1; 
+	#else
+		half mask = DetailMask(texcoords.xy);
+	#endif
+	half3 detailAlbedo = tex2D (_DetailAlbedoMap, texcoords.zw).rgb;
+	#if _DETAIL_MULX2
+		albedo *= LerpWhiteTo (detailAlbedo * unity_ColorSpaceDouble.rgb, mask);
+	#elif _DETAIL_MUL
+		albedo *= LerpWhiteTo (detailAlbedo, mask);
+	#elif _DETAIL_ADD
+		albedo += detailAlbedo * mask;
+	#elif _DETAIL_LERP
+		albedo = lerp (albedo, detailAlbedo, mask);
+	#endif
+#endif
+	return albedo;
+}
+
+half Alpha(float2 uv)
+{
+#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
+	return _Color.a;
+#else
+	return tex2D(_MainTex, uv).a * _Color.a;
+#endif
+}		
+
+half Occlusion(float2 uv)
+{
+#if (SHADER_TARGET < 30)
+	// SM20: instruction count limitation
+	// SM20: simpler occlusion
+	return tex2D(_OcclusionMap, uv).g;
+#else
+	half occ = tex2D(_OcclusionMap, uv).g;
+	return LerpOneTo (occ, _OcclusionStrength);
+#endif
+}
+
+half4 SpecularGloss(float2 uv)
+{
+	half4 sg;
+#ifdef _SPECGLOSSMAP
+	#if defined(_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A)
+		sg.rgb = tex2D(_SpecGlossMap, uv).rgb;
+		sg.a = tex2D(_MainTex, uv).a;
+	#else
+		sg = tex2D(_SpecGlossMap, uv);
+	#endif
+	sg.a *= _GlossMapScale;
+#else
+	sg.rgb = _SpecColor.rgb;
+	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+		sg.a = tex2D(_MainTex, uv).a * _GlossMapScale;
+	#else
+		sg.a = _Glossiness;
+	#endif
+#endif
+	return sg;
+}
+
+half2 MetallicGloss(float2 uv)
+{
+	half2 mg;
+	
+#ifdef _METALLICGLOSSMAP
+	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+		mg.r = tex2D(_MetallicGlossMap, uv).r;
+		mg.g = tex2D(_MainTex, uv).a;
+	#else
+		mg = tex2D(_MetallicGlossMap, uv).ra;
+	#endif
+	mg.g *= _GlossMapScale;
+#else
+	mg.r = _Metallic;
+	#ifdef _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+		mg.g = tex2D(_MainTex, uv).a * _GlossMapScale;
+	#else
+		mg.g = _Glossiness;
+	#endif
+#endif
+	return mg;
+}
+
+half3 Emission(float2 uv)
+{
+#ifndef _EMISSION
+	return 0;
+#else
+	return tex2D(_EmissionMap, uv).rgb * _EmissionColor.rgb;
+#endif
+}
+
+#ifdef _NORMALMAP
+half3 NormalInTangentSpace(float4 texcoords)
+{
+	half3 normalTangent = UnpackScaleNormal(tex2D (_BumpMap, texcoords.xy), _BumpScale);
+	// SM20: instruction count limitation
+	// SM20: no detail normalmaps
+#if _DETAIL && !defined(SHADER_API_MOBILE) && (SHADER_TARGET >= 30) 
+	half mask = DetailMask(texcoords.xy);
+	half3 detailNormalTangent = UnpackScaleNormal(tex2D (_DetailNormalMap, texcoords.zw), _DetailNormalMapScale);
+	#if _DETAIL_LERP
+		normalTangent = lerp(
+			normalTangent,
+			detailNormalTangent,
+			mask);
+	#else				
+		normalTangent = lerp(
+			normalTangent,
+			BlendNormals(normalTangent, detailNormalTangent),
+			mask);
+	#endif
+#endif
+	return normalTangent;
+}
+#endif
+
+float4 Parallax (float4 texcoords, half3 viewDir)
+{
+// D3D9/SM30 supports up to 16 samplers, skip the parallax map in case we exceed the limit
+#define EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT	(defined(LIGHTMAP_ON) && defined(DIRLIGHTMAP_SEPARATE) && defined(SHADOWS_SCREEN) && defined(_NORMALMAP) && \
+											 defined(_EMISSION) && defined(_DETAIL) && (defined(_METALLICGLOSSMAP) || defined(_SPECGLOSSMAP)))
+
+#if !defined(_PARALLAXMAP) || (SHADER_TARGET < 30) || (defined(SHADER_API_D3D9) && EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT)
+	// SM20: instruction count limitation
+	// SM20: no parallax
+	return texcoords;
+#else
+	half h = tex2D (_ParallaxMap, texcoords.xy).g;
+	float2 offset = ParallaxOffset1Step (h, _Parallax, viewDir);
+	return float4(texcoords.xy + offset, texcoords.zw + offset);
+#endif
+
+#undef EXCEEDS_D3D9_SM3_MAX_SAMPLER_COUNT
+}
+			
+#endif // UNITY_STANDARD_INPUT_INCLUDED
--- a/Assets/ColorMask/Shaders/ColorMaskStandardInput.cginc.meta
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardInput.cginc.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 5d44df0214f7ed446bd641e3b25429a0
+timeCreated: 1435093423
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/ColorMaskStandardMeta.cginc
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardMeta.cginc
@ -0,0 +1,56 @@
+#ifndef UNITY_STANDARD_META_INCLUDED
+#define UNITY_STANDARD_META_INCLUDED
+
+// Functionality for Standard shader "meta" pass
+// (extracts albedo/emission for lightmapper etc.)
+
+// define meta pass before including other files; they have conditions
+// on that in some places
+#define UNITY_PASS_META 1
+
+#include "UnityCG.cginc"
+#include "ColorMaskStandardInput.cginc"
+#include "UnityMetaPass.cginc"
+#include "ColorMaskStandardCore.cginc"
+
+struct v2f_meta
+{
+	float4 uv		: TEXCOORD0;
+	float4 pos		: SV_POSITION;
+};
+
+v2f_meta vert_meta (VertexInput v)
+{
+	v2f_meta o;
+	o.pos = UnityMetaVertexPosition(v.vertex, v.uv1.xy, v.uv2.xy, unity_LightmapST, unity_DynamicLightmapST);
+	o.uv = TexCoords(v);
+	return o;
+}
+
+// Albedo for lightmapping should basically be diffuse color.
+// But rough metals (black diffuse) still scatter quite a lot of light around, so
+// we want to take some of that into account too.
+half3 UnityLightmappingAlbedo (half3 diffuse, half3 specular, half smoothness)
+{
+	half roughness = SmoothnessToRoughness(smoothness);
+	half3 res = diffuse;
+	res += specular * roughness * 0.5;
+	return res;
+}
+
+float4 frag_meta (v2f_meta i) : SV_Target
+{
+	// we're interested in diffuse & specular colors,
+	// and surface roughness to produce final albedo.
+	FragmentCommonData data = UNITY_SETUP_BRDF_INPUT (i.uv);
+
+	UnityMetaInput o;
+	UNITY_INITIALIZE_OUTPUT(UnityMetaInput, o);
+
+	o.Albedo = UnityLightmappingAlbedo (data.diffColor, data.specColor, data.smoothness);
+	o.Emission = Emission(i.uv.xy);
+
+	return UnityMetaFragment(o);
+}
+
+#endif // UNITY_STANDARD_META_INCLUDED
--- a/Assets/ColorMask/Shaders/ColorMaskStandardMeta.cginc.meta
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardMeta.cginc.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: ef6599bf52ffb90459f0c70ac32ee0a4
+timeCreated: 1435099795
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/ColorMaskStandardSpecular.shader
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardSpecular.shader
@ -0,0 +1,340 @@
+Shader "ColorMask/Standard (Specular setup)"
+{
+	Properties
+	{
+		_Color("Color", Color) = (1,1,1,1)
+		_MainTex("Albedo", 2D) = "white" {}
+		
+		_Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+		
+		_ColorMaskTex("Color Mask", 2D) = "black" {}
+		_RedColor("Red Color", Color) = (1,1,1,1)
+		_GreenColor("Green Color", Color) = (1,1,1,1)
+		_BlueColor("Blue Color", Color) = (1,1,1,1)
+		_AlphaColor("Alpha Color", Color) = (1,1,1,1)
+		
+		_Glossiness("Smoothness", Range(0.0, 1.0)) = 0.5
+		_GlossMapScale("Smoothness Factor", Range(0.0, 1.0)) = 1.0
+		[Enum(Specular Alpha,0,Albedo Alpha,1)] _SmoothnessTextureChannel ("Smoothness texture channel", Float) = 0
+
+		_SpecColor("Specular", Color) = (0.2,0.2,0.2)
+		_SpecGlossMap("Specular", 2D) = "white" {}
+		[ToggleOff] _SpecularHighlights("Specular Highlights", Float) = 1.0
+		[ToggleOff] _GlossyReflections("Glossy Reflections", Float) = 1.0
+
+		_BumpScale("Scale", Float) = 1.0
+		_BumpMap("Normal Map", 2D) = "bump" {}
+
+		_Parallax ("Height Scale", Range (0.005, 0.08)) = 0.02
+		_ParallaxMap ("Height Map", 2D) = "black" {}
+
+		_OcclusionStrength("Strength", Range(0.0, 1.0)) = 1.0
+		_OcclusionMap("Occlusion", 2D) = "white" {}
+
+		_EmissionColor("Color", Color) = (0,0,0)
+		_EmissionMap("Emission", 2D) = "white" {}
+		
+		_DetailMask("Detail Mask", 2D) = "white" {}
+
+		_DetailAlbedoMap("Detail Albedo x2", 2D) = "grey" {}
+		_DetailNormalMapScale("Scale", Float) = 1.0
+		_DetailNormalMap("Normal Map", 2D) = "bump" {}
+
+		[Enum(UV0,0,UV1,1)] _UVSec ("UV Set for secondary textures", Float) = 0
+
+
+		// Blending state
+		[HideInInspector] _Mode ("__mode", Float) = 0.0
+		[HideInInspector] _SrcBlend ("__src", Float) = 1.0
+		[HideInInspector] _DstBlend ("__dst", Float) = 0.0
+		[HideInInspector] _ZWrite ("__zw", Float) = 1.0
+	}
+
+	CGINCLUDE
+		#define UNITY_SETUP_BRDF_INPUT SpecularSetup
+	ENDCG
+
+	SubShader
+	{
+		Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
+		LOD 300
+	
+
+		// ------------------------------------------------------------------
+		//  Base forward pass (directional light, emission, lightmaps, ...)
+		Pass
+		{
+			Name "FORWARD" 
+			Tags { "LightMode" = "ForwardBase" }
+
+			Blend [_SrcBlend] [_DstBlend]
+			ZWrite [_ZWrite]
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile_fwdbase
+			#pragma multi_compile_fog
+
+			#pragma vertex vertBase
+			#pragma fragment fragBase
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Additive forward pass (one light per pass)
+		Pass
+		{
+			Name "FORWARD_DELTA"
+			Tags { "LightMode" = "ForwardAdd" }
+			Blend [_SrcBlend] One
+			Fog { Color (0,0,0,0) } // in additive pass fog should be black
+			ZWrite Off
+			ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile_fwdadd_fullshadows
+			#pragma multi_compile_fog
+
+			#pragma vertex vertAdd
+			#pragma fragment fragAdd
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Shadow rendering pass
+		Pass {
+			Name "ShadowCaster"
+			Tags { "LightMode" = "ShadowCaster" }
+
+			ZWrite On ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 3.0
+
+			// -------------------------------------
+
+
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature _PARALLAXMAP
+			#pragma multi_compile_shadowcaster
+
+			#pragma vertex vertShadowCaster
+			#pragma fragment fragShadowCaster
+
+			#include "UnityStandardShadow.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Deferred pass
+		Pass
+		{
+			Name "DEFERRED"
+			Tags { "LightMode" = "Deferred" }
+
+			CGPROGRAM
+			#pragma target 3.0
+			#pragma exclude_renderers nomrt
+
+
+			// -------------------------------------
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			#pragma shader_feature _PARALLAXMAP
+
+			#pragma multi_compile ___ UNITY_HDR_ON
+			#pragma multi_compile ___ LIGHTMAP_ON
+			#pragma multi_compile ___ DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
+			#pragma multi_compile ___ DYNAMICLIGHTMAP_ON
+
+			#pragma vertex vertDeferred
+			#pragma fragment fragDeferred
+
+			#include "ColorMaskStandardCore.cginc"
+
+			ENDCG
+		}
+
+		// ------------------------------------------------------------------
+		// Extracts information for lightmapping, GI (emission, albedo, ...)
+		// This pass it not used during regular rendering.
+		Pass
+		{
+			Name "META" 
+			Tags { "LightMode"="Meta" }
+
+			Cull Off
+
+			CGPROGRAM
+			#pragma target 2.5
+			
+			#pragma vertex vert_meta
+			#pragma fragment frag_meta
+
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature ___ _DETAIL_MULX2
+
+			#include "ColorMaskStandardMeta.cginc"
+			ENDCG
+		}
+	}
+
+	SubShader
+	{
+		Tags { "RenderType"="Opaque" "PerformanceChecks"="False" }
+		LOD 150
+
+		// ------------------------------------------------------------------
+		//  Base forward pass (directional light, emission, lightmaps, ...)
+		Pass
+		{
+			Name "FORWARD" 
+			Tags { "LightMode" = "ForwardBase" }
+
+			Blend [_SrcBlend] [_DstBlend]
+			ZWrite [_ZWrite]
+
+			CGPROGRAM
+			#pragma target 2.5
+			
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _EMISSION 
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature _ _GLOSSYREFLECTIONS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP
+
+			#pragma skip_variants SHADOWS_SOFT DYNAMICLIGHTMAP_ON DIRLIGHTMAP_COMBINED DIRLIGHTMAP_SEPARATE
+			
+			#pragma multi_compile_fwdbase
+			#pragma multi_compile_fog
+
+			#pragma vertex vertBase
+			#pragma fragment fragBase
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Additive forward pass (one light per pass)
+		Pass
+		{
+			Name "FORWARD_DELTA"
+			Tags { "LightMode" = "ForwardAdd" }
+			Blend [_SrcBlend] One
+			Fog { Color (0,0,0,0) } // in additive pass fog should be black
+			ZWrite Off
+			ZTest LEqual
+			
+			CGPROGRAM
+			#pragma target 2.5
+
+			#pragma shader_feature _NORMALMAP
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature _ _SPECULARHIGHLIGHTS_OFF
+			#pragma shader_feature ___ _DETAIL_MULX2
+			// SM2.0: NOT SUPPORTED shader_feature _PARALLAXMAP
+			#pragma skip_variants SHADOWS_SOFT
+			
+			#pragma multi_compile_fwdadd_fullshadows
+			#pragma multi_compile_fog
+			
+			#pragma vertex vertAdd
+			#pragma fragment fragAdd
+			#include "ColorMaskStandardCoreForward.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		//  Shadow rendering pass
+		Pass {
+			Name "ShadowCaster"
+			Tags { "LightMode" = "ShadowCaster" }
+			
+			ZWrite On ZTest LEqual
+
+			CGPROGRAM
+			#pragma target 2.5
+
+			#pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma skip_variants SHADOWS_SOFT
+			#pragma multi_compile_shadowcaster
+
+			#pragma vertex vertShadowCaster
+			#pragma fragment fragShadowCaster
+
+			#include "UnityStandardShadow.cginc"
+
+			ENDCG
+		}
+		// ------------------------------------------------------------------
+		// Extracts information for lightmapping, GI (emission, albedo, ...)
+		// This pass it not used during regular rendering.
+		Pass
+		{
+			Name "META" 
+			Tags { "LightMode"="Meta" }
+
+			Cull Off
+
+			CGPROGRAM
+			#pragma target 2.5
+			
+			#pragma vertex vert_meta
+			#pragma fragment frag_meta
+
+			#pragma shader_feature _EMISSION
+			#pragma shader_feature _SPECGLOSSMAP
+			#pragma shader_feature _ _SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A
+			#pragma shader_feature ___ _DETAIL_MULX2
+
+			#include "ColorMaskStandardMeta.cginc"
+			ENDCG
+		}
+	}
+
+	FallBack "VertexLit"
+	CustomEditor "ColorMaskStandardShaderGUI"
+}
--- a/Assets/ColorMask/Shaders/ColorMaskStandardSpecular.shader.meta
+++ b/Assets/ColorMask/Shaders/ColorMaskStandardSpecular.shader.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: bedf46e927dae18459dcdcdef5201a5f
+timeCreated: 1435103330
+licenseType: Store
+ShaderImporter:
+  defaultTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/Editor.meta
+++ b/Assets/ColorMask/Shaders/Editor.meta
@ -0,0 +1,9 @@
+fileFormatVersion: 2
+guid: 276cc93363e40514e8655de2514c9341
+folderAsset: yes
+timeCreated: 1436031523
+licenseType: Store
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ColorMask/Shaders/Editor/ColorMaskStandardShaderGUI.cs
+++ b/Assets/ColorMask/Shaders/Editor/ColorMaskStandardShaderGUI.cs
@ -0,0 +1,469 @@
+using System;
+using UnityEngine;
+
+namespace UnityEditor
+{
+internal class ColorMaskStandardShaderGUI : ShaderGUI
+{
+	private enum WorkflowMode
+	{
+		Specular,
+		Metallic,
+		Dielectric
+	}
+
+	public enum BlendMode
+	{
+		Opaque,
+		Cutout,
+		Fade,		// Old school alpha-blending mode, fresnel does not affect amount of transparency
+		Transparent // Physically plausible transparency mode, implemented as alpha pre-multiply
+	}
+
+	public enum SmoothnessMapChannel
+	{
+		SpecularMetallicAlpha,
+		AlbedoAlpha,
+	}
+
+	private static class Styles
+	{
+		public static GUIStyle optionsButton = "PaneOptions";
+		public static GUIContent uvSetLabel = new GUIContent("UV Set");
+		public static GUIContent[] uvSetOptions = new GUIContent[] { new GUIContent("UV channel 0"), new GUIContent("UV channel 1") };
+
+		public static string emptyTootip = "";
+		public static GUIContent albedoText = new GUIContent("Albedo", "Albedo (RGB) and Transparency (A)");
+		public static GUIContent alphaCutoffText = new GUIContent("Alpha Cutoff", "Threshold for alpha cutoff");
+		public static GUIContent colorMaskText = new GUIContent("Color Mask", "Color Mask (R)");
+		public static GUIContent specularMapText = new GUIContent("Specular", "Specular (RGB) and Smoothness (A)");
+		public static GUIContent metallicMapText = new GUIContent("Metallic", "Metallic (R) and Smoothness (A)");
+		public static GUIContent smoothnessText = new GUIContent("Smoothness", "Smoothness value");
+		public static GUIContent smoothnessScaleText = new GUIContent("Smoothness", "Smoothness scale factor");
+		public static GUIContent smoothnessMapChannelText = new GUIContent("Source", "Smoothness texture and channel");
+		public static GUIContent highlightsText = new GUIContent("Specular Highlights", "Specular Highlights");
+		public static GUIContent reflectionsText = new GUIContent("Reflections", "Glossy Reflections");
+		public static GUIContent normalMapText = new GUIContent("Normal Map", "Normal Map");
+		public static GUIContent heightMapText = new GUIContent("Height Map", "Height Map (G)");
+		public static GUIContent occlusionText = new GUIContent("Occlusion", "Occlusion (G)");
+		public static GUIContent emissionText = new GUIContent("Emission", "Emission (RGB)");
+		public static GUIContent detailMaskText = new GUIContent("Detail Mask", "Mask for Secondary Maps (A)");
+		public static GUIContent detailAlbedoText = new GUIContent("Detail Albedo x2", "Albedo (RGB) multiplied by 2");
+		public static GUIContent detailNormalMapText = new GUIContent("Normal Map", "Normal Map");
+
+		public static string whiteSpaceString = " ";
+		public static string primaryMapsText = "Main Maps";
+		public static string secondaryMapsText = "Secondary Maps";
+		public static string forwardText = "Forward Rendering Options";
+		public static string renderingMode = "Rendering Mode";
+		public static GUIContent emissiveWarning = new GUIContent ("Emissive value is animated but the material has not been configured to support emissive. Please make sure the material itself has some amount of emissive.");
+		public static GUIContent emissiveColorWarning = new GUIContent ("Ensure emissive color is non-black for emission to have effect.");
+		public static readonly string[] blendNames = Enum.GetNames (typeof (BlendMode));
+	}
+
+	MaterialProperty blendMode = null;
+	MaterialProperty albedoMap = null;
+	MaterialProperty albedoColor = null;
+	MaterialProperty alphaCutoff = null;
+	MaterialProperty colorMaskMap = null;
+	MaterialProperty redColor = null;
+	MaterialProperty greenColor = null;
+	MaterialProperty blueColor = null;
+	MaterialProperty alphaColor = null;
+	MaterialProperty specularMap = null;
+	MaterialProperty specularColor = null;
+	MaterialProperty metallicMap = null;
+	MaterialProperty metallic = null;
+	MaterialProperty smoothness = null;
+	MaterialProperty smoothnessScale = null;
+	MaterialProperty smoothnessMapChannel = null;
+	MaterialProperty highlights = null;
+	MaterialProperty reflections = null;
+	MaterialProperty bumpScale = null;
+	MaterialProperty bumpMap = null;
+	MaterialProperty occlusionStrength = null;
+	MaterialProperty occlusionMap = null;
+	MaterialProperty heigtMapScale = null;
+	MaterialProperty heightMap = null;
+	MaterialProperty emissionColorForRendering = null;
+	MaterialProperty emissionMap = null;
+	MaterialProperty detailMask = null;
+	MaterialProperty detailAlbedoMap = null;
+	MaterialProperty detailNormalMapScale = null;
+	MaterialProperty detailNormalMap = null;
+	MaterialProperty uvSetSecondary = null;
+
+	MaterialEditor m_MaterialEditor;
+	WorkflowMode m_WorkflowMode = WorkflowMode.Specular;
+	ColorPickerHDRConfig m_ColorPickerHDRConfig = new ColorPickerHDRConfig(0f, 99f, 1/99f, 3f);
+
+	bool m_FirstTimeApply = true;
+
+	public void FindProperties (MaterialProperty[] props)
+	{
+		blendMode = FindProperty ("_Mode", props);
+		albedoMap = FindProperty ("_MainTex", props);
+		albedoColor = FindProperty ("_Color", props);
+		alphaCutoff = FindProperty ("_Cutoff", props);
+		colorMaskMap = FindProperty ("_ColorMaskTex", props);
+		redColor = FindProperty ("_RedColor", props);
+		greenColor = FindProperty ("_GreenColor", props);
+		blueColor = FindProperty ("_BlueColor", props);
+		alphaColor = FindProperty ("_AlphaColor", props);
+		specularMap = FindProperty ("_SpecGlossMap", props, false);
+		specularColor = FindProperty ("_SpecColor", props, false);
+		metallicMap = FindProperty ("_MetallicGlossMap", props, false);
+		metallic = FindProperty ("_Metallic", props, false);
+		if (specularMap != null && specularColor != null)
+			m_WorkflowMode = WorkflowMode.Specular;
+		else if (metallicMap != null && metallic != null)
+			m_WorkflowMode = WorkflowMode.Metallic;
+		else
+			m_WorkflowMode = WorkflowMode.Dielectric;
+		smoothness = FindProperty ("_Glossiness", props);
+		smoothnessScale = FindProperty ("_GlossMapScale", props, false);
+		smoothnessMapChannel = FindProperty ("_SmoothnessTextureChannel", props, false);
+		highlights = FindProperty ("_SpecularHighlights", props, false);
+		reflections = FindProperty ("_GlossyReflections", props, false);
+		bumpScale = FindProperty ("_BumpScale", props);
+		bumpMap = FindProperty ("_BumpMap", props);
+		heigtMapScale = FindProperty ("_Parallax", props);
+		heightMap = FindProperty("_ParallaxMap", props);
+		occlusionStrength = FindProperty ("_OcclusionStrength", props);
+		occlusionMap = FindProperty ("_OcclusionMap", props);
+		emissionColorForRendering = FindProperty ("_EmissionColor", props);
+		emissionMap = FindProperty ("_EmissionMap", props);
+		detailMask = FindProperty ("_DetailMask", props);
+		detailAlbedoMap = FindProperty ("_DetailAlbedoMap", props);
+		detailNormalMapScale = FindProperty ("_DetailNormalMapScale", props);
+		detailNormalMap = FindProperty ("_DetailNormalMap", props);
+		uvSetSecondary = FindProperty ("_UVSec", props);
+	}
+
+	public override void OnGUI (MaterialEditor materialEditor, MaterialProperty[] props)
+	{
+		FindProperties (props); // MaterialProperties can be animated so we do not cache them but fetch them every event to ensure animated values are updated correctly
+		m_MaterialEditor = materialEditor;
+		Material material = materialEditor.target as Material;
+
+		// Make sure that needed setup (ie keywords/renderqueue) are set up if we're switching some existing
+		// material to a standard shader.
+		// Do this before any GUI code has been issued to prevent layout issues in subsequent GUILayout statements (case 780071)
+		if (m_FirstTimeApply)
+		{
+			MaterialChanged(material, m_WorkflowMode);
+			m_FirstTimeApply = false;
+		}
+
+		ShaderPropertiesGUI (material);
+	}
+
+	public void ShaderPropertiesGUI (Material material)
+	{
+		// Use default labelWidth
+		EditorGUIUtility.labelWidth = 0f;
+
+		// Detect any changes to the material
+		EditorGUI.BeginChangeCheck();
+		{
+			BlendModePopup();
+
+			// Primary properties
+			GUILayout.Label (Styles.primaryMapsText, EditorStyles.boldLabel);
+			DoAlbedoArea(material);
+			DoColorMaskArea(material);
+			DoSpecularMetallicArea();
+			m_MaterialEditor.TexturePropertySingleLine(Styles.normalMapText, bumpMap, bumpMap.textureValue != null ? bumpScale : null);
+			m_MaterialEditor.TexturePropertySingleLine(Styles.heightMapText, heightMap, heightMap.textureValue != null ? heigtMapScale : null);
+			m_MaterialEditor.TexturePropertySingleLine(Styles.occlusionText, occlusionMap, occlusionMap.textureValue != null ? occlusionStrength : null);
+			DoEmissionArea(material);
+			m_MaterialEditor.TexturePropertySingleLine(Styles.detailMaskText, detailMask);
+			EditorGUI.BeginChangeCheck();
+			m_MaterialEditor.TextureScaleOffsetProperty(albedoMap);
+			if (EditorGUI.EndChangeCheck())
+				colorMaskMap.textureScaleAndOffset = albedoMap.textureScaleAndOffset; // Apply the main texture scale and offset to the color mask texture as well
+			
+			EditorGUI.BeginChangeCheck();
+			m_MaterialEditor.TextureScaleOffsetProperty(albedoMap);
+			if (EditorGUI.EndChangeCheck())
+				emissionMap.textureScaleAndOffset = albedoMap.textureScaleAndOffset; // Apply the main texture scale and offset to the emission texture as well, for Enlighten's sake
+
+			EditorGUILayout.Space();
+
+			// Secondary properties
+			GUILayout.Label(Styles.secondaryMapsText, EditorStyles.boldLabel);
+			m_MaterialEditor.TexturePropertySingleLine(Styles.detailAlbedoText, detailAlbedoMap);
+			m_MaterialEditor.TexturePropertySingleLine(Styles.detailNormalMapText, detailNormalMap, detailNormalMapScale);
+			m_MaterialEditor.TextureScaleOffsetProperty(detailAlbedoMap);
+			m_MaterialEditor.ShaderProperty(uvSetSecondary, Styles.uvSetLabel.text);
+
+			// Third properties
+			GUILayout.Label(Styles.forwardText, EditorStyles.boldLabel);
+			if (highlights != null)
+				m_MaterialEditor.ShaderProperty(highlights, Styles.highlightsText);
+			if (reflections != null)
+				m_MaterialEditor.ShaderProperty(reflections, Styles.reflectionsText);
+			
+		}
+		if (EditorGUI.EndChangeCheck())
+		{
+			foreach (var obj in blendMode.targets)
+				MaterialChanged((Material)obj, m_WorkflowMode);
+		}
+	}
+
+	internal void DetermineWorkflow(MaterialProperty[] props)
+	{
+		if (FindProperty("_SpecGlossMap", props, false) != null && FindProperty("_SpecColor", props, false) != null)
+			m_WorkflowMode = WorkflowMode.Specular;
+		else if (FindProperty("_MetallicGlossMap", props, false) != null && FindProperty("_Metallic", props, false) != null)
+			m_WorkflowMode = WorkflowMode.Metallic;
+		else
+			m_WorkflowMode = WorkflowMode.Dielectric;
+	}
+
+	public override void AssignNewShaderToMaterial (Material material, Shader oldShader, Shader newShader)
+	{
+		// _Emission property is lost after assigning Standard shader to the material
+		// thus transfer it before assigning the new shader
+		if (material.HasProperty("_Emission"))
+		{
+			material.SetColor("_EmissionColor", material.GetColor("_Emission"));
+		}
+
+		base.AssignNewShaderToMaterial(material, oldShader, newShader);
+
+		if (oldShader == null || !oldShader.name.Contains("Legacy Shaders/"))
+		{
+			SetupMaterialWithBlendMode(material, (BlendMode)material.GetFloat("_Mode"));
+			return;
+		}
+
+		BlendMode blendMode = BlendMode.Opaque;
+		if (oldShader.name.Contains("/Transparent/Cutout/"))
+		{
+			blendMode = BlendMode.Cutout;
+		}
+		else if (oldShader.name.Contains("/Transparent/"))
+		{
+			// NOTE: legacy shaders did not provide physically based transparency
+			// therefore Fade mode
+			blendMode = BlendMode.Fade;
+		}
+		material.SetFloat("_Mode", (float)blendMode);
+
+		DetermineWorkflow( MaterialEditor.GetMaterialProperties (new Material[] { material }) );
+		MaterialChanged(material, m_WorkflowMode);
+	}
+
+	void BlendModePopup()
+	{
+		EditorGUI.showMixedValue = blendMode.hasMixedValue;
+		var mode = (BlendMode)blendMode.floatValue;
+
+		EditorGUI.BeginChangeCheck();
+		mode = (BlendMode)EditorGUILayout.Popup(Styles.renderingMode, (int)mode, Styles.blendNames);
+		if (EditorGUI.EndChangeCheck())
+		{
+			m_MaterialEditor.RegisterPropertyChangeUndo("Rendering Mode");
+			blendMode.floatValue = (float)mode;
+		}
+
+		EditorGUI.showMixedValue = false;
+	}
+
+	void DoAlbedoArea(Material material)
+	{
+		m_MaterialEditor.TexturePropertySingleLine(Styles.albedoText, albedoMap, albedoColor);
+		if (((BlendMode)material.GetFloat("_Mode") == BlendMode.Cutout))
+		{
+			m_MaterialEditor.ShaderProperty(alphaCutoff, Styles.alphaCutoffText.text, MaterialEditor.kMiniTextureFieldLabelIndentLevel+1);
+		}
+	}
+	
+	void DoColorMaskArea(Material material)
+	{
+		//4 channel color mask - Texture and colors
+		m_MaterialEditor.TexturePropertySingleLine(Styles.colorMaskText, colorMaskMap);
+		m_MaterialEditor.ColorProperty(redColor, "Red Color");
+		m_MaterialEditor.ColorProperty(greenColor, "Green Color");
+		m_MaterialEditor.ColorProperty(blueColor, "Blue Color");
+		m_MaterialEditor.ColorProperty(alphaColor, "Alpha Color");
+	}
+
+	void DoEmissionArea(Material material)
+	{
+		bool showHelpBox = !HasValidEmissiveKeyword(material);
+		
+		bool hadEmissionTexture = emissionMap.textureValue != null;
+
+		// Texture and HDR color controls
+		m_MaterialEditor.TexturePropertyWithHDRColor(Styles.emissionText, emissionMap, emissionColorForRendering, m_ColorPickerHDRConfig, false);
+
+		// If texture was assigned and color was black set color to white
+		float brightness = emissionColorForRendering.colorValue.maxColorComponent;
+		if (emissionMap.textureValue != null && !hadEmissionTexture && brightness <= 0f)
+			emissionColorForRendering.colorValue = Color.white;
+
+		// Emission for GI?
+		m_MaterialEditor.LightmapEmissionProperty (MaterialEditor.kMiniTextureFieldLabelIndentLevel + 1);
+		
+		if (showHelpBox)
+		{
+			EditorGUILayout.HelpBox(Styles.emissiveWarning.text, MessageType.Warning);
+		}
+	}
+
+	void DoSpecularMetallicArea()
+	{
+		bool hasGlossMap = false;
+		if (m_WorkflowMode == WorkflowMode.Specular)
+		{
+			hasGlossMap = specularMap.textureValue != null;
+			m_MaterialEditor.TexturePropertySingleLine(Styles.specularMapText, specularMap, hasGlossMap ? null : specularColor);
+		}
+		else if (m_WorkflowMode == WorkflowMode.Metallic)
+		{
+			hasGlossMap = metallicMap.textureValue != null;
+			m_MaterialEditor.TexturePropertySingleLine(Styles.metallicMapText, metallicMap, hasGlossMap ? null : metallic);
+		}
+
+		bool showSmoothnessScale = hasGlossMap;
+		if (smoothnessMapChannel != null)
+		{
+			int smoothnessChannel = (int) smoothnessMapChannel.floatValue;
+			if (smoothnessChannel == (int) SmoothnessMapChannel.AlbedoAlpha)
+				showSmoothnessScale = true;
+		}
+
+		int indentation = 2; // align with labels of texture properties
+		m_MaterialEditor.ShaderProperty(showSmoothnessScale ? smoothnessScale : smoothness, showSmoothnessScale ? Styles.smoothnessScaleText : Styles.smoothnessText, indentation);
+	
+		++indentation;
+		if (smoothnessMapChannel != null)
+			m_MaterialEditor.ShaderProperty(smoothnessMapChannel, Styles.smoothnessMapChannelText, indentation);
+	}
+
+	public static void SetupMaterialWithBlendMode(Material material, BlendMode blendMode)
+	{
+		switch (blendMode)
+		{
+			case BlendMode.Opaque:
+				material.SetOverrideTag("RenderType", "");
+				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+				material.SetInt("_ZWrite", 1);
+				material.DisableKeyword("_ALPHATEST_ON");
+				material.DisableKeyword("_ALPHABLEND_ON");
+				material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+				material.renderQueue = -1;
+				break;
+			case BlendMode.Cutout:
+				material.SetOverrideTag("RenderType", "TransparentCutout");
+				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
+				material.SetInt("_ZWrite", 1);
+				material.EnableKeyword("_ALPHATEST_ON");
+				material.DisableKeyword("_ALPHABLEND_ON");
+				material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+				material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
+				break;
+			case BlendMode.Fade:
+				material.SetOverrideTag("RenderType", "Transparent");
+				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
+				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+				material.SetInt("_ZWrite", 0);
+				material.DisableKeyword("_ALPHATEST_ON");
+				material.EnableKeyword("_ALPHABLEND_ON");
+				material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
+				material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+				break;
+			case BlendMode.Transparent:
+				material.SetOverrideTag("RenderType", "Transparent");
+				material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
+				material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
+				material.SetInt("_ZWrite", 0);
+				material.DisableKeyword("_ALPHATEST_ON");
+				material.DisableKeyword("_ALPHABLEND_ON");
+				material.EnableKeyword("_ALPHAPREMULTIPLY_ON");
+				material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+				break;
+		}
+	}
+
+	static SmoothnessMapChannel GetSmoothnessMapChannel(Material material)
+	{
+		int ch = (int) material.GetFloat("_SmoothnessTextureChannel");
+		if (ch == (int) SmoothnessMapChannel.AlbedoAlpha)
+			return SmoothnessMapChannel.AlbedoAlpha;
+		else
+			return SmoothnessMapChannel.SpecularMetallicAlpha;
+	}
+
+	static bool ShouldEmissionBeEnabled(Material mat, Color color)
+	{
+		var realtimeEmission = (mat.globalIlluminationFlags & MaterialGlobalIlluminationFlags.RealtimeEmissive) > 0;
+		return color.maxColorComponent > 0.1f / 255.0f || realtimeEmission;
+	}
+
+	static void SetMaterialKeywords(Material material, WorkflowMode workflowMode)
+	{
+		// Note: keywords must be based on Material value not on MaterialProperty due to multi-edit & material animation
+		// (MaterialProperty value might come from renderer material property block)
+		SetKeyword (material, "_NORMALMAP", material.GetTexture ("_BumpMap") || material.GetTexture ("_DetailNormalMap"));
+		if (workflowMode == WorkflowMode.Specular)
+			SetKeyword (material, "_SPECGLOSSMAP", material.GetTexture ("_SpecGlossMap"));
+		else if (workflowMode == WorkflowMode.Metallic)
+			SetKeyword (material, "_METALLICGLOSSMAP", material.GetTexture ("_MetallicGlossMap"));
+		SetKeyword (material, "_PARALLAXMAP", material.GetTexture ("_ParallaxMap"));
+		SetKeyword (material, "_DETAIL_MULX2", material.GetTexture ("_DetailAlbedoMap") || material.GetTexture ("_DetailNormalMap"));
+
+		bool shouldEmissionBeEnabled = ShouldEmissionBeEnabled (material, material.GetColor("_EmissionColor"));
+		SetKeyword (material, "_EMISSION", shouldEmissionBeEnabled);
+
+		if (material.HasProperty("_SmoothnessTextureChannel"))
+		{
+			SetKeyword (material, "_SMOOTHNESS_TEXTURE_ALBEDO_CHANNEL_A", GetSmoothnessMapChannel(material) == SmoothnessMapChannel.AlbedoAlpha);
+		}
+
+		// Setup lightmap emissive flags
+		MaterialGlobalIlluminationFlags flags = material.globalIlluminationFlags;
+		if ((flags & (MaterialGlobalIlluminationFlags.BakedEmissive | MaterialGlobalIlluminationFlags.RealtimeEmissive)) != 0)
+		{
+			flags &= ~MaterialGlobalIlluminationFlags.EmissiveIsBlack;
+			if (!shouldEmissionBeEnabled)
+				flags |= MaterialGlobalIlluminationFlags.EmissiveIsBlack;
+
+			material.globalIlluminationFlags = flags;
+		}
+	}
+
+	bool HasValidEmissiveKeyword (Material material)
+	{
+		// Material animation might be out of sync with the material keyword.
+		// So if the emission support is disabled on the material, but the property blocks have a value that requires it, then we need to show a warning.
+		// (note: (Renderer MaterialPropertyBlock applies its values to emissionColorForRendering))
+		bool hasEmissionKeyword = material.IsKeywordEnabled ("_EMISSION");
+		if (!hasEmissionKeyword && ShouldEmissionBeEnabled (material, emissionColorForRendering.colorValue))
+			return false;
+		else
+			return true;
+	}
+
+	static void MaterialChanged(Material material, WorkflowMode workflowMode)
+	{
+		SetupMaterialWithBlendMode(material, (BlendMode)material.GetFloat("_Mode"));
+
+		SetMaterialKeywords(material, workflowMode);
+	}
+
+	static void SetKeyword(Material m, string keyword, bool state)
+	{
+		if (state)
+			m.EnableKeyword (keyword);
+		else
+			m.DisableKeyword (keyword);
+	}
+}
+
+} // namespace UnityEditor
--- a/Assets/ColorMask/Shaders/Editor/ColorMaskStandardShaderGUI.cs.meta
+++ b/Assets/ColorMask/Shaders/Editor/ColorMaskStandardShaderGUI.cs.meta
@ -0,0 +1,12 @@
+fileFormatVersion: 2
+guid: 57c815331559f6549a3f6d3c4f7102c1
+timeCreated: 1435093423
+licenseType: Store
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: