Added affects transparency flag to decal projectors

com.unity.render-pipelines.high-definition/HDRP/Editor/Material/Decal/DecalProjectorComponentEditor.cs

         private SerializedProperty m_FadeScaleProperty;
         private SerializedProperty m_UVScaleProperty;
         private SerializedProperty m_UVBiasProperty;
+        private SerializedProperty m_AffectsTransparencyProperty;
 
         public class DecalBoundsHandle : BoxBoundsHandle
         {
             m_FadeScaleProperty = serializedObject.FindProperty("m_FadeScale");
             m_UVScaleProperty = serializedObject.FindProperty("m_UVScale");
             m_UVBiasProperty = serializedObject.FindProperty("m_UVBias");
+            m_AffectsTransparencyProperty = serializedObject.FindProperty("m_AffectsTransparency");
         }
 
         private void OnDisable()
             EditorGUILayout.Slider(m_FadeScaleProperty, 0.0f, 1.0f, new GUIContent("Fade scale"));
             EditorGUILayout.PropertyField(m_UVScaleProperty);
             EditorGUILayout.PropertyField(m_UVBiasProperty);
+            EditorGUILayout.PropertyField(m_AffectsTransparencyProperty);
             if (EditorGUI.EndChangeCheck())
             {
                 serializedObject.ApplyModifiedProperties();

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/DecalProjectorComponent.cs

         public float m_FadeScale = 0.9f;
         public Vector2 m_UVScale = new Vector2(1, 1);
         public Vector2 m_UVBias = new Vector2(0, 0);
+        public bool m_AffectsTransparency = false;
         private Material m_OldMaterial = null;
         private DecalSystem.DecalHandle m_Handle = null;
 
             }
 
             Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
-            m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Material);
+            m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Material);
         }
 
         public void OnDisable()
                 if (m_Handle != null)
                     DecalSystem.instance.RemoveDecal(m_Handle);
                 Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
-                m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Material);
+                m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Material);
                 m_OldMaterial = m_Material;
 
                 // notify the editor that material has changed so it can update the shader foldout
                 if (transform.hasChanged == true)
                 {
                     Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
-                    DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Handle);
+                    DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Handle);
                     transform.hasChanged = false;
                 }
             }
             DrawGizmo(true);
             // if this object is selected there is a chance the transform was changed so update culling info
             Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
-            DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Handle);
+            DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Handle);
         }
 
         public void OnDrawGizmos()

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/DecalSystem.cs

                 return res;
             }
 
-            public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, DecalHandle handle)
+            public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, DecalHandle handle)
             {
                 if (m_Material == null)
                     return;
                     : instance.DrawDistance;
                 m_CachedDrawDistances[index].y = fadeScale;
                 m_CachedUVScaleBias[index] = uvScaleBias;
+                m_CachedAffectsTransparency[index] = affectsTransparency;
-            public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, int materialID)
+            public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, int materialID)
             {
                 // increase array size if no space left
                 if (m_DecalsCount == m_Handles.Length)
                     Matrix4x4[] newCachedNormalToWorld = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
                     Vector2[] newCachedDrawDistances = new Vector2[m_DecalsCount + kDecalBlockSize];
                     Vector4[] newCachedUVScaleBias = new Vector4[m_DecalsCount + kDecalBlockSize];
+                    bool[] newCachedAffectsTransparency = new bool[m_DecalsCount + kDecalBlockSize];
                     m_ResultIndices = new int[m_DecalsCount + kDecalBlockSize];
 
                     m_Handles.CopyTo(newHandles, 0);
                     m_CachedDrawDistances.CopyTo(newCachedDrawDistances, 0);
                     m_CachedUVScaleBias.CopyTo(newCachedUVScaleBias, 0);
+                    m_CachedAffectsTransparency.CopyTo(newCachedAffectsTransparency, 0);
 
                     m_Handles = newHandles;
                     m_BoundingSpheres = newSpheres;
                     m_CachedUVScaleBias = newCachedUVScaleBias;
+                    m_CachedAffectsTransparency = newCachedAffectsTransparency;
-                UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, decalHandle);
+                UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, affectsTransparency, decalHandle);
                 m_DecalsCount++;
                 return decalHandle;
             }
                 m_CachedNormalToWorld[removeAtIndex] = m_CachedNormalToWorld[m_DecalsCount - 1];
                 m_CachedDrawDistances[removeAtIndex] = m_CachedDrawDistances[m_DecalsCount - 1];
                 m_CachedUVScaleBias[removeAtIndex] = m_CachedUVScaleBias[m_DecalsCount - 1];
+                m_CachedAffectsTransparency[removeAtIndex] = m_CachedAffectsTransparency[m_DecalsCount - 1];
                 m_DecalsCount--;
                 handle.m_Index = kInvalidIndex;
             }
                     return;
                 if (m_NumResults == 0)
                     return;
-                // only add if anything in this decal set is visible.
-                AddToTextureList(ref instance.m_TextureList);
+
+                bool anyAffectTransparency = false;
 
                 AssignCurrentBatches(ref decalToWorldBatch, ref normalToWorldBatch, batchCount);
 
                         normalToWorldBatch[instanceCount].SetRow(3, m_CachedUVScaleBias[decalIndex]);
 
                         // clustered forward data
-                        m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse;
-                        m_DecalDatas[m_DecalDatasCount].normalToWorld = normalToWorldBatch[instanceCount];
-                        m_DecalDatas[m_DecalDatasCount].diffuseScaleBias = m_Diffuse.m_ScaleBias;
-                        m_DecalDatas[m_DecalDatasCount].normalScaleBias = m_Normal.m_ScaleBias;
-                        m_DecalDatas[m_DecalDatasCount].maskScaleBias = m_Mask.m_ScaleBias;
-                        GetDecalVolumeDataAndBound(decalToWorldBatch[instanceCount], worldToView);
-                        m_DecalDatasCount++;
+                        if(m_CachedAffectsTransparency[decalIndex])
+                        { 
+                            m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse;
+                            m_DecalDatas[m_DecalDatasCount].normalToWorld = normalToWorldBatch[instanceCount];
+                            m_DecalDatas[m_DecalDatasCount].diffuseScaleBias = m_Diffuse.m_ScaleBias;
+                            m_DecalDatas[m_DecalDatasCount].normalScaleBias = m_Normal.m_ScaleBias;
+                            m_DecalDatas[m_DecalDatasCount].maskScaleBias = m_Mask.m_ScaleBias;
+                            GetDecalVolumeDataAndBound(decalToWorldBatch[instanceCount], worldToView);
+                            m_DecalDatasCount++;
+                            anyAffectTransparency = true;
+                        }
 
                         instanceCount++;
                         if (instanceCount == kDrawIndexedBatchSize)
                             AssignCurrentBatches(ref decalToWorldBatch, ref normalToWorldBatch, batchCount);
                         }
                     }
+                }
+
+                // only add if any projectors in this decal set affect transparency
+                if( anyAffectTransparency)
+                { 
+                    AddToTextureList(ref instance.m_TextureList);
                 }
             }
 
             private Matrix4x4[] m_CachedNormalToWorld = new Matrix4x4[kDecalBlockSize];
             private Vector2[] m_CachedDrawDistances = new Vector2[kDecalBlockSize]; // x - draw distance, y - fade scale
             private Vector4[] m_CachedUVScaleBias = new Vector4[kDecalBlockSize]; // xy - scale, zw bias
+            private bool[] m_CachedAffectsTransparency = new bool[kDecalBlockSize];
             private Material m_Material;
             private float m_Blend = 0;
             private float m_AlbedoContribution = 0;
             TextureScaleBias m_Mask = new TextureScaleBias();
         }
 
-        public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, Material material)
+        public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, Material material)
         {
             DecalSet decalSet = null;
             int key = material != null ? material.GetInstanceID() : kNullMaterialIndex;
                 m_DecalSets.Add(key, decalSet);
             }
-            return decalSet.AddDecal(transform, drawDistance, fadeScale, uvScaleBias, key);
+            return decalSet.AddDecal(transform, drawDistance, fadeScale, uvScaleBias, affectsTransparency, key);
         }
 
         public void RemoveDecal(DecalHandle handle)
             }
         }
 
-        public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, DecalHandle handle)
+        public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, DecalHandle handle)
         {
             if (!DecalHandle.IsValid(handle))
                 return;
             if (m_DecalSets.TryGetValue(key, out decalSet))
             {
-                decalSet.UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, handle);
+                decalSet.UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, affectsTransparency, handle);
             }
         }
 

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

                 else
                 {
                     HDUtils.SetRenderTarget(cmd, hdCamera, m_CameraColorBuffer, m_CameraDepthStencilBuffer);
-                    if ((hdCamera.frameSettings.enableDBuffer) && (DecalSystem.m_DecalsVisibleThisFrame > 0)) // enable d-buffer flag value is being interpreted more like enable decals in general now that we have clustered                    
+                    if ((hdCamera.frameSettings.enableDBuffer) && (DecalSystem.m_DecalDatasCount > 0)) // enable d-buffer flag value is being interpreted more like enable decals in general now that we have clustered                    
+                                                                                                       // decal datas count is 0 if no decals affect transparency             
                     {
                         DecalSystem.instance.SetAtlas(cmd); // for clustered decals
                     }