Changed how decal projector extents are modified in the UI, to make editing more intuitive

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

         private SerializedProperty m_UVScaleProperty;
         private SerializedProperty m_UVBiasProperty;
         private SerializedProperty m_AffectsTransparencyProperty;
-
-        public class DecalBoundsHandle : BoxBoundsHandle
-        {
-            protected override Bounds OnHandleChanged(HandleDirection handle, Bounds boundsOnClick, Bounds newBounds)
-            {
-                // special case for Y axis because decal mesh is centered at 0, -0.5, 0
-                if (handle == HandleDirection.NegativeY)
-                {
-                    m_Translation = Vector3.zero;
-                    m_Scale = newBounds.size;
-                }
-                else if (handle == HandleDirection.PositiveY)
-                {
-                    m_Translation = (newBounds.center + newBounds.extents - (m_Center + 0.5f * m_Size));
-                    m_Scale = (m_Size + m_Translation);
-                }
-                else
-                {
-                    m_Translation = newBounds.center - m_Center;
-                    m_Scale = newBounds.size;
-                }
-                return newBounds;
-            }
-
-            public void SetSizeAndCenter(Vector3 inSize, Vector3 inCenter)
-            {
-                // boundsOnClick implies that it gets refreshed only if the handle is clicked on again, but we need actual center and scale which we set before handle is drawn every frame
-                m_Center = inCenter;
-                m_Size = inSize;
-                center = inCenter;
-                size = inSize;
-            }
-
-            private Vector3 m_Center;
-            private Vector3 m_Size;
-
-            public Vector3 m_Translation;
-            public Vector3 m_Scale;
-        }
-
-        private DecalBoundsHandle m_Handle = new DecalBoundsHandle();
+        private SerializedProperty m_Center;
+        private SerializedProperty m_Size;
+       
+        private BoxBoundsHandle m_Handle = new BoxBoundsHandle();
 
         private void OnEnable()
         {
             m_UVScaleProperty = serializedObject.FindProperty("m_UVScale");
             m_UVBiasProperty = serializedObject.FindProperty("m_UVBias");
             m_AffectsTransparencyProperty = serializedObject.FindProperty("m_AffectsTransparency");
+            m_Center = serializedObject.FindProperty("m_Offset");
+            m_Size = serializedObject.FindProperty("m_Size");
         }
 
         private void OnDisable()
         }
 
         void OnSceneGUI()
-        {
-            EditorGUI.BeginChangeCheck();
+        {            
-            // decal mesh is centered at (0, -0.5, 0)
-            // zero out the local scale in the matrix so that handle code gives us back the actual scale
-            Handles.matrix = Matrix4x4.TRS(m_DecalProjectorComponent.transform.position, m_DecalProjectorComponent.transform.rotation, Vector3.one) * Matrix4x4.Translate(new Vector3(0.0f, -0.5f * m_DecalProjectorComponent.transform.localScale.y, 0.0f));
-            // pass in the scale
-            m_Handle.SetSizeAndCenter(m_DecalProjectorComponent.transform.localScale, Vector3.zero);
+            Handles.matrix = m_DecalProjectorComponent.transform.localToWorldMatrix;   
+            m_Handle.center = m_DecalProjectorComponent.m_Offset;
+            m_Handle.size = m_DecalProjectorComponent.m_Size;
+            EditorGUI.BeginChangeCheck();
-                m_DecalProjectorComponent.transform.Translate(m_Handle.m_Translation);
-                m_DecalProjectorComponent.transform.localScale = m_Handle.m_Scale;
-                Repaint();
+                m_DecalProjectorComponent.m_Offset = m_Handle.center;
+                m_DecalProjectorComponent.m_Size = m_Handle.size;
+                EditorUtility.SetDirty(m_DecalProjectorComponent);
-
             Handles.matrix = mat;
             Handles.color = col;
         }
             EditorGUI.BeginChangeCheck();
-
+            EditorGUILayout.PropertyField(m_Center);
+            EditorGUILayout.PropertyField(m_Size);
             EditorGUILayout.PropertyField(m_MaterialProperty);
             EditorGUILayout.PropertyField(m_DrawDistanceProperty);
             EditorGUILayout.Slider(m_FadeScaleProperty, 0.0f, 1.0f, new GUIContent("Fade scale"));

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

         public Vector2 m_UVScale = new Vector2(1, 1);
         public Vector2 m_UVBias = new Vector2(0, 0);
         public bool m_AffectsTransparency = false;
+        public Vector3 m_Offset = new Vector3(0, -0.5f, 0);
+        public Vector3 m_Size = new Vector3(1, 1, 1);
         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_AffectsTransparency, m_Material);
+            Matrix4x4 sizeOffset = Matrix4x4.Translate(m_Offset) * Matrix4x4.Scale(m_Size);
+            m_Handle = DecalSystem.instance.AddDecal(transform, sizeOffset, 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_AffectsTransparency, m_Material);
+                Matrix4x4 sizeOffset = Matrix4x4.Translate(m_Offset) * Matrix4x4.Scale(m_Size);
+                m_Handle = DecalSystem.instance.AddDecal(transform, sizeOffset, 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_AffectsTransparency, m_Handle);
+                    Matrix4x4 sizeOffset = Matrix4x4.Translate(m_Offset) * Matrix4x4.Scale(m_Size);
+                    DecalSystem.instance.UpdateCachedData(transform, sizeOffset, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Handle);
-        private void DrawGizmo(bool selected)
-        {
-            var col = new Color(0.0f, 0.7f, 1f, 1.0f);
-            Matrix4x4 offset = Matrix4x4.Translate(new Vector3(0.0f, -0.5f, 0.0f));
-            Gizmos.matrix = transform.localToWorldMatrix * offset;
-            col.a = selected ? 0.5f : 0.2f;
-            Gizmos.color = col;
-            Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
-        }
-
-            DrawGizmo(true);
-            DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Handle);
+            Matrix4x4 sizeOffset = Matrix4x4.Translate(m_Offset) * Matrix4x4.Scale(m_Size);
+            DecalSystem.instance.UpdateCachedData(transform, sizeOffset, m_DrawDistance, m_FadeScale, uvScaleBias, m_AffectsTransparency, m_Handle);
-            DrawGizmo(false);
+            var col = new Color(0.0f, 0.7f, 1f, 0.5f);
+            Matrix4x4 offsetScale = Matrix4x4.Translate(m_Offset) * Matrix4x4.Scale(m_Size);
+            Gizmos.matrix = transform.localToWorldMatrix * offsetScale;
+            Gizmos.color = col;
+            Gizmos.DrawWireCube(Vector3.zero, Vector3.one);
         }
 
         public bool IsValid()

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

         private const int kDrawIndexedBatchSize = 250;
 
         // cube mesh bounds for decal
-        static Vector4 kMin = new Vector4(-0.5f, -1.0f, -0.5f, 1.0f);
-        static Vector4 kMax = new Vector4(0.5f,  0.0f,  0.5f, 1.0f);
+        static Vector4 kMin = new Vector4(-0.5f, -0.5f, -0.5f, 1.0f);
+        static Vector4 kMax = new Vector4(0.5f,  0.5f,  0.5f, 1.0f);
 
         static public Mesh m_DecalMesh = null;
 
                 return res;
             }
 
-            public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, DecalHandle handle)
+            public void UpdateCachedData(Transform transform, Matrix4x4 sizeOffset, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, DecalHandle handle)
-                m_CachedDecalToWorld[index] = transform.localToWorldMatrix;
+                m_CachedDecalToWorld[index] = transform.localToWorldMatrix * sizeOffset;
 
                 Matrix4x4 decalRotation = Matrix4x4.Rotate(transform.rotation);
                 // z/y axis swap for normal to decal space, Unity is column major
                 m_BoundingSpheres[index] = GetDecalProjectBoundingSphere(m_CachedDecalToWorld[index]);
             }
 
-            public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, int materialID)
+            public DecalHandle AddDecal(Transform transform, Matrix4x4 sizeOffset, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, int materialID)
             {
                 // increase array size if no space left
                 if (m_DecalsCount == m_Handles.Length)
 
                 DecalHandle decalHandle = new DecalHandle(m_DecalsCount, materialID);
                 m_Handles[m_DecalsCount] = decalHandle;
-                UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, affectsTransparency, decalHandle);
+                UpdateCachedData(transform, sizeOffset, drawDistance, fadeScale, uvScaleBias, affectsTransparency, decalHandle);
                 m_DecalsCount++;
                 return decalHandle;
             }
                 var influenceX = decalToWorld.GetColumn(0) * 0.5f;
                 var influenceY = decalToWorld.GetColumn(1) * 0.5f;
                 var influenceZ = decalToWorld.GetColumn(2) * 0.5f;
-                var pos = decalToWorld.GetColumn(3) - influenceY; // decal cube mesh pivot is at 0,0,0, with bottom face at -1 on the y plane
+                var pos = decalToWorld.GetColumn(3);
 
                 Vector3 influenceExtents = new Vector3();
                 influenceExtents.x = influenceX.magnitude;
             TextureScaleBias m_Mask = new TextureScaleBias();
         }
 
-        public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, Material material)
+        public DecalHandle AddDecal(Transform transform, Matrix4x4 sizeOffset, 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, affectsTransparency, key);
+            return decalSet.AddDecal(transform, sizeOffset, drawDistance, fadeScale, uvScaleBias, affectsTransparency, key);
         }
 
         public void RemoveDecal(DecalHandle handle)
             }
         }
 
-        public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, bool affectsTransparency, DecalHandle handle)
+        public void UpdateCachedData(Transform transform, Matrix4x4 sizeOffset, 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, affectsTransparency, handle);
+                decalSet.UpdateCachedData(transform, sizeOffset, drawDistance, fadeScale, uvScaleBias, affectsTransparency, handle);
             }
         }
 

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

             float4x4 worldToDecal = ApplyCameraTranslationToInverseMatrix(decalData.worldToDecal);
 
             float3 positionDS = mul(worldToDecal, float4(positionRWS, 1.0)).xyz;
-            positionDS = positionDS * float3(1.0, -1.0, 1.0) + float3(0.5, 0.0f, 0.5);  // decal clip space
+            positionDS = positionDS * float3(1.0, -1.0, 1.0) + float3(0.5, 0.5f, 0.5);  // decal clip space
             if ((all(positionDS.xyz > 0.0f) && all(1.0f - positionDS.xyz > 0.0f)))
             {
                 float2 uvScale = float2(decalData.normalToWorld[3][0], decalData.normalToWorld[3][1]);

com.unity.render-pipelines.high-definition/HDRP/ShaderPass/ShaderPassDBuffer.hlsl

 	PositionInputs posInput = GetPositionInput(input.positionSS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V);
     // Transform from relative world space to decal space (DS) to clip the decal
     float3 positionDS = TransformWorldToObject(posInput.positionWS);
-    positionDS = positionDS * float3(1.0, -1.0, 1.0) + float3(0.5, 0.0f, 0.5);
+    positionDS = positionDS * float3(1.0, -1.0, 1.0) + float3(0.5, 0.5f, 0.5);
     clip(positionDS);       // clip negative value
     clip(1.0 - positionDS); // Clip value above one