1/**************************************************************************/
2/* debug_effects.cpp */
3/**************************************************************************/
4/* This file is part of: */
5/* GODOT ENGINE */
6/* https://godotengine.org */
7/**************************************************************************/
8/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
9/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
10/* */
11/* Permission is hereby granted, free of charge, to any person obtaining */
12/* a copy of this software and associated documentation files (the */
13/* "Software"), to deal in the Software without restriction, including */
14/* without limitation the rights to use, copy, modify, merge, publish, */
15/* distribute, sublicense, and/or sell copies of the Software, and to */
16/* permit persons to whom the Software is furnished to do so, subject to */
17/* the following conditions: */
18/* */
19/* The above copyright notice and this permission notice shall be */
20/* included in all copies or substantial portions of the Software. */
21/* */
22/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
23/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
24/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
25/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
26/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
27/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
28/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
29/**************************************************************************/
30
31#include "debug_effects.h"
32#include "servers/rendering/renderer_rd/renderer_compositor_rd.h"
33#include "servers/rendering/renderer_rd/storage_rd/light_storage.h"
34#include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
35#include "servers/rendering/renderer_rd/uniform_set_cache_rd.h"
36
37using namespace RendererRD;
38
39DebugEffects::DebugEffects() {
40 {
41 // Shadow Frustum debug shader
42 Vector<String> modes;
43 modes.push_back("");
44
45 shadow_frustum.shader.initialize(modes);
46 shadow_frustum.shader_version = shadow_frustum.shader.version_create();
47
48 RD::PipelineRasterizationState raster_state = RD::PipelineRasterizationState();
49 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);
50
51 raster_state.wireframe = true;
52 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);
53 }
54
55 {
56 // Motion Vectors debug shader.
57 Vector<String> modes;
58 modes.push_back("");
59
60 motion_vectors.shader.initialize(modes);
61 motion_vectors.shader_version = motion_vectors.shader.version_create();
62
63 motion_vectors.pipeline.setup(motion_vectors.shader.version_get_shader(motion_vectors.shader_version, 0), RD::RENDER_PRIMITIVE_TRIANGLES, RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), RD::PipelineColorBlendState::create_blend(), 0);
64 }
65}
66
67void DebugEffects::_create_frustum_arrays() {
68 if (frustum.vertex_buffer.is_null()) {
69 // Create vertex buffer, but don't put data in it yet
70 frustum.vertex_buffer = RD::get_singleton()->vertex_buffer_create(8 * sizeof(float) * 3, Vector<uint8_t>(), false);
71
72 Vector<RD::VertexAttribute> attributes;
73 Vector<RID> buffers;
74 RD::VertexAttribute vd;
75
76 vd.location = 0;
77 vd.stride = sizeof(float) * 3;
78 vd.format = RD::DATA_FORMAT_R32G32B32_SFLOAT;
79
80 attributes.push_back(vd);
81 buffers.push_back(frustum.vertex_buffer);
82
83 frustum.vertex_format = RD::get_singleton()->vertex_format_create(attributes);
84 frustum.vertex_array = RD::get_singleton()->vertex_array_create(8, frustum.vertex_format, buffers);
85 }
86
87 if (frustum.index_buffer.is_null()) {
88 uint16_t indices[6 * 2 * 3] = {
89 // Far
90 0, 1, 2, // FLT, FLB, FRT
91 1, 3, 2, // FLB, FRB, FRT
92 // Near
93 4, 6, 5, // NLT, NRT, NLB
94 6, 7, 5, // NRT, NRB, NLB
95 // Left
96 0, 4, 1, // FLT, NLT, FLB
97 4, 5, 1, // NLT, NLB, FLB
98 // Right
99 6, 2, 7, // NRT, FRT, NRB
100 2, 3, 7, // FRT, FRB, NRB
101 // Top
102 0, 2, 4, // FLT, FRT, NLT
103 2, 6, 4, // FRT, NRT, NLT
104 // Bottom
105 5, 7, 1, // NLB, NRB, FLB,
106 7, 3, 1, // NRB, FRB, FLB
107 };
108
109 // Create our index_array
110 PackedByteArray data;
111 data.resize(6 * 2 * 3 * 4);
112 {
113 uint8_t *w = data.ptrw();
114 uint16_t *p16 = (uint16_t *)w;
115 for (int i = 0; i < 6 * 2 * 3; i++) {
116 *p16 = indices[i];
117 p16++;
118 }
119 }
120
121 frustum.index_buffer = RD::get_singleton()->index_buffer_create(6 * 2 * 3, RenderingDevice::INDEX_BUFFER_FORMAT_UINT16, data);
122 frustum.index_array = RD::get_singleton()->index_array_create(frustum.index_buffer, 0, 6 * 2 * 3);
123 }
124
125 if (frustum.lines_buffer.is_null()) {
126 uint16_t indices[12 * 2] = {
127 0, 1, // FLT - FLB
128 1, 3, // FLB - FRB
129 3, 2, // FRB - FRT
130 2, 0, // FRT - FLT
131
132 4, 6, // NLT - NRT
133 6, 7, // NRT - NRB
134 7, 5, // NRB - NLB
135 5, 4, // NLB - NLT
136
137 0, 4, // FLT - NLT
138 1, 5, // FLB - NLB
139 2, 6, // FRT - NRT
140 3, 7, // FRB - NRB
141 };
142
143 // Create our lines_array
144 PackedByteArray data;
145 data.resize(12 * 2 * 4);
146 {
147 uint8_t *w = data.ptrw();
148 uint16_t *p16 = (uint16_t *)w;
149 for (int i = 0; i < 12 * 2; i++) {
150 *p16 = indices[i];
151 p16++;
152 }
153 }
154
155 frustum.lines_buffer = RD::get_singleton()->index_buffer_create(12 * 2, RenderingDevice::INDEX_BUFFER_FORMAT_UINT16, data);
156 frustum.lines_array = RD::get_singleton()->index_array_create(frustum.lines_buffer, 0, 12 * 2);
157 }
158}
159
160DebugEffects::~DebugEffects() {
161 shadow_frustum.shader.version_free(shadow_frustum.shader_version);
162
163 // Destroy vertex buffer and array.
164 if (frustum.vertex_buffer.is_valid()) {
165 RD::get_singleton()->free(frustum.vertex_buffer); // Array gets freed as dependency.
166 }
167
168 // Destroy index buffer and array,
169 if (frustum.index_buffer.is_valid()) {
170 RD::get_singleton()->free(frustum.index_buffer); // Array gets freed as dependency.
171 }
172
173 // Destroy lines buffer and array.
174 if (frustum.lines_buffer.is_valid()) {
175 RD::get_singleton()->free(frustum.lines_buffer); // Array gets freed as dependency.
176 }
177
178 motion_vectors.shader.version_free(motion_vectors.shader_version);
179}
180
181void 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) {
182 RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
183
184 RID base = light_storage->light_instance_get_base_light(p_light);
185 ERR_FAIL_COND(light_storage->light_get_type(base) != RS::LIGHT_DIRECTIONAL);
186
187 // Make sure our buffers and arrays exist.
188 _create_frustum_arrays();
189
190 // Setup a points buffer for our view frustum.
191 PackedByteArray points;
192 points.resize(8 * sizeof(float) * 3);
193
194 // Get info about our splits.
195 RS::LightDirectionalShadowMode shadow_mode = light_storage->light_directional_get_shadow_mode(base);
196 bool overlap = light_storage->light_directional_get_blend_splits(base);
197 int splits = 1;
198 if (shadow_mode == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
199 splits = 4;
200 } else if (shadow_mode == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
201 splits = 2;
202 }
203
204 // Setup our camera info (this is mostly a duplicate of the logic found in RendererSceneCull::_light_instance_setup_directional_shadow).
205 bool is_orthogonal = p_cam_projection.is_orthogonal();
206 real_t aspect = p_cam_projection.get_aspect();
207 real_t fov = 0.0;
208 Vector2 vp_he;
209 if (is_orthogonal) {
210 vp_he = p_cam_projection.get_viewport_half_extents();
211 } else {
212 fov = p_cam_projection.get_fov(); //this is actually yfov, because set aspect tries to keep it
213 }
214 real_t min_distance = p_cam_projection.get_z_near();
215 real_t max_distance = p_cam_projection.get_z_far();
216 real_t shadow_max = RSG::light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_MAX_DISTANCE);
217 if (shadow_max > 0 && !is_orthogonal) {
218 max_distance = MIN(shadow_max, max_distance);
219 }
220
221 // Make sure we've not got bad info coming in.
222 max_distance = MAX(max_distance, min_distance + 0.001);
223 min_distance = MIN(min_distance, max_distance);
224 real_t range = max_distance - min_distance;
225
226 real_t distances[5];
227 distances[0] = min_distance;
228 for (int i = 0; i < splits; i++) {
229 distances[i + 1] = min_distance + RSG::light_storage->light_get_param(base, RS::LightParam(RS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET + i)) * range;
230 };
231 distances[splits] = max_distance;
232
233 Color colors[4] = {
234 Color(1.0, 0.0, 0.0, 0.1),
235 Color(0.0, 1.0, 0.0, 0.1),
236 Color(0.0, 0.0, 1.0, 0.1),
237 Color(1.0, 1.0, 0.0, 0.1),
238 };
239
240 for (int split = 0; split < splits; split++) {
241 // Load frustum points into vertex buffer.
242 uint8_t *w = points.ptrw();
243 Vector3 *vw = (Vector3 *)w;
244
245 Projection projection;
246
247 if (is_orthogonal) {
248 projection.set_orthogonal(vp_he.y * 2.0, aspect, distances[(split == 0 || !overlap) ? split : split - 1], distances[split + 1], false);
249 } else {
250 projection.set_perspective(fov, aspect, distances[(split == 0 || !overlap) ? split : split - 1], distances[split + 1], true);
251 }
252
253 bool res = projection.get_endpoints(p_cam_transform, vw);
254 ERR_CONTINUE(!res);
255
256 RD::get_singleton()->buffer_update(frustum.vertex_buffer, 0, 8 * sizeof(float) * 3, w);
257
258 // Get our light projection info.
259 Projection light_projection = light_storage->light_instance_get_shadow_camera(p_light, split);
260 Transform3D light_transform = light_storage->light_instance_get_shadow_transform(p_light, split);
261 Rect2 atlas_rect_norm = light_storage->light_instance_get_directional_shadow_atlas_rect(p_light, split);
262
263 if (!is_orthogonal) {
264 light_transform.orthogonalize();
265 }
266
267 // Setup our push constant.
268 ShadowFrustumPushConstant push_constant;
269 MaterialStorage::store_camera(light_projection * Projection(light_transform.inverse()), push_constant.mvp);
270 push_constant.color[0] = colors[split].r;
271 push_constant.color[1] = colors[split].g;
272 push_constant.color[2] = colors[split].b;
273 push_constant.color[3] = colors[split].a;
274
275 // Adjust our rect to our atlas position.
276 Rect2 rect = p_rect;
277 rect.position.x += atlas_rect_norm.position.x * rect.size.x;
278 rect.position.y += atlas_rect_norm.position.y * rect.size.y;
279 rect.size.x *= atlas_rect_norm.size.x;
280 rect.size.y *= atlas_rect_norm.size.y;
281
282 // And draw our frustum.
283 RD::FramebufferFormatID fb_format_id = RD::get_singleton()->framebuffer_get_format(p_dest_fb);
284
285 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);
286
287 RID pipeline = shadow_frustum.pipelines[SFP_TRANSPARENT].get_render_pipeline(frustum.vertex_format, fb_format_id);
288 RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline);
289 RD::get_singleton()->draw_list_bind_vertex_array(draw_list, frustum.vertex_array);
290 RD::get_singleton()->draw_list_bind_index_array(draw_list, frustum.index_array);
291 RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowFrustumPushConstant));
292 RD::get_singleton()->draw_list_draw(draw_list, true);
293
294 pipeline = shadow_frustum.pipelines[SFP_WIREFRAME].get_render_pipeline(frustum.vertex_format, fb_format_id);
295 RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline);
296 RD::get_singleton()->draw_list_bind_vertex_array(draw_list, frustum.vertex_array);
297 RD::get_singleton()->draw_list_bind_index_array(draw_list, frustum.lines_array);
298 RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowFrustumPushConstant));
299 RD::get_singleton()->draw_list_draw(draw_list, true);
300
301 RD::get_singleton()->draw_list_end();
302
303 if (split < (splits - 1) && splits > 1) {
304 // Also draw it in the last split so we get a proper overview of the whole view frustum...
305
306 // Get our light projection info.
307 light_projection = light_storage->light_instance_get_shadow_camera(p_light, (splits - 1));
308 light_transform = light_storage->light_instance_get_shadow_transform(p_light, (splits - 1));
309 atlas_rect_norm = light_storage->light_instance_get_directional_shadow_atlas_rect(p_light, (splits - 1));
310
311 if (!is_orthogonal) {
312 light_transform.orthogonalize();
313 }
314
315 // Update our push constant.
316 MaterialStorage::store_camera(light_projection * Projection(light_transform.inverse()), push_constant.mvp);
317 push_constant.color[0] = colors[split].r;
318 push_constant.color[1] = colors[split].g;
319 push_constant.color[2] = colors[split].b;
320 push_constant.color[3] = colors[split].a;
321
322 // Adjust our rect to our atlas position.
323 rect = p_rect;
324 rect.position.x += atlas_rect_norm.position.x * rect.size.x;
325 rect.position.y += atlas_rect_norm.position.y * rect.size.y;
326 rect.size.x *= atlas_rect_norm.size.x;
327 rect.size.y *= atlas_rect_norm.size.y;
328
329 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);
330
331 pipeline = shadow_frustum.pipelines[SFP_TRANSPARENT].get_render_pipeline(frustum.vertex_format, fb_format_id);
332 RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline);
333 RD::get_singleton()->draw_list_bind_vertex_array(draw_list, frustum.vertex_array);
334 RD::get_singleton()->draw_list_bind_index_array(draw_list, frustum.index_array);
335 RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowFrustumPushConstant));
336 RD::get_singleton()->draw_list_draw(draw_list, true);
337
338 RD::get_singleton()->draw_list_end();
339 }
340 }
341}
342
343void DebugEffects::draw_motion_vectors(RID p_velocity, RID p_dest_fb, Size2i p_velocity_size) {
344 MaterialStorage *material_storage = MaterialStorage::get_singleton();
345 ERR_FAIL_NULL(material_storage);
346
347 UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();
348 ERR_FAIL_NULL(uniform_set_cache);
349
350 RID default_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
351 RD::Uniform u_source_velocity(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>({ default_sampler, p_velocity }));
352
353 RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_dest_fb, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD);
354 RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, motion_vectors.pipeline.get_render_pipeline(RD::INVALID_ID, RD::get_singleton()->framebuffer_get_format(p_dest_fb), false, RD::get_singleton()->draw_list_get_current_pass()));
355
356 motion_vectors.push_constant.velocity_resolution[0] = p_velocity_size.width;
357 motion_vectors.push_constant.velocity_resolution[1] = p_velocity_size.height;
358
359 RID shader = motion_vectors.shader.version_get_shader(motion_vectors.shader_version, 0);
360 RD::get_singleton()->draw_list_bind_uniform_set(draw_list, uniform_set_cache->get_cache(shader, 0, u_source_velocity), 0);
361 RD::get_singleton()->draw_list_set_push_constant(draw_list, &motion_vectors.push_constant, sizeof(MotionVectorsPushConstant));
362 RD::get_singleton()->draw_list_draw(draw_list, false, 1u, 3u);
363 RD::get_singleton()->draw_list_end();
364}
365