Draw frustum splices ontop of direction shadow atlas for debug purposes

doc/classes/RenderingServer.xml

@@ -4625,6 +4625,8 @@
 		</constant>
 		<constant name="VIEWPORT_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS" value="10" enum="ViewportDebugDraw">
 			Draws the shadow atlas that stores shadows from [DirectionalLight3D]s in the upper left quadrant of the [Viewport].
+			The slice of the camera frustum related to the shadow map cascade is superimposed to visualize coverage. The color of each slice matches the colors used for [constant VIEWPORT_DEBUG_DRAW_PSSM_SPLITS]. When shadow cascades are blended the overlap is taken into account when drawing the frustum slices.
+			The last cascade shows all frustum slices to illustrate the coverage of all slices.
 		</constant>
 		<constant name="VIEWPORT_DEBUG_DRAW_SCENE_LUMINANCE" value="11" enum="ViewportDebugDraw">
 			Draws the estimated scene luminance. This is a 1×1 texture that is generated when autoexposure is enabled to control the scene's exposure.

servers/rendering/renderer_rd/effects/debug_effects.cpp

@@ -0,0 +1,328 @@
+/**************************************************************************/
+/*  debug_effects.cpp                                                     */
+/**************************************************************************/
+/*                         This file is part of:                          */
+/*                             GODOT ENGINE                               */
+/*                        https://godotengine.org                         */
+/**************************************************************************/
+/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
+/*                                                                        */
+/* Permission is hereby granted, free of charge, to any person obtaining  */
+/* a copy of this software and associated documentation files (the        */
+/* "Software"), to deal in the Software without restriction, including    */
+/* without limitation the rights to use, copy, modify, merge, publish,    */
+/* distribute, sublicense, and/or sell copies of the Software, and to     */
+/* permit persons to whom the Software is furnished to do so, subject to  */
+/* the following conditions:                                              */
+/*                                                                        */
+/* The above copyright notice and this permission notice shall be         */
+/* included in all copies or substantial portions of the Software.        */
+/*                                                                        */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
+/**************************************************************************/
+
+#include "debug_effects.h"
+#include "servers/rendering/renderer_rd/renderer_compositor_rd.h"
+#include "servers/rendering/renderer_rd/storage_rd/light_storage.h"
+#include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
+#include "servers/rendering/renderer_rd/uniform_set_cache_rd.h"
+
+using namespace RendererRD;
+
+DebugEffects::DebugEffects() {
+	{
+		// Shadow Frustum debug shader
+		Vector<String> modes;
+		modes.push_back("");
+
+		shadow_frustum.shader.initialize(modes);
+		shadow_frustum.shader_version = shadow_frustum.shader.version_create();
+
+		RD::PipelineRasterizationState raster_state = RD::PipelineRasterizationState();
+		shadow_frustum.pipelines[SFP_TRANSPARENT].setup(shadow_frustum.shader.version_get_shader(shadow_frustum.shader_version, 0), RD::RENDER_PRIMITIVE_TRIANGLES, raster_state, RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), RD::PipelineColorBlendState::create_blend(), 0);
+
+		raster_state.wireframe = true;
+		shadow_frustum.pipelines[SFP_WIREFRAME].setup(shadow_frustum.shader.version_get_shader(shadow_frustum.shader_version, 0), RD::RENDER_PRIMITIVE_LINES, raster_state, RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), RD::PipelineColorBlendState::create_disabled(), 0);
+	}
+}
+
+void DebugEffects::_create_frustum_arrays() {
+	if (frustum.vertex_buffer.is_null()) {
+		// Create vertex buffer, but don't put data in it yet
+		frustum.vertex_buffer = RD::get_singleton()->vertex_buffer_create(8 * sizeof(float) * 3, Vector<uint8_t>(), false);
+
+		Vector<RD::VertexAttribute> attributes;
+		Vector<RID> buffers;
+		RD::VertexAttribute vd;
+
+		vd.location = 0;
+		vd.stride = sizeof(float) * 3;
+		vd.format = RD::DATA_FORMAT_R32G32B32_SFLOAT;
+
+		attributes.push_back(vd);
+		buffers.push_back(frustum.vertex_buffer);
+
+		frustum.vertex_format = RD::get_singleton()->vertex_format_create(attributes);
+		frustum.vertex_array = RD::get_singleton()->vertex_array_create(8, frustum.vertex_format, buffers);
+	}
+
+	if (frustum.index_buffer.is_null()) {
+		uint32_t indices[6 * 2 * 3] = {
+			// Far
+			0, 1, 2, // FLT, FLB, FRT
+			1, 3, 2, // FLB, FRB, FRT
+			// Near
+			4, 6, 5, // NLT, NRT, NLB
+			6, 7, 5, // NRT, NRB, NLB
+			// Left
+			0, 4, 1, // FLT, NLT, FLB
+			4, 5, 1, // NLT, NLB, FLB
+			// Right
+			6, 2, 7, // NRT, FRT, NRB
+			2, 3, 7, // FRT, FRB, NRB
+			// Top
+			0, 2, 4, // FLT, FRT, NLT
+			2, 6, 4, // FRT, NRT, NLT
+			// Bottom
+			5, 7, 1, // NLB, NRB, FLB,
+			7, 3, 1, // NRB, FRB, FLB
+		};
+
+		// Create our index_array
+		PackedByteArray data;
+		data.resize(6 * 2 * 3 * 4);
+		{
+			uint8_t *w = data.ptrw();
+			int *p32 = (int *)w;
+			for (int i = 0; i < 6 * 2 * 3; i++) {
+				*p32 = indices[i];
+				p32++;
+			}
+		}
+
+		frustum.index_buffer = RD::get_singleton()->index_buffer_create(6 * 2 * 3, RenderingDevice::INDEX_BUFFER_FORMAT_UINT32, data);
+		frustum.index_array = RD::get_singleton()->index_array_create(frustum.index_buffer, 0, 6 * 2 * 3);
+	}
+
+	if (frustum.lines_buffer.is_null()) {
+		uint32_t indices[12 * 2] = {
+			0, 1, // FLT - FLB
+			1, 3, // FLB - FRB
+			3, 2, // FRB - FRT
+			2, 0, // FRT - FLT
+
+			4, 6, // NLT - NRT
+			6, 7, // NRT - NRB
+			7, 5, // NRB - NLB
+			5, 4, // NLB - NLT
+
+			0, 4, // FLT - NLT
+			1, 5, // FLB - NLB
+			2, 6, // FRT - NRT
+			3, 7, // FRB - NRB
+		};
+
+		// Create our lines_array
+		PackedByteArray data;
+		data.resize(12 * 2 * 4);
+		{
+			uint8_t *w = data.ptrw();
+			int *p32 = (int *)w;
+			for (int i = 0; i < 12 * 2; i++) {
+				*p32 = indices[i];
+				p32++;
+			}
+		}
+
+		frustum.lines_buffer = RD::get_singleton()->index_buffer_create(12 * 2, RenderingDevice::INDEX_BUFFER_FORMAT_UINT32, data);
+		frustum.lines_array = RD::get_singleton()->index_array_create(frustum.lines_buffer, 0, 12 * 2);
+	}
+}
+
+DebugEffects::~DebugEffects() {
+	shadow_frustum.shader.version_free(shadow_frustum.shader_version);
+
+	// Destroy vertex buffer and array.
+	if (frustum.vertex_buffer.is_valid()) {
+		RD::get_singleton()->free(frustum.vertex_buffer); // Array gets freed as dependency.
+	}
+
+	// Destroy index buffer and array,
+	if (frustum.index_buffer.is_valid()) {
+		RD::get_singleton()->free(frustum.index_buffer); // Array gets freed as dependency.
+	}
+
+	// Destroy lines buffer and array.
+	if (frustum.lines_buffer.is_valid()) {
+		RD::get_singleton()->free(frustum.lines_buffer); // Array gets freed as dependency.
+	}
+}
+
+void DebugEffects::draw_shadow_frustum(RID p_light, const Projection &p_cam_projection, const Transform3D &p_cam_transform, RID p_dest_fb, const Rect2 p_rect) {
+	RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
+
+	RID base = light_storage->light_instance_get_base_light(p_light);
+	ERR_FAIL_COND(light_storage->light_get_type(base) != RS::LIGHT_DIRECTIONAL);
+
+	// Make sure our buffers and arrays exist.
+	_create_frustum_arrays();
+
+	// Setup a points buffer for our view frustum.
+	PackedByteArray points;
+	points.resize(8 * sizeof(float) * 3);
+
+	// Get info about our splits.
+	RS::LightDirectionalShadowMode shadow_mode = light_storage->light_directional_get_shadow_mode(base);
+	bool overlap = light_storage->light_directional_get_blend_splits(base);
+	int splits = 1;
+	if (shadow_mode == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
+		splits = 4;
+	} else if (shadow_mode == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
+		splits = 2;
+	}
+
+	// Setup our camera info (this is mostly a duplicate of the logic found in RendererSceneCull::_light_instance_setup_directional_shadow).
+	bool is_orthogonal = p_cam_projection.is_orthogonal();
+	real_t aspect = p_cam_projection.get_aspect();
+	real_t fov = 0.0;
+	Vector2 vp_he;
+	if (is_orthogonal) {
+		vp_he = p_cam_projection.get_viewport_half_extents();
+	} else {
+		fov = p_cam_projection.get_fov(); //this is actually yfov, because set aspect tries to keep it
+	}
+	real_t min_distance = p_cam_projection.get_z_near();
+	real_t max_distance = p_cam_projection.get_z_far();
+	real_t shadow_max = RSG::light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_MAX_DISTANCE);
+	if (shadow_max > 0 && !is_orthogonal) {
+		max_distance = MIN(shadow_max, max_distance);
+	}
+
+	// Make sure we've not got bad info coming in.
+	max_distance = MAX(max_distance, min_distance + 0.001);
+	min_distance = MIN(min_distance, max_distance);
+	real_t range = max_distance - min_distance;
+
+	real_t distances[5];
+	distances[0] = min_distance;
+	for (int i = 0; i < splits; i++) {
+		distances[i + 1] = min_distance + RSG::light_storage->light_get_param(base, RS::LightParam(RS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET + i)) * range;
+	};
+	distances[splits] = max_distance;
+
+	Color colors[4] = {
+		Color(1.0, 0.0, 0.0, 0.1),
+		Color(0.0, 1.0, 0.0, 0.1),
+		Color(0.0, 0.0, 1.0, 0.1),
+		Color(1.0, 1.0, 0.0, 0.1),
+	};
+
+	for (int split = 0; split < splits; split++) {
+		// Load frustum points into vertex buffer.
+		uint8_t *w = points.ptrw();
+		Vector3 *vw = (Vector3 *)w;
+
+		Projection projection;
+
+		if (is_orthogonal) {
+			projection.set_orthogonal(vp_he.y * 2.0, aspect, distances[(split == 0 || !overlap) ? split : split - 1], distances[split + 1], false);
+		} else {
+			projection.set_perspective(fov, aspect, distances[(split == 0 || !overlap) ? split : split - 1], distances[split + 1], true);
+		}
+
+		bool res = projection.get_endpoints(p_cam_transform, vw);
+		ERR_CONTINUE(!res);
+
+		RD::get_singleton()->buffer_update(frustum.vertex_buffer, 0, 8 * sizeof(float) * 3, w);
+
+		// Get our light projection info.
+		Projection light_projection = light_storage->light_instance_get_shadow_camera(p_light, split);
+		Transform3D light_transform = light_storage->light_instance_get_shadow_transform(p_light, split);
+		Rect2 atlas_rect_norm = light_storage->light_instance_get_directional_shadow_atlas_rect(p_light, split);
+
+		if (!is_orthogonal) {
+			light_transform.orthogonalize();
+		}
+
+		// Setup our push constant.
+		ShadowFrustumPushConstant push_constant;
+		MaterialStorage::store_camera(light_projection * Projection(light_transform.inverse()), push_constant.mvp);
+		push_constant.color[0] = colors[split].r;
+		push_constant.color[1] = colors[split].g;
+		push_constant.color[2] = colors[split].b;
+		push_constant.color[3] = colors[split].a;
+
+		// Adjust our rect to our atlas position.
+		Rect2 rect = p_rect;
+		rect.position.x += atlas_rect_norm.position.x * rect.size.x;
+		rect.position.y += atlas_rect_norm.position.y * rect.size.y;
+		rect.size.x *= atlas_rect_norm.size.x;
+		rect.size.y *= atlas_rect_norm.size.y;
+
+		// And draw our frustum.
+		RD::FramebufferFormatID fb_format_id = RD::get_singleton()->framebuffer_get_format(p_dest_fb);
+
+		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_dest_fb, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD, Vector<Color>(), 1.0, 0, rect);
+
+		RID pipeline = shadow_frustum.pipelines[SFP_TRANSPARENT].get_render_pipeline(frustum.vertex_format, fb_format_id);
+		RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline);
+		RD::get_singleton()->draw_list_bind_vertex_array(draw_list, frustum.vertex_array);
+		RD::get_singleton()->draw_list_bind_index_array(draw_list, frustum.index_array);
+		RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowFrustumPushConstant));
+		RD::get_singleton()->draw_list_draw(draw_list, true);
+
+		pipeline = shadow_frustum.pipelines[SFP_WIREFRAME].get_render_pipeline(frustum.vertex_format, fb_format_id);
+		RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline);
+		RD::get_singleton()->draw_list_bind_vertex_array(draw_list, frustum.vertex_array);
+		RD::get_singleton()->draw_list_bind_index_array(draw_list, frustum.lines_array);
+		RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowFrustumPushConstant));
+		RD::get_singleton()->draw_list_draw(draw_list, true);
+
+		RD::get_singleton()->draw_list_end();
+
+		if (split < (splits - 1) && splits > 1) {
+			// Also draw it in the last split so we get a proper overview of the whole view frustum...
+
+			// Get our light projection info.
+			light_projection = light_storage->light_instance_get_shadow_camera(p_light, (splits - 1));
+			light_transform = light_storage->light_instance_get_shadow_transform(p_light, (splits - 1));
+			atlas_rect_norm = light_storage->light_instance_get_directional_shadow_atlas_rect(p_light, (splits - 1));
+
+			if (!is_orthogonal) {
+				light_transform.orthogonalize();
+			}
+
+			// Update our push constant.
+			MaterialStorage::store_camera(light_projection * Projection(light_transform.inverse()), push_constant.mvp);
+			push_constant.color[0] = colors[split].r;
+			push_constant.color[1] = colors[split].g;
+			push_constant.color[2] = colors[split].b;
+			push_constant.color[3] = colors[split].a;
+
+			// Adjust our rect to our atlas position.
+			rect = p_rect;
+			rect.position.x += atlas_rect_norm.position.x * rect.size.x;
+			rect.position.y += atlas_rect_norm.position.y * rect.size.y;
+			rect.size.x *= atlas_rect_norm.size.x;
+			rect.size.y *= atlas_rect_norm.size.y;
+
+			draw_list = RD::get_singleton()->draw_list_begin(p_dest_fb, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD, Vector<Color>(), 1.0, 0, rect);
+
+			pipeline = shadow_frustum.pipelines[SFP_TRANSPARENT].get_render_pipeline(frustum.vertex_format, fb_format_id);
+			RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline);
+			RD::get_singleton()->draw_list_bind_vertex_array(draw_list, frustum.vertex_array);
+			RD::get_singleton()->draw_list_bind_index_array(draw_list, frustum.index_array);
+			RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowFrustumPushConstant));
+			RD::get_singleton()->draw_list_draw(draw_list, true);
+
+			RD::get_singleton()->draw_list_end();
+		}
+	}
+}