(wip) Prepass for transparent

7 年前 · 722dee63
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

    public partial class HDRenderPipeline : RenderPipeline
    {
+        enum ForwardPass
+        {
+            Opaque,
+            PreTransparent,
+            Transparent
+        }
+
+        static readonly RenderQueueRange k_RenderQueue_PreTransparent = new RenderQueueRange { min = (int)HDRenderQueue.GeometryLast + 1, max = (int)HDRenderQueue.PreTransparent };
+        static readonly RenderQueueRange k_RenderQueue_Transparent = new RenderQueueRange { min = (int)HDRenderQueue.PreTransparent + 1, max = 5000 };
+
        readonly HDRenderPipelineAsset m_Asset;

        readonly RenderPipelineMaterial m_DeferredMaterial;
                // therefore, forward-rendered objects do not output split lighting required for the SSS pass.
                SubsurfaceScatteringPass(hdCamera, cmd, sssSettings);

-                RenderForward(m_CullResults, camera, renderContext, cmd, true);
-                RenderForwardError(m_CullResults, camera, renderContext, cmd, true);
+                RenderForward(m_CullResults, camera, renderContext, cmd, ForwardPass.Opaque);
+                RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Opaque);
-                RenderGaussianPyramidColor(camera, cmd);
-
+                cmd.Blit(m_CameraColorBufferRT, m_GaussianPyramidColorBuffer);
+
+                // Render pre transparent objects
+                RenderForward(m_CullResults, camera, renderContext, cmd, ForwardPass.PreTransparent);
+                RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.PreTransparent);
+
+                RenderGaussianPyramidColor(camera, cmd);
+
-                RenderForward(m_CullResults, camera, renderContext, cmd, false);
-                RenderForwardError(m_CullResults, camera, renderContext, cmd, false);
+                RenderForward(m_CullResults, camera, renderContext, cmd, ForwardPass.Transparent);
+                RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.Transparent);

                // Render volumetric lighting
                VolumetricLightingPass(hdCamera, cmd);
                                         ShaderPassName          passName,
                                         RendererConfiguration   rendererConfiguration = 0,
                                         RenderStateBlock?       stateBlock = null,
-                                         Material                overrideMaterial = null)
+                                         Material                overrideMaterial = null,
+                                         bool                    preTransparentQueue = false)
-            RenderTransparentRenderList(cull, camera, renderContext, cmd, m_SinglePassName, rendererConfiguration, stateBlock, overrideMaterial);
+            RenderTransparentRenderList(cull, camera, renderContext, cmd, m_SinglePassName, 
+                rendererConfiguration, stateBlock, overrideMaterial, preTransparentQueue);
        }

        void RenderTransparentRenderList(CullResults             cull,
                                         ShaderPassName[]        passNames,
                                         RendererConfiguration   rendererConfiguration = 0,
                                         RenderStateBlock?       stateBlock = null,
-                                         Material                overrideMaterial = null)
+                                         Material                overrideMaterial = null,
+                                         bool                    preTransparentQueue = false)
        {
            if (!m_CurrentDebugDisplaySettings.renderingDebugSettings.displayTransparentObjects)
                return;
            if (overrideMaterial != null)
                drawSettings.SetOverrideMaterial(overrideMaterial, 0);

-            var filterSettings = new FilterRenderersSettings(true) {renderQueueRange = RenderQueueRange.transparent};
+            var filterSettings = new FilterRenderersSettings(true)
+            {
+                renderQueueRange = preTransparentQueue 
+                    ? k_RenderQueue_PreTransparent 
+                    : k_RenderQueue_Transparent
+            };

            if(stateBlock == null)
                renderContext.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);
        }

        // Render forward is use for both transparent and opaque objects. In case of deferred we can still render opaque object in forward.
-        void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool renderOpaque)
+        void RenderForward(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ForwardPass pass)
        {
            // Guidelines: In deferred by default there is no opaque in forward. However it is possible to force an opaque material to render in forward
            // by using the pass "ForwardOnly". In this case the .shader should not have "Forward" but only a "ForwardOnly" pass.
            string profileName;
            if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
            {
-                profileName = renderOpaque ? "Forward Opaque Debug Display" : "Forward Transparent Debug Display";
+                profileName = string.Format("Forward {0} Debug Display", pass);
-                profileName = renderOpaque ? "Forward Opaque" : "Forward Transparent";
+                profileName = string.Format("Forward {0} Display", pass);
            }

            using (new ProfilingSample(cmd, profileName))
-                m_LightLoop.RenderForward(camera, cmd, renderOpaque);
+                m_LightLoop.RenderForward(camera, cmd, pass == ForwardPass.Opaque);

                if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
                {
                    m_ForwardAndForwardOnlyPassNames[1] = HDShaderPassNames.s_ForwardName;
                }

-
-                if (renderOpaque)
+                if (pass == ForwardPass.Opaque)
                {
                    var passNames = m_Asset.renderingSettings.ShouldUseForwardRenderingOnly() ? m_ForwardAndForwardOnlyPassNames : m_ForwardOnlyPassNames;
                    // Forward opaque material always have a prepass (whether or not we use deferred, whether or not there is option like alpha test only) so we pass the right depth state here.
                {
-
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardAndForwardOnlyPassNames, HDUtils.k_RendererConfigurationBakedLighting);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardAndForwardOnlyPassNames, HDUtils.k_RendererConfigurationBakedLighting, preTransparentQueue: pass == ForwardPass.PreTransparent);
                }
            }
        }
            using (new ProfilingSample(cmd,"Forward Transparent Depth Prepass"))
            {
                CoreUtils.SetRenderTarget(cmd, m_CameraDepthStencilBufferRT);
-                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, HDShaderPassNames.s_TransparentDepthPrepassName);
+                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, HDShaderPassNames.s_TransparentDepthPrepassName, preTransparentQueue: true);
+                RenderTransparentRenderList(cullResults, camera, renderContext, cmd, HDShaderPassNames.s_TransparentDepthPrepassName, preTransparentQueue: false);
-        void RenderForwardError(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool renderOpaque)
+        void RenderForwardError(CullResults cullResults, Camera camera, ScriptableRenderContext renderContext, CommandBuffer cmd, ForwardPass pass)
-                if (renderOpaque)
+                if (pass == ForwardPass.Opaque)
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0, null, m_ErrorMaterial);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0, 
+                        null, m_ErrorMaterial, pass == ForwardPass.PreTransparent);
                }
            }
        }
--- a/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl
        return;
    }

+#ifdef _REFRACTION_ROUGHNESS_ON
+#else
+    diffuseLighting = SAMPLE_TEXTURE2D_LOD(_GaussianPyramidColorTexture, s_trilinear_clamp_sampler, refractedBackPointSS.xy, 0.0).rgb;
+#endif

    // Beer-Lamber law for absorption
    float3 transmittance = exp(-bsdfData.absorptionCoefficient * opticalDepth);
--- a/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.shader
        _ThicknessMultiplier("Thickness Multiplier", Float) = 1.0
        _TransmittanceColor("Transmittance Color", Color) = (1.0, 1.0, 1.0)
        _ATDistance("Transmittance Absorption Distance", Float) = 1.0
+        [ToggleOff] _PreTransparentPass("PreTransparentPass", Float) = 0.0

        // Stencil state
        [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting  (fixed at compile time)
    #pragma shader_feature _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
    #pragma shader_feature _VERTEX_WIND
    #pragma shader_feature _ _REFRACTION_THINPLANE _REFRACTION_THICKPLANE _REFRACTION_THICKSPHERE
+    #pragma shader_feature _REFRACTION_ROUGHNESS_ON

    #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR
    #pragma shader_feature _NORMALMAP_TANGENT_SPACE
--- a/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Editor/BaseUnlitUI.cs
            public static GUIContent distortionBlurScaleText = new GUIContent("Distortion Blur Scale", "Distortion Blur Scale");
            public static GUIContent distortionBlurRemappingText = new GUIContent("Distortion Blur Remapping", "Distortion Blur Remapping");

+            public static GUIContent transparentPrePassText = new GUIContent("Pre Transparent Pass", "Render in pre-transparent pass");
+
            public static string advancedText = "Advanced Options";
        }

        protected const string kDistortionBlurRemapMin = "_DistortionBlurRemapMin";
        protected MaterialProperty distortionBlurRemapMax = null;
        protected const string kDistortionBlurRemapMax = "_DistortionBlurRemapMax";
+        protected MaterialProperty transparentPrepass = null;
+        protected const string kTransparentPrepass = "_PreTransparentPass";

        // See comment in LitProperties.hlsl
        const string kEmissionColor = "_EmissionColor";
            distortionBlurScale = FindProperty(kDistortionBlurScale, props, false);
            distortionBlurRemapMin = FindProperty(kDistortionBlurRemapMin, props, false);
            distortionBlurRemapMax = FindProperty(kDistortionBlurRemapMax, props, false);
+            transparentPrepass = FindProperty(kTransparentPrepass, props, false);
        }

        void SurfaceTypePopup()
            if ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent)
            {
                BlendModePopup();
+
+                m_MaterialEditor.ShaderProperty(transparentPrepass, StylesBaseUnlit.transparentPrePassText);
            }
            m_MaterialEditor.ShaderProperty(alphaCutoffEnable, StylesBaseUnlit.alphaCutoffEnableText);
            if (alphaCutoffEnable.floatValue == 1.0f)
                material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                material.SetInt("_ZWrite", 1);
-                material.renderQueue = alphaTestEnable ? (int)UnityEngine.Rendering.RenderQueue.AlphaTest : -1;
+                material.renderQueue = alphaTestEnable ? (int)HDRenderQueue.AlphaTest : -1;
-                material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
+                var isPrePass = material.GetFloat(kTransparentPrepass) > 0.0f;
+                material.renderQueue = (int)(isPrePass ? HDRenderQueue.PreTransparent : HDRenderQueue.Transparent);
+                SetKeyword(material, "_REFRACTION_ROUGHNESS_ON", !isPrePass); // NOTE: this should be in lit as refraction is only for lit

                SetKeyword(material, "_BLENDMODE_LERP", BlendMode.Lerp == blendMode);
                SetKeyword(material, "_BLENDMODE_ADD", BlendMode.Add == blendMode);
--- a/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/Material/Unlit/Unlit.shader
        _DistortionBlurRemapMin("DistortionBlurRemapMin", Float) = 0.0
        _DistortionBlurRemapMax("DistortionBlurRemapMax", Float) = 1.0

+        // Transparency
+        [ToggleOff] _PreTransparentPass("PreTransparentPass", Float) = 0.0
+
        [ToggleOff]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
        _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5

--- a/SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_thicksphere_EarthMap_pretransparent.mat
+++ b/SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_thicksphere_EarthMap_pretransparent.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: Mat_refraction_thicksphere_EarthMap_pretransparent
+  m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  m_ShaderKeywords: _ALPHACUTOFFENABLE_OFF _BLENDMODE_LERP _MASKMAP _NORMALMAP_TANGENT_SPACE
+    _REFRACTION_ON _REFRACTION_THICKSPHERE _ROUGH_REFRACTION _ROUGH_REFRACTION_ON
+  m_LightmapFlags: 1
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        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}
+    - _DiffuseLightingMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        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}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        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}
+    - _MaskMap:
+        m_Texture: {fileID: 2800000, guid: 9edd5a06bcc2fec4398c5d34172f5d8d, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        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}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubSurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _ATDistance: 1e+15
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CoatCoverage: 1
+    - _CoatIOR: 0.5
+    - _CullMode: 2
+    - _Cutoff: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 1
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 1
+    - _DistortionDepthTest: 0
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedMode: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 10
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnablePerPixelDisplacement: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableVertexDisplacement: 0
+    - _EnableWind: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.02
+    - _HeightBias: 0
+    - _HeightCenter: 0.5
+    - _HeightMapMode: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightScale: 1
+    - _HorizonFade: 1
+    - _IOR: 1.5
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metalic: 1
+    - _Metallic: 0.04
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _Parallax: 0.02
+    - _PerPixelDisplacementObjectScale: 1
+    - _PreTransparentPass: 1
+    - _RefractionAbsorptionEnable: 0
+    - _RefractionEnable: 0
+    - _RefractionMode: 2
+    - _RoughRefractionEnable: 1
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 1
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 5
+    - _StencilRef: 2
+    - _Stiffness: 1
+    - _SubSurfaceRadius: 0
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 1
+    - _TexWorldScale: 1
+    - _Thickness: 0.747
+    - _ThicknessMultiplier: 1
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVMappingPlanar: 0
+    - _UVSec: 0
+    - _VertexDisplacementObjectScale: 1
+    - _VertexDisplacementTilingScale: 1
+    - _ZTestMode: 8
+    - _ZWrite: 0
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _RefractionAbsorption: {r: 0, g: 0, b: 0, a: 1}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _TransmittanceColor: {r: 0.816, g: 0.6632562, b: 0.374544, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
--- a/SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_thicksphere_EarthMap_pretransparent.mat.meta
+++ b/SampleScenes/HDTest/GraphicTest/Common/Material/Mat_refraction_thicksphere_EarthMap_pretransparent.mat.meta
+fileFormatVersion: 2
+guid: f379e3d7cc9fec241851c9ddd228378f
+timeCreated: 1448039507
+licenseType: Pro
+NativeFormatImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/SampleScenes/HDTest/GraphicTest/Common/Prefabs/Refraction
+++ b/SampleScenes/HDTest/GraphicTest/Common/Prefabs/Refraction
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1001 &100100000
+Prefab:
+  m_ObjectHideFlags: 1
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications: []
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 0}
+  m_RootGameObject: {fileID: 1329294594657462}
+  m_IsPrefabParent: 1
+--- !u!1 &1329294594657462
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 4301820151681734}
+  - component: {fileID: 33235095751850106}
+  - component: {fileID: 23359103481084912}
+  m_Layer: 0
+  m_Name: Refraction ThickSphere Sphere Map Earth - PreTransparent
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &4301820151681734
+Transform:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1329294594657462}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!23 &23359103481084912
+MeshRenderer:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1329294594657462}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_Materials:
+  - {fileID: 2100000, guid: f379e3d7cc9fec241851c9ddd228378f, 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_StitchLightmapSeams: 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!33 &33235095751850106
+MeshFilter:
+  m_ObjectHideFlags: 1
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 100100000}
+  m_GameObject: {fileID: 1329294594657462}
+  m_Mesh: {fileID: 10207, guid: 0000000000000000e000000000000000, type: 0}
--- a/SampleScenes/HDTest/GraphicTest/Common/Prefabs/Refraction
+++ b/SampleScenes/HDTest/GraphicTest/Common/Prefabs/Refraction
+fileFormatVersion: 2
+guid: b7484be2c0334fe43b57152ed9531a88
+timeCreated: 1507017860
+licenseType: Pro
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 100100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRenderQueue.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRenderQueue.cs
+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public enum HDRenderQueue
+    {
+        Background = UnityEngine.Rendering.RenderQueue.Background,
+        Geometry = UnityEngine.Rendering.RenderQueue.Geometry,
+        AlphaTest = UnityEngine.Rendering.RenderQueue.AlphaTest,
+        GeometryLast = UnityEngine.Rendering.RenderQueue.GeometryLast,
+        PreTransparent = 2750,
+        Transparent = UnityEngine.Rendering.RenderQueue.Transparent,
+        Overlay = UnityEngine.Rendering.RenderQueue.Overlay
+    }
+}
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRenderQueue.cs.meta
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRenderQueue.cs.meta
+fileFormatVersion: 2
+guid: cf249f1049774fd4387b98e6300fc441
+timeCreated: 1507815420
+licenseType: Pro
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: