Refactor math constant defines

ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl

 // unsigned integer bit field extract implementation
 uint BitFieldExtract(uint data, uint numBits, uint offset)
 {
-    uint mask = 0xFFFFFFFFu >> (32u - numBits);
+    uint mask = UINT_MAX >> (32u - numBits);
     return (data >> offset) & mask;
 }
 #endif // INTRINSIC_BITFIELD_EXTRACT
 #endif // INTRINSIC_CUBEMAP_FACE_ID
 
 // ----------------------------------------------------------------------------
-// Common math definition and fastmath function
+// Common math functions
-#define PI          3.14159265359
-#define TWO_PI      6.28318530718
-#define FOUR_PI     12.56637061436
-#define INV_PI      0.31830988618
-#define INV_TWO_PI  0.15915494309
-#define INV_FOUR_PI 0.07957747155
-#define HALF_PI     1.57079632679
-#define INV_HALF_PI 0.636619772367
-#define INFINITY    asfloat(0x7F800000)
-#define LOG2_E      1.44269504089
-
-#define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
-#define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number
-#define FLT_MAX     3.402823466e+38 // Maximum representable floating-point number
-
-#define HFLT_MIN    0.00006103515625 // 2^14  it is the same for 10, 11 and 16bit float. ref: https://www.khronos.org/opengl/wiki/Small_Float_Formats
-
 float DegToRad(float deg)
 {
     return deg * (PI / 180.0);
 // Using pow often result to a warning like this
 // "pow(f, e) will not work for negative f, use abs(f) or conditionally handle negative values if you expect them"
 // PositivePow remove this warning when you know the value is positive and avoid inf/NAN.
-TEMPLATE_2_FLT(PositivePow, base, power, return pow(max(abs(base), FLT_EPSILON), power))
+TEMPLATE_2_FLT(PositivePow, base, power, return pow(max(abs(base), FLT_EPS), power))
 
 // Ref: https://twitter.com/SebAaltonen/status/878250919879639040
 // 2 mads (mad_sat and mad), faster than regular sign

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

 // These clamping function to max of floating point 16 bit are use to prevent INF in code in case of extreme value
 float ClampToFloat16Max(float value)
 {
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
 }
 
 // Ligthing convention

ScriptableRenderPipeline/Core/ShaderLibrary/CommonMaterial.hlsl

 // all pixels which belong to an SSS material are not black (those that don't always are).
 float3 TagLightingForSSS(float3 subsurfaceLighting)
 {
-    subsurfaceLighting.r = max(subsurfaceLighting.r, HFLT_MIN);
+    subsurfaceLighting.r = max(subsurfaceLighting.r, HALF_MIN);
     return subsurfaceLighting;
 }
 

ScriptableRenderPipeline/Core/ShaderLibrary/ImageBasedLighting.hlsl

     float m = PerceptualRoughnessToRoughness(perceptualRoughness);
 
     // Remap to spec power. See eq. 21 in --> https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
-    float n = (2.0 / max(FLT_EPSILON, m * m)) - 2.0;
+    float n = (2.0 / max(FLT_EPS, m * m)) - 2.0;
-    n /= (4.0 * max(NdotR, FLT_EPSILON));
+    n /= (4.0 * max(NdotR, FLT_EPS));
 
     // remap back to square root of real roughness (0.25 include both the sqrt root of the conversion and sqrt for going from roughness to perceptualRoughness)
     perceptualRoughness = pow(2.0 / (n + 2.0), 0.25);

ScriptableRenderPipeline/Core/ShaderLibrary/Macros.hlsl

 #define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)
 #endif
 
+#define PI          3.14159265358979323846
+#define TWO_PI      6.28318530717958647693
+#define FOUR_PI     12.5663706143591729538
+#define INV_PI      0.31830988618379067154
+#define INV_TWO_PI  0.15915494309189533577
+#define INV_FOUR_PI 0.07957747154594766788
+#define HALF_PI     1.57079632679489661923
+#define INV_HALF_PI 0.63661977236758134308
+#define LOG2_E      1.44269504088896340736
+#define INFINITY    asfloat(0x7F800000)
+
+#define FLT_EPS     1.192092896e-07	// Smallest positive number, such that 1.0 + FLT_EPS != 1.0
+#define FLT_MIN     1.175494351e-38	// Minimum representable positive floating-point number
+#define FLT_MAX     3.402823466e+38	// Maximum representable floating-point number
+#define HALF_MIN    6.103515625e-5  // 2^-14, the same value for 10, 11 and 16-bit: https://www.khronos.org/opengl/wiki/Small_Float_Formats
+#define HALF_MAX    65504.0
+#define UINT_MAX    0xFFFFFFFFu
+
 #define TEMPLATE_1_FLT(FunctionName, Parameter1, FunctionBody) \
 float  FunctionName(float  Parameter1) { FunctionBody; } \
 float2 FunctionName(float2 Parameter1) { FunctionBody; } \

ScriptableRenderPipeline/Core/ShaderLibrary/NormalSurfaceGradient.hlsl

 float3 SurfaceGradientFromPerturbedNormal(float3 nrmVertexNormal, float3 v)
 {
     float3 n = nrmVertexNormal;
-    float s = 1.0 / max(FLT_EPSILON, abs(dot(n, v)));
+    float s = 1.0 / max(FLT_EPS, abs(dot(n, v)));
     return s * (dot(n, v) * n - v);
 }
 

ScriptableRenderPipeline/Core/ShaderLibrary/Packing.hlsl

 // Packs an integer stored using at most 'numBits' into a [0..1] float.
 float PackInt(uint i, uint numBits)
 {
-    uint maxInt = 0xFFFFFFFFu >> (32u - numBits);
+    uint maxInt = UINT_MAX >> (32u - numBits);
     return saturate(i * rcp(maxInt));
 }
 
-    uint maxInt = 0xFFFFFFFFu >> (32u - numBits);
+    uint maxInt = UINT_MAX >> (32u - numBits);
     return (uint)(f * maxInt + 0.5); // Round instead of truncating
 }
 
 
 float UnpackUIntToFloat(uint src, uint numBits, uint offset)
 {
-    uint maxInt = 0xFFFFFFFFu >> (32u - numBits);
+    uint maxInt = UINT_MAX >> (32u - numBits);
     return float(BitFieldExtract(src, numBits, offset)) * rcp(maxInt);
 }
 

ScriptableRenderPipeline/Core/ShaderLibrary/VolumeRendering.hlsl

 // Absorption coefficient from Disney: http://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf
 float3 TransmittanceColorAtDistanceToAbsorption(float3 transmittanceColor, float atDistance)
 {
-    return -log(transmittanceColor + FLT_EPSILON) / max(atDistance, FLT_EPSILON);
+    return -log(transmittanceColor + FLT_EPS) / max(atDistance, FLT_EPS);
 }
 
 

ScriptableRenderPipeline/Core/Shadow/Shadow.cs

             }
 
             m_TmpSortKeys.Sort( new SortReverter() );
-            m_TmpSortKeys.ExtractTo( shadowRequests, 0, out shadowRequestsCount, delegate(long key) { return (int) (key & 0xffffffff); } );
+            m_TmpSortKeys.ExtractTo( shadowRequests, 0, out shadowRequestsCount, delegate(long key) { return (int) (key & UINT_MAX); } );
         }
 
         protected override void PruneShadowCasters( Camera camera, List<VisibleLight> lights, ref VectorArray<int> shadowRequests, ref ShadowRequestVector requestsGranted, out uint totalRequestCount )

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

 
                 BSDFData bsdfData;
                 BakeLightingData bakeLightingData;
-                DECODE_FROM_GBUFFER(posInput.unPositionSS, 0xFFFFFFFF, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                DECODE_FROM_GBUFFER(posInput.unPositionSS, UINT_MAX, bsdfData, bakeLightingData.bakeDiffuseLighting);
                 #ifdef SHADOWS_SHADOWMASK
                 DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
                 #endif

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/ClusteredUtils.hlsl

 float SuggestLogBase50(float tileFarPlane)
 {
     const float C = (float)(1 << g_iLog2NumClusters);
-    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPSILON, 1.0);
+    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPS, 1.0);
     float suggested_base = pow((1.0 + sqrt(max(0.0, 1.0 - 4.0 * rangeFittedDistance * (1.0 - rangeFittedDistance)))) / (2.0 * rangeFittedDistance), 2.0 / C);      //
     return max(g_fClustBase, suggested_base);
 }
 {
     const float C = (float)(1 << g_iLog2NumClusters);
-    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPSILON, 1.0);
+    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPS, 1.0);
     float suggested_base = pow((1 / 2.3) * max(0.0, (0.8 / rangeFittedDistance) - 1), 4.0 / (C * 2));     // approximate inverse of d*x^4 + (-x) + (1-d) = 0       - d is normalized distance
     return max(g_fClustBase, suggested_base);
 }

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/SortingComputeUtils.hlsl

 // have to make this sort routine a macro unfortunately because hlsl doesn't take
 // groupshared memory of unspecified length as an input parameter to a function.
 // maxcapacity_in must be a power of two.
-// all data from length_in and up to closest power of two will be filled with 0xffffffff
+// all data from length_in and up to closest power of two will be filled with UINT_MAX
-    for(int t=length+localThreadID; t<N; t+=nrthreads) { data[t]=0xffffffff; }              \
+    for(int t=length+localThreadID; t<N; t+=nrthreads) { data[t]=UINT_MAX; }              \
     GroupMemoryBarrierWithGroupSync();                                                      \
                                                                                             \
     for(int k=2; k<=N; k=2*k)                                                               \

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-bigtile.compute

 		SFiniteLightBound lgtDat = g_data[lightsListLDS[l]];
 
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
-			lightsListLDS[l]=0xffffffff;
+			lightsListLDS[l]=UINT_MAX;
 	}
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 				int resf = (positive>0 && negative>0) ? 0 : (positive>0 ? 1 : (negative>0 ? (-1) : 0));
 
 				bool bFoundSepPlane = (resh*resf)<0;
-				if(bFoundSepPlane) lightsListLDS[l]=0xffffffff;
+				if(bFoundSepPlane) lightsListLDS[l]=UINT_MAX;
 			}
 		}
 	}

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/lightlistbuild-clustered.compute

 		SFiniteLightBound lgtDat = g_data[coarseList[l]];
 
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
-			coarseList[l]=0xffffffff;
+			coarseList[l]=UINT_MAX;
 	}
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 		int offs = 0;
 		for(int l=0; l<iNrCoarseLights; l++)
 		{
-			if(coarseList[l]!=0xffffffff)
+			if(coarseList[l]!=UINT_MAX)
 				coarseList[offs++] = coarseList[l];
 		}
 		lightOffsSph = offs;

ScriptableRenderPipeline/HDRenderPipeline/Lighting/TilePass/scrbound.compute

 				float fW = vPnts[k].w;
 				float fS = fW<0 ? -1 : 1;
 				float fWabs = fW<0 ? (-fW) : fW;
-				fW = fS * (fWabs<FLT_EPSILON ? FLT_EPSILON : fWabs);
+				fW = fS * (fWabs<FLT_EPS ? FLT_EPS : fWabs);
 				float3 vP = float3(vPnts[k].x/fW, vPnts[k].y/fW, vPnts[k].z/fW);
 				if(k==0) { vMin=vP; vMax=vP; }
 

ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/Lit.hlsl

 // If a user do a lighting architecture without material classification, this can be remove
 #include "../../Lighting/TilePass/TilePass.cs.hlsl"
 
-static int g_FeatureFlags = 0xFFFFFFFF;
+static uint g_FeatureFlags = UINT_MAX;
-bool HasMaterialFeatureFlag(int flag)
+bool HasMaterialFeatureFlag(uint flag)
 {
     return ((g_FeatureFlags & flag) != 0);
 }
 
     // The material features system for material classification must allow compile time optimization (i.e everything should be static)
     // Note that as we store materialId for Aniso based on content of RT2 we need to add few extra condition.
-    // The code is also call from MaterialFeatureFlagsFromGBuffer, so must work fully dynamic if featureFlags is 0xFFFFFFFF
+    // The code is also call from MaterialFeatureFlagsFromGBuffer, so must work fully dynamic if featureFlags is UINT_MAX
     int supportsStandard = HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_STANDARD);
     int supportsSSS = HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_SSS);
     int supportsAniso = HasMaterialFeatureFlag(MATERIALFEATUREFLAGS_LIT_ANISO);
 
     DecodeFromGBuffer(
         unPositionSS,
-        0xFFFFFFFF,
+        UINT_MAX,
         bsdfData,
         unused
     );
         float NdotL = saturate(dot(bsdfData.coatNormalWS, L));
         float NdotV = preLightData.coatNdotV;
         float LdotV = dot(L, V);
-        float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_EPSILON));
+        float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_EPS));
         float NdotH = saturate((NdotL + NdotV) * invLenLV);
         float LdotH = saturate(invLenLV * LdotV + invLenLV);
 
     float NdotL    = saturate(dot(bsdfData.normalWS, L)); // Must have the same value without the clamp
     float NdotV    = preLightData.NdotV;                  // Get the unaltered (geometric) version
     float LdotV    = dot(L, V);
-    float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_EPSILON)); // invLenLV = rcp(length(L + V)) - caution about the case where V and L are opposite, it can happen, use max to avoid this
+    float invLenLV = rsqrt(max(2 * LdotV + 2, FLT_EPS));  // invLenLV = rcp(length(L + V)) - caution about the case where V and L are opposite, it can happen, use max to avoid this
     float NdotH    = saturate((NdotL + NdotV) * invLenLV);
     float LdotH    = saturate(invLenLV * LdotV + invLenLV);