Update comment + rename packUint to PackInt function

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Packing.hlsl

 }
 
 // Define various variante for ease of read
-real PackFloatUInt8bit(real f, uint i, real maxi)
+real PackFloatInt8bit(real f, uint i, real maxi)
-void UnpackFloatUInt8bit(real val, real maxi, out real f, out uint i)
+void UnpackFloatInt8bit(real val, real maxi, out real f, out uint i)
-real PackFloatUInt10bit(real f, uint i, real maxi)
+real PackFloatInt10bit(real f, uint i, real maxi)
-void UnpackFloatUInt10bit(real val, real maxi, out real f, out uint i)
+void UnpackFloatInt10bit(real val, real maxi, out real f, out uint i)
-real PackFloatUInt16bit(real f, uint i, real maxi)
+real PackFloatInt16bit(real f, uint i, real maxi)
-void UnpackFloatUInt16bit(real val, real maxi, out real f, out uint i)
+void UnpackFloatInt16bit(real val, real maxi, out real f, out uint i)
 {
     UnpackFloatInt(val, maxi, 65536.0, f, i);
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.hlsl

 
     // In forward everything is statically know and we could theorically cumulate all the material features. So the code reflect it.
     // However in practice we keep parity between deferred and forward, so we should constrain the various features.
-    // The UI is in charge of setuping the constrain, not the code. So if users is forward only and want unlish power, it is easy to unleash by some UI change
+    // The UI is in charge of setuping the constrain, not the code. So if users is forward only and want unleash power, it is easy to unleash by some UI change
 
     if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
     {
 
         outGBuffer2.rgb = float3(surfaceData.anisotropy * 0.5 + 0.5,
                                  sinOrCos,
-                                 PackFloatUInt8bit(surfaceData.metallic, storeSin | quadrant, 8));
+                                 PackFloatInt8bit(surfaceData.metallic, storeSin | quadrant, 8));
     }
     else if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
     {
-                                 PackFloatUInt8bit(surfaceData.metallic, 0, 8));
+                                 PackFloatInt8bit(surfaceData.metallic, 0, 8));
-        // In the case of standard or specular color we always uncompress before encoding, so decoding is more efficient (it allow better optimization for the compiler and save VGPR)
+        // In the case of standard or specular color we always convert to specular color parametrization before encoding, 
+        // so decoding is more efficient (it allow better optimization for the compiler and save VGPR)
         // This mean that on the decode side, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR doesn't exist anymore
         materialFeatureId = GBUFFER_LIT_STANDARD;
 
     // Ensure that surfaceData.coatMask is 0 if the feature is not enabled
     float coatMask = HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT) ? surfaceData.coatMask : 0.0;
     // Note: no need to store MATERIALFEATUREFLAGS_LIT_STANDARD, always present
-    outGBuffer2.a  = PackFloatUInt8bit(coatMask, materialFeatureId, 8);
+    outGBuffer2.a  = PackFloatInt8bit(coatMask, materialFeatureId, 8);
 
     // RT3 - 11f:11f:10f
     outGBuffer3 = float4(bakeDiffuseLighting, 0.0);
 // from the contents of the G-buffer, which can be used by the feature classification system.
-// Note that return type is not part of the MACRO DECODE_FROM_GBUFFER, so it is sage to use return value for our need
+// Note that return type is not part of the MACRO DECODE_FROM_GBUFFER, so it is safe to use return value for our need
 // 'tileFeatureFlags' are compile-time flags provided by the feature classification system.
 // If you're not using the feature classification system, pass UINT_MAX.
 // Also, see comment in TileVariantToFeatureFlags. When we are the worse case (i.e last variant), we read the featureflags
     // Material classification only uses the G-Buffer 2.
     float coatMask;
     uint materialFeatureId;
-    UnpackFloatUInt8bit(inGBuffer2.a, 8, coatMask, materialFeatureId);
+    UnpackFloatInt8bit(inGBuffer2.a, 8, coatMask, materialFeatureId);
 
     uint pixelFeatureFlags    = MATERIALFEATUREFLAGS_LIT_STANDARD; // Only sky/background do not have the Standard flag.
     bool pixelHasSubsurface   = materialFeatureId == GBUFFER_LIT_TRANSMISSION_SSS || materialFeatureId == GBUFFER_LIT_SSS;
     {
         float metallic;
         uint unused;
-        UnpackFloatUInt8bit(inGBuffer2.b, 8, metallic, unused);
+        UnpackFloatInt8bit(inGBuffer2.b, 8, metallic, unused);
 
         bsdfData.diffuseColor = ComputeDiffuseColor(baseColor, metallic);
         bsdfData.fresnel0     = ComputeFresnel0(baseColor, metallic, DEFAULT_SPECULAR_VALUE);
         // We must do this so the compiler can optimize away the read from the G-Buffer 0 to the very end (in PostEvaluateBSDF)
         // Note that we don't use sssData.subsurfaceMask here. But it is still assign so we can have the information in the 
         // material debug view + If we require it in the future. 
-        UnpackFloatUInt8bit(inGBuffer2.b, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
+        UnpackFloatInt8bit(inGBuffer2.b, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
 
         // Reminder: when using SSS we exchange specular occlusion and subsurfaceMask/profileID
         bsdfData.specularOcclusion = inGBuffer2.r;
 
             float unused;
             uint tangentFlags;
-            UnpackFloatUInt8bit(inGBuffer2.b, 8, unused, tangentFlags);
+            UnpackFloatInt8bit(inGBuffer2.b, 8, unused, tangentFlags);
 
             // Get the rotation angle of the actual tangent frame with respect to the default one.
             uint  quadrant = tangentFlags;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/SubsurfaceScattering/SubsurfaceScattering.hlsl

 // Note: The SSS buffer used here is sRGB
 void EncodeIntoSSSBuffer(SSSData sssData, uint2 positionSS, out SSSBufferType0 outSSSBuffer0)
 {
-    outSSSBuffer0 = float4(sssData.diffuseColor, PackFloatUInt8bit(sssData.subsurfaceMask, sssData.diffusionProfile, 16));
+    outSSSBuffer0 = float4(sssData.diffuseColor, PackFloatInt8bit(sssData.subsurfaceMask, sssData.diffusionProfile, 16));
 }
 
 // Note: The SSS buffer used here is sRGB
-    UnpackFloatUInt8bit(sssBuffer.a, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
+    UnpackFloatInt8bit(sssBuffer.a, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
 }
 
 void DecodeFromSSSBuffer(uint2 positionSS, out SSSData sssData)