Merge branch 'master' of https://github.com/Unity-Technologies/ScriptableRenderPipeline into volumetrics

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

     return max(0.5 * log2(d), 0.0);
 }
 
-// texelSize is Unity XXX_TexelSize feature parameters
-// x contains 1.0/width, y contains 1.0 / height, z contains width, w contains height
-float ComputeTextureLOD(float2 uv, float4 texelSize)
+// x contains width, w contains height
+float ComputeTextureLOD(float2 uv, float2 texelSize)
-    uv *= texelSize.zw;
+    uv *= texelSize;
 
     return ComputeTextureLOD(uv);
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraEditor.Handlers.cs

             m_PreviewCamera.CopyFrom(c);
             EditorUtility.CopySerialized(c, m_PreviewCamera);
             EditorUtility.CopySerialized(c.GetComponent<HDAdditionalCameraData>(), m_PreviewAdditionalCameraData);
-            var layer = c.GetComponent<PostProcessLayer>() ?? Assets.ScriptableRenderLoop.PostProcessing.PostProcessing.Runtime.Utils.ComponentSingleton<PostProcessLayer>.instance;
+            var layer = c.GetComponent<PostProcessLayer>() ?? ComponentSingleton<PostProcessLayer>.instance;
             EditorUtility.CopySerialized(layer, m_PreviewPostProcessLayer);
             m_PreviewCamera.cameraType = CameraType.SceneView;
             m_PreviewHDCamera.Update(m_PreviewPostProcessLayer, m_PreviewAdditionalCameraData.GetFrameSettings());

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineInspector.cs

             m_FrameSettingsUI.Reset(serializedFrameSettings, Repaint);
         }
 
-        static void HackSetDirty(RenderPipelineAsset asset)
-        {
-            EditorUtility.SetDirty(asset);
-            var method = typeof(RenderPipelineAsset).GetMethod("OnValidate", BindingFlags.FlattenHierarchy | BindingFlags.NonPublic | BindingFlags.Instance);
-            if (method != null)
-                method.Invoke(asset, new object[0]);
-        }
-
-            EditorGUI.BeginChangeCheck();
             EditorGUILayout.PropertyField(m_SpotCookieSize, s_Styles.spotCookieSize);
             EditorGUILayout.PropertyField(m_PointCookieSize, s_Styles.pointCookieSize);
             EditorGUILayout.PropertyField(m_ReflectionCubemapSize, s_Styles.reflectionCubemapSize);
             EditorGUILayout.PropertyField(m_SkyLightingOverrideLayerMask, s_Styles.skyLightingOverride);
-            if (EditorGUI.EndChangeCheck())
-            {
-                HackSetDirty(hdAsset); // Repaint
-            }
             EditorGUI.indentLevel--;
         }
 
             EditorGUILayout.LabelField(s_Styles.renderingSettingsLabel);
             EditorGUI.indentLevel++;
-            EditorGUI.BeginChangeCheck();
-            if (EditorGUI.EndChangeCheck())
-            {
-                HackSetDirty(hdAsset); // Repaint
-            }
             EditorGUI.indentLevel--;
         }
 
             EditorGUILayout.LabelField(s_Styles.shadowSettings);
             EditorGUI.indentLevel++;
-            EditorGUI.BeginChangeCheck();
-            if (EditorGUI.EndChangeCheck())
-            {
-                HackSetDirty(hdAsset); // Repaint
-            }
             EditorGUI.indentLevel--;
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/LightLoopSettingsUI.cs

             {
                 EditorGUI.indentLevel++;
                 EditorGUILayout.PropertyField(p.enableBigTilePrepass, _.GetContent("Enable Big Tile Prepass"));
-                // Allow to disable cluster for forward opaque when in forward only (option have no effect when MSAA is enabled)
-                // Deferred opaque are always tiled
-                EditorGUILayout.PropertyField(p.enableFptlForForwardOpaque, _.GetContent("Enable FPTL For Forward Opaque"));
                 EditorGUILayout.PropertyField(p.enableComputeLightEvaluation, _.GetContent("Enable Compute Light Evaluation"));
                 GUILayout.BeginVertical();
                 if (EditorGUILayout.BeginFadeGroup(s.isSectionExpandedComputeLightEvaluation.faded))
             GUILayout.EndVertical();
 
             EditorGUILayout.PropertyField(p.isFptlEnabled, _.GetContent("Enable FPTL"));
+            // Allow to disable cluster for forward opaque when in forward only (option have no effect when MSAA is enabled)
+            // Deferred opaque are always tiled
             EditorGUILayout.PropertyField(p.enableFptlForForwardOpaque, _.GetContent("Enable FPTL For Forward Opaque"));
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.asset

     enableForwardRenderingOnly: 0
     enableDepthPrepassWithDeferredRendering: 0
     enableAlphaTestOnlyInDeferredPrepass: 0
-    enableTransparentPrePass: 1
+    enableTransparentPrepass: 1
-    enableTransparentPostPass: 1
+    enableTransparentPostpass: 1
     enableDistortion: 1
     enablePostprocess: 1
     enableStereo: 1
     shadowInitParams:
       shadowAtlasWidth: 4096
       shadowAtlasHeight: 4096
-  sssSettings: {fileID: 0}
-  m_DefaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
-    type: 2}
-  m_DefaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
+  sssSettings: {fileID: 11400000, guid: c4d57f106d34d0046a33b3e66da29a72, type: 2}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.cs

-namespace UnityEngine.Experimental.Rendering.HDPipeline
+namespace UnityEngine.Experimental.Rendering.HDPipeline
-    public class HDRenderPipelineAsset : RenderPipelineAsset
+    public class HDRenderPipelineAsset : RenderPipelineAsset, ISerializationCallbackReceiver
     {
         HDRenderPipelineAsset()
         {
         public FrameSettings GetFrameSettings()
         {
             return m_FrameSettings;
-        }
-
-        public void OnEnable()
-        {
-            // At creation we need to copy serializedFrameSettings to m_FrameSettings
-            OnValidate();
-        }
-
-        public void OnValidate()
-        {
-            // Modification of defaultFrameSettings in the inspector will call OnValidate().
-            // We do a copy of the settings to those effectively used
-            serializedFrameSettings.CopyTo(m_FrameSettings);
         }
 
         // Store the various RenderPipelineSettings for each platform (for now only one)
         public override Material GetDefault2DMaterial()
         {
             return null;
+        }
+
+        void ISerializationCallbackReceiver.OnBeforeSerialize()
+        {
+        }
+
+        void ISerializationCallbackReceiver.OnAfterDeserialize()
+        {
+            // Modification of defaultFrameSettings in the inspector will call OnValidate().
+            // We do a copy of the settings to those effectively used
+            serializedFrameSettings.CopyTo(m_FrameSettings);
         }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Editor/ShaderGUI/LightweightStandardParticlesShaderGUI.cs

 
             EditorGUILayout.Space();
 
-            GUILayout.Label(Styles.advancedOptionsText, EditorStyles.boldLabel);
-            m_MaterialEditor.RenderQueueField();
-
-            EditorGUILayout.Space();
-
             GUILayout.Label(Styles.requiredVertexStreamsText, EditorStyles.boldLabel);
             DoVertexStreamsArea(material);
         }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightShaderLibrary/Core.hlsl

 #endif
 }
 
-void ApplyFog(inout half3 color, half fogFactor)
+void ApplyFogColor(inout half3 color, half3 fogColor, half fogFactor)
-    color = lerp(unity_FogColor.rgb, color, fogFactor);
+    color = lerp(fogColor, color, fogFactor);
+
+void ApplyFog(inout half3 color, half fogFactor)
+{
+    ApplyFogColor(color, unity_FogColor.rgb, fogFactor);
+}
+
 #endif

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightShaderLibrary/Particles.hlsl

 #include "InputSurface.hlsl"
 #include "CoreRP/ShaderLibrary/Color.hlsl"
 
+TEXTURE2D(_CameraDepthTexture);
+SAMPLER(sampler_CameraDepthTexture);
+float4 _SoftParticleFadeParams;
+float4 _CameraFadeParams;
+
+#define SOFT_PARTICLE_NEAR_FADE _SoftParticleFadeParams.x
+#define SOFT_PARTICLE_INV_FADE_DISTANCE _SoftParticleFadeParams.y
+
+#define CAMERA_NEAR_FADE _CameraFadeParams.x
+#define CAMERA_INV_FADE_DISTANCE _CameraFadeParams.y
+
 #if defined (_COLORADDSUBDIFF_ON)
 half4 _ColorAddSubDiff;
 #endif
 
 // Fading vertex function
 #if defined(SOFTPARTICLES_ON) || defined(_FADING_ON)
-#define vertFading(o) \
-    o.projectedPosition = ComputeScreenPos (clipPosition); \
-    COMPUTE_EYEDEPTH(o.projectedPosition.z);
+#define vertFading(o, positionWS, positionCS) \
+    o.projectedPosition.xy = positionCS.xy * 0.5 + positionCS.w; \
+    o.projectedPosition.y *= _ProjectionParams.x; \
+    o.projectedPosition.w = positionCS.w; \
+    o.projectedPosition.z = -TransformWorldToView(positionWS.xyz).z
-#define vertFading(o)
+#define vertFading(o, positionWS, positionCS)
-#define fragColorMode(albedo, color) \
+#define fragColorMode(i) \
-    half3 aHSL = RGBtoHSV(albedo.rgb); \
-    half3 bHSL = RGBtoHSV(i.color.rgb); \
+    half3 aHSL = RgbToHsv(albedo.rgb); \
+    half3 bHSL = RgbToHsv(i.color.rgb); \
-    albedo = half4(HSVtoRGB(rHSL), albedo.a * i.color.a);
+    albedo = half4(HsvToRgb(rHSL), albedo.a * i.color.a);
 #elif defined(_COLORADDSUBDIFF_ON)
 #define fragColorMode(i) \
     albedo.rgb = albedo.rgb + i.color.rgb * _ColorAddSubDiff.x; \
 #define fragSoftParticles(i) \
     if (SOFT_PARTICLE_NEAR_FADE > 0.0 || SOFT_PARTICLE_INV_FADE_DISTANCE > 0.0) \
     { \
-        float sceneZ = LinearEyeDepth (SAMPLE_DEPTH_TEXTURE_PROJ(_CameraDepthTexture, UNITY_PROJ_COORD(i.projectedPosition))); \
+        float sceneZ = LinearEyeDepth(SAMPLE_DEPTH_TEXTURE(_CameraDepthTexture, sampler_CameraDepthTexture, i.projectedPosition.xy / i.projectedPosition.w), _ZBufferParams); \
         float fade = saturate (SOFT_PARTICLE_INV_FADE_DISTANCE * ((sceneZ - SOFT_PARTICLE_NEAR_FADE) - i.projectedPosition.z)); \
         ALBEDO_MUL *= fade; \
     }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticles.shader

             VertexOutputLit ParticlesLitVertex(appdata_particles v)
             {
                 VertexOutputLit o;
-                float4 clipPosition = TransformObjectToHClip(v.vertex.xyz);
-
 #if _NORMALMAP
                 OutputTangentToWorld(v.tangent, v.normal, o.tangent, o.binormal, o.normal);
 #else
                 o.posWS.xyz = TransformObjectToWorld(v.vertex.xyz).xyz;
-                o.clipPos = TransformWorldToHClip(o.posWS.xyz);
+                o.clipPos = TransformWorldToHClip(o.posWS.xyz);
-                vertFading(o);
-                o.clipPos = clipPosition;
+                vertFading(o, o.posWS, o.clipPos);
                 return o;
             }
 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardParticlesUnlit.shader

         _EmissionColor("Color", Color) = (0,0,0)
         _EmissionMap("Emission", 2D) = "white" {}
 
-        _DistortionStrength("Strength", Float) = 1.0
-        _DistortionBlend("Blend", Range(0.0, 1.0)) = 0.5
-
         _SoftParticlesNearFadeDistance("Soft Particles Near Fade", Float) = 0.0
         _SoftParticlesFarFadeDistance("Soft Particles Far Fade", Float) = 1.0
         _CameraNearFadeDistance("Camera Near Fade", Float) = 1.0
         [HideInInspector] _ColorMode("__colormode", Float) = 0.0
         [HideInInspector] _FlipbookMode("__flipbookmode", Float) = 0.0
         [HideInInspector] _LightingEnabled("__lightingenabled", Float) = 0.0
-        [HideInInspector] _DistortionEnabled("__distortionenabled", Float) = 0.0
         [HideInInspector] _EmissionEnabled("__emissionenabled", Float) = 0.0
         [HideInInspector] _BlendOp("__blendop", Float) = 0.0
         [HideInInspector] _SrcBlend("__src", Float) = 1.0
         [HideInInspector] _SoftParticleFadeParams("__softparticlefadeparams", Vector) = (0,0,0,0)
         [HideInInspector] _CameraFadeParams("__camerafadeparams", Vector) = (0,0,0,0)
         [HideInInspector] _ColorAddSubDiff("__coloraddsubdiff", Vector) = (0,0,0,0)
-        [HideInInspector] _DistortionStrengthScaled("__distortionstrengthscaled", Float) = 0.0
     }
 
     Category
 
             Pass
             {
-                CGPROGRAM
+                HLSLPROGRAM
                 #pragma multi_compile __ SOFTPARTICLES_ON
                 #pragma multi_compile_fog
                 #pragma target 2.5
                 #pragma vertex vertParticleUnlit
                 #pragma fragment fragParticleUnlit
 
-                #include "UnityStandardParticles.cginc"
-                ENDCG
+                #include "LightweightShaderLibrary/Particles.hlsl"
+                #include "LightweightShaderLibrary/Core.hlsl"
+
+                VertexOutputLit vertParticleUnlit(appdata_particles v)
+                {
+                    VertexOutputLit o = (VertexOutputLit)0;
+
+                    // position ws is used to compute eye depth in vertFading
+                    o.posWS.xyz = TransformObjectToWorld(v.vertex.xyz);
+                    o.posWS.w = ComputeFogFactor(o.clipPos.z);
+                    o.clipPos = TransformWorldToHClip(o.posWS.xyz);
+                    o.color = v.color;
+
+                    vertColor(o.color);
+                    vertTexcoord(v, o);
+                    vertFading(o, o.posWS, o.clipPos);
+
+                    return o;
+                }
+
+                half4 fragParticleUnlit(VertexOutputLit IN) : SV_Target
+                {
+                    half4 albedo = readTexture(_MainTex, sampler_MainTex, IN);
+                    albedo *= _Color;
+
+                    fragColorMode(IN);
+                    fragSoftParticles(IN);
+                    fragCameraFading(IN);
+
+        #if defined(_NORMALMAP)
+                    float3 normal = normalize(UnpackNormalScale(readTexture(_BumpMap, sampler_BumpMap, IN), _BumpScale));
+        #else
+                    float3 normal = float3(0,0,1);
+        #endif
+
+        #if defined(_EMISSION)
+                    half3 emission = readTexture(_EmissionMap, sampler_EmissionMap, IN).rgb;
+        #else
+                    half3 emission = 0;
+        #endif
+
+                    half4 result = albedo;
+
+        #if defined(_ALPHAMODULATE_ON)
+                    result.rgb = lerp(half3(1.0, 1.0, 1.0), albedo.rgb, albedo.a);
+        #endif
+
+                    result.rgb += emission * _EmissionColor.rgb;
+
+        #if !defined(_ALPHABLEND_ON) && !defined(_ALPHAPREMULTIPLY_ON) && !defined(_ALPHAOVERLAY_ON)
+                    result.a = 1;
+        #endif
+
+        #if defined(_ALPHATEST_ON)
+                    clip(albedo.a - _Cutoff + 0.0001);
+        #endif
+
+                    half fogFactor = IN.posWS.w;
+                    ApplyFogColor(result.rgb, half3(0, 0, 0), fogFactor);
+                    return result;
+                }
+                ENDHLSL
             }
         }
     }

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_DefaultShader: {fileID: 4800000, guid: 933532a4fcc9baf4fa0491de14d08ed7, type: 3}
   m_BlitShader: {fileID: 4800000, guid: c17132b1f77d20942aa75f8429c0f8bc, type: 3}
   m_CopyDepthShader: {fileID: 4800000, guid: d6dae50ee9e1bfa4db75f19f99355220, type: 3}
-  m_ResourceAsset: {fileID: 0}
+  m_ResourceAsset: {fileID: 11400000, guid: c8afc0a27fb8c0b4da18151c689a1082, type: 2}