HDRenderPipeline: Fix issue with Transmission due to padding between compute and shader float array

- Move Thickness remap float array to float4 array to avoid packing
issue between compute path and pixel path

Assets/ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs

                 Shader.SetGlobalInt(     "_EnableSSSAndTransmission",          m_DebugDisplaySettings.renderingDebugSettings.enableSSSAndTransmission ? 1 : 0);
                 Shader.SetGlobalInt(     "_TexturingModeFlags", (int)sssParameters.texturingModeFlags);
                 Shader.SetGlobalInt(     "_TransmissionFlags",  (int)sssParameters.transmissionFlags);
-                cmd.SetGlobalFloatArray( "_ThicknessRemaps",         sssParameters.thicknessRemaps);
+                cmd.SetGlobalVectorArray( "_ThicknessRemaps",        sssParameters.thicknessRemaps);
                 // We are currently supporting two different SSS mode: Jimenez (with 2-Gaussian profile) and Disney
                 // We have added the ability to switch between each other for subsurface scattering, but for transmittance this is more tricky as we need to add
                 // shader variant for forward, gbuffer and deferred shader. We want to avoid this.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/TilePass.cs

                             int enableSSSAndTransmission = Shader.GetGlobalInt("_EnableSSSAndTransmission");
                             int texturingModeFlags = Shader.GetGlobalInt("_TexturingModeFlags");
                             int transmissionFlags = Shader.GetGlobalInt("_TransmissionFlags");
-                            float[] thicknessRemaps = Shader.GetGlobalFloatArray("_ThicknessRemaps");
+                            Vector4[] thicknessRemaps = Shader.GetGlobalVectorArray("_ThicknessRemaps");
                             Vector4[] shapeParams = Shader.GetGlobalVectorArray("_ShapeParams");
                             Vector4[] transmissionTints = Shader.GetGlobalVectorArray("_TransmissionTints");
 
                                 cmd.SetComputeIntParam(   shadeOpaqueShader, "_EnableSSSAndTransmission", enableSSSAndTransmission);
                                 cmd.SetComputeIntParam(   shadeOpaqueShader, "_TexturingModeFlags",       texturingModeFlags);
                                 cmd.SetComputeIntParam(   shadeOpaqueShader, "_TransmissionFlags",        transmissionFlags);
-                                cmd.SetComputeFloatParams(shadeOpaqueShader, "_ThicknessRemaps",          thicknessRemaps);
+                                cmd.SetComputeVectorArrayParam(shadeOpaqueShader, "_ThicknessRemaps",     thicknessRemaps);
                                 // We are currently supporting two different SSS mode: Jimenez (with 2-Gaussian profile) and Disney
                                 // We have added the ability to switch between each other for subsurface scattering, but for transmittance this is more tricky as we need to add
                                 // shader variant for forward, gbuffer and deferred shader. We want to avoid this.

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 uint   _EnableSSSAndTransmission;           // Globally toggles subsurface and transmission scattering on/off
 uint   _TexturingModeFlags;                 // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
 uint   _TransmissionFlags;                  // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
-float  _ThicknessRemaps[SSS_N_PROFILES][2]; // Remap: 0 = start, 1 = end - start
+// Use float4 to avoid any packing issue between compute and pixel shaders
+float4  _ThicknessRemaps[SSS_N_PROFILES];   // R: start, G = end - start, BA unused
 float4 _ShapeParams[SSS_N_PROFILES];        // RGB = S = 1 / D, A = filter radius
 float4 _TransmissionTints[SSS_N_PROFILES];  // RGB = color, A = unused
 CBUFFER_END
     bsdfData.fresnel0 = 0.04; // Should be 0.028 for the skin
     bsdfData.subsurfaceProfile = subsurfaceProfile;
     bsdfData.subsurfaceRadius  = subsurfaceRadius;
-    bsdfData.thickness         = _ThicknessRemaps[subsurfaceProfile][0] +
-                                 _ThicknessRemaps[subsurfaceProfile][1] * thickness;
+    bsdfData.thickness         = _ThicknessRemaps[subsurfaceProfile].x +
+                                 _ThicknessRemaps[subsurfaceProfile].y * thickness;
 
     uint transmissionMode = BitFieldExtract(_TransmissionFlags, 2u, 2u * subsurfaceProfile);
 

Assets/ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/SubsurfaceScatteringProfile.cs

             // PDF(r, s) = s * (Exp[-r * s] + Exp[-r * s / 3]) / 4
             // CDF(r, s) = 1 - 1/4 * Exp[-r * s] - 3/4 * Exp[-r * s / 3]
             // ------------------------------------------------------------------------------------
-            
+
-                
+
                 // N.b.: computation of normalized weights, and multiplication by the surface albedo
                 // of the actual geometry is performed at runtime (in the shader).
                 m_FilterKernelNearField[i].x = r;
             // Set in BuildKernel().
             get { return m_FilterKernelNearField; }
         }
-        
+
         public Vector2[] filterKernelFarField
         {
             // Set in BuildKernel().
         // Below are the cached values.
         [NonSerialized] public uint          texturingModeFlags;        // 1 bit/profile; 0 = PreAndPostScatter, 1 = PostScatter
         [NonSerialized] public uint          transmissionFlags;         // 2 bit/profile; 0 = inf. thick, 1 = thin, 2 = regular
-        [NonSerialized] public float[]       thicknessRemaps;           // Remap: 0 = start, 1 = end - start
+        [NonSerialized] public Vector4[]     thicknessRemaps;           // Remap: 0 = start, 1 = end - start
         [NonSerialized] public float[]       worldScales;               // Size of the world unit in meters
         [NonSerialized] public Vector4[]     shapeParams;               // RGB = S = 1 / D, A = filter radius
         [NonSerialized] public Vector4[]     transmissionTints;         // RGB = color, A = unused
         {
             texturingModeFlags = transmissionFlags = 0;
 
-            const int thicknessRemapsLen = SssConstants.SSS_N_PROFILES * 2;
-            if (thicknessRemaps == null || thicknessRemaps.Length != thicknessRemapsLen)
+            if (thicknessRemaps == null || thicknessRemaps.Length != SssConstants.SSS_N_PROFILES)
-                thicknessRemaps = new float[thicknessRemapsLen];
+                thicknessRemaps = new Vector4[SssConstants.SSS_N_PROFILES];
             }
 
             if (worldScales == null || worldScales.Length != SssConstants.SSS_N_PROFILES)
                 texturingModeFlags |= (uint)profiles[i].texturingMode    << i;
                 transmissionFlags  |= (uint)profiles[i].transmissionMode << i * 2;
 
-                thicknessRemaps[2 * i]     = profiles[i].thicknessRemap.x;
-                thicknessRemaps[2 * i + 1] = profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x;
+                thicknessRemaps[i]         = new Vector4(profiles[i].thicknessRemap.x, profiles[i].thicknessRemap.y - profiles[i].thicknessRemap.x, 0.0f, 0.0f);
                 worldScales[i]             = profiles[i].worldScale;
                 shapeParams[i]             = profiles[i].shapeParameter;
                 shapeParams[i].w           = profiles[i].maxRadius;
                 if (useDisneySSS)
                 {
                     EditorGUILayout.PropertyField(m_ScatteringDistance, styles.sssProfileScatteringDistance);
-                
+
                     GUI.enabled = false;
                     EditorGUILayout.PropertyField(m_MaxRadius, styles.sssProfileMaxRadius);
                     GUI.enabled = true;
             m_ProfileMaterial.SetFloat("_MaxRadius",  rMax);
             // <<< Old SSS Model
             EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(256, 256), m_ProfileImage, m_ProfileMaterial, ScaleMode.ScaleToFit, 1.0f);
-            
+
             EditorGUILayout.Space();
             EditorGUILayout.LabelField(styles.sssTransmittancePreview0, styles.centeredMiniBoldLabel);
             EditorGUILayout.LabelField(styles.sssTransmittancePreview1, EditorStyles.centeredGreyMiniLabel);

Assets/ScriptableRenderPipeline/ShaderLibrary/Common.hlsl

 
 // headers from ShaderLibrary do not include "common.hlsl", this should be included in the .shader using it (or Material.hlsl)
 
+// Rules: When doing an array for constant buffer variables, we always use float4 to avoid any packing issue, particularly between compute shader and pixel shaders
+// i.e don't use SetGlobalFloatArray or SetComputeFloatParams
+// The array can be alias in hlsl. Exemple:
+// uniform float4 packedArray[3];
+// static float unpackedArray[12] = (float[12]packedArray;
+
 
 // Include language header
 #if defined(SHADER_API_D3D11)