perf(Terrain Variation): feature rework, miplevel & sample optimisation

features/Terrain Variation/Shaders/TerrainVariation/TerrainVariation.hlsli

@@ -8,6 +8,20 @@
 #include "Common/Random.hlsli"
 #include "Common/SharedData.hlsli"
 
+// --------------------- CONSTANTS AND STRUCTURES --------------------- //
+// Height blend operator settings - DO NOT CHANGE THESE VALUES.
+static const float HEIGHT_BLEND_CONTRAST = 12.0;  // Controls sharpness of height-based transitions (reduced from 16.0 for performance)
+static const float HEIGHT_INFLUENCE = 0.3;        // How much height affects blending (0=pure stochastic, 1=pure height)
+// Pre-computed constants to avoid runtime calculations
+static const float2x2 SKEW_MATRIX = float2x2(1.0, 0.0, -0.57735027, 1.15470054);
+static const float WORLD_SCALE = 332.54;
+// Blending constants
+static const float3 DEFAULT_WEIGHTS = float3(0.33, 0.33, 0.34);
+static const float3 LUMINANCE_WEIGHTS = float3(0.2126, 0.7152, 0.0722);
+// Hash constants
+static const float2 HASH_MULTIPLIER = float2(1271.5151, 3337.8237);
+static const float2 HASH_SINE_MULTIPLIER = float2(43758.5453, 28637.1369);
+
 // Structure to hold stochastic sampling offsets and weights
 struct StochasticOffsets
 {
@@ -17,86 +31,185 @@ struct StochasticOffsets
 	float3 weights;
 };
 
-// Compute a distance factor for scaling stochastic effect strength (0-1)
-// Returns 0 for distances <= startDistance, 1 for distances >= maxDistance
-inline float ComputeDistanceFactor(float distance)
+// --------------------- COMPUTE FUNCTIONS --------------------- //
+
+// Hash function for stochastic sampling
+inline float2 hash2D2D(float2 s)
 {
-	if (!SharedData::terrainVariationSettings.enableTilingFix)
-		return 0.0;
+	s = s * HASH_MULTIPLIER;
+	return frac(sin(s.x + s.y) * HASH_SINE_MULTIPLIER);
+}
 
-	return saturate((distance - SharedData::terrainVariationSettings.startDistance) *
-					SharedData::terrainVariationSettings.invDistanceRange);
+inline float2 hashLOD(float2 p)
+{
+	p = frac(p * 0.318);
+	return frac(p.x + p.y * 17.0);
 }
 
-// Hash function for stochastic sampling
-inline float2 hash2D2D(float2 s)
+// Common barycentric coordinate calculation for stochastic sampling
+inline float4x3 ComputeBarycentricVerts(float2 landscapeUV)
 {
-	// Choose hash implementation based on quality setting
-	if (SharedData::terrainVariationSettings.hashQuality == 0) {
-		// Low quality, no fmod, slight tiling, almost negligible difference, 0.05ms or so.
-		s = s * float2(1271.5151, 3337.8237);
-		return frac(sin(s.x + s.y) * float2(43758.5453, 28637.1369));
-	} else {
-		// High quality, better blend with fmod funct.
-		return frac(sin(fmod(float2(dot(s, float2(127.1, 311.7)), dot(s, float2(269.5, 183.3))), 3.14159)) * 43758.5453);
-	}
+    float2 scaledUV = landscapeUV * (WORLD_SCALE);
+    float2 skewUV = mul(SKEW_MATRIX, scaledUV);
+    float2 vxID = floor(skewUV);
+    float2 frac_uv = frac(skewUV);
+    float barry_z = 1.0 - frac_uv.x - frac_uv.y;
+    float3 barry = float3(frac_uv, barry_z);
+
+    return (barry.z > 0) ?
+        float4x3(float3(vxID, 0), float3(vxID + float2(0, 1), 0), float3(vxID + float2(1, 0), 0), barry.zyx) :
+        float4x3(float3(vxID + float2(1, 1), 0), float3(vxID + float2(1, 0), 0), float3(vxID + float2(0, 1), 0), float3(-barry.z, 1.0 - barry.y, 1.0 - barry.x));
+}
+
+inline StochasticOffsets ComputeStochasticOffsets(float2 landscapeUV)
+{
+    float4x3 BW_vx = ComputeBarycentricVerts(landscapeUV);
+
+    StochasticOffsets offsets;
+    offsets.offset1 = hash2D2D(BW_vx[0].xy);
+    offsets.offset2 = hash2D2D(BW_vx[1].xy);
+    offsets.offset3 = hash2D2D(BW_vx[2].xy);
+    offsets.weights = BW_vx[3];
+
+    return offsets;
+}
+
+inline StochasticOffsets ComputeStochasticOffsetsLOD(float2 landscapeUV)
+{
+	// Precomputed scaling: (WORLD_SCALE / 0.010416667) * 8.0 = ~255437
+	static const float LOD_SCALE = 255437.0;
+
+	float2 scaledUV = landscapeUV * LOD_SCALE;
+	float2 cellID = floor(scaledUV);
+
+	StochasticOffsets offsetsLOD;
+	// Generate both offsets from single hash to reduce calls
+	float2 hash1 = hashLOD(cellID);
+	float2 hash2 = hashLOD(cellID + 127.0);
+
+	offsetsLOD.offset1 = hash1 * 0.08;
+	offsetsLOD.offset2 = hash2 * 0.08;
+
+	// Simplified weights since we only use 2 samples now
+	offsetsLOD.weights = float3(0.65, 0.35, 0.0);
+
+	return offsetsLOD;
 }
 
-// Compute offsets for stochastic sampling
-inline StochasticOffsets ComputeStochasticOffsets(float2 UV)
+// --------------------- STOCHASTIC SAMPLING FUNCTIONS --------------------- //
+
+inline float3 NormalizeWeights(float3 weights)
 {
-	float2 skewUV = mul(float2x2(1.0, 0.0, -0.57735027, 1.15470054), UV * 3.464);
-	float2 vxID = floor(skewUV);
-	float3 barry = float3(frac(skewUV), 0.0);
-	barry.z = 1.0 - barry.x - barry.y;
-
-	float4x3 BW_vx = (barry.z > 0) ?
-	                     float4x3(float3(vxID, 0), float3(vxID + float2(0, 1), 0), float3(vxID + float2(1, 0), 0), barry.zyx) :
-	                     float4x3(float3(vxID + float2(1, 1), 0), float3(vxID + float2(1, 0), 0), float3(vxID + float2(0, 1), 0), float3(-barry.z, 1.0 - barry.y, 1.0 - barry.x));
-
-	StochasticOffsets offsets;
-	offsets.offset1 = hash2D2D(BW_vx[0].xy);
-	offsets.offset2 = hash2D2D(BW_vx[1].xy);
-	offsets.offset3 = hash2D2D(BW_vx[2].xy);
-	offsets.weights = BW_vx[3];
-	return offsets;
+	float rcpWeightSum = rcp(weights.x + weights.y + weights.z);
+	return weights * rcpWeightSum;
+}
+
+// Stochastic sampling function for Terrain LOD & LOD Mask.
+inline float4 StochasticSampleLOD(float rnd, float mipLevel, Texture2D tex, SamplerState samp, float2 uv, StochasticOffsets offsetsLOD, float2 dx, float2 dy)
+{
+	// Apply mip bias to match normal sampling behavior
+	float adjustedMipLevel = mipLevel + SharedData::MipBias;
+	float offsetScale = 0.01;
+
+	// Cheap pseudo-rotation using simple transforms
+	float2 dir1 = float2(rnd - 0.5, frac(rnd * 1.618) - 0.5);
+	float2 dir2 = float2(dir1.y, -dir1.x);
+
+	// Apply simple scaled offsets
+	float2 microOffset1 = (offsetsLOD.offset1 + dir1) * offsetScale;
+	float2 microOffset2 = (offsetsLOD.offset2 + dir2) * offsetScale;
+
+	// Sample only two offsets
+	float4 sample1 = tex.SampleLevel(samp, uv + microOffset1, adjustedMipLevel);
+	float4 sample2 = tex.SampleLevel(samp, uv + microOffset2, adjustedMipLevel);
+
+	// Simple 2-sample blend weighted toward first sample
+	return lerp(sample2, sample1, 0.65);
 }
 
 // Main stochastic sampling function
-inline float4 StochasticEffect(float rnd, float mipLevel, Texture2D tex, SamplerState samp, float2 uv, StochasticOffsets offsets, float2 dx, float2 dy, float distance = 0.0)
+inline float4 StochasticEffect(float rnd, float mipLevel, Texture2D tex, SamplerState samp, float2 uv, StochasticOffsets offsets, float2 dx, float2 dy)
+{
+
+	// Apply mip bias to match normal sampling behavior
+	float adjustedMipLevel = mipLevel + SharedData::MipBias;
+
+	// Take first sample (always needed)
+	float4 sample1 = tex.SampleLevel(samp, uv + offsets.offset1, adjustedMipLevel);
+
+	// Calculate smooth transition factor - starts blending at mip 2.5, fully single sample at mip 5.0
+	float mipFactor = saturate((mipLevel - 2.5) / 2.5);
+
+	// Early exit for very high mip levels - single sample is sufficient
+	if (mipFactor >= 0.8)
+	{
+		return sample1;
+	}
+
+	// Take remaining samples for blending
+	float4 sample2 = tex.SampleLevel(samp, uv + offsets.offset2, adjustedMipLevel);
+	float4 sample3 = tex.SampleLevel(samp, uv + offsets.offset3, adjustedMipLevel);
+
+	// Full height-based blending for low mip levels (close terrain)
+	float contrastFactor = HEIGHT_BLEND_CONTRAST * (1.0 - HEIGHT_INFLUENCE);
+	float3 blendWeights = pow(saturate(offsets.weights), contrastFactor);
+
+	// Direct height calculation without matrix
+	float3 luminanceHeights = float3(
+		dot(sample1.rgb, LUMINANCE_WEIGHTS),
+		dot(sample2.rgb, LUMINANCE_WEIGHTS),
+		dot(sample3.rgb, LUMINANCE_WEIGHTS)
+	);
+
+	// Use alpha for height only for PBR systems, fallback to luminance for Complex Material
+	#if defined(TRUE_PBR)
+	float3 alphaValues = float3(sample1.a, sample2.a, sample3.a);
+	float3 alphaMask = step(0.001, alphaValues);
+	float3 heights = lerp(luminanceHeights, alphaValues, alphaMask);
+	#else
+	// For Complex Material systems, use luminance-based height to avoid alpha channel conflicts
+	float3 heights = luminanceHeights;
+	#endif
+
+	// Combined weight calculation and normalization
+	float3 weights = NormalizeWeights(blendWeights * (1.0 + HEIGHT_INFLUENCE * heights));
+
+	// Direct blend without intermediate variable
+	float4 highQualitySample = sample1 * weights.x + sample2 * weights.y + sample3 * weights.z;
+
+	// Smooth transition between high quality and single sample based on mip level
+	return lerp(highQualitySample, sample1, mipFactor);
+}
+
+// Stochastic sampling function without height blending for better performance
+inline float4 StochasticEffectNoHeight(float rnd, float mipLevel, Texture2D tex, SamplerState samp, float2 uv, StochasticOffsets offsets, float2 dx, float2 dy)
 {
-	// If feature is disabled, return standard sample
-	if (!SharedData::terrainVariationSettings.enableTilingFix)
-		return tex.SampleGrad(samp, uv, dx, dy);
-
-	// Calculate distance factor (0 when close, 1 when far)
-	float distanceFactor = ComputeDistanceFactor(distance);
-
-	bool useParallax = SharedData::extendedMaterialSettings.EnableTerrainParallax;
-	float4 sample1, sample2, sample3, standardSample;
-
-	// Get stochastic samples
-	if (useParallax) {
-		// Parallax enabled, can use SampleLevel for better perf
-		sample1 = tex.SampleLevel(samp, uv + offsets.offset1, mipLevel);
-		sample2 = tex.SampleLevel(samp, uv + offsets.offset2, mipLevel);
-		sample3 = tex.SampleLevel(samp, uv + offsets.offset3, mipLevel);
-		standardSample = tex.SampleLevel(samp, uv, mipLevel);
-	} else {
-		// When parallax disabled, samplelevel causes mipmap issues, it uses too low a mipmap level up close.
-		sample1 = tex.SampleGrad(samp, uv + offsets.offset1, dx, dy);
-		sample2 = tex.SampleGrad(samp, uv + offsets.offset2, dx, dy);
-		sample3 = tex.SampleGrad(samp, uv + offsets.offset3, dx, dy);
-		standardSample = tex.SampleGrad(samp, uv, dx, dy);
+	// Apply mip bias to match normal sampling behavior
+	float adjustedMipLevel = mipLevel + SharedData::MipBias;
+
+	// Take first sample (always needed)
+	float4 sample1 = tex.SampleLevel(samp, uv + offsets.offset1, adjustedMipLevel);
+
+	// Calculate smooth transition factor - starts blending at mip 2.5, fully single sample at mip 5.0
+	float mipFactor = saturate((mipLevel - 2.5) / 2.5);
+
+	// Early exit for very high mip levels - single sample is sufficient
+	if (mipFactor >= 0.8)
+	{
+		return sample1;
 	}
 
-	// Weight samples according to offsets
-	float4 stochasticSample = sample1 * offsets.weights.x +
-	                          sample2 * offsets.weights.y +
-	                          sample3 * offsets.weights.z;
+	// Take remaining samples for blending
+	float4 sample2 = tex.SampleLevel(samp, uv + offsets.offset2, adjustedMipLevel);
+	float4 sample3 = tex.SampleLevel(samp, uv + offsets.offset3, adjustedMipLevel);
 
-	return lerp(standardSample, stochasticSample, distanceFactor);
+	// Simple barycentric blend without height influence
+	float3 weights = NormalizeWeights(saturate(offsets.weights));
+	float4 blendedSample = sample1 * weights.x + sample2 * weights.y + sample3 * weights.z;
+
+	// Smooth transition between blended and single sample based on mip level
+	return lerp(blendedSample, sample1, mipFactor);
 }
-#define StochasticSample(rnd, mipLevel, tex, samp, uv, dist) StochasticEffect(rnd, mipLevel, tex, samp, uv, ComputeStochasticOffsets(uv), ddx(uv), ddy(uv), dist).rgb
+
 
 #endif  // TERRAIN_VARIATION_HLSLI

package/Shaders/Common/SharedData.hlsli

@@ -165,13 +165,8 @@ namespace SharedData
 	struct TerrainVariationSettings
 	{
 		bool enableTilingFix;
-		float startDistance;
-		float maxDistance;
-		float invDistanceRange;          // For distance calc optimisation
-		float heightCompensationFactor;  // Compensation multiplier for terrain parallax
-		float shadowRayDirFactor;        // Shadow ray direction multiplier
-		int hashQuality;                 // 0 = Low quality hash, 1 = High quality hash
-		float pad;
+		bool enableLODTerrainTilingFix;
+		float2 pad0;
 	};
 
 	struct IBLSettings