lightmap leaking fixes, optimizations (#986)

WickedEngine/offlineshadercompiler.cpp

@@ -232,6 +232,7 @@ wi::vector<ShaderEntry> shaders = {
 	{"causticsCS", wi::graphics::ShaderStage::CS },
 	{"depth_reprojectCS", wi::graphics::ShaderStage::CS },
 	{"depth_pyramidCS", wi::graphics::ShaderStage::CS },
+	{"lightmap_expandCS", wi::graphics::ShaderStage::CS },
 
 
 	{"emittedparticlePS_soft", wi::graphics::ShaderStage::PS },

WickedEngine/shaders/ShaderInterop_Renderer.h

@@ -649,7 +649,7 @@ struct alignas(16) ShaderMeshInstance
 	uint layerMask;
 	uint geometryOffset;	// offset of all geometries for currently active LOD
 
-	uint2 emissive;
+	uint2 emissive; // packed half4
 	uint color;
 	uint geometryCount;		// number of all geometries in currently active LOD
 
@@ -664,12 +664,11 @@ struct alignas(16) ShaderMeshInstance
 	int vb_ao;
 	int vb_wetmap;
 	int lightmap;
-	uint alphaTest_size;
+	uint alphaTest_size; // packed half2
 
-	uint2 rimHighlight;
-	uint2 padding;
+	uint2 rimHighlight; // packed half4
+	uint2 quaternion; // packed half4
 
-	float4 quaternion;
 	ShaderTransform transform;
 	ShaderTransform transformPrev;
 	ShaderTransform transformRaw; // without quantization remapping applied
@@ -693,7 +692,11 @@ struct alignas(16) ShaderMeshInstance
 		vb_ao = -1;
 		vb_wetmap = -1;
 		alphaTest_size = 0;
-		quaternion = float4(0, 0, 0, 1);
+#ifdef __cplusplus
+		quaternion = wi::math::pack_half4(float4(0, 0, 0, 1));
+#else
+		quaternion = pack_half4(float4(0, 0, 0, 1));
+#endif // __cplusplus
 		rimHighlight = uint2(0, 0);
 		transform.init();
 		transformPrev.init();
@@ -715,6 +718,7 @@ struct alignas(16) ShaderMeshInstance
 	inline half GetAlphaTest() { return unpack_half2(alphaTest_size).x; }
 	inline half GetSize() { return unpack_half2(alphaTest_size).y; }
 	inline half4 GetRimHighlight() { return unpack_half4(rimHighlight); }
+	inline half4 GetQuaternion() { return unpack_half4(quaternion); }
 #endif // __cplusplus
 };
 struct ShaderMeshInstancePointer
@@ -1146,7 +1150,7 @@ struct alignas(16) FrameCB
 
 	float		cloudShadowFarPlaneKm;
 	int			texture_volumetricclouds_shadow_index;
-	float		gi_boost;
+	uint		giboost_packed; // force fp16 load
 	uint		entity_culling_count;
 
 	float		blue_noise_phase;

WickedEngine/shaders/ShaderInterop_Weather.h

@@ -355,29 +355,28 @@ struct alignas(16) ShaderOcean
 
 struct alignas(16) ShaderWeather
 {
-	float3 sun_color;
-	float stars; // number of stars (0: disable stars, >0: increase number of stars)
+	uint2 sun_direction; // packed half3
+	uint2 sun_color; // packed half3
 
-	float3 sun_direction;
+	uint2 ambient; // packed half3
 	uint most_important_light_index;
+	float stars; // number of stars (0: disable stars, >0: increase number of stars)
 
-	float3 horizon;
-	float sky_exposure;
-
-	float3 zenith;
-	float sky_rotation_sin;
+	uint2 horizon; // packed half3
+	uint2 zenith; // packed half3
 
-	float3 ambient;
-	float sky_rotation_cos;
+	float4 stars_rotation; // quaternion
 
-	float4x4 stars_rotation;
+	float3 padding_stars;
 
+	float sky_rotation_sin;
+	float sky_rotation_cos;
+	float sky_exposure;
 	float rain_amount;
+
 	float rain_length;
 	float rain_speed;
 	float rain_scale;
-
-	float3 padding_rain;
 	float rain_splash_scale;
 
 	float4 rain_color;

WickedEngine/shaders/Shaders_SOURCE.vcxitems

@@ -434,6 +434,10 @@
     <FxCompile Include="$(MSBuildThisFileDirectory)impostorPS_prepass_depthonly.hlsl">
       <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Pixel</ShaderType>
     </FxCompile>
+    <FxCompile Include="$(MSBuildThisFileDirectory)lightmap_expandCS.hlsl">
+      <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Compute</ShaderType>
+      <ShaderModel Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">4.0</ShaderModel>
+    </FxCompile>
     <FxCompile Include="$(MSBuildThisFileDirectory)lineardepthCS.hlsl">
       <ShaderType Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Compute</ShaderType>
       <ShaderModel Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">4.0</ShaderModel>

WickedEngine/shaders/Shaders_SOURCE.vcxitems.filters

@@ -1181,6 +1181,9 @@
     <FxCompile Include="$(MSBuildThisFileDirectory)paintdecalPS.hlsl">
       <Filter>PS</Filter>
     </FxCompile>
+    <FxCompile Include="$(MSBuildThisFileDirectory)lightmap_expandCS.hlsl">
+      <Filter>CS</Filter>
+    </FxCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="$(MSBuildThisFileDirectory)ShaderInterop.h">

WickedEngine/shaders/fogHF.hlsli

@@ -19,7 +19,7 @@ inline half GetFogAmount(float distance, float3 O, float3 V)
 
 	if (GetFrame().options & OPTION_BIT_HEIGHT_FOG)
 	{
-		float fogFalloffScale = 1.0 / max(0.01, fog.height_end - fog.height_start);
+		float fogFalloffScale = rcp(max(0.01, fog.height_end - fog.height_start));
 
 		// solve for x, e^(-h * x) = 0.001
 		// x = 6.907755 * h^-1
@@ -71,19 +71,19 @@ inline half4 GetFog(float distance, float3 O, float3 V)
 
 	// Sample inscattering color:
 	{
-		const float3 L = GetSunDirection();
+		const half3 L = GetSunDirection();
 
 		half3 inscatteringColor = GetSunColor();
 
 		// Apply atmosphere transmittance:
 		if (GetFrame().options & OPTION_BIT_REALISTIC_SKY)
 		{
 			// 0 for position since fog is centered around world center
-			inscatteringColor *= GetAtmosphericLightTransmittance(GetWeather().atmosphere, float3(0.0, 0.0, 0.0), L, texture_transmittancelut);
+			inscatteringColor *= GetAtmosphericLightTransmittance(GetWeather().atmosphere, 0, L, texture_transmittancelut);
 		}
 
 		// Apply phase function solely for directionality:
-		const float cosTheta = dot(-V, L);
+		const half cosTheta = dot(-V, L);
 		inscatteringColor *= HgPhase(FOG_INSCATTERING_PHASE_G, cosTheta);
 
 		// Apply uniform phase since this medium is constant:

WickedEngine/shaders/fontPS.hlsl

@@ -8,7 +8,7 @@ struct VertextoPixel
 	float2 bary : TEXCOORD1;
 };
 
-half4 main(VertextoPixel input) : SV_TARGET
+float4 main(VertextoPixel input) : SV_TARGET
 {
 	Texture2D<half4> tex = bindless_textures_half4[font.texture_index];
 	half value = tex.SampleLevel(sampler_linear_clamp, input.uv, 0).r;

WickedEngine/shaders/globals.hlsli

@@ -185,6 +185,10 @@ T inverse_lerp(T value1, T value2, T pos)
 		"SRV(t0, space = 22, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
 		"SRV(t0, space = 23, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
 		"SRV(t0, space = 24, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
+		"SRV(t0, space = 25, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
+		"SRV(t0, space = 26, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
+		"SRV(t0, space = 27, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
+		"SRV(t0, space = 28, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
 		"UAV(u0, space = 100, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
 		"UAV(u0, space = 101, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
 		"UAV(u0, space = 102, offset = 0, numDescriptors = unbounded, flags = DESCRIPTORS_VOLATILE | DATA_VOLATILE)," \
@@ -248,6 +252,10 @@ static const BindlessResource<Buffer<float>> bindless_buffers_float;
 static const BindlessResource<Buffer<float2>> bindless_buffers_float2;
 static const BindlessResource<Buffer<float3>> bindless_buffers_float3;
 static const BindlessResource<Buffer<float4>> bindless_buffers_float4;
+static const BindlessResource<Buffer<half>> bindless_buffers_half;
+static const BindlessResource<Buffer<half2>> bindless_buffers_half2;
+static const BindlessResource<Buffer<half3>> bindless_buffers_half3;
+static const BindlessResource<Buffer<half4>> bindless_buffers_half4;
 static const BindlessResource<Texture2DArray> bindless_textures2DArray;
 static const BindlessResource<Texture2DArray<half4>> bindless_textures2DArray_half4;
 static const BindlessResource<TextureCube> bindless_cubemaps;
@@ -300,6 +308,10 @@ static const uint DESCRIPTOR_SET_BINDLESS_ACCELERATION_STRUCTURE = 7;
 [[vk::binding(0, DESCRIPTOR_SET_BINDLESS_UNIFORM_TEXEL_BUFFER)]] Buffer<float2> bindless_buffers_float2[];
 [[vk::binding(0, DESCRIPTOR_SET_BINDLESS_UNIFORM_TEXEL_BUFFER)]] Buffer<float3> bindless_buffers_float3[];
 [[vk::binding(0, DESCRIPTOR_SET_BINDLESS_UNIFORM_TEXEL_BUFFER)]] Buffer<float4> bindless_buffers_float4[];
+[[vk::binding(0, DESCRIPTOR_SET_BINDLESS_UNIFORM_TEXEL_BUFFER)]] Buffer<half> bindless_buffers_half[];
+[[vk::binding(0, DESCRIPTOR_SET_BINDLESS_UNIFORM_TEXEL_BUFFER)]] Buffer<half2> bindless_buffers_half2[];
+[[vk::binding(0, DESCRIPTOR_SET_BINDLESS_UNIFORM_TEXEL_BUFFER)]] Buffer<half3> bindless_buffers_half3[];
+[[vk::binding(0, DESCRIPTOR_SET_BINDLESS_UNIFORM_TEXEL_BUFFER)]] Buffer<half4> bindless_buffers_half4[];
 [[vk::binding(0, DESCRIPTOR_SET_BINDLESS_SAMPLER)]] SamplerState bindless_samplers[];
 [[vk::binding(0, DESCRIPTOR_SET_BINDLESS_SAMPLED_IMAGE)]] Texture2D bindless_textures[];
 [[vk::binding(0, DESCRIPTOR_SET_BINDLESS_SAMPLED_IMAGE)]] Texture2DArray bindless_textures2DArray[];
@@ -362,6 +374,10 @@ Texture2D<float2> bindless_textures_float2[] : register(space21);
 Texture2D<uint> bindless_textures_uint[] : register(space22);
 Texture2D<uint4> bindless_textures_uint4[] : register(space23);
 Texture2D<half4> bindless_textures_half4[] : register(space24);
+Buffer<half> bindless_buffers_half[] : register(space25);
+Buffer<half2> bindless_buffers_half2[] : register(space26);
+Buffer<half3> bindless_buffers_half3[] : register(space27);
+Buffer<half4> bindless_buffers_half4[] : register(space28);
 
 RWTexture2D<float4> bindless_rwtextures[] : register(space100);
 RWByteAddressBuffer bindless_rwbuffers[] : register(space101);
@@ -618,15 +634,15 @@ struct PrimitiveID
 
 #define texture_random64x64 bindless_textures[GetFrame().texture_random64x64_index]
 #define texture_bluenoise bindless_textures[GetFrame().texture_bluenoise_index]
-#define texture_sheenlut bindless_textures[GetFrame().texture_sheenlut_index]
-#define texture_skyviewlut bindless_textures[GetFrame().texture_skyviewlut_index]
-#define texture_transmittancelut bindless_textures[GetFrame().texture_transmittancelut_index]
-#define texture_multiscatteringlut bindless_textures[GetFrame().texture_multiscatteringlut_index]
-#define texture_skyluminancelut bindless_textures[GetFrame().texture_skyluminancelut_index]
-#define texture_cameravolumelut bindless_textures3D[GetFrame().texture_cameravolumelut_index]
+#define texture_sheenlut bindless_textures_half4[GetFrame().texture_sheenlut_index]
+#define texture_skyviewlut bindless_textures_half4[GetFrame().texture_skyviewlut_index]
+#define texture_transmittancelut bindless_textures_half4[GetFrame().texture_transmittancelut_index]
+#define texture_multiscatteringlut bindless_textures_half4[GetFrame().texture_multiscatteringlut_index]
+#define texture_skyluminancelut bindless_textures_half4[GetFrame().texture_skyluminancelut_index]
+#define texture_cameravolumelut bindless_textures3D_half4[GetFrame().texture_cameravolumelut_index]
 #define texture_wind bindless_textures3D[GetFrame().texture_wind_index]
 #define texture_wind_prev bindless_textures3D[GetFrame().texture_wind_prev_index]
-#define texture_caustics bindless_textures[GetFrame().texture_caustics_index]
+#define texture_caustics bindless_textures_half4[GetFrame().texture_caustics_index]
 #define scene_acceleration_structure bindless_accelerationstructures[GetScene().TLAS]
 
 #define texture_depth bindless_textures_float[GetCamera().texture_depth_index]
@@ -806,18 +822,19 @@ inline half3 clipspace_to_uv(in half3 clipspace)
 	return clipspace * half3(0.5, -0.5, 0.5) + 0.5;
 }
 
-inline half3 GetSunColor() { return GetWeather().sun_color; } // sun color with intensity applied
-inline float3 GetSunDirection() { return GetWeather().sun_direction; }
-inline half3 GetHorizonColor() { return GetWeather().horizon.rgb; }
-inline half3 GetZenithColor() { return GetWeather().zenith.rgb; }
-inline half3 GetAmbientColor() { return GetWeather().ambient.rgb; }
+inline half3 GetSunColor() { return unpack_half3(GetWeather().sun_color); } // sun color with intensity applied
+inline half3 GetSunDirection() { return unpack_half3(GetWeather().sun_direction); }
+inline half3 GetHorizonColor() { return unpack_half3(GetWeather().horizon); }
+inline half3 GetZenithColor() { return unpack_half3(GetWeather().zenith); }
+inline half3 GetAmbientColor() { return unpack_half3(GetWeather().ambient); }
 inline uint2 GetInternalResolution() { return GetCamera().internal_resolution; }
 inline float GetDeltaTime() { return GetFrame().delta_time; }
 inline float GetTime() { return GetFrame().time; }
 inline float GetTimePrev() { return GetFrame().time_previous; }
 inline float GetFrameCount() { return GetFrame().frame_count; }
 inline min16uint2 GetTemporalAASampleRotation() { return uint2(GetFrame().temporalaa_samplerotation & 0xFF, (GetFrame().temporalaa_samplerotation >> 8u) & 0xFF); }
 inline bool IsStaticSky() { return GetScene().globalenvmap >= 0; }
+inline half GetGIBoost() { return unpack_half2(GetFrame().giboost_packed).x; }
 
 // Mie scaterring approximated with Henyey-Greenstein phase function.
 //	https://www.alexandre-pestana.com/volumetric-lights/

WickedEngine/shaders/hairparticle_simulateCS.hlsl

@@ -11,8 +11,8 @@ static const float3 HAIRPATCH[] = {
 
 Buffer<uint> meshIndexBuffer : register(t0);
 Buffer<float4> meshVertexBuffer_POS : register(t1);
-Buffer<float4> meshVertexBuffer_NOR : register(t2);
-Buffer<float> meshVertexBuffer_length : register(t3);
+Buffer<half4> meshVertexBuffer_NOR : register(t2);
+Buffer<half> meshVertexBuffer_length : register(t3);
 
 RWStructuredBuffer<PatchSimulationData> simulationBuffer : register(u0);
 RWBuffer<float4> vertexBuffer_POS : register(u1);

WickedEngine/shaders/lightingHF.hlsli

@@ -40,7 +40,7 @@ struct Lighting
 
 inline void ApplyLighting(in Surface surface, in Lighting lighting, inout half4 color)
 {
-	half3 diffuse = lighting.direct.diffuse / PI + lighting.indirect.diffuse * (half)GetFrame().gi_boost * (1 - surface.F) * surface.occlusion + surface.ssgi;
+	half3 diffuse = lighting.direct.diffuse / PI + lighting.indirect.diffuse * GetGIBoost() * (1 - surface.F) * surface.occlusion + surface.ssgi;
 	half3 specular = lighting.direct.specular + lighting.indirect.specular * surface.occlusion; // reminder: cannot apply surface.F for whole indirect specular, because multiple layers have separate fresnels (sheen, clearcoat)
 	color.rgb = lerp(surface.albedo * diffuse, surface.refraction.rgb, surface.refraction.a);
 	color.rgb += specular;
@@ -412,19 +412,20 @@ inline half3 EnvironmentReflection_Global(in Surface surface)
 	uint2 dim;
 	uint mipcount;
 	cubemap.GetDimensions(0, dim.x, dim.y, mipcount);
+	half mipcount16f = half(mipcount);
 
-	half MIP = surface.roughness * mipcount;
+	half MIP = surface.roughness * mipcount16f;
 	envColor = cubemap.SampleLevel(sampler_linear_clamp, surface.R, MIP).rgb * surface.F;
 
 #ifdef SHEEN
 	envColor *= surface.sheen.albedoScaling;
-	MIP = surface.sheen.roughness * mipcount;
+	MIP = surface.sheen.roughness * mipcount16f;
 	envColor += cubemap.SampleLevel(sampler_linear_clamp, surface.R, MIP).rgb * surface.sheen.color * surface.sheen.DFG;
 #endif // SHEEN
 
 #ifdef CLEARCOAT
 	envColor *= 1 - surface.clearcoat.F;
-	MIP = surface.clearcoat.roughness * mipcount;
+	MIP = surface.clearcoat.roughness * mipcount16f;
 	envColor += cubemap.SampleLevel(sampler_linear_clamp, surface.clearcoat.R, MIP).rgb * surface.clearcoat.F;
 #endif // CLEARCOAT
 
@@ -455,15 +456,16 @@ inline half4 EnvironmentReflection_Local(in TextureCube<half4> cubemap, in Surfa
 	uint2 dim;
 	uint mipcount;
 	cubemap.GetDimensions(0, dim.x, dim.y, mipcount);
+	half mipcount16f = half(mipcount);
 
 	// Sample cubemap texture:
-	half MIP = surface.roughness * mipcount;
-	half3 envColor = (half3)cubemap.SampleLevel(sampler_linear_clamp, R_parallaxCorrected, MIP).rgb * surface.F;
+	half MIP = surface.roughness * mipcount16f;
+	half3 envColor = cubemap.SampleLevel(sampler_linear_clamp, R_parallaxCorrected, MIP).rgb * surface.F;
 
 #ifdef SHEEN
 	envColor *= surface.sheen.albedoScaling;
-	MIP = surface.sheen.roughness * mipcount;
-	envColor += (half3)cubemap.SampleLevel(sampler_linear_clamp, R_parallaxCorrected, MIP).rgb * surface.sheen.color * surface.sheen.DFG;
+	MIP = surface.sheen.roughness * mipcount16f;
+	envColor += cubemap.SampleLevel(sampler_linear_clamp, R_parallaxCorrected, MIP).rgb * surface.sheen.color * surface.sheen.DFG;
 #endif // SHEEN
 
 #ifdef CLEARCOAT
@@ -475,8 +477,8 @@ inline half4 EnvironmentReflection_Local(in TextureCube<half4> cubemap, in Surfa
 	R_parallaxCorrected = surface.P - probe.position + surface.clearcoat.R * Distance;
 
 	envColor *= 1 - surface.clearcoat.F;
-	MIP = surface.clearcoat.roughness * mipcount;
-	envColor += (half3)cubemap.SampleLevel(sampler_linear_clamp, R_parallaxCorrected, MIP).rgb * surface.clearcoat.F;
+	MIP = surface.clearcoat.roughness * mipcount16f;
+	envColor += cubemap.SampleLevel(sampler_linear_clamp, R_parallaxCorrected, MIP).rgb * surface.clearcoat.F;
 #endif // CLEARCOAT
 
 	// blend out if close to any cube edge:

WickedEngine/shaders/lightmap_expandCS.hlsl

@@ -0,0 +1,58 @@
+#include "globals.hlsli"
+#include "ShaderInterop_Postprocess.h"
+
+Texture2D lightmap_input : register(t0);
+
+RWTexture2D<float4> lightmap_output : register(u0);
+
+static const int TILE_BORDER = 4;
+static const uint TILE_SIZE = POSTPROCESS_BLOCKSIZE + TILE_BORDER * 2;
+groupshared uint2 tile_cache[TILE_SIZE*TILE_SIZE];
+
+[numthreads(POSTPROCESS_BLOCKSIZE, POSTPROCESS_BLOCKSIZE, 1)]
+void main(uint3 DTid : SV_DispatchThreadID, uint3 GTid : SV_GroupThreadID, uint3 Gid : SV_GroupID, uint groupIndex : SV_GroupIndex)
+{
+	const int2 tile_upperleft = Gid.xy * POSTPROCESS_BLOCKSIZE - TILE_BORDER;
+	for (uint t = groupIndex; t < TILE_SIZE * TILE_SIZE; t += POSTPROCESS_BLOCKSIZE * POSTPROCESS_BLOCKSIZE)
+	{
+		const uint2 pixel = tile_upperleft + unflatten2D(t, TILE_SIZE);
+		tile_cache[t] = pack_half4(lightmap_input[pixel]);
+	}
+	GroupMemoryBarrierWithGroupSync();
+
+	float4 color = unpack_half4(tile_cache[flatten2D(GTid.xy + TILE_BORDER, TILE_SIZE)]);
+
+	if (color.a < 1)
+	{
+		// spin outwards from center in spiral pattern and take the first sample which has valid opacity:
+		int generation = TILE_BORDER;
+		for (int growth = 0; (growth < generation) && (color.a < 1); ++growth)
+		{
+			const int side = 2 * (growth + 1);
+			int x = -growth - 1;
+			int y = -growth - 1;
+			for (int i = 0; (i < side) && (color.a < 1); ++i)
+			{
+				color = unpack_half4(tile_cache[flatten2D(GTid.xy + TILE_BORDER + int2(x, y), TILE_SIZE)]);
+				x++;
+			}
+			for (int i = 0; (i < side) && (color.a < 1); ++i)
+			{
+				color = unpack_half4(tile_cache[flatten2D(GTid.xy + TILE_BORDER + int2(x, y), TILE_SIZE)]);
+				y++;
+			}
+			for (int i = 0; (i < side) && (color.a < 1); ++i)
+			{
+				color = unpack_half4(tile_cache[flatten2D(GTid.xy + TILE_BORDER + int2(x, y), TILE_SIZE)]);
+				x--;
+			}
+			for (int i = 0; (i < side) && (color.a < 1); ++i)
+			{
+				color = unpack_half4(tile_cache[flatten2D(GTid.xy + TILE_BORDER + int2(x, y), TILE_SIZE)]);
+				y--;
+			}
+		}
+	}
+
+	lightmap_output[DTid.xy] = color;
+}