Merge remote-tracking branch 'remotes/origin/master' into StackLit2

com.unity.render-pipelines.high-definition/CHANGELOG.md

 - Allow to double click on a render pipeline asset to setup it automatically in GraphicSettings
 - Add shortcut to create DensityVolume and PlanarReflection in hierarchy
 - Add a DefaultHDMirrorMaterial material for PlanarReflection
-- Added a script to be able to update material to newer version of Unity
+- Added a script to be able to upgrade material to newer version of HDRP
+- Removed useless duplication of ForwardError passes.
 
 ### Changed, Removals and deprecations
 - Removed GlobalLightLoopSettings.maxPlanarReflectionProbes and instead use value of GlobalLightLoopSettings.planarReflectionProbeCacheSize
 - Fix discrepency between object motion vector and camera motion vector
 - Fix issue with spot and dir light gizmo axis not highlighted correctly
 - Fix potential crash while register debug windows inputs at startup
+- Fix warning when creating Planar reflection
+- Fix specular lighting debug mode (was rendering black)
+- Allow projector decal with null material to allow to configure decal when HDRP is not set
 
 
 ## [2018.1 undecided]

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs

                     );
 
             Inspector = CED.Group(
-                    SectionProbeModeSettings,
+                    //SectionProbeModeSettings,
                     CED.space,
                     CED.Action((s, d, o) => EditorGUILayout.LabelField(_.GetContent("Proxy Volume"), EditorStyles.boldLabel)),
                     CED.Action(Drawer_FieldProxyVolumeReference),
             GUI.enabled = false;
             EditorGUILayout.PropertyField(d.refreshMode, _.GetContent("Refresh Mode"));
             EditorGUILayout.PropertyField(d.capturePositionMode, _.GetContent("Capture Position Mode"));
-            d.refreshMode.enumValueIndex = (int)ReflectionProbeRefreshMode.EveryFrame;
-            d.capturePositionMode.enumValueIndex = (int)PlanarReflectionProbe.CapturePositionMode.MirrorCamera;
             GUI.enabled = true;
         }
 
         {
             GUI.enabled = false;
             EditorGUILayout.PropertyField(d.mode, _.GetContent("Type"));
-            d.mode.enumValueIndex = (int)ReflectionProbeMode.Realtime;
             GUI.enabled = true;
         }
 

com.unity.render-pipelines.high-definition/HDRP/Editor/Lighting/Reflection/SerializedPlanarReflectionProbe.cs

         {
             serializedObject.Update();
 
+            mode.enumValueIndex = (int)ReflectionProbeMode.Realtime;
+            refreshMode.enumValueIndex = (int)ReflectionProbeRefreshMode.EveryFrame;
+            capturePositionMode.enumValueIndex = (int)PlanarReflectionProbe.CapturePositionMode.MirrorCamera;
+
             var updateProxyVolume = reflectionProxyVolume != null
                 && serializedObject.targetObjects.Length != reflectionProxyVolume.serializedObject.targetObjects.Length;
             if (!updateProxyVolume && reflectionProxyVolume != null)

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/HDAssetFactory.cs

                 newAsset.skyboxCubemap = Shader.Find("Skybox/Cubemap");
 
                 // Material
-                newAsset.preIntegratedFGD = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD.shader");
+                newAsset.preIntegratedFGD = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD.shader");
 
                 // Utilities / Core
                 newAsset.encodeBC6HCS = Load<ComputeShader>(CorePath + "CoreResources/EncodeBC6H.compute");

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRPass.template

     //-------------------------------------------------------------------------------------
 
     HLSLPROGRAM
-    
+
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
     //#pragma enable_d3d11_debug_symbols
     //-------------------------------------------------------------------------------------
     // End Defines
     //-------------------------------------------------------------------------------------
-    
+
     #include "HDRP/ShaderVariables.hlsl"
     #ifdef DEBUG_DISPLAY
         #include "HDRP/Debug/DebugDisplay.hlsl"
 
             // TODO: positionSS is SV_Position, graph input expects screenPosition to be 0..1 across the active viewport (?)
             $SurfaceDescriptionInputs.screenPosition:            output.screenPosition = input.positionSS;
-            
+
-            
+
             $SurfaceDescriptionInputs.vertexColor:               output.vertexColor =    input.color;
 
             return output;
 
         builtinData.opacity =                   surfaceDescription.Alpha;
         builtinData.bakeDiffuseLighting =       SampleBakedGI(fragInputs.positionWS, bentNormalWS, fragInputs.texCoord1, fragInputs.texCoord2);    // see GetBuiltinData()
-     
+
         // It is safe to call this function here as surfaceData have been filled
         // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
         BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
             builtinData.bakeDiffuseLighting += SampleBakedGI(fragInputs.positionWS, -fragInputs.worldToTangent[2], fragInputs.texCoord1, fragInputs.texCoord2) * bsdfData.transmittance;
         }
 
-        builtinData.emissiveIntensity =         1.0f;
 $SurfaceDescription.Emission:     builtinData.emissiveColor =             surfaceDescription.Emission;
         builtinData.velocity =                  float2(0.0, 0.0);
 #ifdef SHADOWS_SHADOWMASK
     //-------------------------------------------------------------------------------------
 
     ENDHLSL
-}
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitPassForward.template

     //-------------------------------------------------------------------------------------
 
     HLSLPROGRAM
-    
+
     #pragma target 4.5
     #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
     //#pragma enable_d3d11_debug_symbols
     //-------------------------------------------------------------------------------------
     // End Defines
     //-------------------------------------------------------------------------------------
-    
+
     #include "HDRP/ShaderVariables.hlsl"
     #ifdef DEBUG_DISPLAY
         #include "HDRP/Debug/DebugDisplay.hlsl"
             $SurfaceDescriptionInputs.ViewSpacePosition:         float4 posViewSpace =                mul(UNITY_MATRIX_V, float4(input.positionWS, 1.0f));
             $SurfaceDescriptionInputs.ViewSpacePosition:         output.ViewSpacePosition =           posViewSpace.xyz / posViewSpace.w;
             $SurfaceDescriptionInputs.TangentSpacePosition:      output.TangentSpacePosition =        float3(0.0f, 0.0f, 0.0f);
-            
+
-            
+
-            
+
             $SurfaceDescriptionInputs.vertexColor:               output.vertexColor =    input.color;
 
             return output;
 
         builtinData.opacity =                   surfaceDescription.Alpha;
         builtinData.bakeDiffuseLighting =       float3(0.0, 0.0, 0.0);
-     
-        builtinData.emissiveIntensity =         1.0f;
+
 $SurfaceDescription.Emission:     builtinData.emissiveColor =             surfaceDescription.Emission;
         builtinData.velocity =                  float2(0.0, 0.0);
         builtinData.shadowMask0 = 0.0;
     //-------------------------------------------------------------------------------------
 
     ENDHLSL
-}
+}

com.unity.render-pipelines.high-definition/HDRP/Editor/Upgraders/HDRPVersion.cs

             // Compare project version with current version - Trigger an upgrade if user ask for it
             if (GetCurrentHDRPProjectVersion() < hdrpVersion)
             {
-                if (EditorUtility.DisplayDialog("A newer version of Unity has been detected",
-                                                "Do you want to upgrade your materials to newer version?\n You can also upgrade manually materials in Edit -> Render Pipeline submenu", "Yes", "No"))
+                if (EditorUtility.DisplayDialog("A newer version of HDRP has been detected",
+                                                "Do you want to upgrade your materials to newer version?\n You can also upgrade manually materials in 'Edit -> Render Pipeline' submenu", "Yes", "No"))
+        }
+    }
-            // Update current project version with HDRP version
-            WriteCurrentHDRPProjectVersion();
+    public class FileModificationWarning : UnityEditor.AssetModificationProcessor
+    {
+        static string[] OnWillSaveAssets(string[] paths)
+        {
+            foreach (string path in paths)
+            {
+                // Detect when we save project and write our HDRP version at this time.
+                if (path == "ProjectSettings/ProjectSettings.asset")
+                {
+                    // Update current project version with HDRP version
+                    HDRPVersion.WriteCurrentHDRPProjectVersion();
+                }
+            }
+            return paths;
         }
     }
 }

com.unity.render-pipelines.high-definition/HDRP/Editor/Upgraders/UpgradeMenuItem.cs

             }
         }
 
-        [MenuItem("Edit/Render Pipeline/Update all Materials to latest version", priority = CoreUtils.editMenuPriority3)]
+        [MenuItem("Edit/Render Pipeline/Single step upgrade script/Upgrade all Materials EmissionColor", priority = CoreUtils.editMenuPriority3)]
+        static public void UpdateMaterialToNewerVersionEmissiveColor()
+        {
+            UpdateMaterialToNewerVersion("(EmissiveColor)", UpdateMaterial_EmissiveColor, UpdateMaterialFile_EmissiveColor);
+        }
+
+        [MenuItem("Edit/Render Pipeline/Upgrade all Materials to latest version", priority = CoreUtils.editMenuPriority3)]
         static public void UpdateMaterialToNewerVersion()
         {
             // Add here all the material upgrade function supported in this version

com.unity.render-pipelines.high-definition/HDRP/Material/LayeredLit/LayeredLitData.hlsl

 
     // Normalize
     maxHeight = GetMaxHeight(maskedHeights);
-    maskedHeights = maskedHeights / maxHeight.xxxx;
+    maskedHeights = maskedHeights / max(maxHeight.xxxx, 1e-6);
 
     return maskedHeights.yzwx;
 }

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.hlsl

 
     if (_DebugLightingMode != 0)
     {
-        bool keepSpecular = false;
-
+        // Caution: _DebugLightingMode is used in other part of the code, don't do anything outside of
+        // current cases
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            else
-                keepSpecular = true;
-            else
-                keepSpecular = true;
-
-        if (!keepSpecular)
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
     }
     else if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
     {

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.hlsl

 
     if (_DebugLightingMode != 0)
     {
-        specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-
+        // Caution: _DebugLightingMode is used in other part of the code, don't do anything outside of
+        // current cases
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            //diffuseLighting = aoFactor.indirectSpecularOcclusion;
+            diffuseLighting = aoFactor.indirectSpecularOcclusion;
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            //    diffuseLighting = lighting.indirect.specularTransmitted;
+             //   diffuseLighting = lighting.indirect.specularTransmitted;
+            break;
+
+        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFLECTION:
+            //if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
+            //    diffuseLighting = lighting.indirect.specularReflected;
             break;
         }
     }

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDRenderPipeline.cs

         RTHandleSystem.RTHandle m_DistortionBuffer;
 
         // The pass "SRPDefaultUnlit" is a fall back to legacy unlit rendering and is required to support unity 2d + unity UI that render in the scene.
-        ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { new ShaderPassName(), new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName };
-        ShaderPassName[] m_ForwardOnlyPassNames = { new ShaderPassName(), HDShaderPassNames.s_SRPDefaultUnlitName };
+        ShaderPassName[] m_ForwardAndForwardOnlyPassNames = { HDShaderPassNames.s_ForwardOnlyName, HDShaderPassNames.s_ForwardName, HDShaderPassNames.s_SRPDefaultUnlitName };
+        ShaderPassName[] m_ForwardOnlyPassNames = { HDShaderPassNames.s_ForwardOnlyName, HDShaderPassNames.s_SRPDefaultUnlitName };
 
         ShaderPassName[] m_AllTransparentPassNames = {  HDShaderPassNames.s_TransparentBackfaceName,
                                                         HDShaderPassNames.s_ForwardOnlyName,
                         StartStereoRendering(renderContext, hdCamera);
 
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
-                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Opaque);
 
                         // SSS pass here handle both SSS material from deferred and forward
                         m_SSSBufferManager.SubsurfaceScatteringPass(hdCamera, cmd, diffusionProfileSettings,
 
                         // Render pre refraction objects
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
-                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
-                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
+
+                        // Render All forward error
+                        RenderForwardError(m_CullResults, hdCamera, renderContext, cmd);
 
                         // Fill depth buffer to reduce artifact for transparent object during postprocess
                         RenderTransparentDepthPostpass(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
                         HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer);
                     }
 
-                    m_ForwardAndForwardOnlyPassNames[0] = m_ForwardOnlyPassNames[0] =
-                            HDShaderPassNames.s_ForwardOnlyName;
-                    m_ForwardAndForwardOnlyPassNames[1] = HDShaderPassNames.s_ForwardName;
-
                     var passNames = hdCamera.frameSettings.enableForwardRenderingOnly
                         ? m_ForwardAndForwardOnlyPassNames
                         : m_ForwardOnlyPassNames;
 
         // This is use to Display legacy shader with an error shader
         [Conditional("DEVELOPMENT_BUILD"), Conditional("UNITY_EDITOR")]
-        void RenderForwardError(CullResults cullResults, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd, ForwardPass pass)
+        void RenderForwardError(CullResults cullResults, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd)
-
-                if (pass == ForwardPass.Opaque)
-                {
-                    RenderOpaqueRenderList(cullResults, hdCamera, renderContext, cmd, m_ForwardErrorPassNames, 0, null, null, m_ErrorMaterial);
-                }
-                else
-                {
-                    RenderTransparentRenderList(cullResults, hdCamera, renderContext, cmd, m_ForwardErrorPassNames, 0, pass == ForwardPass.PreRefraction ? HDRenderQueue.k_RenderQueue_PreRefraction : HDRenderQueue.k_RenderQueue_Transparent, null, m_ErrorMaterial);
-                }
+                RenderOpaqueRenderList(cullResults, hdCamera, renderContext, cmd, m_ForwardErrorPassNames, 0, RenderQueueRange.all, null, m_ErrorMaterial);
             }
         }