add game&rawdata

gamedata/shaders/d3d11/gtao_render.ps.hlsl

@@ -0,0 +1,183 @@
+/*
+		Ground-Truth *Based* Ambient Occlusion (unidirectional variant, no arccos)
+
+		References:
+		- Practical Real-Time Strategies for Accurate Indirect Occlusion [Jimenez et. al];
+		- Screen space indirect lighting with visibility bitmask [Olivier Therrien, Yannick Levesque, Guillaume Gilet]
+		- "GT-VBAO (uniformly weighted)" on ShaderToy [TinyTexel]
+
+		Credits:
+		- MartyMcFly (huge help with GTAO(VB) implementation and understading the concept of visibility bitmask)
+		- TinyTexel (no-arccosine GTAO; main inspiration, https://www.shadertoy.com/view/4cdfzf)
+		- Olivier Therrien (original bitmask implementation, + https://x.com/volfaze/status/1865481248929456639)
+
+		Author:
+		- LVutner
+
+		---IX-Ray Engine---
+*/
+
+#include "common.hlsli"
+
+struct PSInput
+{
+	float4 hpos : SV_POSITION;
+	float2 texcoord : TEXCOORD0;
+};
+
+float gtao_parameters; //Factor used to transform world space radius into screen space
+
+float example_how_to_not_implement_gtao(float3 view_position, float3 view_normal, float2 texcoord, float2 jitter)
+{
+	//Few constants
+	//TBD: Put everything into common header
+	const float GTAO_PI = 3.1415927;
+	const float GTAO_TAU = 6.2831854;	
+	const float GTAO_HALF_PI = 1.5707964;
+	const float GTAO_PI_RCP = 0.31830988148;
+	const float GTAO_2_OVER_PI = 0.63661976296;
+
+	//Settings
+	int GTAO_DIRECTIONS = 3; //Direction count (3 is sufficient for low radii)
+	int GTAO_STEPS = 4; //Step count
+	float GTAO_RADIUS = 0.85; //World space radius (Keep it low. Cache-trasher. I am not joking.)
+	float GTAO_NEG_1_OVER_RADIUSQR = -1.0 / (GTAO_RADIUS * GTAO_RADIUS); //Just for falloff. Hardcode it if you need to
+
+	//Bias the position to avoid numerical issues
+	//0.9992 would be OK even for vanilla view-z buffer
+	view_position *= 0.9992;
+
+	//View direction
+	float3 view_direction = -normalize(view_position);
+
+	//Screen-space radius (clamped)
+	float screen_radius = min((GTAO_RADIUS * gtao_parameters) / view_position.z, 256.0);
+
+	//Slice scale
+	//Y flipped as in original GTAO paper, DirectX hello
+	float2 slice_scale = pos_decompression_params2.zw * screen_radius * float2(1.0, -1.0);
+
+	//Slice angle, we integrate AO over 2*PI
+	float slice_angle = GTAO_TAU / float(GTAO_DIRECTIONS);
+
+	//Accumulated occlusion and slice weight
+	float2 occ_weight = (0.0).xx;
+
+	for (int i = 0; i < GTAO_DIRECTIONS; i++)
+	{
+		float angle = (float(i) + jitter.x) * slice_angle;
+
+		//Slice direction
+		float3 slice_direction = float3(cos(angle), sin(angle), 0.0);
+
+		//GTAO math
+		float3 axis = cross(view_direction, slice_direction);
+		float3 proj_normal = view_normal - axis * dot(view_normal, axis);
+		float3 proj_tangent = cross(axis, proj_normal);
+		float proj_normal_length = length(proj_normal);
+		float sin_n = dot(proj_tangent, view_direction) * rcp(proj_normal_length);
+
+		//Init horizon
+		float max_horizon_cos = sin_n;
+
+		//Find hot horizons in your area :flushed:
+		for(int j = 0; j < GTAO_STEPS; j += 2)
+		{
+			//Ray increment
+			float2 increment = (j + float2(0.0, 1.0) + jitter.yy) / GTAO_STEPS;
+
+			//Squared for more detail in crevices...			
+			increment *= increment;
+
+			//le sample coords
+			float4 s_texcoord = texcoord.xyxy + slice_direction.xyxy * slice_scale.xyxy * increment.xxyy;
+
+			//Guard band
+			if(dot(s_texcoord.zw - saturate(s_texcoord.zw), 1.0) != 0.0)
+				break;
+
+			//Fetch z-buffer
+			float2 s_depth = {
+				s_position.SampleLevel(smp_nofilter, s_texcoord.xy, 0.0f).x,
+				s_position.SampleLevel(smp_nofilter, s_texcoord.zw, 0.0f).x
+			};
+
+			//1st tap
+			//Manual unrolling, process 2 steps at the time
+			{
+				// Sample the view space position
+				float3 s_vector = GbufferGetPointRealUnjitter(s_texcoord.xy, s_depth.x);
+				s_vector -= view_position; //Occlusion vector
+
+				float s_vec_length = dot(s_vector, s_vector);
+				float s_horizon = dot(s_vector, view_direction) * rsqrt(s_vec_length);
+
+				//'Obscurance' term, basically a simple falloff known from HBAO/HBAO+. Just a MAD + saturate
+				float falloff = saturate(s_vec_length * GTAO_NEG_1_OVER_RADIUSQR + 1.0);
+				s_horizon = lerp(-1.0, s_horizon, falloff);
+
+				max_horizon_cos = max(max_horizon_cos, s_horizon);
+			}
+
+			//2nd tap
+			{
+				float3 s_vector = GbufferGetPointRealUnjitter(s_texcoord.zw, s_depth.y);
+				s_vector -= view_position;
+
+				float s_vec_length = dot(s_vector, s_vector);
+				float s_horizon = dot(s_vector, view_direction) * rsqrt(s_vec_length);
+
+				float falloff = saturate(s_vec_length * GTAO_NEG_1_OVER_RADIUSQR + 1.0);
+				s_horizon = lerp(-1.0, s_horizon, falloff);
+
+				max_horizon_cos = max(max_horizon_cos, s_horizon);
+			}
+		}
+
+		//This is an approximation of importance sampling (Horizon remap is baked into equation)
+		//Marty's MXAO uses smoothstep() which is a neat approximation (~2% error IIRC?).
+		//Note: 1.0 + sinNm - c_horizon_cos is identical to uniformly weighted GTAO (See Jimenez et al presentation for details)
+		max_horizon_cos = saturate(0.5 * sin(GTAO_HALF_PI * (1.0 + sin_n) - GTAO_HALF_PI * max_horizon_cos) + 0.5);
+
+		//Accumulate
+		//rcp(x) because we are supposed to weight samples by length of projected normal
+		occ_weight += float2(1.0 - max_horizon_cos, 1.0) * proj_normal_length;
+	}
+
+    //Normalize
+	occ_weight.x *= rcp(occ_weight.y);
+
+	//Compensate for missing side...
+	return saturate(1.0 - occ_weight.x * 2.0);
+}
+
+Texture3D s_blue_noise;
+uint main(PSInput I) : SV_Target
+{
+	//Sample depth buffer
+	float zbuffer = s_position.SampleLevel(smp_nofilter, I.texcoord.xy, 0.0f).x;
+
+	//Early exit
+	if(zbuffer == 1.0)
+		return asuint(f32tof16(1000.0)) | (asuint(f32tof16(1.0)) << 16);
+
+	//Sample blue noise texture
+	//You can replace 0 with m_taa_jitter.w % 32 to animate it (texture contains 32 frames)
+	float3 jitter_tex = s_blue_noise[uint3(uint2(I.hpos.xy) % 128, 0)].xyz;
+
+	//Unpack G-Buffer data...
+	float3 Normal, Point;
+	{
+		Normal = s_normal.SampleLevel(smp_nofilter, I.texcoord.xy, 0.0f).xyz;
+		Normal = NormalDecode(Normal.xy);
+		Point = GbufferGetPointRealUnjitter(I.texcoord.xy, zbuffer);
+    }
+
+	//Init. Don't render GTAO past 60 units. It will become a noisy mess...
+	//View-pos is shifted towards view normal; this eliminates self-occlusion
+	float occlusion = Point.z > 60.0 ? 1.0 : example_how_to_not_implement_gtao(Point + Normal * 0.0035, Normal, I.texcoord.xy, jitter_tex.xy);
+
+	//Pack the data into R32_UINT (16 bits for depth, and 16 for occlusion)
+	return asuint(f32tof16(Point.z)) | (asuint(f32tof16(occlusion)) << 16);
+
+}