Demo stuff

Author: VZout

demo/demo_frame_graphs.hpp

@@ -92,7 +92,7 @@ namespace fg_manager
 			wr::AddPostProcessingTask<wr::DeferredCompositionTaskData>(*fg);
 
 			// Do Depth of field task
-			wr::AddDoFCoCTask<wr::DeferredMainTaskData>(*fg);
+			/*wr::AddDoFCoCTask<wr::DeferredMainTaskData>(*fg);
 
 			wr::AddDoFDownScaleTask<wr::PostProcessingData, wr::DoFCoCData>(*fg,
 				rs.m_window.value()->GetWidth(), rs.m_window.value()->GetHeight());
@@ -112,12 +112,12 @@ namespace fg_manager
 			wr::AddDoFBokehPostFilterTask<wr::DoFBokehData>(*fg,
 				rs.m_window.value()->GetWidth(), rs.m_window.value()->GetHeight());
 
-			wr::AddDoFCompositionTask<wr::PostProcessingData, wr::DoFBokehPostFilterData, wr::DoFCoCData>(*fg);
+			wr::AddDoFCompositionTask<wr::PostProcessingData, wr::DoFBokehPostFilterData, wr::DoFCoCData>(*fg);*/
 
 			// Copy the scene render pixel data to the final render target
-			wr::AddRenderTargetCopyTask<wr::DoFCompositionData>(*fg);
+			wr::AddRenderTargetCopyTask<wr::PostProcessingData>(*fg);
 			// Display ImGui
-			fg->AddTask<wr::ImGuiTaskData>(wr::GetImGuiTask<wr::DoFCompositionData>(imgui_func));
+			fg->AddTask<wr::ImGuiTaskData>(wr::GetImGuiTask<wr::PostProcessingData>(imgui_func));
 
 			fg->Setup(rs);
 		}

demo/scene_viknell.hpp

@@ -45,7 +45,7 @@ namespace viknell_scene
 			wr::TextureHandle bamboo_roughness = texture_pool->LoadFromFile("resources/materials/bamboo/bamboo-wood-semigloss-roughness.png", false, true);
 			wr::TextureHandle bamboo_metallic = texture_pool->LoadFromFile("resources/materials/bamboo/bamboo-wood-semigloss-metal.png", false, true);
 
-			equirectangular_environment_map = texture_pool->LoadFromFile("resources/materials/Circus_Backstage_3k.hdr", false, false);
+			equirectangular_environment_map = texture_pool->LoadFromFile("resources/materials/SunTemple_Skybox.hdr", false, false);
 
 			// Create Materials
 			mirror_material = material_pool->Create();
@@ -69,7 +69,7 @@ namespace viknell_scene
 			bamboo_material_internal->SetMetallic(bamboo_metallic);
 
 			plane_model = model_pool->Load<wr::VertexColor>(material_pool.get(), texture_pool.get(), "resources/models/plane.fbx");
-			test_model = model_pool->LoadWithMaterials<wr::VertexColor>(material_pool.get(), texture_pool.get(), "resources/models/sponza_jacco/sponza.obj");
+			test_model = model_pool->LoadWithMaterials<wr::VertexColor>(material_pool.get(), texture_pool.get(), "resources/materials/SunTemple.fbx");
 			sphere_model = model_pool->Load<wr::VertexColor>(material_pool.get(), texture_pool.get(), "resources/models/sphere.fbx");
 		}
 
@@ -98,9 +98,9 @@ namespace viknell_scene
 		camera->SetPosition({0, 0, 2});
 		camera->SetSpeed(10);
 
-		camera_spline_node = scene_graph->CreateChild<SplineNode>(nullptr, "Camera Spline");
-		light_1_spline_node = scene_graph->CreateChild<SplineNode>(nullptr, "Light 1 Spline");
-		light_2_spline_node = scene_graph->CreateChild<SplineNode>(nullptr, "Light 2 Spline");
+		camera_spline_node = scene_graph->CreateChild<SplineNode>(nullptr, "Camera Spline", false);
+		light_1_spline_node = scene_graph->CreateChild<SplineNode>(nullptr, "Light 1 Spline", true);
+		light_2_spline_node = scene_graph->CreateChild<SplineNode>(nullptr, "Light 2 Spline", true);
 
 		scene_graph->m_skybox = resources::equirectangular_environment_map;
 		auto skybox = scene_graph->CreateChild<wr::SkyboxNode>(nullptr, resources::equirectangular_environment_map);
@@ -137,16 +137,16 @@ namespace viknell_scene
 
 
 		// Lights
-		auto point_light_0 = scene_graph->CreateChild<wr::LightNode>(nullptr, wr::LightType::DIRECTIONAL, DirectX::XMVECTOR{1, 1, 1});
+		auto point_light_0 = scene_graph->CreateChild<wr::LightNode>(nullptr, wr::LightType::POINT, DirectX::XMVECTOR{ 1000 / 255, 1000 / 255, 1000 / 255 });
 		//point_light_0->SetRadius(3.0f);
-		point_light_0->SetRotation({20.950, 0.98, 0});
-		point_light_0->SetPosition({-0.002, 0.080, 1.404});
+		point_light_0->SetPosition({ 0, 2.5, 0 });
+		point_light_0->SetRadius(10000.f);
 
-		point_light_1 = scene_graph->CreateChild<wr::LightNode>(nullptr, wr::LightType::POINT, DirectX::XMVECTOR{1, 0, 0});
+		point_light_1 = scene_graph->CreateChild<wr::LightNode>(nullptr, wr::LightType::POINT, DirectX::XMVECTOR{3000 / 255, 0, 0});
 		point_light_1->SetRadius(5.0f);
 		point_light_1->SetPosition({0.5, 0, -0.3});
 
-		point_light_2 = scene_graph->CreateChild<wr::LightNode>(nullptr, wr::LightType::POINT, DirectX::XMVECTOR{0, 0, 1});
+		point_light_2 = scene_graph->CreateChild<wr::LightNode>(nullptr, wr::LightType::POINT, DirectX::XMVECTOR{0, 0, 3000 / 255});
 		point_light_2->SetRadius(5.0f);
 		point_light_2->SetPosition({-0.5, 0.5, -0.3});
 

demo/spline_node.cpp

@@ -8,7 +8,7 @@
 
 static bool initialized = false;
 
-SplineNode::SplineNode(std::string name) : Node(typeid(SplineNode)), m_name(name), m_animate(false), m_speed(1), m_time(0), m_spline(nullptr), m_quat_spline(nullptr)
+SplineNode::SplineNode(std::string name, bool looping) : Node(typeid(SplineNode)), m_name(name), m_animate(false), m_speed(1), m_time(0), m_spline(nullptr), m_quat_spline(nullptr), m_looping(looping)
 {
 	if (initialized) return;
 	initialized = true;
@@ -110,6 +110,11 @@ SplineNode::SplineNode(std::string name) : Node(typeid(SplineNode)), m_name(name
 						scene_graph->GetActiveCamera()->SetRotation(cp.m_rotation);
 					}
 
+					if (ImGui::Button("Remove"))
+					{
+						spline_node->m_control_points.erase(spline_node->m_control_points.begin() + i);
+					}
+
 					ImGui::TreePop();
 				}
 			}
@@ -130,36 +135,43 @@ void SplineNode::UpdateSplineNode(float delta, std::shared_ptr<wr::Node> node)
 
 	auto num_points = m_control_points.size();
 
-	m_time += delta * m_speed;
-	m_time = std::fmod(m_time, m_spline->getMaxT());
-
-	auto lerp_delta = m_time / m_spline->getMaxT();
-#ifdef LOOPING
-	auto segment_i = lerp_delta * ((float)num_points);
-	auto alpha = (lerp_delta * ((float)num_points)) - floor(segment_i);
-#else
-	auto segment_i = lerp_delta * ((float)num_points - 1.f);
-	auto alpha = (lerp_delta * ((float)num_points - 1.f)) - floor(segment_i);
-#endif
-
-	float backback = std::fmod((std::fmod(floor(segment_i), num_points) + num_points), num_points);
-	auto back_point = m_control_points[backback];
-	auto prev_point = m_control_points[floor(segment_i)];
-	auto next_point = m_control_points[fmod(ceil(segment_i), num_points)];
-	auto end_point = m_control_points[fmod(ceil(segment_i+1), num_points)];
-
-	auto rot_a = DirectX::XMQuaternionRotationRollPitchYawFromVector(prev_point.m_rotation);
-	auto rot_b = DirectX::XMQuaternionRotationRollPitchYawFromVector(next_point.m_rotation);
-	auto interp = DirectX::XMQuaternionSlerp(rot_a, rot_b, alpha);
-
-	auto new_pos = m_spline->getPosition(m_time);
-	auto new_rot = m_quat_spline->getPosition(m_time);
-
-	LOG("{} -- {}", floor(segment_i), fmod(ceil(segment_i), num_points));
+	auto impl = [&](auto spline, auto quat_spline)
+	{
+		m_time += delta * m_speed;
+		m_time = std::fmod(m_time, spline->getMaxT());
+
+		auto lerp_delta = m_time / spline->getMaxT();
+		
+		auto mod = m_looping ? 0.f : 1.f;
+		auto segment_i = lerp_delta * ((float)num_points - mod);
+		auto alpha = (lerp_delta * ((float)num_points - mod)) - floor(segment_i);
+
+		float backback = std::fmod((std::fmod(floor(segment_i), num_points) + num_points), num_points);
+		auto back_point = m_control_points[backback];
+		auto prev_point = m_control_points[floor(segment_i)];
+		auto next_point = m_control_points[fmod(ceil(segment_i), num_points)];
+		auto end_point = m_control_points[fmod(ceil(segment_i + 1), num_points)];
+
+		auto rot_a = DirectX::XMQuaternionRotationRollPitchYawFromVector(prev_point.m_rotation);
+		auto rot_b = DirectX::XMQuaternionRotationRollPitchYawFromVector(next_point.m_rotation);
+		auto interp = DirectX::XMQuaternionSlerp(rot_a, rot_b, alpha);
+
+		auto new_pos = spline->getPosition(m_time);
+		auto new_rot = quat_spline->getPosition(m_time);
+
+		node->SetPosition({ new_pos[0], new_pos[1], new_pos[2] });
+		node->SetRotationQuat(interp);
+		node->SetRotationQuat({ new_rot[0], new_rot[1], new_rot[2], new_rot[3] });
+	};
 
-	node->SetPosition({ new_pos[0], new_pos[1], new_pos[2] });
-	node->SetRotationQuat(interp);
-	node->SetRotationQuat({ new_rot[0], new_rot[1], new_rot[2], new_rot[3] });
+	if (m_looping)
+	{
+		impl(reinterpret_cast<LoopingNaturalSpline<Vector<3>>*>(m_spline), reinterpret_cast<LoopingNaturalSpline<Vector<4>>*>(m_quat_spline));
+	}
+	else
+	{
+		impl(reinterpret_cast<NaturalSpline<Vector<3>>*>(m_spline), reinterpret_cast<NaturalSpline<Vector<4>>*>(m_quat_spline));
+	}
 }
 
 void SplineNode::UpdateNaturalSpline()
@@ -176,7 +188,7 @@ void SplineNode::UpdateNaturalSpline()
 		m_quat_spline = nullptr;
 	}
 
-	if (m_control_points.size() < 3)
+	if (m_control_points.size() < (m_looping ? 2 : 3))
 	{
 		return;
 	}
@@ -189,11 +201,14 @@ void SplineNode::UpdateNaturalSpline()
 			m_spline_positions.push_back(Vector<3>({ cp.m_position.m128_f32[0], cp.m_position.m128_f32[1], cp.m_position.m128_f32[2] }));
 		}
 
-#ifdef LOOPING
-		m_spline = new LoopingNaturalSpline<Vector<3>>(m_spline_positions);
-#else
-		m_spline = new NaturalSpline<Vector<3>>(m_spline_positions);
-#endif
+		if (m_looping)
+		{
+			m_spline = new LoopingNaturalSpline<Vector<3>>(m_spline_positions);
+		}
+		else
+		{
+			m_spline = new NaturalSpline<Vector<3>>(m_spline_positions);
+		}
 	}
 
 	{
@@ -204,11 +219,15 @@ void SplineNode::UpdateNaturalSpline()
 			auto quat = DirectX::XMQuaternionRotationRollPitchYawFromVector(cp.m_rotation);
 			m_spline_rotations.push_back(Vector<4>({ quat.m128_f32[0], quat.m128_f32[1], quat.m128_f32[2], quat.m128_f32[3] }));
 		}
-#ifdef LOOPING
-		m_quat_spline = new LoopingNaturalSpline<Vector<4>>(m_spline_positions);
-#else
-		m_quat_spline = new NaturalSpline<Vector<4>>(m_spline_rotations);
-#endif
+
+		if (m_looping)
+		{
+			m_quat_spline = new LoopingNaturalSpline<Vector<4>>(m_spline_rotations);
+		}
+		else
+		{
+			m_quat_spline = new NaturalSpline<Vector<4>>(m_spline_rotations);
+		}
 	}
 }
 

demo/spline_node.hpp

@@ -14,7 +14,7 @@ class SplineNode : public wr::Node
 	};
 
 public:
-	SplineNode(std::string name);
+	SplineNode(std::string name, bool looping = false);
 	~SplineNode();
 
 	void UpdateSplineNode(float delta, std::shared_ptr<wr::Node> node);
@@ -32,16 +32,14 @@ class SplineNode : public wr::Node
 	DirectX::XMVECTOR m_initial_position;
 	DirectX::XMVECTOR m_initial_rotation;
 
-#ifdef LOOPING
-	LoopingNaturalSpline<Vector<3>>* m_spline;
-	LoopingNaturalSpline<Vector<4>>* m_quat_spline;
-#else
-	NaturalSpline<Vector<3>>* m_spline;
-	NaturalSpline<Vector<4>>* m_quat_spline;
-#endif
+	void* m_spline;
+	void* m_quat_spline;
+
 	std::vector<ControlPoint> m_control_points;
 	float m_speed;
 	float m_time;
 
+	bool m_looping;
+
 	std::string m_name;
 };

resources/shaders/basic.hlsl

@@ -58,7 +58,7 @@ VS_OUTPUT main_vs(VS_INPUT input, uint instid : SV_InstanceId)
 	output.uv = float2(input.uv.x, 1.0f - input.uv.y);
 	output.tangent = normalize(mul(inst.model, float4(input.tangent, 0))).xyz;
 	output.bitangent = normalize(mul(inst.model, float4(input.bitangent, 0))).xyz;
-	output.normal = normalize(mul(inst.model, float4(input.normal, 0))).xyz;
+	output.normal = normalize(mul(inst.model, float4(-input.normal, 0))).xyz;
 	output.color = input.color;
 
 	return output;

resources/shaders/deferred_composition.hlsl

@@ -80,14 +80,19 @@ void main_cs(int3 dispatch_thread_id : SV_DispatchThreadID)
 		else
 		{
 			irradiance = irradiance_map.SampleLevel(linear_sampler, flipped_N, 0).xyz;
+			irradiance /= 2;
 		}
 
+		#ifdef HARD_IRR
+			irradiance = IRR;
+		#endif
+
 		// Get shadow factor (0: fully shadowed, 1: no shadow)
 		float shadow_factor = lerp(
 			// Do deferred shadow (fully lit for now)
 			1.0,
 			// Shadow buffer if its hybrid rendering
-			buffer_refl_shadow[screen_coord].a,
+			buffer_refl_shadow.SampleLevel(linear_sampler, uv, 0).w,	
 			// Lerp factor (0: no hybrid, 1: hybrid)
 			is_hybrid);
 
@@ -98,12 +103,13 @@ void main_cs(int3 dispatch_thread_id : SV_DispatchThreadID)
 			// Sample from environment if it IS NOT hybrid rendering
 			sampled_environment_map,
 			// Reflection buffer if it IS hybrid rendering
-			buffer_refl_shadow[screen_coord].xyz,	
+			buffer_refl_shadow.SampleLevel(linear_sampler, uv, 0).xyz,	
 			// Lerp factor (0: no hybrid, 1: hybrid)
 			is_hybrid);
 
 		// Shade pixel
 		retval = shade_pixel(pos, V, albedo, metallic, roughness, normal, irradiance, reflection, sampled_brdf, shadow_factor);
+		//retval = reflection;
 	}
 	else
 	{	

resources/shaders/lighting.hlsl

@@ -72,9 +72,9 @@ float3 shade_pixel(float3 pos, float3 V, float3 albedo, float metallic, float ro
 	float3 specular = prefiltered_color * (kS * sampled_brdf.x + sampled_brdf.y);
 	//float3 specular = reflection * kS;
 
-	float3 ambient = (kD * diffuse + specular) * 1.0f; //Replace 1.0f with AO, when we have it.
+	float3 ambient = ((kD * diffuse) + specular) * 1.0f; //Replace 1.0f with AO, when we have it.
 
-	return ambient + (res * shadow_factor);
+	return ambient + (res);
 }
 
 float3 shade_light(float3 pos, float3 V, float3 albedo, float3 normal, float metallic, float roughness, Light light, inout uint rand_seed, uint depth)
@@ -147,8 +147,18 @@ float DoShadowAllLights(float3 wpos, uint depth, inout float rand_seed)
 		// Get maxium ray length (depending on type)
 		float t_max = lerp(light_dist, 100000, tid == light_type_directional);
 
+		float min_cos = cos(light.ang);
+		float max_cos = lerp(min_cos, 1, 0.5f);
+		float cos_angle = dot(light.dir, L);
+		float spot_intensity = lerp(smoothstep(min_cos, max_cos, cos_angle), 1, tid != light_type_spot);
+
+		//Attenuation & spot intensity (only used with point or spot)
+		float attenuation = lerp(1.0f - smoothstep(0, light.rad, light_dist), 1, tid == light_type_directional);
+
+		float3 radiance = attenuation;
+
 		// Add shadow factor to final result
-		res += GetShadowFactor(wpos, L, t_max, depth + 1, rand_seed);
+		res += GetShadowFactor(wpos, L, t_max, depth, rand_seed) * length(radiance);
 	}
 
 	// return final res

resources/shaders/material_util.hlsl

@@ -49,7 +49,7 @@ OutputMaterialData InterpretMaterialData(MaterialData data,
 
 	float4 albedo = lerp(material_albedo.Sample(s0, uv), float4(data.albedo_alpha.xyz, 1.0f), use_albedo_constant != 0 || has_albedo_texture == 0);
 
-	//#define COMPRESSED_PBR
+	#define COMPRESSED_PBR
 #ifdef COMPRESSED_PBR
 	float4 roughness = lerp(material_metallic.Sample(s0, uv).y, data.metallic_roughness.w, use_roughness_constant != 0 || has_roughness_texture == 0);
 	float4 metallic = lerp(material_metallic.Sample(s0, uv).z, length(data.metallic_roughness.xyz), use_metallic_constant != 0 || has_metallic_texture == 0);
@@ -86,7 +86,7 @@ OutputMaterialData InterpretMaterialDataRT(MaterialData data,
 	uint has_metallic_texture = data.flags & MATERIAL_HAS_METALLIC_TEXTURE;
 	uint use_normal_texture = data.flags & MATERIAL_HAS_NORMAL_TEXTURE;
 
-	//#define COMPRESSED_PBR
+	#define COMPRESSED_PBR
 #ifdef COMPRESSED_PBR
 	const float3 albedo = lerp(material_albedo.SampleLevel(s0, uv, mip_level).xyz,
 		data.albedo_alpha.xyz,

resources/shaders/post_processing.hlsl

@@ -20,18 +20,18 @@ void main(uint3 DTid : SV_DispatchThreadID)
 	float2 uv = (float2(DTid.xy) / resolution);
 
 	float gamma = 2.2;
-	float exposure = 1;
+	float exposure = 2;
 
 	float3 color = input[DTid.xy].rgb;
-	//color = SampleFXAA(input, s0, DTid.xy, resolution);
+	color = SampleFXAA(input, s0, DTid.xy, resolution);
 	//uv = ZoomUV(uv, 0.75);
 	//float3 color = input.SampleLevel(s0, BarrelDistortUV(uv, 2), 0);
 	//float3 color = ChromaticAberrationV2(input, s0, uv, 0.2, 0.96f).rgb;
 
 	if (hdr == 0)
 	{
-		color = linearToneMapping(color, exposure, gamma);
-		//color = simpleReinhardToneMapping(color, exposure, gamma);
+		//color = linearToneMapping(color, exposure, gamma);
+		color = simpleReinhardToneMapping(color, exposure, gamma);
 		//color = lumaBasedReinhardToneMapping(color, gamma);
 		//color = whitePreservingLumaBasedReinhardToneMapping(color, gamma);
 		//color = RomBinDaHouseToneMapping(color, gamma);

resources/shaders/rt_global.hlsl

@@ -1,9 +1,10 @@
-#define MAX_RECURSION 3
+#define MAX_RECURSION 2
 //#define FOUR_X_A
 //#define PATH_TRACING
 //#define DEPTH_OF_FIELD
-#define EPSILON 0.01
-#define MAX_SHADOW_SAMPLES 4
+#define SOFT_SHADOWS
+#define EPSILON 0.05
+#define MAX_SHADOW_SAMPLES 8
 
 #ifdef FALLBACK
 	#undef MAX_RECURSION
@@ -12,5 +13,10 @@
 	#define NO_SHADOWS
 #endif
 
+#define HARD_IRR
+#ifdef HARD_IRR
+#define IRR 0.15
+#endif
+
 RaytracingAccelerationStructure Scene : register(t0, space0);