Merge pull request #1118 from Unity-Technologies/lw/bugfixes

Lw/bugfixes

ScriptableRenderPipeline/Core/CoreRP/Editor/MaterialUpgrader.cs

 
 namespace UnityEditor.Experimental.Rendering
 {
+    public static class DialogText
+    {
+        public static readonly string title = "Material Upgrader";
+        public static readonly string proceed = "Proceed";
+        public static readonly string ok = "Ok";
+        public static readonly string cancel = "Cancel";
+        public static readonly string noSelectionMessage = "You must select at least one material.";
+        public static readonly string projectBackMessage = "Make sure to have a project backup before proceeding.";
+    }
+
     public class MaterialUpgrader
     {
         public delegate void MaterialFinalizer(Material mat);
-        private static readonly string projectBackMessage = "Make sure to have a project backup before proceeding.";
+
         MaterialFinalizer m_Finalizer;
 
         Dictionary<string, string> m_TextureRename = new Dictionary<string, string>();
 
         public static void UpgradeProjectFolder(List<MaterialUpgrader> upgraders, string progressBarName, UpgradeFlags flags = UpgradeFlags.None)
         {
-            if (!EditorUtility.DisplayDialog("Material Upgrader", "The upgrade will overwrite materials in your project. " + projectBackMessage, "Proceed", "Cancel"))
+            if (!EditorUtility.DisplayDialog(DialogText.title, "The upgrade will overwrite materials in your project. " + DialogText.projectBackMessage, DialogText.proceed, DialogText.cancel))
                 return;
 
             int totalMaterialCount = 0;
 
         public static void Upgrade(Material material, List<MaterialUpgrader> upgraders, UpgradeFlags flags)
         {
+            if (material == null)
+                return;
+
             var upgrader = GetUpgrader(upgraders, material);
 
             if (upgrader != null)
         {
             var selection = Selection.objects;
 
-            if (selection == null || selection.Length == 0)
-                if (EditorUtility.DisplayDialog("Material Upgrader", "You must select at least one material.", "Ok"))
-                    return;
+            if (selection == null)
+            {
+                EditorUtility.DisplayDialog(DialogText.title, DialogText.noSelectionMessage, DialogText.ok);
+                return;
+            }
+
+            List<Material> selectedMaterials = new List<Material>(selection.Length);
+            for (int i = 0; i < selection.Length; ++i)
+            {
+                Material mat = selection[i] as Material;
+                if (mat != null)
+                    selectedMaterials.Add(mat);
+            }
+
+            int selectedMaterialsCount = selectedMaterials.Count;
+            if (selectedMaterialsCount == 0)
+            {
+                EditorUtility.DisplayDialog(DialogText.title, DialogText.noSelectionMessage, DialogText.ok);
+                return;
+            }
-            if (!EditorUtility.DisplayDialog("Material Upgrader", string.Format("The upgrade will overwrite {0} selected material{1}. ", selection.Length, (selection.Length > 1) ? "s" : "") +
-                    projectBackMessage, "Proceed", "Cancel"))
+            if (!EditorUtility.DisplayDialog(DialogText.title, string.Format("The upgrade will overwrite {0} selected material{1}. ", selectedMaterialsCount, selectedMaterialsCount > 1 ? "s" : "") +
+                    DialogText.projectBackMessage, DialogText.proceed, DialogText.cancel))
-            Debug.Log(selection.Length);
-            for (int i = 0; i < selection.Length; i++)
+            for (int i = 0; i < selectedMaterialsCount; i++)
-                if (UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format("({0} of {1}) {2}", i, selection.Length, lastMaterialName), (float)i / (float)selection.Length))
+                if (UnityEditor.EditorUtility.DisplayCancelableProgressBar(progressBarName, string.Format("({0} of {1}) {2}", i, selectedMaterialsCount, lastMaterialName), (float)i / (float)selectedMaterialsCount))
-                var material = selection[i] as Material;
+                var material = selectedMaterials[i];
                 Upgrade(material, upgraders, flags);
                 if (material != null)
                     lastMaterialName = material.name;

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightConstantBuffer.cs

         public static int _AdditionalLightDistanceAttenuation;
         public static int _AdditionalLightSpotDir;
         public static int _AdditionalLightSpotAttenuation;
+
+        public static int _ScaledScreenParams;
     }
 
     public static class ShadowConstantBuffer

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

 
         private static readonly int kMaxVertexLights = 4;
 
+        private static readonly float kRenderScaleThreshold = 0.05f;
+
         private bool m_IsOffscreenCamera;
 
         private Vector4 kDefaultLightPosition = new Vector4(0.0f, 0.0f, 1.0f, 0.0f);
         private RenderTargetIdentifier m_CopyDepth;
         private RenderTargetIdentifier m_Color;
 
+        private float m_RenderScale;
+
         private bool m_IntermediateTextureArray;
         private bool m_RequireDepthTexture;
         private bool m_RequireCopyColor;
             PerCameraBuffer._AdditionalLightDistanceAttenuation = Shader.PropertyToID("_AdditionalLightDistanceAttenuation");
             PerCameraBuffer._AdditionalLightSpotDir = Shader.PropertyToID("_AdditionalLightSpotDir");
             PerCameraBuffer._AdditionalLightSpotAttenuation = Shader.PropertyToID("_AdditionalLightSpotAttenuation");
+            PerCameraBuffer._ScaledScreenParams = Shader.PropertyToID("_ScaledScreenParams");
 
             ShadowConstantBuffer._WorldToShadow = Shader.PropertyToID("_WorldToShadow");
             ShadowConstantBuffer._ShadowData = Shader.PropertyToID("_ShadowData");
             Array.Sort(cameras, m_CameraComparer);
             foreach (Camera camera in cameras)
             {
-                RenderPipeline.BeginCameraRendering(camera);
-
-                bool sceneViewCamera = camera.cameraType == CameraType.SceneView;
-                bool stereoEnabled = XRSettings.isDeviceActive && !sceneViewCamera && (camera.stereoTargetEye == StereoTargetEyeMask.Both);
+                bool sceneViewCamera = m_CurrCamera.cameraType == CameraType.SceneView;
+                bool stereoEnabled = IsStereoEnabled(m_CurrCamera);
+
+                // Disregard variations around kRenderScaleThreshold.
+                m_RenderScale = (Mathf.Abs(1.0f - m_Asset.RenderScale) < kRenderScaleThreshold) ? 1.0f : m_Asset.RenderScale;
+
+                // XR has it's own scaling mechanism.
+                m_RenderScale = (m_CurrCamera.cameraType == CameraType.Game && !stereoEnabled) ? m_RenderScale : 1.0f;
+
+                SetupPerCameraShaderConstants();
+                RenderPipeline.BeginCameraRendering(m_CurrCamera);
 
                 var cmd = CommandBufferPool.Get("");
                 cmd.BeginSample("LightweightPipeline.Render");
 
                 FrameRenderingConfiguration frameRenderingConfiguration;
                 SetupFrameRenderingConfiguration(out frameRenderingConfiguration, shadows, stereoEnabled, sceneViewCamera);
-                SetupIntermediateResources(frameRenderingConfiguration, ref context);
+                SetupIntermediateResources(frameRenderingConfiguration, shadows, ref context);
 
                 // SetupCameraProperties does the following:
                 // Setup Camera RenderTarget and Viewport
 
             SetShadowCollectPassKeywords(cmd, visibleLights[lightData.mainLightIndex], ref lightData);
 
-            // TODO: Support RenderScale for the SSSM target.  Should probably move allocation elsewhere, or at
-            // least propogate RenderTextureDescriptor generation
-            if (LightweightUtils.HasFlag(frameRenderingConfiguration, FrameRenderingConfiguration.Stereo))
-            {
-                var desc = XRSettings.eyeTextureDesc;
-                desc.depthBufferBits = 0;
-                desc.colorFormat = m_ShadowSettings.screenspaceShadowmapTextureFormat;
-                cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, desc, FilterMode.Bilinear);
-            }
-            else
-            {
-                cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, m_CurrCamera.pixelWidth, m_CurrCamera.pixelHeight, 0, FilterMode.Bilinear, m_ShadowSettings.screenspaceShadowmapTextureFormat);
-            }
-
             // Note: The source isn't actually 'used', but there's an engine peculiarity (bug) that
             // doesn't like null sources when trying to determine a stereo-ized blit.  So for proper
             // stereo functionality, we use the screen-space shadow map as the source (until we have
                 m_IntermediateTextureArray = false;
 
             bool hdrEnabled = m_Asset.SupportsHDR && m_CurrCamera.allowHDR;
+
+            bool defaultRenderScale = Mathf.Approximately(GetRenderScale(), 1.0f);
-                m_Asset.RenderScale < 1.0f || hdrEnabled;
+                !defaultRenderScale || hdrEnabled;
 
             m_ColorFormat = hdrEnabled ? RenderTextureFormat.DefaultHDR : RenderTextureFormat.Default;
             m_RequireCopyColor = false;
                 configuration |= FrameRenderingConfiguration.IntermediateTexture;
         }
 
-        private void SetupIntermediateResources(FrameRenderingConfiguration renderingConfig, ref ScriptableRenderContext context)
+        private void SetupIntermediateResources(FrameRenderingConfiguration renderingConfig, bool shadows, ref ScriptableRenderContext context)
         {
             CommandBuffer cmd = CommandBufferPool.Get("Setup Intermediate Resources");
 
 
             if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.IntermediateTexture) || m_RequireDepthTexture)
-                SetupIntermediateRenderTextures(cmd, renderingConfig, msaaSamples);
+                SetupIntermediateRenderTextures(cmd, renderingConfig, shadows, msaaSamples);
-        private void SetupIntermediateRenderTextures(CommandBuffer cmd, FrameRenderingConfiguration renderingConfig, int msaaSamples)
+        private void SetupIntermediateRenderTextures(CommandBuffer cmd, FrameRenderingConfiguration renderingConfig, bool shadows, int msaaSamples)
         {
             RenderTextureDescriptor baseDesc;
             if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.Stereo))
 
-            float renderScale = (m_CurrCamera.cameraType == CameraType.Game) ? m_Asset.RenderScale : 1.0f;
+            float renderScale = GetRenderScale();
-            // TODO: Might be worth caching baseDesc for allocation of other targets (Screen-space Shadow Map?)
-
             if (m_RequireDepthTexture)
             {
                 var depthRTDesc = baseDesc;
 
                 if (LightweightUtils.HasFlag(renderingConfig, FrameRenderingConfiguration.DepthCopy))
                     cmd.GetTemporaryRT(CameraRenderTargetID.depthCopy, depthRTDesc, FilterMode.Bilinear);
+
+                if (shadows && m_ShadowSettings.screenSpace)
+                {
+                    var screenspaceShadowmapDesc = baseDesc;
+                    screenspaceShadowmapDesc.depthBufferBits = 0;
+                    screenspaceShadowmapDesc.colorFormat = m_ShadowSettings.screenspaceShadowmapTextureFormat;
+                    cmd.GetTemporaryRT(m_ScreenSpaceShadowMapRTID, screenspaceShadowmapDesc, FilterMode.Bilinear);
+                }
             }
 
             var colorRTDesc = baseDesc;
 
             // Used when subtractive mode is selected
             Shader.SetGlobalVector(PerFrameBuffer._SubtractiveShadowColor, CoreUtils.ConvertSRGBToActiveColorSpace(RenderSettings.subtractiveShadowColor));
+        }
+
+        private void SetupPerCameraShaderConstants()
+        {
+            float cameraWidth = GetScaledCameraWidth(m_CurrCamera);
+            float cameraHeight = GetScaledCameraHeight(m_CurrCamera);
+            Shader.SetGlobalVector(PerCameraBuffer._ScaledScreenParams, new Vector4(cameraWidth, cameraHeight, 1.0f + 1.0f / cameraWidth, 1.0f + 1.0f / cameraHeight));
         }
 
         private void SetupShaderLightConstants(CommandBuffer cmd, List<VisibleLight> lights, ref LightData lightData)
             }
         }
 
-        RendererConfiguration GetRendererSettings(ref LightData lightData)
+        private bool IsStereoEnabled(Camera camera)
+        {
+            bool isSceneViewCamera = camera.cameraType == CameraType.SceneView;
+            return XRSettings.isDeviceActive && !isSceneViewCamera && (camera.stereoTargetEye == StereoTargetEyeMask.Both);
+        }
+
+        private float GetRenderScale()
+        {
+            return m_RenderScale;
+        }
+
+        private float GetScaledCameraWidth(Camera camera)
+        {
+            return (float) camera.pixelWidth * GetRenderScale();
+        }
+
+        private float GetScaledCameraHeight(Camera camera)
+        {
+            return (float) camera.pixelHeight * GetRenderScale();
+        }
+
+        private RendererConfiguration GetRendererSettings(ref LightData lightData)
         {
             RendererConfiguration settings = RendererConfiguration.PerObjectReflectionProbes | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbe;
             if (lightData.totalAdditionalLightsCount > 0)

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Core.hlsl

     #define UNITY_Z_0_FAR_FROM_CLIPSPACE(coord) (coord)
 #endif
 
+float4 GetScaledScreenParams()
+{
+    return _ScaledScreenParams;
+}
+
 void AlphaDiscard(half alpha, half cutoff, half offset = 0.0h)
 {
 #ifdef _ALPHATEST_ON

ScriptableRenderPipeline/LightweightPipeline/LWRP/ShaderLibrary/Input.hlsl

 half4 _AdditionalLightDistanceAttenuation[MAX_VISIBLE_LIGHTS];
 half4 _AdditionalLightSpotDir[MAX_VISIBLE_LIGHTS];
 half4 _AdditionalLightSpotAttenuation[MAX_VISIBLE_LIGHTS];
+
+float4 _ScaledScreenParams;
 CBUFFER_END
 
 #define UNITY_MATRIX_M     unity_ObjectToWorld

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandard.shader

             // Required to compile gles 2.0 with standard SRP library
             // All shaders must be compiled with HLSLcc and currently only gles is not using HLSLcc by default
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
 
             // -------------------------------------
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
 
             // -------------------------------------
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
 
             #pragma vertex DepthOnlyVertex

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticles.shader

             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma vertex ParticlesLitVertex
             #pragma fragment ParticlesLitFragment
             #pragma multi_compile __ SOFTPARTICLES_ON
                 o.posWS.w = ComputeFogFactor(o.clipPos.z);
                 o.clipPos = TransformWorldToHClip(o.posWS.xyz);
                 o.viewDirShininess.xyz = VertexViewDirWS(GetCameraPositionWS() - o.posWS.xyz);
+                o.viewDirShininess.w = 0.0;
                 vertTexcoord(v, o);
                 vertFading(o, o.posWS, o.clipPos);
                 return o;

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesSimpleLighting.shader

             #pragma vertex ParticlesLitVertex
             #pragma fragment ParticlesLitFragment
             #pragma multi_compile __ SOFTPARTICLES_ON
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
 
             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON _ALPHAPREMULTIPLY_ON _ALPHAMODULATE_ON

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesUnlit.shader

                 HLSLPROGRAM
                 // Required to compile gles 2.0 with standard srp library
                 #pragma prefer_hlslcc gles
+                #pragma exclude_renderers d3d11_9x
                 #pragma multi_compile __ SOFTPARTICLES_ON
                 #pragma multi_compile_fog
                 #pragma target 2.0

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
 
             // -------------------------------------
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
 
             // -------------------------------------
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
 
             #pragma vertex DepthOnlyVertex

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardTerrain.shader

             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 3.0
 
             #pragma vertex SplatmapVert
             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
             #pragma target 2.0
             #pragma vertex vert
             #pragma fragment frag

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardUnlit.shader

             HLSLPROGRAM
             // Required to compile gles 2.0 with standard srp library
             #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
+
             #pragma vertex vert
             #pragma fragment frag
             #pragma multi_compile_fog
                 UNITY_SETUP_INSTANCE_ID(v);
                 UNITY_TRANSFER_INSTANCE_ID(v, o);
                 UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-                
+
                 o.vertex = TransformObjectToHClip(v.vertex.xyz);
                 o.uv0AndFogCoord.xy = TRANSFORM_TEX(v.uv, _MainTex);
                 o.uv0AndFogCoord.z = ComputeFogFactor(o.vertex.z);
                 half2 uv = IN.uv0AndFogCoord.xy;
                 half4 texColor = SAMPLE_TEXTURE2D(_MainTex, sampler_MainTex, uv);
                 half3 color = texColor.rgb * _Color.rgb;
-                half alpha = texColor.a * _Color.a;     
+                half alpha = texColor.a * _Color.a;
                 AlphaDiscard(alpha, _Cutoff);
 
 #if _SAMPLE_GI
                 color *= SampleGI(IN.lightmapOrVertexSH, normalWS);
 #endif
                 ApplyFog(color, IN.uv0AndFogCoord.z);
-       
+
+            ENDHLSL
+        }
+
+        Pass
+        {
+            Tags{"LightMode" = "DepthOnly"}
+
+            ZWrite On
+            ColorMask 0
+
+            HLSLPROGRAM
+            // Required to compile gles 2.0 with standard srp library
+            #pragma prefer_hlslcc gles
+            #pragma exclude_renderers d3d11_9x
+            #pragma target 2.0
+
+            #pragma vertex DepthOnlyVertex
+            #pragma fragment DepthOnlyFragment
+
+            // -------------------------------------
+            // Material Keywords
+            #pragma shader_feature _ALPHATEST_ON
+
+            //--------------------------------------
+            // GPU Instancing
+            #pragma multi_compile_instancing
+
+            #include "LWRP/ShaderLibrary/InputSurfaceUnlit.hlsl"
+            #include "LWRP/ShaderLibrary/LightweightPassDepthOnly.hlsl"
             ENDHLSL
         }
     }