Fix error: Output Particle Lit Quad': undeclared identifier 'ComputeReflectionProbeNormalizationDirection'. Fix a bunch of shader warnings in DynamicGI shaders. (#11)

Co-authored-by: pastasfuture <[email protected]>

Author: pastasfuture

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ExtractGIData.compute

@@ -30,7 +30,7 @@ int _RequestBatchSize;
 [numthreads(GROUP_SIZE, 1, 1)]
 void ExtractData(uint3 id : SV_DispatchThreadID)
 {
-    if (id.x < _RequestBatchSize)
+    if (id.x < (uint)_RequestBatchSize)
     {
         ExtraDataRequest req = _RequestsInputData[id.x];
         ExtraDataRequestOutput output;

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagation.hlsl

@@ -29,7 +29,7 @@ float3 ReadPreviousPropagationAxis(uint probeIndex, uint axisIndex)
     const uint index = probeIndex * NEIGHBOR_AXIS_COUNT + axisIndex;
 
     // TODO: remove this if check with stricter checks on construction side in C#
-    if(index < _RadianceCacheAxisCount)
+    if(index < (uint)_RadianceCacheAxisCount)
     {
         return _PreviousRadianceCacheAxis[index];
     }
@@ -53,7 +53,7 @@ void WritePropagationOutput(uint probeIndex, uint axisIndex, float4 lightingAndW
     const uint index = probeIndex * NEIGHBOR_AXIS_COUNT + axisIndex;
 
     // TODO: remove this if check with stricter checks on construction side in C#
-    if(index < _RadianceCacheAxisCount)
+    if(index < (uint)_RadianceCacheAxisCount)
     {
         const float3 finalRadiance = NormalizeOutputRadiance(lightingAndWeight, probeValidity);
         _RadianceCacheAxis[index] = finalRadiance;

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationAxes.compute

@@ -61,8 +61,8 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
     const int index = id.x;
     if (index < _ProbeVolumeNeighborsCount)
     {
-        const uint probeIndex = index / NEIGHBOR_AXIS_COUNT;
-        const uint axisIndex = index - probeIndex * NEIGHBOR_AXIS_COUNT;
+        const uint probeIndex = (uint)index / NEIGHBOR_AXIS_COUNT;
+        const uint axisIndex = (uint)index - probeIndex * NEIGHBOR_AXIS_COUNT;
 
         float4 lightingAndWeight = float4(0, 0, 0, 1);
         uint3 probeCoordinate = ProbeIndexToProbeCoordinatesUint(probeIndex);
@@ -79,11 +79,11 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
         float3 incomingRadiance = 0;
         float weight = 0.0f;
         float probeValidity = 0;
-        float3 axis = _RayAxis[axisIndex];
+        float3 axis = _RayAxis[axisIndex].xyz;
 
         for(int i=0; i < NEIGHBOR_AXIS_COUNT; ++i)
         {
-            float3 neighborDirection = _RayAxis[i];
+            float3 neighborDirection = _RayAxis[i].xyz;
             uint sampleAxis = probeIndex * NEIGHBOR_AXIS_COUNT + i;
             NeighborAxis neighbor = _ProbeVolumeNeighbors[sampleAxis];
 
@@ -99,7 +99,7 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
             UnpackIndicesAndValidityOnly(neighbor.hitIndexValidity, hitIndex, probeAxisValidity);
             probeValidity += probeAxisValidity;
 
-            if(hitIndex < _HitRadianceCacheAxisCount)
+            if(hitIndex < (uint)_HitRadianceCacheAxisCount)
             {
                 // Hit
                 weight += sgWeight;
@@ -112,9 +112,9 @@ void PropagateLight(uint3 id : SV_DispatchThreadID)
                 int3 neighborProbeCoordinate = probeCoordinate + offset;
 
                 //TODO: remove missed axis on generation to avoid this branch entirely here
-                if(neighborProbeCoordinate.x >= 0 && neighborProbeCoordinate.x < _ProbeVolumeDGIResolutionX &&
-                   neighborProbeCoordinate.y >= 0 && neighborProbeCoordinate.y < _ProbeVolumeDGIResolutionY &&
-                   neighborProbeCoordinate.z >= 0 && neighborProbeCoordinate.z < _ProbeVolumeDGIResolutionZ)
+                if(neighborProbeCoordinate.x >= 0 && neighborProbeCoordinate.x < (int)_ProbeVolumeDGIResolutionX &&
+                   neighborProbeCoordinate.y >= 0 && neighborProbeCoordinate.y < (int)_ProbeVolumeDGIResolutionY &&
+                   neighborProbeCoordinate.z >= 0 && neighborProbeCoordinate.z < (int)_ProbeVolumeDGIResolutionZ)
                 {
                     uint neighborProbeIndex = ProbeCoordinateToIndex(neighborProbeCoordinate);
                     float3 prevAxisRadiance = ReadPreviousPropagationAxis(neighborProbeIndex, axisIndex);

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationCombine.compute

@@ -148,7 +148,8 @@ SHIncomingIrradiance ProjectPropagationAxisFromPeak(uint probeIndex)
 #if !defined(SH_FROM_SG_PBR_FIT_WITH_COSINE_WINDOW)
 float ZHWindowComputeFromSphericalGaussianC0(float sharpness)
 {
-    return pow(sharpness * 1.22962 + 0.823224, -1.25462) * 3.73236 + 0.0289582;
+    // sharpness * 1.22962 + 0.823224 is always positive. abs is to simply make the compiler happy.
+    return pow(abs(sharpness) * 1.22962 + 0.823224, -1.25462) * 3.73236 + 0.0289582;
 }
 
 float ZHWindowComputeFromSphericalGaussianC1(float sharpness)
@@ -173,7 +174,8 @@ float ZHWindowComputeFromSphericalGaussianC2(float sharpness)
 #else
 float ZHWindowComputeFromSphericalGaussianC0(float sharpness)
 {
-    return pow(sharpness * 0.386254 + 1.55848, -1.52661) * 1.72542 + 0.0290483;
+    // sharpness * 0.386254 + 1.55848 is always positive. abs is to simply make the compiler happy.
+    return pow(abs(sharpness) * 0.386254 + 1.55848, -1.52661) * 1.72542 + 0.0290483;
 }
 
 float ZHWindowComputeFromSphericalGaussianC1(float sharpness)

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationHits.compute

@@ -81,15 +81,15 @@ void GatherLighting(SurfaceHitData hit, inout float4 lighting)
 #if SUPPORTS_AREA_LIGHTS
     // Area lights
     int lastAreaLightIndex = _DynamicGIPunctualLightCount + _DynamicGIAreaLightCount;
-    for (uint areaLightIdx = _DynamicGIPunctualLightCount; areaLightIdx < lastAreaLightIndex; ++areaLightIdx)
+    for (uint areaLightIdx = (uint)_DynamicGIPunctualLightCount; areaLightIdx < (uint)lastAreaLightIndex; ++areaLightIdx)
     {
         light = _DynamicGILightDatas[areaLightIdx];
         lighting.xyz += GetLightingForAxisArea(light, _IndirectScale, hit) * _DirectContribution;
     }
 #endif
 
     // Directional
-    for (uint dirLightIdx = 0; dirLightIdx < _DirectionalLightCount; ++dirLightIdx)
+    for (uint dirLightIdx = 0; dirLightIdx < (uint)_DirectionalLightCount; ++dirLightIdx)
     {
         DirectionalLightData dirData = _DirectionalLightDatas[dirLightIdx];
         // Only support the shadow casting one otherwise result is completely off.
@@ -135,7 +135,7 @@ float3 ProbeCoordinatesToWorldPosition(float3 probeCoordinates, float3x3 probeVo
 SurfaceHitData ConstructSurfaceHit(PackedNeighborHit neighborData, float3 worldPosition, float3x3 probeVolumeLtw)
 {
     float4 albedoDistance = UnpackAlbedoAndDistance(neighborData.albedoDistance, _ProbeVolumeDGIMaxNeighborDistance);
-    float3 axis = UnpackAxis(neighborData.normalAxis);
+    float3 axis = UnpackAxis(neighborData.normalAxis).xyz;
 
     axis = mul(axis, probeVolumeLtw);
 

com.unity.render-pipelines.high-definition/Runtime/Lighting/ProbeVolume/DynamicGI/ProbePropagationSphericalGaussians.hlsl

@@ -11,7 +11,7 @@ float3 EvaluateSG(uint probeIndex, float3 normal, float sharpness, in float4 _Ra
     for(int i=0; i < NEIGHBOR_AXIS_COUNT; ++i)
     {
         float3 prevAxisRadiance = ReadPreviousPropagationAxis(probeIndex, i);
-        float3 axis = _RayAxis[i];
+        float3 axis = _RayAxis[i].xyz;
 
         SphericalGaussian sg;
         sg.amplitude = 1;
@@ -36,7 +36,7 @@ float3 EvaluateBRDFLambertApproximate(uint probeIndex, float3 surfaceNormal, flo
     for(int i=0; i < NEIGHBOR_AXIS_COUNT; ++i)
     {
         float3 prevAxisRadiance = ReadPreviousPropagationAxis(probeIndex, i);
-        float3 axis = _RayAxis[i];
+        float3 axis = _RayAxis[i].xyz;
 
         SphericalGaussian sg;
         sg.amplitude = 1;

com.unity.render-pipelines.high-definition/Runtime/Material/Lit/SimpleLit.hlsl

@@ -396,6 +396,15 @@ DirectLighting EvaluateBSDF_Area(LightLoopContext lightLoopContext,
     return lighting;
 }
 
+float3 ComputeReflectionProbeNormalizationDirection(BSDFData bsdfData, PreLightData preLightData, float3 V)
+{
+    // SimpleLit is used in the context of VFX, who only sample the DC term of the SH data.
+    // Could technically return any direction.
+    // To keep things reasonable, in case sampling additional SH terms is added at a later point to VFX,
+    // use the surface normal as the normalization direction. This works best with fully rough surfaces.
+    return bsdfData.normalWS;
+}
+
 //-----------------------------------------------------------------------------
 // EvaluateBSDF_Env
 // ----------------------------------------------------------------------------