branch from classicDeferredMobile to add new render target functionality from Unity branch graphics/renderpass/staging

8 年前 · d1175b8d
--- a/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/ClassicDeferredPipeline.cs
+++ b/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/ClassicDeferredPipeline.cs
 	public Shader deferredShader;
 	public Shader deferredReflectionShader;

-	private static int s_GBufferAlbedo;
-	private static int s_GBufferSpecRough;
-	private static int s_GBufferNormal;
-	private static int s_GBufferEmission;
-	private static int s_GBufferRedF32;
-	private static int s_GBufferZ;
+	private static RenderPassAttachment s_GBufferAlbedo;
+	private static RenderPassAttachment s_GBufferSpecRough;
+	private static RenderPassAttachment s_GBufferNormal;
+	private static RenderPassAttachment s_GBufferEmission;
+	private static RenderPassAttachment s_GBufferZ;
+
+	private static RenderPassAttachment s_CameraTarget;
-	private static int s_CameraTarget;
-	private static int s_CameraDepthTexture;
+	//private static int s_GBufferRedF32;
+	//private static int s_CameraDepthTexture;

 	private Material m_DirectionalDeferredLightingMaterial;
 	private Material m_FiniteDeferredLightingMaterial;

 	public void Build()
 	{
-		s_GBufferAlbedo = Shader.PropertyToID ("_CameraGBufferTexture0");
-		s_GBufferSpecRough = Shader.PropertyToID ("_CameraGBufferTexture1");
-		s_GBufferNormal = Shader.PropertyToID ("_CameraGBufferTexture2");
-		s_GBufferEmission = Shader.PropertyToID ("_CameraGBufferTexture3");
-		s_GBufferRedF32 = Shader.PropertyToID ("_CameraVPDepth"); 
+		s_GBufferAlbedo = new RenderPassAttachment(RenderTextureFormat.ARGB32);
+		s_GBufferSpecRough = new RenderPassAttachment(RenderTextureFormat.ARGB32);
+		s_GBufferNormal = new RenderPassAttachment(RenderTextureFormat.ARGB2101010);
+		s_GBufferEmission = new RenderPassAttachment(RenderTextureFormat.ARGBHalf);
+		s_GBufferZ = new RenderPassAttachment(RenderTextureFormat.Depth);
+		s_CameraTarget = new RenderPassAttachment(RenderTextureFormat.ARGB32);
-		s_GBufferZ = Shader.PropertyToID ("_CameraGBufferZ"); // used while rendering into G-buffer+
-		s_CameraDepthTexture = Shader.PropertyToID ("_CameraDepthTexture"); // copy of that for later sampling in shaders
-		s_CameraTarget = Shader.PropertyToID ("_CameraTarget");
+		s_GBufferEmission.Clear(new Color(0.0f, 0.0f, 0.0f, 0.0f), 1.0f, 0);
+		s_GBufferZ.Clear(new Color(), 1.0f, 0);
+		s_CameraTarget.BindSurface(BuiltinRenderTextureType.CameraTarget, false, true);
+
+		// material setup
 		m_BlitMaterial = new Material (finalPassShader) { hideFlags = HideFlags.HideAndDontSave };

 		m_DirectionalDeferredLightingMaterial = new Material (deferredShader) { hideFlags = HideFlags.HideAndDontSave };

 	public void Render(ScriptableRenderContext context, IEnumerable<Camera> cameras)
 	{
+		RenderDeferred(context, cameras);
+
+		context.Submit ();
+	}
+	void RenderDeferred(ScriptableRenderContext context, IEnumerable<Camera> cameras)
+	{
+			var cullResults = CullResults.Cull (ref cullingParams, context);
+			RenderShadowMaps(cullResults, context);
-			var cullResults = CullResults.Cull (ref cullingParams, context);
-			ExecuteRenderLoop(camera, cullResults, context);
-		}
+			// Setup camera for rendering (sets render target, view/projection matrices and other
+			// per-camera built-in shader variables).
+			context.SetupCameraProperties(camera);
+
+			using (RenderPass rp = new RenderPass (context, camera.pixelWidth, camera.pixelHeight, 1, new[] { s_GBufferAlbedo, s_GBufferSpecRough, s_GBufferNormal, s_GBufferEmission, s_CameraTarget }, s_GBufferZ)) 
+			{
+				using (new RenderPass.SubPass(rp, new[] { s_GBufferAlbedo, s_GBufferSpecRough, s_GBufferNormal, s_GBufferEmission }, null))
+				{
+					using (var cmd = new CommandBuffer { name = "Create G-Buffer" } )
+					{
+						cmd.EnableShaderKeyword("UNITY_HDR_ON");
+
+						context.ExecuteCommandBuffer(cmd);
+					}
-		context.Submit ();
-	}
+					var settings = new DrawRendererSettings(cullResults, camera, new ShaderPassName("Deferred"))
+					{
+						sorting = { flags = SortFlags.CommonOpaque },
+						rendererConfiguration = RendererConfiguration.PerObjectLightmaps
-	void ExecuteRenderLoop(Camera camera, CullResults cullResults, ScriptableRenderContext loop)
-	{
-		RenderShadowMaps(cullResults, loop);
+					};
-		loop.SetupCameraProperties(camera);
-		RenderGBuffer(cullResults, camera, loop);
-	
-		//DepthOnlyForForwardOpaques(cullResults, camera, loop);
+					settings.inputFilter.SetQueuesOpaque();
+					context.DrawRenderers(ref settings);
+				}
-		// IF PLATFORM_MAC -- cannot use framebuffer fetch
-		#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
-		CopyDepthAfterGBuffer(loop);
-		#endif
+				PushGlobalShadowParams (context);
-		PushGlobalShadowParams (loop);
+				// lighting pass
+				using (new RenderPass.SubPass(rp, new[] { s_GBufferEmission }, new[] { s_GBufferAlbedo, s_GBufferSpecRough, s_GBufferNormal, s_GBufferZ }, true))
+				{
+					using (var cmd = new CommandBuffer { name = "Lighting and Reflections"} )
+					{
+						RenderLightGeometry (camera, cullResults, cmd, context);
+						RenderReflections (camera, cmd, cullResults, context);
-		RenderLighting (camera, cullResults, loop);
+						context.ExecuteCommandBuffer(cmd);
+					}
+				}
-		loop.DrawSkybox (camera);
+				using (new RenderPass.SubPass (rp, new[] { s_GBufferEmission }, null, true)) {
+					context.DrawSkybox (camera);
+				}
-		loop.SetupCameraProperties (camera);
+				//needed?
+				context.SetupCameraProperties(camera);
-		// present frame buffer.
-		FinalPass(loop);
-	}
+				using (new RenderPass.SubPass(rp, new[] { s_CameraTarget }, new[] { s_GBufferEmission }))
+				{
+					var cmd = new CommandBuffer { name = "FinalPass" };
-	static Matrix4x4 GetFlipMatrix()
-	{
-		Matrix4x4 flip = Matrix4x4.identity;
-		bool isLeftHand = ((int)LightDefinitions.USE_LEFTHAND_CAMERASPACE) != 0;
-		if (isLeftHand) flip.SetColumn(2, new Vector4(0.0f, 0.0f, -1.0f, 0.0f));
-		return flip;
-	}
+					cmd.DrawProcedural(new Matrix4x4(), m_BlitMaterial, 0, MeshTopology.Triangles, 3);
-	static Matrix4x4 WorldToCamera(Camera camera)
-	{
-		return GetFlipMatrix() * camera.worldToCameraMatrix;
+					context.ExecuteCommandBuffer(cmd);
+					cmd.Dispose();
+
+				}
+			}
+		}
+

 	void RenderReflections(Camera camera, CommandBuffer cmd, CullResults cullResults, ScriptableRenderContext loop)
 	{
 		m_Shadow3X3PCFTerms[3] = new Vector4(-flTexelEpsilonX, -flTexelEpsilonY, 0.0f, 0.0f);
 	}

-	static void SetupGBuffer(int width, int height, CommandBuffer cmd)
-	{
-		var format10 = RenderTextureFormat.ARGB32;
-		if (SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGB2101010))
-			format10 = RenderTextureFormat.ARGB2101010;
-		var formatHDR = RenderTextureFormat.DefaultHDR;
-
-		//@TODO: cleanup, right now only because we want to use unmodified Standard shader that encodes emission differently based on HDR or not,
-		// so we make it think we always render in HDR
-		cmd.EnableShaderKeyword ("UNITY_HDR_ON");
-
-		//@TODO: GetGraphicsCaps().buggyMRTSRGBWriteFlag
-		cmd.GetTemporaryRT(s_GBufferAlbedo, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default);
-		cmd.GetTemporaryRT(s_GBufferSpecRough, width, height, 0, FilterMode.Point, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Default);
-		cmd.GetTemporaryRT(s_GBufferNormal, width, height, 0, FilterMode.Point, format10, RenderTextureReadWrite.Linear);
-		cmd.GetTemporaryRT(s_GBufferEmission, width, height, 0, FilterMode.Point, formatHDR, RenderTextureReadWrite.Linear);
-		cmd.GetTemporaryRT(s_CameraDepthTexture, width, height, 24, FilterMode.Point, RenderTextureFormat.Depth);
-		cmd.GetTemporaryRT(s_CameraTarget, width, height, 0, FilterMode.Point, formatHDR, RenderTextureReadWrite.Default, 1, true); // rtv/uav
-
-		#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
-		cmd.GetTemporaryRT(s_GBufferZ, width, height, 24, FilterMode.Point, RenderTextureFormat.Depth);
-
-		var colorMRTs = new RenderTargetIdentifier[4] { s_GBufferAlbedo, s_GBufferSpecRough, s_GBufferNormal, s_GBufferEmission };
-		cmd.SetRenderTarget(colorMRTs, new RenderTargetIdentifier(s_GBufferZ));
-
-		#else
-		cmd.GetTemporaryRT(s_GBufferZ, width, height, 24, FilterMode.Point, RenderTextureFormat.Depth);
-		cmd.GetTemporaryRT(s_GBufferRedF32, width, height, 24, FilterMode.Point, RenderTextureFormat.RFloat);
-
-		var colorMRTs = new RenderTargetIdentifier[5] { s_GBufferAlbedo, s_GBufferSpecRough, s_GBufferNormal, s_GBufferEmission, s_GBufferRedF32 };
-		cmd.SetRenderTarget(colorMRTs, new RenderTargetIdentifier(s_GBufferZ));
-
-		#endif
-
-		cmd.ClearRenderTarget(true, true, new Color(0, 0, 0, 0));
-
-	}
-
-	static void RenderGBuffer(CullResults cull, Camera camera, ScriptableRenderContext loop)
-	{
-		// setup GBuffer for rendering
-		var cmd = new CommandBuffer { name = "Create G-Buffer" };
-		SetupGBuffer(camera.pixelWidth, camera.pixelHeight, cmd);
-		loop.ExecuteCommandBuffer(cmd);
-		cmd.Dispose();
-
-		// render opaque objects using Deferred pass
-		var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("Deferred"))
-		{
-			sorting = {flags = SortFlags.CommonOpaque},
-			rendererConfiguration = RendererConfiguration.PerObjectLightmaps
-		};
-
-		//@TODO: need to get light probes + LPPV too?
-		settings.inputFilter.SetQueuesOpaque();
-		settings.rendererConfiguration = RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
-		loop.DrawRenderers(ref settings);
-	}
-
-	void RenderLighting (Camera camera, CullResults inputs, ScriptableRenderContext loop)
-	{
-		var cmd = new CommandBuffer { name = "Lighting" };
-
-		// IF PLATFORM_MAC -- cannot use framebuffer fetch
-		#if UNITY_EDITOR_OSX || UNITY_STANDALONE_OSX
-		cmd.SetRenderTarget (new RenderTargetIdentifier (s_GBufferEmission), new RenderTargetIdentifier (s_GBufferZ));
-		#endif
-
-		RenderLightGeometry (camera, inputs, cmd, loop);
-
-		// TODO: UNITY_BRDF_PBS1 writes out alpha 1 to our emission alpha. Should preclear emission alpha after gbuffer pass in case this ever changes
-		RenderReflections (camera, cmd, inputs, loop);
-
-		loop.ExecuteCommandBuffer (cmd);
-		cmd.Dispose ();
-	}
-
 	void RenderLightGeometry (Camera camera, CullResults inputs, CommandBuffer cmd, ScriptableRenderContext loop)
 	{
 		int lightCount = inputs.visibleLights.Length;
 		//m_InvCosHalfSpotAngle = 1.0f / cs;
 	}

-	static void DepthOnlyForForwardOpaques(CullResults cull, Camera camera, ScriptableRenderContext loop)
+	static Matrix4x4 GetFlipMatrix()
-		var cmd = new CommandBuffer { name = "Forward Opaques - Depth Only" };
-		cmd.SetRenderTarget(new RenderTargetIdentifier(s_GBufferZ));
-		loop.ExecuteCommandBuffer(cmd);
-		cmd.Dispose();
-
-		// render opaque objects using Deferred pass
-		var settings = new DrawRendererSettings(cull, camera, new ShaderPassName("DepthOnly"))
-		{
-			sorting = { flags = SortFlags.CommonOpaque }
-		};
-		settings.inputFilter.SetQueuesOpaque();
-		loop.DrawRenderers(ref settings);
+		Matrix4x4 flip = Matrix4x4.identity;
+		bool isLeftHand = ((int)LightDefinitions.USE_LEFTHAND_CAMERASPACE) != 0;
+		if (isLeftHand) flip.SetColumn(2, new Vector4(0.0f, 0.0f, -1.0f, 0.0f));
+		return flip;
-	static void CopyDepthAfterGBuffer(ScriptableRenderContext loop)
+	static Matrix4x4 WorldToCamera(Camera camera)
-		var cmd = new CommandBuffer { name = "Copy depth" };
-		cmd.CopyTexture(new RenderTargetIdentifier(s_GBufferZ), new RenderTargetIdentifier(s_CameraDepthTexture));
-		loop.ExecuteCommandBuffer(cmd);
-		cmd.Dispose();
+		return GetFlipMatrix() * camera.worldToCameraMatrix;
-
-	void FinalPass(ScriptableRenderContext loop)
-	{
-		var cmd = new CommandBuffer { name = "FinalPass" };
-		cmd.Blit(s_GBufferEmission, BuiltinRenderTextureType.CameraTarget, m_BlitMaterial, 0);
-		loop.ExecuteCommandBuffer(cmd);
-		cmd.Dispose();
-	}
-
-
 }

--- a/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/Internal-DeferredReflections.shader
+++ b/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/Internal-DeferredReflections.shader
    return max(max(p - aabbMax, aabbMin - p), half3(0.0, 0.0, 0.0));
 }

-#ifdef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-void frag (unity_v2f_deferred i,
-	in half4 gbuffer0 : SV_Target0,
-	in half4 gbuffer1 : SV_Target1,
-	in half4 gbuffer2 : SV_Target2,
-	out half4 outEmission : SV_Target3, 
-	in float linearDepth : SV_Target4)
-#else
+
-#endif
-	#ifndef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-    	OnChipDeferredFragSetup(i, uv, viewPos, worldPos, 0.0);
-	#else
-    	OnChipDeferredFragSetup(i, uv, viewPos, worldPos, linearDepth);
-	#endif
+    float depth = UNITY_READ_FRAMEBUFFER_INPUT(3, i.pos);
+    OnChipDeferredFragSetup(i, uv, viewPos, worldPos, depth);
-#ifndef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-	// unpack Gbuffer
-	half4 gbuffer0 = tex2D (_CameraGBufferTexture0, uv);
-	half4 gbuffer1 = tex2D (_CameraGBufferTexture1, uv);
-	half4 gbuffer2 = tex2D (_CameraGBufferTexture2, uv);
-#endif
+	half4 gbuffer0 = UNITY_READ_FRAMEBUFFER_INPUT(0, i.pos);
+	half4 gbuffer1 = UNITY_READ_FRAMEBUFFER_INPUT(1, i.pos);
+	half4 gbuffer2 = UNITY_READ_FRAMEBUFFER_INPUT(2, i.pos);
-
-// ---

    half3 worldNormalRefl = reflect(eyeVec, data.normalWorld);

    half3 distance = distanceFromAABB(worldPos, unity_SpecCube0_BoxMin.xyz, unity_SpecCube0_BoxMax.xyz);
    half falloff = saturate(1.0 - length(distance)/blendDistance);

-    half4 ret = half4(rgb*falloff, 1-falloff);
-
-    //debug
+        //debug
-    // UNITY_BRDF_PBS1 writes out alpha 1 to our emission alpha. TODO: Should preclear emission alpha after gbuffer pass in case this ever changes
-    #ifdef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-    	outEmission = ret;
-    #else
-        return ret;
-    #endif
+    return half4(rgb*falloff, 1-falloff);
 }

 ENDCG
--- a/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/Internal-DeferredShading.shader
+++ b/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/Internal-DeferredShading.shader

 #include "LightingTemplate.hlsl"

-#ifdef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-void frag (unity_v2f_deferred i,
-	in half4 outGBuffer0 : SV_Target0,
-	in half4 outGBuffer1 : SV_Target1,
-	in half4 outGBuffer2 : SV_Target2,
-	out half4 outEmission : SV_Target3, 
-	in float outLinearDepth : SV_Target4)
-#else
+
-#endif
-	#ifdef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-		outEmission = CalculateLight(i, outGBuffer0, outGBuffer1, outGBuffer2, outLinearDepth);
-	#else
-		return CalculateLight(i);
-	#endif
+	return CalculateLight(i);
 }

 ENDCG
--- a/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/LightingTemplate.hlsl
+++ b/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/LightingTemplate.hlsl
 #define CUBEMAPFACE_POSITIVE_Z 4
 #define CUBEMAPFACE_NEGATIVE_Z 5

-sampler2D _CameraGBufferTexture0;
-sampler2D _CameraGBufferTexture1;
-sampler2D _CameraGBufferTexture2;
+UNITY_DECLARE_FRAMEBUFFER_INPUT_HALF(0);
+UNITY_DECLARE_FRAMEBUFFER_INPUT_HALF(1);
+UNITY_DECLARE_FRAMEBUFFER_INPUT_HALF(2);
+UNITY_DECLARE_FRAMEBUFFER_INPUT_FLOAT(3);

 // from LightDefinitions.cs.hlsl
 #define SPOT_LIGHT (0)
 	float2 uv = i.uv.xy / i.uv.w;
 	//float2 uv = i.pos.xy / float2(_ScreenParams.xy);

-	// read depth and reconstruct world position
-	// if we have framebuffer fetch, its expected depth was passed in the parameter from the framebuffer so no need to fetch
-	#ifndef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-		depth = SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, uv);
-	#endif
-
 	depth = Linear01Depth (depth);

 	//debug
 	outCookieColor = colorCookie;
 }

-#ifdef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-half4 CalculateLight (unity_v2f_deferred i, inout half4 gbuffer0, inout half4 gbuffer1, inout half4 gbuffer2, inout float vpDepth)
-#else
+
-#endif
 {
 	float3 wpos;
 	float2 uv;
 	UnityLight light;
 	UNITY_INITIALIZE_OUTPUT(UnityLight, light);
+	float depth = UNITY_READ_FRAMEBUFFER_INPUT(3, i.pos);
-#ifdef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-	OnChipDeferredCalculateLightParams (i, wpos, uv, light.dir, atten, fadeDist, colorCookie, vpDepth);
-#else
-	OnChipDeferredCalculateLightParams (i, wpos, uv, light.dir, atten, fadeDist, colorCookie, 0.0);
-#endif
+	OnChipDeferredCalculateLightParams (i, wpos, uv, light.dir, atten, fadeDist, colorCookie, depth);

 	#if defined (POINT_COOKIE) || defined (DIRECTIONAL_COOKIE) || defined (SPOT)
 		light.color = _LightColor.rgb * colorCookie.rgb * atten;

-#ifndef UNITY_FRAMEBUFFER_FETCH_AVAILABLE
-	// unpack Gbuffer
-	half4 gbuffer0 = tex2D (_CameraGBufferTexture0, uv);
-	half4 gbuffer1 = tex2D (_CameraGBufferTexture1, uv);
-	half4 gbuffer2 = tex2D (_CameraGBufferTexture2, uv);
-#endif
+	half4 gbuffer0 = UNITY_READ_FRAMEBUFFER_INPUT(0, i.pos);
+	half4 gbuffer1 = UNITY_READ_FRAMEBUFFER_INPUT(1, i.pos);
+	half4 gbuffer2 = UNITY_READ_FRAMEBUFFER_INPUT(2, i.pos);
+
 	UnityStandardData data = UnityStandardDataFromGbuffer(gbuffer0, gbuffer1, gbuffer2);

 	float3 eyeVec = normalize(wpos-_WorldSpaceCameraPos);
--- a/Assets/ScriptableRenderPipeline/fptl/FinalPass.shader
+++ b/Assets/ScriptableRenderPipeline/fptl/FinalPass.shader

 Shader "Hidden/FinalPass"
 {
-    Properties { _MainTex ("Texture", any) = "" {} }
    SubShader {
        Pass {
            ZTest Always Cull Off ZWrite Off
            #pragma fragment frag
-            #pragma target 2.0
+            #pragma target 3.5
-            sampler2D _MainTex;
-            uniform float4 _MainTex_ST;
-
-            struct appdata_t {
-                float4 vertex : POSITION;
-                float2 texcoord : TEXCOORD0;
-            };
+            struct v2f
+			{
+				float4 vertex : SV_Position;
+			};
-            struct v2f {
-                float4 vertex : SV_POSITION;
-                float2 texcoord : TEXCOORD0;
-            };
+			UNITY_DECLARE_FRAMEBUFFER_INPUT_HALF(0);
+ 
+			v2f vert(uint id : SV_VertexID)
+			{
+				v2f o;
+                o.vertex.x = (id & 1) != 0 ? 3 : -1;
+                o.vertex.y = (id & 2) != 0 ? -3 : 1;
+                o.vertex.z = 0;
+                o.vertex.w = 1;
+				return o;
+			}
-            v2f vert (appdata_t v)
-            {
-                v2f o;
-                o.vertex = UnityObjectToClipPos(v.vertex);
-                o.texcoord = TRANSFORM_TEX(v.texcoord.xy, _MainTex);
-                return o;
-            }
+			half4 frag(v2f i) : SV_Target
+			{
+    			return UNITY_READ_FRAMEBUFFER_INPUT(0, i.vertex);
+			}
-            fixed4 frag (v2f i) : SV_Target
-            {
-                return tex2D(_MainTex, i.texcoord);
-            }
            ENDCG

        }
--- a/Assets/TestScenes/MobileDeferredTest/ClassicDeferredTest.unity
+++ b/Assets/TestScenes/MobileDeferredTest/ClassicDeferredTest.unity
  m_FogDensity: 0.01
  m_LinearFogStart: 0
  m_LinearFogEnd: 300
-  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientSkyColor: {r: 0.2, g: 0.2, b: 0.2, a: 0}
-  m_SkyboxMaterial: {fileID: 2100000, guid: c7dc449c6cd0747f6b97d82bd85f08c6, type: 2}
+  m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
  m_HaloStrength: 0.5
  m_FlareStrength: 1
  m_FlareFadeSpeed: 3
  m_ReflectionIntensity: 1
  m_CustomReflection: {fileID: 0}
  m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.36928672, g: 0.28023016, b: 0.3261155, a: 1}
+  m_IndirectSpecularColor: {r: 0.18328291, g: 0.2289299, b: 0.30645376, a: 1}
 --- !u!157 &3
 LightmapSettings:
  m_ObjectHideFlags: 0
  - {fileID: 220495833}
  m_Father: {fileID: 0}
  m_RootOrder: 5
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &735392791
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 735392795}
+  - component: {fileID: 735392794}
+  - component: {fileID: 735392793}
+  - component: {fileID: 735392792}
+  m_Layer: 0
+  m_Name: Transperent Quad
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!23 &735392792
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 735392791}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: 667b8205a363441b8a0d18556bfb719b, 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!64 &735392793
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 735392791}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 2
+  m_Convex: 0
+  m_InflateMesh: 0
+  m_SkinWidth: 0.01
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!33 &735392794
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 735392791}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &735392795
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 735392791}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -72.9, y: 32.6, z: -129.3}
+  m_LocalScale: {x: 50, y: 50, z: 50}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 12
  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &736623251
 GameObject:
--- a/Assets/TestScenes/MobileDeferredTest/Materials/transperentAluminum.mat
+++ b/Assets/TestScenes/MobileDeferredTest/Materials/transperentAluminum.mat
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: transperentAluminum
+  m_Shader: {fileID: 4800000, guid: b262af00aeb504b0a8eba68d77150908, type: 3}
+  m_ShaderKeywords: _ALPHAPREMULTIPLY_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.227
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 10
+    - _GlossMapScale: 1
+    - _Glossiness: 0.496
+    - _GlossyReflections: 1
+    - _Metallic: 0.066
+    - _Mode: 3
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 0
+    m_Colors:
+    - _Color: {r: 0.8308824, g: 0.42155063, b: 0.42155063, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
--- a/Assets/TestScenes/MobileDeferredTest/Materials/transperentAluminum.mat.meta
+++ b/Assets/TestScenes/MobileDeferredTest/Materials/transperentAluminum.mat.meta
+fileFormatVersion: 2
+guid: 667b8205a363441b8a0d18556bfb719b
+timeCreated: 1494447555
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/HLSLSupport.cginc.meta
+++ b/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/HLSLSupport.cginc.meta
-fileFormatVersion: 2
-guid: 5cccb757ee7ed4a63aac84c8c8954a3f
-timeCreated: 1490056564
-licenseType: Pro
-ShaderImporter:
-  defaultTextures: []
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
--- a/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/HLSLSupport.cginc
+++ b/Assets/ScriptableRenderPipeline/MobileRenderPipeline/ClassicDeferred/HLSLSupport.cginc
-#ifndef HLSL_SUPPORT_INCLUDED
-#define HLSL_SUPPORT_INCLUDED
-
-// Define the underlying compiler being used. Skips this step if the compiler is already specified,
-// which may happen during development of new shader compiler for certain platform
-#if !defined(UNITY_COMPILER_CG) && !defined(UNITY_COMPILER_HLSL) && !defined(UNITY_COMPILER_HLSL2GLSL) && !defined(UNITY_COMPILER_HLSLCC)
-	#if defined(SHADER_TARGET_SURFACE_ANALYSIS)
-		// Cg is used for surface shader analysis step
-		#define UNITY_COMPILER_CG
-	#elif defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN)
-		// N.B. For Metal, the correct flags are set during internal shader compiler setup
-		#define UNITY_COMPILER_HLSL
-		#define UNITY_COMPILER_HLSLCC
-	#elif defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_D3D9) || defined(SHADER_API_XBOXONE)
-		#define UNITY_COMPILER_HLSL
-	#elif defined(SHADER_TARGET_GLSL) || defined(SHADER_API_WIIU)
-		#define UNITY_COMPILER_HLSL2GLSL
-	#else
-		#define UNITY_COMPILER_CG
-	#endif
-#endif
-
-#if defined(STEREO_MULTIVIEW_ON) && (defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE))
-#define UNITY_SUPPORT_MULTIVIEW
-#endif
-
-#if defined(UNITY_FRAMEBUFFER_FETCH_AVAILABLE) && defined(UNITY_FRAMEBUFFER_FETCH_ENABLED) && defined(UNITY_COMPILER_HLSLCC)
-// In the fragment shader, setting inout <type> var : SV_Target would result to
-// compiler error, unless SV_Target is defined to COLOR semantic for compatibility
-// reasons. Unfortunately, we still need to have a clear distinction between
-// vertex shader COLOR output and SV_Target, so the following workaround abuses
-// the fact that semantic names are case insensitive and preprocessor macros
-// are not. The resulting HLSL bytecode has semantics in case preserving form,
-// helps code generator to do extra work required for framebuffer fetch
-
-// You should always declare color inouts against SV_Target
-#define SV_Target CoLoR
-#define SV_Target0 CoLoR0
-#define SV_Target1 CoLoR1
-#define SV_Target2 CoLoR2
-#define SV_Target3 CoLoR3
-#define SV_Target4 CoLoR4
-#define SV_Target5 CoLoR5
-#define SV_Target6 CoLoR6
-#define SV_Target7 CoLoR7
-
-#define COLOR VCOLOR
-#define COLOR0 VCOLOR0
-#define COLOR1 VCOLOR1
-#define COLOR2 VCOLOR2
-#define COLOR3 VCOLOR3
-#define COLOR4 VCOLOR4
-#define COLOR5 VCOLOR5
-#define COLOR6 VCOLOR6
-#define COLOR7 VCOLOR7
-
-#endif
-
-// SV_Target[n] / SV_Depth defines, if not defined by compiler already
-#if !defined(SV_Target)
-#	if !defined(SHADER_API_XBOXONE)
-#		define SV_Target COLOR
-#	endif
-#endif
-#if !defined(SV_Target0)
-#	if !defined(SHADER_API_XBOXONE)
-#		define SV_Target0 COLOR0
-#	endif
-#endif
-#if !defined(SV_Target1)
-#	if !defined(SHADER_API_XBOXONE)
-#		define SV_Target1 COLOR1
-#	endif
-#endif
-#if !defined(SV_Target2)
-#	if !defined(SHADER_API_XBOXONE)
-#		define SV_Target2 COLOR2
-#	endif
-#endif
-#if !defined(SV_Target3)
-#	if !defined(SHADER_API_XBOXONE)
-#		define SV_Target3 COLOR3
-#	endif
-#endif
-#if !defined(SV_Target4)
-#	if defined(SHADER_API_PSSL)
-#		define SV_Target4 S_TARGET_OUTPUT4
-#	endif
-#endif
-#if !defined(SV_Target5)
-#	if defined(SHADER_API_PSSL)
-#		define SV_Target5 S_TARGET_OUTPUT5
-#	endif
-#endif
-#if !defined(SV_Target6)
-#	if defined(SHADER_API_PSSL)
-#		define SV_Target6 S_TARGET_OUTPUT6
-#	endif
-#endif
-#if !defined(SV_Target7)
-#	if defined(SHADER_API_PSSL)
-#		define SV_Target7 S_TARGET_OUTPUT7
-#	endif
-#endif
-#if !defined(SV_Depth)
-#	if !defined(SHADER_API_XBOXONE)
-#		define SV_Depth DEPTH
-#	endif
-#endif
-
-#if (defined(SHADER_API_GLES3) && !defined(SHADER_API_DESKTOP)) || defined(SHADER_API_D3D9) || defined(SHADER_API_GLES) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_PSP2) || defined(SHADER_API_N3DS)
-	#define UNITY_ALLOWED_MRT_COUNT 4
-#else
-	#define UNITY_ALLOWED_MRT_COUNT 8
-#endif
-
-#if (SHADER_TARGET < 30) || defined(SHADER_API_GLES3) || defined(SHADER_API_D3D9) || defined(SHADER_API_GLES) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_PSP2) || defined(SHADER_API_N3DS)
-	//no fast coherent dynamic branching on these hardware
-#else
-	#define UNITY_FAST_COHERENT_DYNAMIC_BRANCHING 1
-#endif
-
-// Disable warnings we aren't interested in
-#if defined(UNITY_COMPILER_HLSL)
-#pragma warning (disable : 3205) // conversion of larger type to smaller
-#pragma warning (disable : 3568) // unknown pragma ignored
-#pragma warning (disable : 3571) // "pow(f,e) will not work for negative f"; however in majority of our calls to pow we know f is not negative
-#pragma warning (disable : 3206) // implicit truncation of vector type
-#endif
-
-
-// Define "fixed" precision to be half on non-GLSL platforms,
-// and sampler*_prec to be just simple samplers.
-#if !defined(SHADER_TARGET_GLSL) && !defined(SHADER_API_PSSL) && !defined(SHADER_API_GLES3) && !defined(SHADER_API_VULKAN) && !(defined(SHADER_API_METAL) && defined(UNITY_COMPILER_HLSLCC))
-#define fixed half
-#define fixed2 half2
-#define fixed3 half3
-#define fixed4 half4
-#define fixed4x4 half4x4
-#define fixed3x3 half3x3
-#define fixed2x2 half2x2
-#define sampler2D_half sampler2D
-#define sampler2D_float sampler2D
-#define samplerCUBE_half samplerCUBE
-#define samplerCUBE_float samplerCUBE
-#define sampler3D_float sampler3D
-#define sampler3D_half sampler3D
-#define Texture2D_half Texture2D
-#define Texture2D_float Texture2D
-#define TextureCUBE_half TextureCUBE
-#define TextureCUBE_float TextureCUBE
-#define Texture3D_float Texture3D
-#define Texture3D_half Texture3D
-#endif
-
-#if defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN) || (defined(SHADER_API_METAL) && defined(UNITY_COMPILER_HLSLCC))
-// GLES3 and later via HLSLcc, use DX11.1 partial precision for translation
-// we specifically define fixed to be float16 (same as half) as all new GPUs seems to agree on float16 being minimal precision float
-#define fixed min16float
-#define fixed2 min16float2
-#define fixed3 min16float3
-#define fixed4 min16float4
-#define fixed4x4 min16float4x4
-#define fixed3x3 min16float3x3
-#define fixed2x2 min16float2x2
-#define half min16float
-#define half2 min16float2
-#define half3 min16float3
-#define half4 min16float4
-#define half2x2 min16float2x2
-#define half3x3 min16float3x3
-#define half4x4 min16float4x4
-#endif // defined(SHADER_API_GLES3) || defined(SHADER_API_VULKAN)
-
-
-// Define min16float/min10float to be half/fixed on non-D3D11 platforms.
-// This allows people to use min16float and friends in their shader code if they
-// really want to (making that will make shaders not load before DX11.1, e.g. on Win7,
-// but if they target WSA/WP exclusively that's fine).
-#if !defined(SHADER_API_D3D11) && !defined(SHADER_API_D3D11_9X) && !defined(SHADER_API_GLES3) && !defined(SHADER_API_VULKAN) && !(defined(SHADER_API_METAL) && defined(UNITY_COMPILER_HLSLCC))
-#define min16float half
-#define min16float2 half2
-#define min16float3 half3
-#define min16float4 half4
-#define min10float fixed
-#define min10float2 fixed2
-#define min10float3 fixed3
-#define min10float4 fixed4
-#endif
-
-#if defined(SHADER_API_PSP2)
-// The PSP2 cg compiler does not define uint<N>
-#define uint2 unsigned int2
-#define uint3 unsigned int3
-#define uint4 unsigned int4
-#endif
-
-// specifically for samplers that are provided as arguments to entry functions
-#if defined(SHADER_API_PSSL)
-#define SAMPLER_UNIFORM uniform
-#define SHADER_UNIFORM 
-#else
-#define SAMPLER_UNIFORM
-#endif
-
-#if defined(SHADER_API_PSSL)
-#define CBUFFER_START(name) ConstantBuffer name {
-#define CBUFFER_END };
-#elif defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X)
-#define CBUFFER_START(name) cbuffer name {
-#define CBUFFER_END };
-#elif defined(UNITY_SUPPORT_MULTIVIEW) || (defined(UNITY_SINGLE_PASS_STEREO) && defined(SHADER_API_GLCORE))
-#define CBUFFER_START(name) cbuffer name {
-#define CBUFFER_END };
-#else
-// On specific platforms, like OpenGL and GLES3, constant buffers may still be used for instancing
-#define CBUFFER_START(name)
-#define CBUFFER_END
-#endif
-
-#if defined(UNITY_SUPPORT_MULTIVIEW)
-// OVR_multiview
-// In order to convey this info over the DX compiler, we wrap it into a cbuffer.
-#define UNITY_DECLARE_MULTIVIEW(number_of_views) CBUFFER_START(OVR_multiview) uint gl_ViewID; uint numViews_##number_of_views; CBUFFER_END
-#define UNITY_VIEWID gl_ViewID
-#endif
-
-// Special declaration macro for requiring the extended blend functionality
-#if defined(SHADER_API_GLES3)
-// Declare the need for the KHR_blend_equation_advanced extension plus the specific blend mode (see the extension spec for list or "all_equations" for all)
-#define UNITY_REQUIRE_ADVANCED_BLEND(mode) uint hlslcc_blend_support_##mode
-#else
-#define UNITY_REQUIRE_ADVANCED_BLEND(mode)
-#endif
-
-
-#if defined(SHADER_API_PSP2)
-	// For tex2Dproj the PSP2 cg compiler doesn't like casting half3/4 to
-	// float3/4 with swizzle (optimizer generates invalid assembly), so declare
-	// explicit versions for half3/4
-	half4 tex2Dproj(sampler2D s, in half3 t)		{ return tex2D(s, t.xy / t.z); }
-	half4 tex2Dproj(sampler2D s, in half4 t)		{ return tex2D(s, t.xy / t.w); }
-
-	// As above but for sampling from single component textures, e.g. depth textures.
-	// NOTE that hardware PCF does not work with these versions, currently we have to ensure
-	// that tex coords for shadow sampling use float, not half; and for some reason casting half
-	// to float and using tex2Dproj also does not work.
-	half4 tex2DprojShadow(sampler2D s, in half3 t)		{ return tex2D<float>(s, t.xy / t.z); }
-	half4 tex2DprojShadow(sampler2D s, in half4 t)		{ return tex2D<float>(s, t.xy / t.w); }
-
-	// ...and versions of tex2DprojShadow for float uv.
-	half4 tex2DprojShadow(sampler2D s, in float3 t)		{ return tex2Dproj<float>(s, t); }
-	half4 tex2DprojShadow(sampler2D s, in float4 t)		{ return tex2Dproj<float>(s, t); }
-#endif
-
-
-#if defined(SHADER_API_PSP2)
-#define UNITY_BUGGY_TEX2DPROJ4
-#define UNITY_PROJ_COORD(a) (a).xyw
-#else
-#define UNITY_PROJ_COORD(a) a
-#endif
-
-
-// Depth texture sampling helpers.
-// On most platforms you can just sample them, but some (e.g. PSP2) need special handling.
-//
-// SAMPLE_DEPTH_TEXTURE(sampler,uv): returns scalar depth
-// SAMPLE_DEPTH_TEXTURE_PROJ(sampler,uv): projected sample
-// SAMPLE_DEPTH_TEXTURE_LOD(sampler,uv): sample with LOD level
-
-#if defined(SHADER_API_PSP2) && !defined(SHADER_API_PSM)
-#	define SAMPLE_DEPTH_TEXTURE(sampler, uv) (tex2D<float>(sampler, uv))
-#	define SAMPLE_DEPTH_TEXTURE_PROJ(sampler, uv) (tex2DprojShadow(sampler, uv))
-#	define SAMPLE_DEPTH_TEXTURE_LOD(sampler, uv) (tex2Dlod<float>(sampler, uv))
-#	define SAMPLE_RAW_DEPTH_TEXTURE(sampler, uv) SAMPLE_DEPTH_TEXTURE(sampler, uv)
-#	define SAMPLE_RAW_DEPTH_TEXTURE_PROJ(sampler, uv) SAMPLE_DEPTH_TEXTURE_PROJ(sampler, uv)
-#	define SAMPLE_RAW_DEPTH_TEXTURE_LOD(sampler, uv) SAMPLE_DEPTH_TEXTURE_LOD(sampler, uv)
-#else
-	// Sample depth, just the red component.
-#	define SAMPLE_DEPTH_TEXTURE(sampler, uv) (tex2D(sampler, uv).r)
-#	define SAMPLE_DEPTH_TEXTURE_PROJ(sampler, uv) (tex2Dproj(sampler, uv).r)
-#	define SAMPLE_DEPTH_TEXTURE_LOD(sampler, uv) (tex2Dlod(sampler, uv).r)
-	// Sample depth, all components.
-#	define SAMPLE_RAW_DEPTH_TEXTURE(sampler, uv) (tex2D(sampler, uv))
-#	define SAMPLE_RAW_DEPTH_TEXTURE_PROJ(sampler, uv) (tex2Dproj(sampler, uv))
-#	define SAMPLE_RAW_DEPTH_TEXTURE_LOD(sampler, uv) (tex2Dlod(sampler, uv))
-#endif
-
-// Deprecated; use SAMPLE_DEPTH_TEXTURE & SAMPLE_DEPTH_TEXTURE_PROJ instead
-#if defined(SHADER_API_PSP2)
-#	define UNITY_SAMPLE_DEPTH(value) (value).r
-#else
-#	define UNITY_SAMPLE_DEPTH(value) (value).r
-#endif
-
-
-// Macros to declare and sample shadow maps.
-//
-// UNITY_DECLARE_SHADOWMAP declares a shadowmap.
-// UNITY_SAMPLE_SHADOW samples with a float3 coordinate (UV in xy, Z in z) and returns 0..1 scalar result.
-// UNITY_SAMPLE_SHADOW_PROJ samples with a projected coordinate (UV and Z divided by w).
-
-
-#if !defined(SHADER_API_GLES)
-	// all platforms except GLES2.0 have built-in shadow comparison samplers
-	#define SHADOWS_NATIVE
-#elif defined(SHADER_API_GLES) && defined(UNITY_ENABLE_NATIVE_SHADOW_LOOKUPS)
-	// GLES2.0 also has built-in shadow comparison samplers, but only on platforms where we pass UNITY_ENABLE_NATIVE_SHADOW_LOOKUPS from the editor
-	#define SHADOWS_NATIVE
-#endif
-
-#if defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(UNITY_COMPILER_HLSLCC)
-	// DX11 & hlslcc platforms: built-in PCF
-	#if defined(SHADER_API_D3D11_9X)
-		// FL9.x has some bug where the runtime really wants resource & sampler to be bound to the same slot,
-		// otherwise it is skipping draw calls that use shadowmap sampling. Let's bind to #15
-		// and hope all works out.
-		#define UNITY_DECLARE_SHADOWMAP(tex) Texture2D tex : register(t15); SamplerComparisonState sampler##tex : register(s15)
-	#else
-		#define UNITY_DECLARE_SHADOWMAP(tex) Texture2D tex; SamplerComparisonState sampler##tex
-	#endif
-	#define UNITY_SAMPLE_SHADOW(tex,coord) tex.SampleCmpLevelZero (sampler##tex,(coord).xy,(coord).z)
-	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) tex.SampleCmpLevelZero (sampler##tex,(coord).xy/(coord).w,(coord).z/(coord).w)
-#elif defined(UNITY_COMPILER_HLSL2GLSL) && defined(SHADOWS_NATIVE)
-	// OpenGL-like hlsl2glsl platforms: most of them always have built-in PCF
-	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2DShadow tex
-	#define UNITY_SAMPLE_SHADOW(tex,coord) shadow2D (tex,(coord).xyz)
-	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) shadow2Dproj (tex,coord)
-#elif defined(SHADER_API_D3D9)
-	// D3D9: Native shadow maps FOURCC "driver hack", looks just like a regular
-	// texture sample. Have to always do a projected sample
-	// so that HLSL compiler doesn't try to be too smart and mess up swizzles
-	// (thinking that Z is unused).
-	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2D tex
-	#define UNITY_SAMPLE_SHADOW(tex,coord) tex2Dproj (tex,float4((coord).xyz,1)).r
-	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) tex2Dproj (tex,coord).r
-#elif defined(SHADER_API_PSSL)
-	// PS4: built-in PCF
-	#define UNITY_DECLARE_SHADOWMAP(tex)		Texture2D tex; SamplerComparisonState sampler##tex
-	#define UNITY_SAMPLE_SHADOW(tex,coord)		tex.SampleCmpLOD0(sampler##tex,(coord).xy,(coord).z)
-	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord)	tex.SampleCmpLOD0(sampler##tex,(coord).xy/(coord).w,(coord).z/(coord).w)
-#elif defined(SHADER_API_PSP2)
-	// Vita
-	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2D tex
-	// tex2d shadow comparison on Vita returns 0 instead of 1 when shadowCoord.z >= 1 causing artefacts in some tests.
-	// Clamping Z to the range 0.0 <= Z < 1.0 solves this.
-	#define UNITY_SAMPLE_SHADOW(tex,coord) tex2D<float>(tex, float3((coord).xy, clamp((coord).z, 0.0, 0.999999)))
-	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) tex2DprojShadow(tex, coord)
-#else
-	// Fallback / No built-in shadowmap comparison sampling: regular texture sample and do manual depth comparison
-	#define UNITY_DECLARE_SHADOWMAP(tex) sampler2D_float tex
-	#define UNITY_SAMPLE_SHADOW(tex,coord) ((SAMPLE_DEPTH_TEXTURE(tex,(coord).xy) < (coord).z) ? 0.0 : 1.0)
-	#define UNITY_SAMPLE_SHADOW_PROJ(tex,coord) ((SAMPLE_DEPTH_TEXTURE_PROJ(tex,UNITY_PROJ_COORD(coord)) < ((coord).z/(coord).w)) ? 0.0 : 1.0)
-#endif
-
-
-// Macros to declare textures and samplers, possibly separately. For platforms
-// that have separate samplers & textures (like DX11), and we'd want to conserve
-// the samplers.
-//	- UNITY_DECLARE_TEX*_NOSAMPLER declares a texture, without a sampler.
-//	- UNITY_SAMPLE_TEX*_SAMPLER samples a texture, using sampler from another texture.
-//		That another texture must also be actually used in the current shader, otherwise
-//		the correct sampler will not be set.
-#if defined(SHADER_API_D3D11) || defined(SHADER_API_XBOXONE) || defined(UNITY_COMPILER_HLSLCC) || defined(SHADER_API_PSSL)
-	// DX11 style HLSL syntax; separate textures and samplers
-	// NB for HLSLcc we have special unity-specific syntax to pass sampler precision information
-
-	// 2D textures
-	#define UNITY_DECLARE_TEX2D(tex) Texture2D tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER(tex) Texture2D tex
-	#define UNITY_SAMPLE_TEX2D(tex,coord) tex.Sample (sampler##tex,coord)
-	#define UNITY_SAMPLE_TEX2D_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
-
-#if defined(UNITY_COMPILER_HLSLCC) && !defined(SHADER_API_GLCORE) // GL Core doesn't have the _half mangling, the rest of them do.
-	#define UNITY_DECLARE_TEX2D_HALF(tex) Texture2D_half tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX2D_FLOAT(tex) Texture2D_float tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER_HALF(tex) Texture2D_half tex
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER_FLOAT(tex) Texture2D_float tex
-#else
-	#define UNITY_DECLARE_TEX2D_HALF(tex) Texture2D tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX2D_FLOAT(tex) Texture2D tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER_HALF(tex) Texture2D tex
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER_FLOAT(tex) Texture2D tex
-#endif
-
-	// Cubemaps
-	#define UNITY_DECLARE_TEXCUBE(tex) TextureCube tex; SamplerState sampler##tex
-	#define UNITY_ARGS_TEXCUBE(tex) TextureCube tex, SamplerState sampler##tex
-	#define UNITY_PASS_TEXCUBE(tex) tex, sampler##tex
-	#define UNITY_PASS_TEXCUBE_SAMPLER(tex,samplertex) tex, sampler##samplertex
-	#define UNITY_PASS_TEXCUBE_SAMPLER_LOD(tex, samplertex, lod) tex, sampler##samplertex, lod
-	#define UNITY_DECLARE_TEXCUBE_NOSAMPLER(tex) TextureCube tex
-	#define UNITY_SAMPLE_TEXCUBE(tex,coord) tex.Sample (sampler##tex,coord)
-	#define UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
-	#define UNITY_SAMPLE_TEXCUBE_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
-	#define UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(tex, samplertex, coord, lod) tex.SampleLevel (sampler##samplertex, coord, lod)
-	// 3D textures
-	#define UNITY_DECLARE_TEX3D(tex) Texture3D tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX3D_NOSAMPLER(tex) Texture3D tex
-	#define UNITY_SAMPLE_TEX3D(tex,coord) tex.Sample (sampler##tex,coord)
-	#define UNITY_SAMPLE_TEX3D_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
-	#define UNITY_SAMPLE_TEX3D_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
-	#define UNITY_SAMPLE_TEX3D_SAMPLER_LOD(tex, samplertex, coord, lod) tex.SampleLevel(sampler##samplertex, coord, lod)
-
-#if defined(UNITY_COMPILER_HLSLCC) && !defined(SHADER_API_GLCORE) // GL Core doesn't have the _half mangling, the rest of them do.
-	#define UNITY_DECLARE_TEX3D_FLOAT(tex) Texture3D_float tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX3D_HALF(tex) Texture3D_half tex; SamplerState sampler##tex
-#else
-	#define UNITY_DECLARE_TEX3D_FLOAT(tex) Texture3D tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX3D_HALF(tex) Texture3D tex; SamplerState sampler##tex
-#endif
-
-	// 2D arrays
-	#define UNITY_DECLARE_TEX2DARRAY(tex) Texture2DArray tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) Texture2DArray tex
-	#define UNITY_ARGS_TEX2DARRAY(tex) Texture2DArray tex, SamplerState sampler##tex
-	#define UNITY_PASS_TEX2DARRAY(tex) tex, sampler##tex
-	#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) tex.Sample (sampler##tex,coord)
-	#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
-	#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
-	#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex.SampleLevel (sampler##samplertex,coord,lod)
-	
-	// Cube arrays
-	#define UNITY_DECLARE_TEXCUBEARRAY(tex) TextureCubeArray tex; SamplerState sampler##tex
-	#define UNITY_DECLARE_TEXCUBEARRAY_NOSAMPLER(tex) TextureCubeArray tex
-	#define UNITY_ARGS_TEXCUBEARRAY(tex) TextureCubeArray tex, SamplerState sampler##tex
-	#define UNITY_PASS_TEXCUBEARRAY(tex) tex, sampler##tex
-#if defined(SHADER_API_PSSL)
-	// round the layer index to get DX11-like behaviour (otherwise fractional indices result in mixed up cubemap faces)
-	#define UNITY_SAMPLE_TEXCUBEARRAY(tex,coord) tex.Sample (sampler##tex,float4((coord).xyz, round((coord).w)))
-	#define UNITY_SAMPLE_TEXCUBEARRAY_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,float4((coord).xyz, round((coord).w)), lod)
-	#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,float4((coord).xyz, round((coord).w)))
-	#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex.SampleLevel (sampler##samplertex,float4((coord).xyz, round((coord).w)), lod)		
-#else
-	#define UNITY_SAMPLE_TEXCUBEARRAY(tex,coord) tex.Sample (sampler##tex,coord)
-	#define UNITY_SAMPLE_TEXCUBEARRAY_LOD(tex,coord,lod) tex.SampleLevel (sampler##tex,coord, lod)
-	#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER(tex,samplertex,coord) tex.Sample (sampler##samplertex,coord)
-	#define UNITY_SAMPLE_TEXCUBEARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex.SampleLevel (sampler##samplertex,coord,lod)
-#endif	
-
-	
-#else
-	// DX9 style HLSL syntax; same object for texture+sampler
-	// 2D textures
-	#define UNITY_DECLARE_TEX2D(tex) sampler2D tex
-	#define UNITY_DECLARE_TEX2D_HALF(tex) sampler2D_half tex
-	#define UNITY_DECLARE_TEX2D_FLOAT(tex) sampler2D_float tex
-
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER(tex) sampler2D tex
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER_HALF(tex) sampler2D_half tex
-	#define UNITY_DECLARE_TEX2D_NOSAMPLER_FLOAT(tex) sampler2D_float tex
-
-	#define UNITY_SAMPLE_TEX2D(tex,coord) tex2D (tex,coord)
-	#define UNITY_SAMPLE_TEX2D_SAMPLER(tex,samplertex,coord) tex2D (tex,coord)
-	// Cubemaps
-	#define UNITY_DECLARE_TEXCUBE(tex) samplerCUBE tex
-	#define UNITY_ARGS_TEXCUBE(tex) samplerCUBE tex
-	#define UNITY_PASS_TEXCUBE(tex) tex
-	#define UNITY_PASS_TEXCUBE_SAMPLER(tex,samplertex) tex
-	#define UNITY_DECLARE_TEXCUBE_NOSAMPLER(tex) samplerCUBE tex
-	#define UNITY_SAMPLE_TEXCUBE(tex,coord) texCUBE (tex,coord)
-
-	// DX9 with SM2.0, and DX11 FL 9.x do not have texture LOD sampling.
-	// We will approximate that with mip bias (very poor approximation, but not much we can do)
-	#if ((SHADER_TARGET < 25) && defined(SHADER_API_D3D9)) || defined(SHADER_API_D3D11_9X)
-	#	define UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod) texCUBEbias(tex, half4(coord, lod))
-	#	define UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(tex,samplertex,coord,lod) UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod)
-	#else
-	#	define UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod) texCUBElod (tex, half4(coord, lod))
-	#	define UNITY_SAMPLE_TEXCUBE_SAMPLER_LOD(tex,samplertex,coord,lod) UNITY_SAMPLE_TEXCUBE_LOD(tex,coord,lod)
-	#endif
-	#define UNITY_SAMPLE_TEXCUBE_SAMPLER(tex,samplertex,coord) texCUBE (tex,coord)
-
-	// 3D textures
-	#define UNITY_DECLARE_TEX3D(tex) sampler3D tex
-	#define UNITY_DECLARE_TEX3D_NOSAMPLER(tex) sampler3D tex
-	#define UNITY_DECLARE_TEX3D_FLOAT(tex) sampler3D_float tex
-	#define UNITY_DECLARE_TEX3D_HALF(tex) sampler3D_float tex
-	#define UNITY_SAMPLE_TEX3D(tex,coord) tex3D (tex,coord)
-	#define UNITY_SAMPLE_TEX3D_LOD(tex,coord,lod) tex3D (tex,float4(coord,lod))
-	#define UNITY_SAMPLE_TEX3D_SAMPLER(tex,samplertex,coord) tex3D (tex,coord)
-	#define UNITY_SAMPLE_TEX3D_SAMPLER_LOD(tex,samplertex,coord,lod) tex3D (tex,float4(coord,lod))
-
-	// 2D array syntax for hlsl2glsl and surface shader analysis
-	#if defined(UNITY_COMPILER_HLSL2GLSL) || defined(SHADER_TARGET_SURFACE_ANALYSIS)
-		#define UNITY_DECLARE_TEX2DARRAY(tex) sampler2DArray tex
-		#define UNITY_DECLARE_TEX2DARRAY_NOSAMPLER(tex) sampler2DArray tex
-		#define UNITY_ARGS_TEX2DARRAY(tex) sampler2DArray tex
-		#define UNITY_PASS_TEX2DARRAY(tex) tex
-		#define UNITY_SAMPLE_TEX2DARRAY(tex,coord) tex2DArray (tex,coord)
-		#define UNITY_SAMPLE_TEX2DARRAY_LOD(tex,coord,lod) tex2DArraylod (tex, float4(coord,lod))
-		#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER(tex,samplertex,coord) tex2DArray (tex,coord)
-		#define UNITY_SAMPLE_TEX2DARRAY_SAMPLER_LOD(tex,samplertex,coord,lod) tex2DArraylod (tex, float4(coord,lod))
-	#endif
-
-	// surface shader analysis; just pretend that 2D arrays are cubemaps
-	#if defined(SHADER_TARGET_SURFACE_ANALYSIS)
-		#define sampler2DArray samplerCUBE
-		#define tex2DArray texCUBE
-		#define tex2DArraylod texCUBElod
-	#endif
-
-#endif
-
-// For backwards compatibility, so we won't accidentally break shaders written by user
-#define SampleCubeReflection(env, dir, lod) UNITY_SAMPLE_TEXCUBE_LOD(env, dir, lod)
-
-
-#define samplerRECT sampler2D
-#define texRECT tex2D
-#define texRECTlod tex2Dlod
-#define texRECTbias tex2Dbias
-#define texRECTproj tex2Dproj
-
-#if defined(SHADER_API_PSSL)
-#define VPOS			S_POSITION
-#elif defined(UNITY_COMPILER_CG)
-// Cg seems to use WPOS instead of VPOS semantic?
-#define VPOS WPOS
-// Cg does not have tex2Dgrad and friends, but has tex2D overload that
-// can take the derivatives
-#define tex2Dgrad tex2D
-#define texCUBEgrad texCUBE
-#define tex3Dgrad tex3D
-#endif
-
-
-// Data type to be used for "screen space position" pixel shader input semantic;
-// D3D9 needs it to be float2, unlike all other platforms.
-#if defined(SHADER_API_D3D9)
-#define UNITY_VPOS_TYPE float2
-#else
-#define UNITY_VPOS_TYPE float4
-#endif
-
-
-
-#if defined(UNITY_COMPILER_HLSL) || defined (SHADER_TARGET_GLSL)
-#define FOGC FOG
-#endif
-
-// Use VFACE pixel shader input semantic in your shaders to get front-facing scalar value.
-// Requires shader model 3.0 or higher.
-#if defined(UNITY_COMPILER_CG)
-#define VFACE FACE
-#endif
-#if defined(UNITY_COMPILER_HLSL2GLSL)
-#define FACE VFACE
-#endif
-#if defined(SHADER_API_PSSL)
-#define VFACE S_FRONT_FACE
-#endif
-// Is VFACE affected by flipped projection?
-#if defined(SHADER_API_D3D9) || defined(SHADER_API_PSSL)
-#define UNITY_VFACE_AFFECTED_BY_PROJECTION 1
-#endif
-
-
-#if !defined(SHADER_API_D3D11) && !defined(SHADER_API_D3D11_9X) && !defined(UNITY_COMPILER_HLSLCC) && !defined(SHADER_API_PSSL)
-#define SV_POSITION POSITION
-#endif
-
-// Declare position that is also available for read in fragment shader
-#if defined(SHADER_API_D3D9) && defined(SHADER_STAGE_FRAGMENT) && SHADER_TARGET >= 30
-#define UNITY_POSITION(pos) float4 pos : VPOS
-#else
-// On D3D reading screen space coordinates from fragment shader requires SM3.0
-#define UNITY_POSITION(pos) float4 pos : SV_POSITION
-#endif
-
-#if defined(SHADER_API_D3D9) || defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_PSP2) || defined(SHADER_API_PSSL)
-#define UNITY_ATTEN_CHANNEL r
-#else
-#define UNITY_ATTEN_CHANNEL a
-#endif
-
-#if defined(SHADER_API_D3D9) || defined(SHADER_API_D3D11) || defined(SHADER_API_D3D11_9X) || defined(SHADER_API_PSP2) || defined(SHADER_API_PSSL) || defined(SHADER_API_METAL) || defined(SHADER_API_WIIU) || defined(SHADER_API_VULKAN)
-#define UNITY_UV_STARTS_AT_TOP 1
-#endif
-
-#if defined(SHADER_API_D3D11) || defined(SHADER_API_PSSL) || defined(SHADER_API_XBOXONE) || defined(SHADER_API_METAL) || defined(SHADER_API_VULKAN)
-#define UNITY_REVERSED_Z 1
-#endif
-
-#if defined(UNITY_REVERSED_Z)
-#define UNITY_NEAR_CLIP_VALUE (1.0)
-#elif defined(SHADER_API_D3D9)  || defined(SHADER_API_WIIU) || defined(SHADER_API_D3D11_9X)
-#define UNITY_NEAR_CLIP_VALUE (0.0)
-#else
-#define UNITY_NEAR_CLIP_VALUE (-1.0)
-#endif
-
-// "platform caps" defines that were moved to editor, so they are set automatically when compiling shader
-// UNITY_NO_DXT5nm				- no DXT5NM support, so normal maps will encoded in rgb
-// UNITY_NO_RGBM				- no RGBM support, so doubleLDR
-// UNITY_NO_SCREENSPACE_SHADOWS	- no screenspace cascaded shadowmaps
-// UNITY_FRAMEBUFFER_FETCH_AVAILABLE	- framebuffer fetch
-// UNITY_ENABLE_REFLECTION_BUFFERS - render reflection probes in deferred way, when using deferred shading
-
-
-#if defined(SHADER_API_PSP2)
-// To get acceptable precision from the SGX interpolators when decoding RGBM type
-// textures we have to disable sRGB reads and then convert to gamma space in the shader
-// explicitly.
-#define UNITY_FORCE_LINEAR_READ_FOR_RGBM
-#endif
-
-
-// On most platforms, use floating point render targets to store depth of point
-// light shadowmaps. However, on some others they either have issues, or aren't widely
-// supported; in which case fallback to encoding depth into RGBA channels.
-// Make sure this define matches GraphicsCaps.useRGBAForPointShadows.
-#if defined(SHADER_API_GLES) || defined(SHADER_API_GLES3) || defined(SHADER_API_PSP2)
-#define UNITY_USE_RGBA_FOR_POINT_SHADOWS
-#endif
-
-
-// Initialize arbitrary structure with zero values.
-// Not supported on some backends (e.g. Cg-based particularly with nested structs).
-// hlsl2glsl would almost support it, except with structs that have arrays -- so treat as not supported there either :(
-#if defined(UNITY_COMPILER_HLSL) || defined(SHADER_API_PSSL) || defined(UNITY_COMPILER_HLSLCC)
-#define UNITY_INITIALIZE_OUTPUT(type,name) name = (type)0;
-#else
-#define UNITY_INITIALIZE_OUTPUT(type,name)
-#endif
-
-#if defined(SHADER_API_D3D11) || defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE) || defined(SHADER_API_VULKAN) || defined(SHADER_API_PSSL)
-#define UNITY_CAN_COMPILE_TESSELLATION 1
-#	define UNITY_domain					domain
-#	define UNITY_partitioning			partitioning
-#	define UNITY_outputtopology			outputtopology
-#	define UNITY_patchconstantfunc		patchconstantfunc
-#	define UNITY_outputcontrolpoints	outputcontrolpoints
-#endif
-
-// Not really needed anymore, but did ship in Unity 4.0; with D3D11_9X remapping them to .r channel.
-// Now that's not used.
-#define UNITY_SAMPLE_1CHANNEL(x,y) tex2D(x,y).a
-#define UNITY_ALPHA_CHANNEL a
-
-
-// HLSL attributes
-#if defined(UNITY_COMPILER_HLSL)
-	#define UNITY_BRANCH	[branch]
-	#define UNITY_FLATTEN	[flatten]
-	#define UNITY_UNROLL	[unroll]
-	#define UNITY_LOOP		[loop]
-	#define UNITY_FASTOPT	[fastopt]
-#else
-	#define UNITY_BRANCH
-	#define UNITY_FLATTEN
-	#define UNITY_UNROLL
-	#define UNITY_LOOP
-	#define UNITY_FASTOPT
-#endif
-
-
-// Unity 4.x shaders used to mostly work if someone used WPOS semantic,
-// which was accepted by Cg. The correct semantic to use is "VPOS",
-// so define that so that old shaders keep on working.
-#if !defined(UNITY_COMPILER_CG)
-#define WPOS VPOS
-#endif
-
-// define use to identify platform with modern feature like texture 3D with filtering, texture array etc...
-#define UNITY_SM40_PLUS_PLATFORM (!((SHADER_TARGET < 30) || defined (SHADER_API_MOBILE) || defined(SHADER_API_D3D9) || defined(SHADER_API_D3D11_9X) || defined (SHADER_API_PSP2) || defined(SHADER_API_GLES)))
-
-// Ability to manually set descriptor set and binding numbers (Vulkan only)
-#if defined(SHADER_API_VULKAN)
-	#define CBUFFER_START_WITH_BINDING(Name, Set, Binding) CBUFFER_START(Name##Xhlslcc_set_##Set##_bind_##Binding##X)
-	// Sampler / image declaration with set/binding decoration 
-	#define DECL_WITH_BINDING(Type, Name, Set, Binding) Type Name##hlslcc_set_##Set##_bind_##Binding
-#else
-	#define CBUFFER_START_WITH_BINDING(Name, Set, Binding) CBUFFER_START(Name)
-	#define DECL_WITH_BINDING(Type, Name, Set, Binding) Type Name
-#endif
-
-// ---- Shader keyword backwards compatibility
-// We used to have some built-in shader keywords, but they got removed at some point to save on shader keyword count.
-// However some existing shader code might be checking for the old names, so define them as regular
-// macros based on other criteria -- so that existing code keeps on working.
-
-// Unity 5.0 renamed HDR_LIGHT_PREPASS_ON to UNITY_HDR_ON
-#if defined(UNITY_HDR_ON)
-#define HDR_LIGHT_PREPASS_ON 1
-#endif
-
-// UNITY_NO_LINEAR_COLORSPACE was removed in 5.4 when UNITY_COLORSPACE_GAMMA was introduced as a platform keyword and runtime gamma fallback removed.
-#if !defined(UNITY_NO_LINEAR_COLORSPACE) && defined(UNITY_COLORSPACE_GAMMA)
-#define UNITY_NO_LINEAR_COLORSPACE 1
-#endif
-
-#if !defined(DIRLIGHTMAP_OFF) && !defined(DIRLIGHTMAP_COMBINED)
-#define DIRLIGHTMAP_OFF 1
-#endif
-
-#if !defined(LIGHTMAP_OFF) && !defined(LIGHTMAP_ON)
-#define LIGHTMAP_OFF 1
-#endif
-
-#if !defined(DYNAMICLIGHTMAP_OFF) && !defined(DYNAMICLIGHTMAP_ON)
-#define DYNAMICLIGHTMAP_OFF 1
-#endif
-
-
-#if defined (SHADER_API_D3D11) && defined(STEREO_INSTANCING_ON)
-
-	#undef UNITY_DECLARE_DEPTH_TEXTURE
-	#define UNITY_DECLARE_DEPTH_TEXTURE(tex) Texture2DArray tex; SamplerState sampler##tex
-
-	#undef SAMPLE_DEPTH_TEXTURE
-	#define SAMPLE_DEPTH_TEXTURE(tex, uv) UNITY_SAMPLE_TEX2DARRAY(tex, float3(uv.x, uv.y, (float)unity_StereoEyeIndex)).r
-
-	#undef SAMPLE_DEPTH_TEXTURE_PROJ
-	#define SAMPLE_DEPTH_TEXTURE_PROJ(tex, uv) UNITY_SAMPLE_TEX2DARRAY(tex, float3(uv.x/uv.w, uv.y/uv.w, (float)unity_StereoEyeIndex)).r
-
-	#define UNITY_DECLARE_SCREENSPACE_SHADOWMAP UNITY_DECLARE_TEX2DARRAY
-	#define UNITY_SAMPLE_SCREEN_SHADOW(tex, uv) UNITY_SAMPLE_TEX2DARRAY( tex, float3(uv.x/uv.w, uv.y/uv.w, (float)unity_StereoEyeIndex) ).r
-
-#else
-	#define UNITY_DECLARE_DEPTH_TEXTURE(tex) sampler2D_float tex
-	#define UNITY_DECLARE_SCREENSPACE_SHADOWMAP(tex) sampler2D tex
-	#define UNITY_SAMPLE_SCREEN_SHADOW(tex, uv) tex2Dproj( tex, UNITY_PROJ_COORD(uv) ).r
-#endif
-
-#endif // HLSL_SUPPORT_INCLUDED