Merge pull request #1344 from Unity-Technologies/decals/tiled_uvs

Decals/tiled uvs

ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md

 - Add a better mapping of roughness to mipmap for planar reflection
 - The VolumetricLightingSystem now uses RTHandles, which allows to save memory by sharing buffers between different cameras (history buffers are not shared), and reduce reallocation frequency by reallocating buffers only if the rendering resolution increases (and suballocating within existing buffers if the rendering resolution decreases)
 - Add a Volumetric Dimmer slider to lights to control the intensity of the scattered volumetric lighting
+- Add UV tiling and offset support for decals.
 
 ### Changed, Removals and deprecations
 - Remove Resource folder of PreIntegratedFGD and add the resource to RenderPipeline Asset

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;

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

 			positionDS = positionDS * float3(1.0, -1.0, 1.0) + float3(0.5, 0.0f, 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]);
+				float2 uvBias = float2(decalData.normalToWorld[3][2], decalData.normalToWorld[3][3]);
+				positionDS.xz = positionDS.xz * uvScale + uvBias;
+				positionDS.xz = frac(positionDS.xz);
+
 				// clamp by half a texel to avoid sampling neighboring textures in the atlas
 				float2 clampAmount = float2(0.5f / _DecalAtlasResolution.x, 0.5f / _DecalAtlasResolution.y);