Merge pull request #848 from Unity-Technologies/prototype/decals_premult_alpha

Prototype/decals premult alpha
7 年前 · 6e5bc8c0
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs
    {
        public Material m_Material = null;
        private Material m_OldMaterial = null;
-        public const int kInvalidIndex = -1;
+        public const int kInvalidIndex = -1;  
        private int m_CullIndex = kInvalidIndex;

        public int CullIndex
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs
            }
        }

+        private static readonly int m_NormalToWorldID = Shader.PropertyToID("normalToWorld");
+        private static MaterialPropertyBlock m_PropertyBlock = new MaterialPropertyBlock();
+
        private const int kDecalBlockSize = 128;

        // to work on Vulkan Mobile?

        static public Mesh m_DecalMesh = null;
        static public Matrix4x4[] m_InstanceMatrices = new Matrix4x4[kDrawIndexedBatchSize];
+        static public Matrix4x4[] m_InstanceNormalToWorld = new Matrix4x4[kDrawIndexedBatchSize];

        private Dictionary<int, DecalSet> m_DecalSets = new Dictionary<int, DecalSet>();

            public void UpdateBoundingSphere(DecalProjectorComponent decal)
            {
                m_CachedTransforms[decal.CullIndex] = decal.transform.localToWorldMatrix;
+
+                Matrix4x4 decalRotation = Matrix4x4.Rotate(decal.transform.rotation);
+                // z/y axis swap for normal to decal space
+                Vector4 row2 = decalRotation.GetRow(2);
+                decalRotation.SetRow(2, decalRotation.GetRow(1));
+                decalRotation.SetRow(1, row2);
+                m_CachedNormalToWorld[decal.CullIndex] = decalRotation;
+
                m_BoundingSpheres[decal.CullIndex] = GetDecalProjectBoundingSphere(m_CachedTransforms[decal.CullIndex]);
            }

                    DecalProjectorComponent[] newDecals = new DecalProjectorComponent[m_DecalsCount + kDecalBlockSize];
                    BoundingSphere[] newSpheres = new BoundingSphere[m_DecalsCount + kDecalBlockSize];
                    Matrix4x4[] newCachedTransforms = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
+                    Matrix4x4[] newCachedNormalToWorld = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
+                    m_CachedNormalToWorld.CopyTo(newCachedNormalToWorld, 0);
+                    m_CachedNormalToWorld = newCachedNormalToWorld;
                }

                m_Decals[m_DecalsCount] = decal;
                // update the bounding spheres array
                m_BoundingSpheres[removeAtIndex] = m_BoundingSpheres[m_DecalsCount - 1];
                m_CachedTransforms[removeAtIndex] = m_CachedTransforms[m_DecalsCount - 1];
+                m_CachedNormalToWorld[removeAtIndex] = m_CachedNormalToWorld[m_DecalsCount - 1];
                m_DecalsCount--;
                decal.CullIndex = DecalProjectorComponent.kInvalidIndex;
            }
                    int decalIndex = m_ResultIndices[resultIndex];

                    m_InstanceMatrices[instanceCount] = m_CachedTransforms[decalIndex];
+                    m_InstanceNormalToWorld[instanceCount] = m_CachedNormalToWorld[decalIndex];
-                        cmd.DrawMeshInstanced(m_DecalMesh, 0, m_Decals[0].m_Material, 0, m_InstanceMatrices, kDrawIndexedBatchSize);
+                        m_PropertyBlock.SetMatrixArray(m_NormalToWorldID, m_InstanceNormalToWorld);
+                        cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_InstanceMatrices, kDrawIndexedBatchSize, m_PropertyBlock);
-                    cmd.DrawMeshInstanced(m_DecalMesh, 0, m_Decals[0].m_Material, 0, m_InstanceMatrices, instanceCount);
+                    m_PropertyBlock.SetMatrixArray(m_NormalToWorldID, m_InstanceNormalToWorld);
+                    cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_InstanceMatrices, instanceCount, m_PropertyBlock);                    
                }
            }

            private int m_NumResults = 0;
            private int m_DecalsCount = 0;
            private Matrix4x4[] m_CachedTransforms = new Matrix4x4[kDecalBlockSize];
+            private Matrix4x4[] m_CachedNormalToWorld = new Matrix4x4[kDecalBlockSize];
            private Material m_Material;
        }
        
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs
            return m_ColorMRTs;
        }

+		public void ClearNormalTarget(Color clearColor, CommandBuffer cmd)
+		{
+			// index 1 is normals
+			CoreUtils.SetRenderTarget(cmd, m_ColorMRTs[1], ClearFlag.Color, clearColor);
+		}
+
        public void PushGlobalParams(CommandBuffer cmd)
        {
            cmd.SetGlobalInt(HDShaderIDs._EnableDBuffer, vsibleDecalCount > 0 ? 1 : 0);
                // Depth texture is now ready, bind it.
                cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());

-                CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+				// for alpha compositing, color is cleared to 0, alpha to 1 
+				// https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+
+				Color clearColor = new Color(0.0f, 0.0f, 0.0f, 1.0f); 
+				CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, clearColor);
+
+				// we need to do a separate clear for normals, because they are cleared to a different color
+				Color clearColorNormal = new Color(0.5f, 0.5f, 0.5f, 1.0f); // for normals 0.5 is neutral
+				m_DbufferManager.ClearNormalTarget(clearColorNormal, cmd);
+
+				CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT); // do not clear anymore
                DecalSystem.instance.Render(renderContext, camera, cmd);
            }
        }
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.hlsl
 	uint _EnableDBuffer;
 CBUFFER_END

+UNITY_INSTANCING_BUFFER_START(Decal)      
+	UNITY_DEFINE_INSTANCED_PROP(float4x4, normalToWorld)
+UNITY_INSTANCING_BUFFER_END(matrix)       
+
+
 // Must be in sync with RT declared in HDRenderPipeline.cs ::Rebuild
 void EncodeIntoDBuffer( DecalSurfaceData surfaceData,
                        out DBufferType0 outDBuffer0,
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.shader
            Name "DBuffer"  // Name is not used
            Tags { "LightMode" = "DBuffer" } // This will be only for opaque object based on the RenderQueue index

-			// need to optimize this and use proper Cull and ZTest modes for cases when decal geometry is clipped by camera 
-            Cull Off
+			// back faces with zfail, for cases when camera is inside the decal volume
+            Cull Front
-			ZTest Always
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha

 			HLSLPROGRAM

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalData.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalData.hlsl
 #endif
 #if _MASKMAP
 	surfaceData.mask = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, texCoordDS.xy); 
-	surfaceData.mask.z = totalBlend;
+	surfaceData.mask.z = surfaceData.mask.w;
+	surfaceData.mask.w = totalBlend;
 #endif

 }
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalProperties.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalProperties.hlsl
 #ifndef UNITY_DECALPROPERTIES_INCLUDED
 #define UNITY_DECALPROPERTIES_INCLUDED

-
 TEXTURE2D(_BaseColorMap);
 SAMPLER(sampler_BaseColorMap);
 TEXTURE2D(_NormalMap);

 float _DecalBlend;
-
-CBUFFER_START(Decal)
-float4x4 _WorldToDecal;
-float4x4 _DecalToWorldR;
-CBUFFER_END

 #endif 
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalUtilities.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalUtilities.hlsl
 		DecalSurfaceData decalSurfaceData;
 		DECODE_FROM_DBUFFER(DBuffer, decalSurfaceData);

-		surfaceData.baseColor.xyz = lerp(surfaceData.baseColor.xyz, decalSurfaceData.baseColor.xyz, decalSurfaceData.baseColor.w);
-		surfaceData.normalWS.xyz = normalize(lerp(surfaceData.normalWS.xyz, decalSurfaceData.normalWS.xyz, decalSurfaceData.normalWS.w));
-		surfaceData.metallic = lerp(surfaceData.metallic, decalSurfaceData.mask.x, decalSurfaceData.mask.z);
-		surfaceData.ambientOcclusion = lerp(surfaceData.ambientOcclusion, decalSurfaceData.mask.y, decalSurfaceData.mask.z);
-		surfaceData.perceptualSmoothness = lerp(surfaceData.perceptualSmoothness, decalSurfaceData.mask.w, decalSurfaceData.mask.z);
+		// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+		surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz;
+		surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz);
+		surfaceData.metallic = surfaceData.metallic * decalSurfaceData.mask.w + decalSurfaceData.mask.x;
+		surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.mask.w + decalSurfaceData.mask.y;
+		surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z;
 	}
 }
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/ShaderPass/DecalSharePass.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/ShaderPass/DecalSharePass.hlsl
 #error Undefine_SHADERPASS
 #endif

-// need 3 x float3 interpolators...
-#define VARYINGS_NEED_POSITION_WS
-#define VARYINGS_NEED_TANGENT_TO_WORLD
-
 // This include will define the various Attributes/Varyings structure
 #include "../../ShaderPass/VaryingMesh.hlsl"
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassDBuffer.hlsl
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassDBuffer.hlsl

 #include "VertMesh.hlsl"

-float3 RemoveScale(float3 val)
-{
-	return normalize(val / length(val));
-}
-
-VaryingsMeshType Transform(AttributesMesh input)
-{
-    VaryingsMeshType output;
-
-	UNITY_SETUP_INSTANCE_ID(input)
-	UNITY_TRANSFER_INSTANCE_ID(input, output);
-
-    float3 positionWS = TransformObjectToWorld(input.positionOS);
-	positionWS = GetCameraRelativePositionWS(positionWS);
-	output.positionCS = TransformWorldToHClip(positionWS);
-
-	float3x3 decalRotation;
-	decalRotation[0] = RemoveScale(float3(UNITY_MATRIX_M[0][0], UNITY_MATRIX_M[0][1], UNITY_MATRIX_M[0][2]));
-	decalRotation[2] = RemoveScale(float3(UNITY_MATRIX_M[1][0], UNITY_MATRIX_M[1][1], UNITY_MATRIX_M[1][2]));
-	decalRotation[1] = RemoveScale(float3(UNITY_MATRIX_M[2][0], UNITY_MATRIX_M[2][1], UNITY_MATRIX_M[2][2]));
-
-	decalRotation = transpose(decalRotation);
-
-	output.positionWS = decalRotation[0];
-    output.normalWS = decalRotation[1];
-    output.tangentWS = float4(decalRotation[2], 0.0);
-
-    return output;
-}
-    varyingsType.vmesh = Transform(inputMesh);
+    varyingsType.vmesh = VertMesh(inputMesh);
    return PackVaryingsType(varyingsType);
 }

 	clip(1.0 - positionDS); // Clip value above one

    DecalSurfaceData surfaceData;
-	float3x3 decalToWorld;
-	// using the interpolators directly, because UnpackVaryingsMeshToFragInputs does some tangent space manipulations
-	decalToWorld[0] = packedInput.vmesh.interpolators0;
-	decalToWorld[1] = packedInput.vmesh.interpolators1;
-	decalToWorld[2] = packedInput.vmesh.interpolators2.xyz;
-
+	float3x3 decalToWorld = (float3x3)UNITY_ACCESS_INSTANCED_PROP(matrix, normalToWorld);
    GetSurfaceData(positionDS.xz, decalToWorld, surfaceData);

 	ENCODE_INTO_DBUFFER(surfaceData, outDBuffer);