uv tiling working for opaques

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

                 return res;
             }
 
-            public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, DecalHandle handle) 
+            public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, DecalHandle handle) 
             {
                 int index = handle.m_Index;
                 m_CachedDecalToWorld[index] = transform.localToWorldMatrix;
                     ? drawDistance
                     : instance.DrawDistance;
                 m_CachedDrawDistances[index].y = fadeScale;
+                m_CachedUVScaleBias[index] = uvScaleBias;
-            public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, int materialID)
+            public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, int materialID)
             {
                 // increase array size if no space left
                 if (m_DecalsCount == m_Handles.Length)
                     Matrix4x4[] newCachedTransforms = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
                     Matrix4x4[] newCachedNormalToWorld = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
                     Vector2[] newCachedDrawDistances = new Vector2[m_DecalsCount + kDecalBlockSize];
+                    Vector4[] newCachedUVScaleBias = new Vector4[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_Handles = newHandles;
                     m_BoundingSpheres = newSpheres;
+                    m_CachedUVScaleBias = newCachedUVScaleBias;
-                UpdateCachedData(transform, drawDistance, fadeScale, decalHandle);
+                UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, decalHandle);
                 m_DecalsCount++;
                 return decalHandle;
             }
                 m_CachedDecalToWorld[removeAtIndex] = m_CachedDecalToWorld[m_DecalsCount - 1];
                 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_DecalsCount--;
                 handle.m_Index = kInvalidIndex;
             }
                         normalToWorldBatch[instanceCount] = m_CachedNormalToWorld[decalIndex];
                         float fadeFactor = Mathf.Clamp((cullDistance - distanceToDecal) / (cullDistance * (1.0f - m_CachedDrawDistances[decalIndex].y)), 0.0f, 1.0f);
                         normalToWorldBatch[instanceCount].m03 = fadeFactor * m_Blend;   // vector3 rotation matrix so bottom row and last column can be used for other data to save space
+                        normalToWorldBatch[instanceCount].SetRow(3, m_CachedUVScaleBias[decalIndex]);
 
                         // clustered forward data
                         m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse;
             private Matrix4x4[] m_CachedDecalToWorld = new Matrix4x4[kDecalBlockSize];
             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 Material m_Material;
             private float m_Blend = 0;
 
         }
 
-        public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Material material)
+        public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, Material material)
         {			
             DecalSet decalSet = null;
             int key = material.GetInstanceID();
                 m_DecalSets.Add(key, decalSet);
             }
-            return decalSet.AddDecal(transform, drawDistance, fadeScale, key);
+            return decalSet.AddDecal(transform, drawDistance, fadeScale, uvScaleBias, key);
         }
 
         public void RemoveDecal(DecalHandle handle)
             }
         }
 
-        public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, DecalHandle handle)
+        public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, DecalHandle handle)
         {
             if(!DecalHandle.IsValid(handle))
                 return;
             if (m_DecalSets.TryGetValue(key, out decalSet))
             {
-                decalSet.UpdateCachedData(transform, drawDistance, fadeScale, handle);
+                decalSet.UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, handle);
             }
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Decal/DecalProjectorComponentEditor.cs

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalData.hlsl

 	surfaceData.mask = float4(0,0,0,0);
 	surfaceData.HTileMask = 0;
 	float totalBlend = clamp(normalToWorld[0][3], 0.0f, 1.0f);
+	float2 scale = float2(normalToWorld[3][0], normalToWorld[3][1]);
+	float2 offset = float2(normalToWorld[3][2], normalToWorld[3][3]);
+	texCoordDS = texCoordDS * scale + offset;
 #if _COLORMAP
 	surfaceData.baseColor = SAMPLE_TEXTURE2D(_BaseColorMap, sampler_BaseColorMap, texCoordDS.xy);
 	surfaceData.baseColor.w *= totalBlend;