asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp

6034 lines
241 KiB
C++
Raw Normal View History

Fix code formatting issues and VS compilation Also temporarily disable multicheck build so that we get a full build even when there are style issues on Vulkan. Fixes #33356.
2019-11-05 12:01:00 +01:00
/*************************************************************************/
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
/* renderer_scene_render_rd.cpp */
Fix code formatting issues and VS compilation Also temporarily disable multicheck build so that we get a full build even when there are style issues on Vulkan. Fixes #33356.
2019-11-05 12:01:00 +01:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
Update copyright statements to 2022 Happy new year to the wonderful Godot community!
2022-01-03 21:27:34 +01:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
Fix code formatting issues and VS compilation Also temporarily disable multicheck build so that we get a full build even when there are style issues on Vulkan. Fixes #33356.
2019-11-05 12:01:00 +01:00
/* */
/* 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. */
/*************************************************************************/
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
#include "renderer_scene_render_rd.h"
doc: Sync classref with current source Lots of internal API changes and some docstrings were lost in the conversion. I manually salvaged many of them but for all the rendering-related ones, an additional pass is needed. Added missing enum bindings in BaseMaterial3D and VisualServer.
2020-02-12 09:59:06 +01:00
Reorganized core/ directory, it was too fatty already -Removed FuncRef, since Callable makes it obsolete -Removed int_types.h as its obsolete in c++11+ -Changed color names code
2020-11-07 23:33:38 +01:00
#include "core/config/project_settings.h"
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
#include "core/os/os.h"
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
#include "renderer_compositor_rd.h"
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
#include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
#include "servers/rendering/renderer_rd/storage_rd/texture_storage.h"
Reorganize rendering server. -Made RenderingServerScene abstract, allowing reimplementation -RenderingServerRaster -> RenderingServerDefault, but this class is going away soon.
2020-12-03 22:09:47 +01:00
#include "servers/rendering/rendering_server_default.h"
Environment: Refactor code for readability + more - Makes all boolean setters/getters consistent. - Fixes bug where `glow_hdr_bleed_scale` was not used. - Split CameraEffects to their own source file. - Reorder all Environment method and properties declarations, definitions and bindings to be consistent with each other and with the order of property bindings. - Bind missing enum values added with SDFGI. - Remove unused SDFGI enhance_ssr boolean. - Sync doc changes after SDFGI merge and other misc changes.
2020-07-01 14:18:13 +02:00
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
void get_vogel_disk(float *r_kernel, int p_sample_count) {
const float golden_angle = 2.4;
for (int i = 0; i < p_sample_count; i++) {
float r = Math::sqrt(float(i) + 0.5) / Math::sqrt(float(p_sample_count));
float theta = float(i) * golden_angle;
r_kernel[i * 4] = Math::cos(theta) * r;
r_kernel[i * 4 + 1] = Math::sin(theta) * r;
}
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
bool needs_sdfgi = env && env->sdfgi_enabled;
if (!needs_sdfgi) {
if (rb->sdfgi != nullptr) {
//erase it
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
rb->sdfgi->erase();
memdelete(rb->sdfgi);
rb->sdfgi = nullptr;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
return;
}
static const uint32_t history_frames_to_converge[RS::ENV_SDFGI_CONVERGE_MAX] = { 5, 10, 15, 20, 25, 30 };
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
uint32_t requested_history_size = history_frames_to_converge[gi.sdfgi_frames_to_converge];
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Allow using between 1 and 8 cascades for SDFGI This provides more flexibility between performance and quality adjustments, especially when using SDFGI for small-scale levels (which can be useful for procedurally generated scenes).
2022-01-13 19:46:14 +01:00
if (rb->sdfgi && (rb->sdfgi->num_cascades != env->sdfgi_cascades || rb->sdfgi->min_cell_size != env->sdfgi_min_cell_size || requested_history_size != rb->sdfgi->history_size || rb->sdfgi->uses_occlusion != env->sdfgi_use_occlusion || rb->sdfgi->y_scale_mode != env->sdfgi_y_scale)) {
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
//configuration changed, erase
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
rb->sdfgi->erase();
memdelete(rb->sdfgi);
rb->sdfgi = nullptr;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
RendererSceneGIRD::SDFGI *sdfgi = rb->sdfgi;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
if (sdfgi == nullptr) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
// re-create
rb->sdfgi = gi.create_sdfgi(env, p_world_position, requested_history_size);
} else {
//check for updates
rb->sdfgi->update(env, p_world_position);
}
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
int RendererSceneRenderRD::sdfgi_get_pending_region_count(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND_V(rb == nullptr, 0);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (rb->sdfgi == nullptr) {
return 0;
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
int dirty_count = 0;
for (uint32_t i = 0; i < rb->sdfgi->cascades.size(); i++) {
const RendererSceneGIRD::SDFGI::Cascade &c = rb->sdfgi->cascades[i];
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (c.dirty_regions == RendererSceneGIRD::SDFGI::Cascade::DIRTY_ALL) {
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
dirty_count++;
} else {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
for (int j = 0; j < 3; j++) {
if (c.dirty_regions[j] != 0) {
dirty_count++;
}
}
Working sky shader implementation
2020-03-20 01:32:19 +01:00
}
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
return dirty_count;
}
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
AABB RendererSceneRenderRD::sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const {
AABB bounds;
Vector3i from;
Vector3i size;
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND_V(rb == nullptr, AABB());
ERR_FAIL_COND_V(rb->sdfgi == nullptr, AABB());
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
int c = rb->sdfgi->get_pending_region_data(p_region, from, size, bounds);
ERR_FAIL_COND_V(c == -1, AABB());
return bounds;
}
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
uint32_t RendererSceneRenderRD::sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const {
AABB bounds;
Vector3i from;
Vector3i size;
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND_V(rb == nullptr, -1);
ERR_FAIL_COND_V(rb->sdfgi == nullptr, -1);
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
return rb->sdfgi->get_pending_region_data(p_region, from, size, bounds);
}
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
RID RendererSceneRenderRD::sky_allocate() {
return sky.allocate_sky_rid();
}
void RendererSceneRenderRD::sky_initialize(RID p_rid) {
sky.initialize_sky_rid(p_rid);
}
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
void RendererSceneRenderRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) {
sky.sky_set_radiance_size(p_sky, p_radiance_size);
Working sky shader implementation
2020-03-20 01:32:19 +01:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
void RendererSceneRenderRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) {
sky.sky_set_mode(p_sky, p_mode);
}
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
void RendererSceneRenderRD::sky_set_material(RID p_sky, RID p_material) {
sky.sky_set_material(p_sky, p_material);
Working sky shader implementation
2020-03-20 01:32:19 +01:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
Ref<Image> RendererSceneRenderRD::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) {
return sky.sky_bake_panorama(p_sky, p_energy, p_bake_irradiance, p_size);
Working sky shader implementation
2020-03-20 01:32:19 +01:00
}
Make Servers truly Thread Safe -Rendering server now uses a split RID allocate/initialize internally, this allows generating RIDs immediately but initialization to happen later on the proper thread (as rendering APIs generally requiere to call on the right thread). -RenderingServerWrapMT is no more, multithreading is done in RenderingServerDefault. -Some functions like texture or mesh creation, when renderer supports it, can register and return immediately (so no waiting for server API to flush, and saving staging and command buffer memory). -3D physics server changed to be made multithread friendly. -Added PhysicsServer3DWrapMT to use 3D physics server from multiple threads. -Disablet Bullet (too much effort to make multithread friendly, this needs to be fixed eventually).
2021-02-09 17:19:03 +01:00
RID RendererSceneRenderRD::environment_allocate() {
return environment_owner.allocate_rid();
}
void RendererSceneRenderRD::environment_initialize(RID p_rid) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
environment_owner.initialize_rid(p_rid, RendererSceneEnvironmentRD());
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_background(RID p_env, RS::EnvironmentBG p_bg) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
env->background = p_bg;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_sky(RID p_env, RID p_sky) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
env->sky = p_sky;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_sky_custom_fov(RID p_env, float p_scale) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
env->sky_custom_fov = p_scale;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_sky_orientation(RID p_env, const Basis &p_orientation) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
env->sky_orientation = p_orientation;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_bg_color(RID p_env, const Color &p_color) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
env->bg_color = p_color;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_bg_energy(RID p_env, float p_energy) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
env->bg_energy = p_energy;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_canvas_max_layer(RID p_env, int p_max_layer) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
env->canvas_max_layer = p_max_layer;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
Remove unimplemented `Environment.ambient_light_occlusion_color` property This property was intended to provide a way to have SSAO or VoxelGI ambient occlusion with a color other than black. However, it was dropped during the Vulkan renderer development due to the performance overhead it caused when the feature wasn't used.
2021-10-07 15:01:14 +02:00
void RendererSceneRenderRD::environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient, float p_energy, float p_sky_contribution, RS::EnvironmentReflectionSource p_reflection_source) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND(!env);
Remove unimplemented `Environment.ambient_light_occlusion_color` property This property was intended to provide a way to have SSAO or VoxelGI ambient occlusion with a color other than black. However, it was dropped during the Vulkan renderer development due to the performance overhead it caused when the feature wasn't used.
2021-10-07 15:01:14 +02:00
env->set_ambient_light(p_color, p_ambient, p_energy, p_sky_contribution, p_reflection_source);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RS::EnvironmentBG RendererSceneRenderRD::environment_get_background(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
ERR_FAIL_COND_V(!env, RS::ENV_BG_MAX);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
return env->background;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::environment_get_sky(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, RID());
return env->sky;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_sky_custom_fov(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->sky_custom_fov;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
Basis RendererSceneRenderRD::environment_get_sky_orientation(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, Basis());
return env->sky_orientation;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
Color RendererSceneRenderRD::environment_get_bg_color(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, Color());
return env->bg_color;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_bg_energy(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->bg_energy;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
int RendererSceneRenderRD::environment_get_canvas_max_layer(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->canvas_max_layer;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
Color RendererSceneRenderRD::environment_get_ambient_light_color(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, Color());
return env->ambient_light;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RS::EnvironmentAmbientSource RendererSceneRenderRD::environment_get_ambient_source(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
ERR_FAIL_COND_V(!env, RS::ENV_AMBIENT_SOURCE_BG);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
return env->ambient_source;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_ambient_light_energy(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->ambient_light_energy;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_ambient_sky_contribution(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->ambient_sky_contribution;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RS::EnvironmentReflectionSource RendererSceneRenderRD::environment_get_reflection_source(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
ERR_FAIL_COND_V(!env, RS::ENV_REFLECTION_SOURCE_DISABLED);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
return env->reflection_source;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_tonemap(RID p_env, RS::EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white, bool p_auto_exposure, float p_min_luminance, float p_max_luminance, float p_auto_exp_speed, float p_auto_exp_scale) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Tonemapping ported (not all parameters supported yet, only enough to get correct color)
2019-08-27 20:27:35 +02:00
ERR_FAIL_COND(!env);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
env->set_tonemap(p_tone_mapper, p_exposure, p_white, p_auto_exposure, p_min_luminance, p_max_luminance, p_auto_exp_speed, p_auto_exp_scale);
Tonemapping ported (not all parameters supported yet, only enough to get correct color)
2019-08-27 20:27:35 +02:00
}
add support for glow maps
2022-01-20 16:47:25 +01:00
void RendererSceneRenderRD::environment_set_glow(RID p_env, bool p_enable, Vector<float> p_levels, float p_intensity, float p_strength, float p_mix, float p_bloom_threshold, RS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, float p_hdr_luminance_cap, float p_glow_map_strength, RID p_glow_map) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
ERR_FAIL_COND(!env);
add support for glow maps
2022-01-20 16:47:25 +01:00
env->set_glow(p_enable, p_levels, p_intensity, p_strength, p_mix, p_bloom_threshold, p_blend_mode, p_hdr_bleed_threshold, p_hdr_bleed_scale, p_hdr_luminance_cap, p_glow_map_strength, p_glow_map);
Move glow upscale quality to a global setting, for consistency
2020-03-30 15:46:03 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_glow_set_use_bicubic_upscale(bool p_enable) {
Move glow upscale quality to a global setting, for consistency
2020-03-30 15:46:03 +02:00
glow_bicubic_upscale = p_enable;
Tonemapping ported (not all parameters supported yet, only enough to get correct color)
2019-08-27 20:27:35 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_glow_set_use_high_quality(bool p_enable) {
Add high quality glow mode
2020-09-01 08:04:45 +02:00
glow_high_quality = p_enable;
}
Allow using between 1 and 8 cascades for SDFGI This provides more flexibility between performance and quality adjustments, especially when using SDFGI for small-scale levels (which can be useful for procedurally generated scenes).
2022-01-13 19:46:14 +01:00
void RendererSceneRenderRD::environment_set_sdfgi(RID p_env, bool p_enable, int p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, float p_bounce_feedback, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND(!env);
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 13:06:48 +02:00
if (!is_dynamic_gi_supported()) {
Add support for low-end 3D rendering. -Reduce number of uniform sets from 6 to 4. -Remove features in low end mode, in order to reduce the number of texture units fit to 16.
2020-12-07 22:27:38 +01:00
return;
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
env->set_sdfgi(p_enable, p_cascades, p_min_cell_size, p_y_scale, p_use_occlusion, p_bounce_feedback, p_read_sky, p_energy, p_normal_bias, p_probe_bias);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_fog_aerial_perspective) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND(!env);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
env->set_fog(p_enable, p_light_color, p_light_energy, p_sun_scatter, p_density, p_height, p_height_density, p_fog_aerial_perspective);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::environment_is_fog_enabled(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND_V(!env, false);
return env->fog_enabled;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
Color RendererSceneRenderRD::environment_get_fog_light_color(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND_V(!env, Color());
return env->fog_light_color;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_fog_light_energy(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->fog_light_energy;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_fog_sun_scatter(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->fog_sun_scatter;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_fog_density(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->fog_density;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_fog_height(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->fog_height;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_fog_height_density(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Restored fog (non volumetric). Uses a simpler and more intuitive implementation based on density. Its less flexible than before, but its easier to get nice results.
2020-08-14 03:07:49 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->fog_height_density;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_fog_aerial_perspective(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Add aerial perspective to fixed fog
2020-08-21 07:48:04 +02:00
ERR_FAIL_COND_V(!env, 0);
return env->fog_aerial_perspective;
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_albedo, const Color &p_emission, float p_emission_energy, float p_anisotropy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount, float p_ambient_inject) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
ERR_FAIL_COND(!env);
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 13:06:48 +02:00
if (!is_volumetric_supported()) {
Add support for low-end 3D rendering. -Reduce number of uniform sets from 6 to 4. -Remove features in low end mode, in order to reduce the number of texture units fit to 16.
2020-12-07 22:27:38 +01:00
return;
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
env->set_volumetric_fog(p_enable, p_density, p_albedo, p_emission, p_emission_energy, p_anisotropy, p_length, p_detail_spread, p_gi_inject, p_temporal_reprojection, p_temporal_reprojection_amount, p_ambient_inject);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
volumetric_fog_size = p_size;
volumetric_fog_depth = p_depth;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_volumetric_fog_filter_active(bool p_enable) {
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
volumetric_fog_filter_active = p_enable;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
gi.sdfgi_ray_count = p_ray_count;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
gi.sdfgi_frames_to_converge = p_frames;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
void RendererSceneRenderRD::environment_set_sdfgi_frames_to_update_light(RS::EnvironmentSDFGIFramesToUpdateLight p_update) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
gi.sdfgi_frames_to_update_light = p_update;
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_ssr(RID p_env, bool p_enable, int p_max_steps, float p_fade_int, float p_fade_out, float p_depth_tolerance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
ERR_FAIL_COND(!env);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
env->set_ssr(p_enable, p_max_steps, p_fade_int, p_fade_out, p_depth_tolerance);
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) {
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
ssr_roughness_quality = p_quality;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RS::EnvironmentSSRRoughnessQuality RendererSceneRenderRD::environment_get_ssr_roughness_quality() const {
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
return ssr_roughness_quality;
}
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
void RendererSceneRenderRD::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_power, float p_detail, float p_horizon, float p_sharpness, float p_light_affect, float p_ao_channel_affect) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
ERR_FAIL_COND(!env);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
env->set_ssao(p_enable, p_radius, p_intensity, p_power, p_detail, p_horizon, p_sharpness, p_light_affect, p_ao_channel_affect);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
void RendererSceneRenderRD::environment_set_ssao_quality(RS::EnvironmentSSAOQuality p_quality, bool p_half_size, float p_adaptive_target, int p_blur_passes, float p_fadeout_from, float p_fadeout_to) {
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
ssao_quality = p_quality;
Revert "Replace SAO implementation with MSSAO"
2020-10-19 00:27:51 +02:00
ssao_half_size = p_half_size;
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
ssao_adaptive_target = p_adaptive_target;
ssao_blur_passes = p_blur_passes;
ssao_fadeout_from = p_fadeout_from;
ssao_fadeout_to = p_fadeout_to;
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
void RendererSceneRenderRD::environment_set_ssil(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_sharpness, float p_normal_rejection) {
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
ERR_FAIL_COND(!env);
env->ssil_enabled = p_enable;
env->ssil_radius = p_radius;
env->ssil_intensity = p_intensity;
env->ssil_sharpness = p_sharpness;
env->ssil_normal_rejection = p_normal_rejection;
}
void RendererSceneRenderRD::environment_set_ssil_quality(RS::EnvironmentSSILQuality p_quality, bool p_half_size, float p_adaptive_target, int p_blur_passes, float p_fadeout_from, float p_fadeout_to) {
ssil_quality = p_quality;
ssil_half_size = p_half_size;
ssil_adaptive_target = p_adaptive_target;
ssil_blur_passes = p_blur_passes;
ssil_fadeout_from = p_fadeout_from;
ssil_fadeout_to = p_fadeout_to;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::environment_is_ssao_enabled(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
ERR_FAIL_COND_V(!env, false);
return env->ssao_enabled;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_ssao_ao_affect(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 19:58:49 +01:00
ERR_FAIL_COND_V(!env, 0.0);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
return env->ssao_ao_channel_affect;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 14:29:06 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::environment_get_ssao_light_affect(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 19:58:49 +01:00
ERR_FAIL_COND_V(!env, 0.0);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
return env->ssao_direct_light_affect;
}
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
bool RendererSceneRenderRD::environment_is_ssil_enabled(RID p_env) const {
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
ERR_FAIL_COND_V(!env, false);
return env->ssil_enabled;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::environment_is_ssr_enabled(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
ERR_FAIL_COND_V(!env, false);
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
return env->ssr_enabled;
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::environment_is_sdfgi_enabled(RID p_env) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!env, false);
return env->sdfgi_enabled;
}
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::is_environment(RID p_env) const {
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
return environment_owner.owns(p_env);
}
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
Ref<Image> RendererSceneRenderRD::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
ERR_FAIL_COND_V(!env, Ref<Image>());
GPULightmapper: react on sky ambient properties The panorama texture creation, used by GPULightmapper, has been adjusted to also take the sky ambient properties into account.
2021-12-24 15:47:42 +01:00
RS::EnvironmentBG environment_background = env->background;
if (environment_background == RS::ENV_BG_CAMERA_FEED || environment_background == RS::ENV_BG_CANVAS || environment_background == RS::ENV_BG_KEEP) {
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
return Ref<Image>(); //nothing to bake
}
GPULightmapper: react on sky ambient properties The panorama texture creation, used by GPULightmapper, has been adjusted to also take the sky ambient properties into account.
2021-12-24 15:47:42 +01:00
RS::EnvironmentAmbientSource ambient_source = env->ambient_source;
bool use_ambient_light = false;
bool use_cube_map = false;
if (ambient_source == RS::ENV_AMBIENT_SOURCE_BG && (environment_background == RS::ENV_BG_CLEAR_COLOR || environment_background == RS::ENV_BG_COLOR)) {
use_ambient_light = true;
} else {
use_cube_map = (ambient_source == RS::ENV_AMBIENT_SOURCE_BG && environment_background == RS::ENV_BG_SKY) || ambient_source == RS::ENV_AMBIENT_SOURCE_SKY;
use_ambient_light = use_cube_map || ambient_source == RS::ENV_AMBIENT_SOURCE_COLOR;
}
use_cube_map = use_cube_map || (environment_background == RS::ENV_BG_SKY && env->sky.is_valid());
Color ambient_color;
float ambient_color_sky_mix;
if (use_ambient_light) {
ambient_color_sky_mix = env->ambient_sky_contribution;
const float ambient_energy = env->ambient_light_energy;
ambient_color = env->ambient_light;
Color: Rename `to_srgb`/`to_linear` to include base color space This helps reduce confusion around sRGB <> Linear conversions by making both input and output color spaces explicit.
2022-04-13 10:37:22 +02:00
ambient_color = ambient_color.srgb_to_linear();
GPULightmapper: react on sky ambient properties The panorama texture creation, used by GPULightmapper, has been adjusted to also take the sky ambient properties into account.
2021-12-24 15:47:42 +01:00
ambient_color.r *= ambient_energy;
ambient_color.g *= ambient_energy;
ambient_color.b *= ambient_energy;
}
if (use_cube_map) {
Ref<Image> panorama = sky_bake_panorama(env->sky, env->bg_energy, p_bake_irradiance, p_size);
if (use_ambient_light) {
for (int x = 0; x < p_size.width; x++) {
for (int y = 0; y < p_size.height; y++) {
panorama->set_pixel(x, y, ambient_color.lerp(panorama->get_pixel(x, y), ambient_color_sky_mix));
}
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
}
}
GPULightmapper: react on sky ambient properties The panorama texture creation, used by GPULightmapper, has been adjusted to also take the sky ambient properties into account.
2021-12-24 15:47:42 +01:00
return panorama;
} else {
const float bg_energy = env->bg_energy;
Color panorama_color = ((environment_background == RS::ENV_BG_CLEAR_COLOR) ? storage->get_default_clear_color() : env->bg_color);
Color: Rename `to_srgb`/`to_linear` to include base color space This helps reduce confusion around sRGB <> Linear conversions by making both input and output color spaces explicit.
2022-04-13 10:37:22 +02:00
panorama_color = panorama_color.srgb_to_linear();
GPULightmapper: react on sky ambient properties The panorama texture creation, used by GPULightmapper, has been adjusted to also take the sky ambient properties into account.
2021-12-24 15:47:42 +01:00
panorama_color.r *= bg_energy;
panorama_color.g *= bg_energy;
panorama_color.b *= bg_energy;
if (use_ambient_light) {
panorama_color = ambient_color.lerp(panorama_color, ambient_color_sky_mix);
}
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
GPULightmapper: react on sky ambient properties The panorama texture creation, used by GPULightmapper, has been adjusted to also take the sky ambient properties into account.
2021-12-24 15:47:42 +01:00
Ref<Image> panorama;
panorama.instantiate();
panorama->create(p_size.width, p_size.height, false, Image::FORMAT_RGBAF);
Use fill() to fill an entire image instead of setting pixels individually.
2022-01-08 12:58:15 +01:00
panorama->fill(panorama_color);
GPULightmapper: react on sky ambient properties The panorama texture creation, used by GPULightmapper, has been adjusted to also take the sky ambient properties into account.
2021-12-24 15:47:42 +01:00
return panorama;
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
}
return Ref<Image>();
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
////////////////////////////////////////////////////////////
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RID RendererSceneRenderRD::fog_volume_instance_create(RID p_fog_volume) {
FogVolumeInstance fvi;
fvi.volume = p_fog_volume;
return fog_volume_instance_owner.make_rid(fvi);
}
void RendererSceneRenderRD::fog_volume_instance_set_transform(RID p_fog_volume_instance, const Transform3D &p_transform) {
FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
ERR_FAIL_COND(!fvi);
fvi->transform = p_transform;
}
void RendererSceneRenderRD::fog_volume_instance_set_active(RID p_fog_volume_instance, bool p_active) {
FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
ERR_FAIL_COND(!fvi);
fvi->active = p_active;
}
RID RendererSceneRenderRD::fog_volume_instance_get_volume(RID p_fog_volume_instance) const {
FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
ERR_FAIL_COND_V(!fvi, RID());
return fvi->volume;
}
Vector3 RendererSceneRenderRD::fog_volume_instance_get_position(RID p_fog_volume_instance) const {
FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
ERR_FAIL_COND_V(!fvi, Vector3());
return fvi->transform.get_origin();
}
////////////////////////////////////////////////////////////
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::reflection_atlas_create() {
Reflection probes working
2019-09-09 22:50:51 +02:00
ReflectionAtlas ra;
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
ra.count = GLOBAL_GET("rendering/reflections/reflection_atlas/reflection_count");
ra.size = GLOBAL_GET("rendering/reflections/reflection_atlas/reflection_size");
Reflection probes working
2019-09-09 22:50:51 +02:00
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
if (is_clustered_enabled()) {
ra.cluster_builder = memnew(ClusterBuilderRD);
ra.cluster_builder->set_shared(&cluster_builder_shared);
ra.cluster_builder->setup(Size2i(ra.size, ra.size), max_cluster_elements, RID(), RID(), RID());
} else {
ra.cluster_builder = nullptr;
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Reflection probes working
2019-09-09 22:50:51 +02:00
return reflection_atlas_owner.make_rid(ra);
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_ref_atlas);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND(!ra);
if (ra->size == p_reflection_size && ra->count == p_reflection_count) {
return; //no changes
}
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
if (ra->cluster_builder) {
// only if we're using our cluster
ra->cluster_builder->setup(Size2i(ra->size, ra->size), max_cluster_elements, RID(), RID(), RID());
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Basic fast filtering implementation
2020-02-21 00:27:34 +01:00
ra->size = p_reflection_size;
ra->count = p_reflection_count;
Reflection probes working
2019-09-09 22:50:51 +02:00
if (ra->reflection.is_valid()) {
//clear and invalidate everything
RD::get_singleton()->free(ra->reflection);
ra->reflection = RID();
Properly free reflection probe atlas
2020-03-01 08:26:57 +01:00
RD::get_singleton()->free(ra->depth_buffer);
ra->depth_buffer = RID();
Reflection probes working
2019-09-09 22:50:51 +02:00
for (int i = 0; i < ra->reflections.size(); i++) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ra->reflections.write[i].data.clear_reflection_data();
Reflection probes working
2019-09-09 22:50:51 +02:00
if (ra->reflections[i].owner.is_null()) {
continue;
}
reflection_probe_release_atlas_index(ra->reflections[i].owner);
//rp->atlasindex clear
}
ra->reflections.clear();
}
}
Implement automatic LOD (Level of Detail) -Happens on import by default for all models -Just works (tm) -Biasing can be later adjusted per node or per viewport (as well as globally) -Disabled AABB.get_support test because its broken
2020-12-17 19:56:59 +01:00
int RendererSceneRenderRD::reflection_atlas_get_size(RID p_ref_atlas) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_ref_atlas);
Implement automatic LOD (Level of Detail) -Happens on import by default for all models -Just works (tm) -Biasing can be later adjusted per node or per viewport (as well as globally) -Disabled AABB.get_support test because its broken
2020-12-17 19:56:59 +01:00
ERR_FAIL_COND_V(!ra, 0);
return ra->size;
}
Reflection probes working
2019-09-09 22:50:51 +02:00
////////////////////////
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::reflection_probe_instance_create(RID p_probe) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ReflectionProbeInstance rpi;
rpi.probe = p_probe;
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
rpi.forward_id = _allocate_forward_id(FORWARD_ID_TYPE_REFLECTION_PROBE);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
return reflection_probe_instance_owner.make_rid(rpi);
}
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::reflection_probe_instance_set_transform(RID p_instance, const Transform3D &p_transform) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND(!rpi);
rpi->transform = p_transform;
rpi->dirty = true;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::reflection_probe_release_atlas_index(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND(!rpi);
if (rpi->atlas.is_null()) {
return; //nothing to release
}
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND(!atlas);
ERR_FAIL_INDEX(rpi->atlas_index, atlas->reflections.size());
atlas->reflections.write[rpi->atlas_index].owner = RID();
rpi->atlas_index = -1;
rpi->atlas = RID();
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::reflection_probe_instance_needs_redraw(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(!rpi, false);
if (rpi->rendering) {
return false;
}
if (rpi->dirty) {
return true;
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
return true;
}
Reflection probes working
2019-09-09 22:50:51 +02:00
return rpi->atlas_index == -1;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::reflection_probe_instance_has_reflection(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND_V(!rpi, false);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Reflection probes working
2019-09-09 22:50:51 +02:00
return rpi->atlas.is_valid();
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_reflection_atlas);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND_V(!atlas, false);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Basic fast filtering implementation
2020-02-21 00:27:34 +01:00
ERR_FAIL_COND_V(!rpi, false);
Porting cubemap compute shaders to raster for the mobile renderer
2021-07-27 15:33:47 +02:00
RD::get_singleton()->draw_command_begin_label("Reflection probe render");
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS && atlas->reflection.is_valid() && atlas->size != 256) {
Working sky shader implementation
2020-03-20 01:32:19 +01:00
WARN_PRINT("ReflectionProbes set to UPDATE_ALWAYS must have an atlas size of 256. Please update the atlas size in the ProjectSettings.");
reflection_atlas_set_size(p_reflection_atlas, 256, atlas->count);
Basic fast filtering implementation
2020-02-21 00:27:34 +01:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS && atlas->reflection.is_valid() && atlas->reflections[0].data.layers[0].mipmaps.size() != 8) {
Improve cubemap importance sampling
2020-03-01 02:16:50 +01:00
// Invalidate reflection atlas, need to regenerate
RD::get_singleton()->free(atlas->reflection);
atlas->reflection = RID();
for (int i = 0; i < atlas->reflections.size(); i++) {
if (atlas->reflections[i].owner.is_null()) {
continue;
}
reflection_probe_release_atlas_index(atlas->reflections[i].owner);
}
atlas->reflections.clear();
}
Reflection probes working
2019-09-09 22:50:51 +02:00
if (atlas->reflection.is_null()) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
int mipmaps = MIN(sky.roughness_layers, Image::get_image_required_mipmaps(atlas->size, atlas->size, Image::FORMAT_RGBAH) + 1);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
mipmaps = RSG::light_storage->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS ? 8 : mipmaps; // always use 8 mipmaps with real time filtering
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
{
Reflection probes working
2019-09-09 22:50:51 +02:00
//reflection atlas was unused, create:
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
RD::TextureFormat tf;
Reflection probes working
2019-09-09 22:50:51 +02:00
tf.array_layers = 6 * atlas->count;
Use 32bit instead of 64bit 3D render buffer on mobile
2021-06-17 12:37:08 +02:00
tf.format = _render_buffers_get_color_format();
Rename RD texture "type" to "texture_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-11-27 04:50:05 +01:00
tf.texture_type = RD::TEXTURE_TYPE_CUBE_ARRAY;
Basic fast filtering implementation
2020-02-21 00:27:34 +01:00
tf.mipmaps = mipmaps;
Reflection probes working
2019-09-09 22:50:51 +02:00
tf.width = atlas->size;
tf.height = atlas->size;
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | (_render_buffers_can_be_storage() ? RD::TEXTURE_USAGE_STORAGE_BIT : 0);
Reflection probes working
2019-09-09 22:50:51 +02:00
atlas->reflection = RD::get_singleton()->texture_create(tf, RD::TextureView());
}
{
RD::TextureFormat tf;
tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D32_SFLOAT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D32_SFLOAT : RD::DATA_FORMAT_X8_D24_UNORM_PACK32;
tf.width = atlas->size;
tf.height = atlas->size;
tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
atlas->depth_buffer = RD::get_singleton()->texture_create(tf, RD::TextureView());
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Reflection probes working
2019-09-09 22:50:51 +02:00
atlas->reflections.resize(atlas->count);
for (int i = 0; i < atlas->count; i++) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
atlas->reflections.write[i].data.update_reflection_data(storage, atlas->size, mipmaps, false, atlas->reflection, i * 6, RSG::light_storage->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS, sky.roughness_layers, _render_buffers_get_color_format());
Reflection probes working
2019-09-09 22:50:51 +02:00
for (int j = 0; j < 6; j++) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
atlas->reflections.write[i].fbs[j] = reflection_probe_create_framebuffer(atlas->reflections.write[i].data.layers[0].mipmaps[0].views[j], atlas->depth_buffer);
Reflection probes working
2019-09-09 22:50:51 +02:00
}
}
GIProbes working.
2019-10-03 22:39:08 +02:00
Vector<RID> fb;
fb.push_back(atlas->depth_buffer);
atlas->depth_fb = RD::get_singleton()->framebuffer_create(fb);
Reflection probes working
2019-09-09 22:50:51 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Reflection probes working
2019-09-09 22:50:51 +02:00
if (rpi->atlas_index == -1) {
for (int i = 0; i < atlas->reflections.size(); i++) {
if (atlas->reflections[i].owner.is_null()) {
rpi->atlas_index = i;
break;
}
}
//find the one used last
if (rpi->atlas_index == -1) {
//everything is in use, find the one least used via LRU
uint64_t pass_min = 0;
for (int i = 0; i < atlas->reflections.size(); i++) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi2 = reflection_probe_instance_owner.get_or_null(atlas->reflections[i].owner);
Reflection probes working
2019-09-09 22:50:51 +02:00
if (rpi2->last_pass < pass_min) {
pass_min = rpi2->last_pass;
rpi->atlas_index = i;
}
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
}
Reflection probes working
2019-09-09 22:50:51 +02:00
Fix indexing of multiple reflection probes
2021-07-06 05:00:33 +02:00
if (rpi->atlas_index != -1) { // should we fail if this is still -1 ?
atlas->reflections.write[rpi->atlas_index].owner = p_instance;
}
Reflection probes working
2019-09-09 22:50:51 +02:00
rpi->atlas = p_reflection_atlas;
rpi->rendering = true;
rpi->dirty = false;
Improve cubemap importance sampling
2020-03-01 02:16:50 +01:00
rpi->processing_layer = 1;
Reflection probes working
2019-09-09 22:50:51 +02:00
rpi->processing_side = 0;
Porting cubemap compute shaders to raster for the mobile renderer
2021-07-27 15:33:47 +02:00
RD::get_singleton()->draw_command_end_label();
Reflection probes working
2019-09-09 22:50:51 +02:00
return true;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
RID RendererSceneRenderRD::reflection_probe_create_framebuffer(RID p_color, RID p_depth) {
Vector<RID> fb;
fb.push_back(p_color);
fb.push_back(p_depth);
return RD::get_singleton()->framebuffer_create(fb);
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::reflection_probe_instance_postprocess_step(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(!rpi, false);
ERR_FAIL_COND_V(!rpi->rendering, false);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND_V(rpi->atlas.is_null(), false);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 22:50:51 +02:00
if (!atlas || rpi->atlas_index == -1) {
//does not belong to an atlas anymore, cancel (was removed from atlas or atlas changed while rendering)
rpi->rendering = false;
return false;
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS) {
Working sky shader implementation
2020-03-20 01:32:19 +01:00
// Using real time reflections, all roughness is done in one step
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
atlas->reflections.write[rpi->atlas_index].data.create_reflection_fast_filter(storage, false);
Working sky shader implementation
2020-03-20 01:32:19 +01:00
rpi->rendering = false;
rpi->processing_side = 0;
rpi->processing_layer = 1;
return true;
}
Improve cubemap importance sampling
2020-03-01 02:16:50 +01:00
if (rpi->processing_layer > 1) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
atlas->reflections.write[rpi->atlas_index].data.create_reflection_importance_sample(storage, false, 10, rpi->processing_layer, sky.sky_ggx_samples_quality);
Improve cubemap importance sampling
2020-03-01 02:16:50 +01:00
rpi->processing_layer++;
if (rpi->processing_layer == atlas->reflections[rpi->atlas_index].data.layers[0].mipmaps.size()) {
rpi->rendering = false;
rpi->processing_side = 0;
rpi->processing_layer = 1;
return true;
}
return false;
} else {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
atlas->reflections.write[rpi->atlas_index].data.create_reflection_importance_sample(storage, false, rpi->processing_side, rpi->processing_layer, sky.sky_ggx_samples_quality);
Basic fast filtering implementation
2020-02-21 00:27:34 +01:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
rpi->processing_side++;
if (rpi->processing_side == 6) {
rpi->processing_side = 0;
Improve cubemap importance sampling
2020-03-01 02:16:50 +01:00
rpi->processing_layer++;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Improve cubemap importance sampling
2020-03-01 02:16:50 +01:00
return false;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
uint32_t RendererSceneRenderRD::reflection_probe_instance_get_resolution(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(!rpi, 0);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND_V(!atlas, 0);
return atlas->size;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::reflection_probe_instance_get_framebuffer(RID p_instance, int p_index) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(!rpi, RID());
ERR_FAIL_INDEX_V(p_index, 6, RID());
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 22:50:51 +02:00
ERR_FAIL_COND_V(!atlas, RID());
return atlas->reflections[rpi->atlas_index].fbs[p_index];
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::reflection_probe_instance_get_depth_framebuffer(RID p_instance, int p_index) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
GIProbes working.
2019-10-03 22:39:08 +02:00
ERR_FAIL_COND_V(!rpi, RID());
ERR_FAIL_INDEX_V(p_index, 6, RID());
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
GIProbes working.
2019-10-03 22:39:08 +02:00
ERR_FAIL_COND_V(!atlas, RID());
return atlas->depth_fb;
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
///////////////////////////////////////////////////////////
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::shadow_atlas_create() {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
return shadow_atlas_owner.make_rid(ShadowAtlas());
}
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
void RendererSceneRenderRD::_update_shadow_atlas(ShadowAtlas *shadow_atlas) {
if (shadow_atlas->size > 0 && shadow_atlas->depth.is_null()) {
RD::TextureFormat tf;
tf.format = shadow_atlas->use_16_bits ? RD::DATA_FORMAT_D16_UNORM : RD::DATA_FORMAT_D32_SFLOAT;
tf.width = shadow_atlas->size;
tf.height = shadow_atlas->size;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
shadow_atlas->depth = RD::get_singleton()->texture_create(tf, RD::TextureView());
Vector<RID> fb_tex;
fb_tex.push_back(shadow_atlas->depth);
shadow_atlas->fb = RD::get_singleton()->framebuffer_create(fb_tex);
}
}
void RendererSceneRenderRD::shadow_atlas_set_size(RID p_atlas, int p_size, bool p_16_bits) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND(!shadow_atlas);
ERR_FAIL_COND(p_size < 0);
p_size = next_power_of_2(p_size);
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
if (p_size == shadow_atlas->size && p_16_bits == shadow_atlas->use_16_bits) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
// erasing atlas
if (shadow_atlas->depth.is_valid()) {
RD::get_singleton()->free(shadow_atlas->depth);
shadow_atlas->depth = RID();
}
for (int i = 0; i < 4; i++) {
//clear subdivisions
Vectors: Use clear() and has(). Use clear() instead of resize(0). Use has() instead of "find(p_val) != -1".
2022-02-01 19:19:13 +01:00
shadow_atlas->quadrants[i].shadows.clear();
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
shadow_atlas->quadrants[i].shadows.resize(1 << shadow_atlas->quadrants[i].subdivision);
}
//erase shadow atlas reference from lights
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
for (const KeyValue<RID, uint32_t> &E : shadow_atlas->shadow_owners) {
LightInstance *li = light_instance_owner.get_or_null(E.key);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_CONTINUE(!li);
li->shadow_atlases.erase(p_atlas);
}
//clear owners
shadow_atlas->shadow_owners.clear();
shadow_atlas->size = p_size;
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
shadow_atlas->use_16_bits = p_16_bits;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND(!shadow_atlas);
ERR_FAIL_INDEX(p_quadrant, 4);
ERR_FAIL_INDEX(p_subdivision, 16384);
uint32_t subdiv = next_power_of_2(p_subdivision);
if (subdiv & 0xaaaaaaaa) { //sqrt(subdiv) must be integer
subdiv <<= 1;
}
subdiv = int(Math::sqrt((float)subdiv));
//obtain the number that will be x*x
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (shadow_atlas->quadrants[p_quadrant].subdivision == subdiv) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
//erase all data from quadrant
for (int i = 0; i < shadow_atlas->quadrants[p_quadrant].shadows.size(); i++) {
if (shadow_atlas->quadrants[p_quadrant].shadows[i].owner.is_valid()) {
shadow_atlas->shadow_owners.erase(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *li = light_instance_owner.get_or_null(shadow_atlas->quadrants[p_quadrant].shadows[i].owner);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_CONTINUE(!li);
li->shadow_atlases.erase(p_atlas);
}
}
Vectors: Use clear() and has(). Use clear() instead of resize(0). Use has() instead of "find(p_val) != -1".
2022-02-01 19:19:13 +01:00
shadow_atlas->quadrants[p_quadrant].shadows.clear();
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
shadow_atlas->quadrants[p_quadrant].shadows.resize(subdiv * subdiv);
shadow_atlas->quadrants[p_quadrant].subdivision = subdiv;
//cache the smallest subdiv (for faster allocation in light update)
shadow_atlas->smallest_subdiv = 1 << 30;
for (int i = 0; i < 4; i++) {
if (shadow_atlas->quadrants[i].subdivision) {
shadow_atlas->smallest_subdiv = MIN(shadow_atlas->smallest_subdiv, shadow_atlas->quadrants[i].subdivision);
}
}
if (shadow_atlas->smallest_subdiv == 1 << 30) {
shadow_atlas->smallest_subdiv = 0;
}
//resort the size orders, simple bublesort for 4 elements..
int swaps = 0;
do {
swaps = 0;
for (int i = 0; i < 3; i++) {
if (shadow_atlas->quadrants[shadow_atlas->size_order[i]].subdivision < shadow_atlas->quadrants[shadow_atlas->size_order[i + 1]].subdivision) {
SWAP(shadow_atlas->size_order[i], shadow_atlas->size_order[i + 1]);
swaps++;
}
}
} while (swaps > 0);
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
for (int i = p_quadrant_count - 1; i >= 0; i--) {
int qidx = p_in_quadrants[i];
if (shadow_atlas->quadrants[qidx].subdivision == (uint32_t)p_current_subdiv) {
return false;
}
//look for an empty space
int sc = shadow_atlas->quadrants[qidx].shadows.size();
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
const ShadowAtlas::Quadrant::Shadow *sarr = shadow_atlas->quadrants[qidx].shadows.ptr();
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
int found_free_idx = -1; //found a free one
int found_used_idx = -1; //found existing one, must steal it
uint64_t min_pass = 0; // pass of the existing one, try to use the least recently used one (LRU fashion)
for (int j = 0; j < sc; j++) {
if (!sarr[j].owner.is_valid()) {
found_free_idx = j;
break;
}
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *sli = light_instance_owner.get_or_null(sarr[j].owner);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_CONTINUE(!sli);
if (sli->last_scene_pass != scene_pass) {
//was just allocated, don't kill it so soon, wait a bit..
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (p_tick - sarr[j].alloc_tick < shadow_atlas_realloc_tolerance_msec) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
continue;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
if (found_used_idx == -1 || sli->last_scene_pass < min_pass) {
found_used_idx = j;
min_pass = sli->last_scene_pass;
}
}
}
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (found_free_idx == -1 && found_used_idx == -1) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
continue; //nothing found
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
if (found_free_idx == -1 && found_used_idx != -1) {
found_free_idx = found_used_idx;
}
r_quadrant = qidx;
r_shadow = found_free_idx;
return true;
}
return false;
}
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
bool RendererSceneRenderRD::_shadow_atlas_find_omni_shadows(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow) {
for (int i = p_quadrant_count - 1; i >= 0; i--) {
int qidx = p_in_quadrants[i];
if (shadow_atlas->quadrants[qidx].subdivision == (uint32_t)p_current_subdiv) {
return false;
}
//look for an empty space
int sc = shadow_atlas->quadrants[qidx].shadows.size();
const ShadowAtlas::Quadrant::Shadow *sarr = shadow_atlas->quadrants[qidx].shadows.ptr();
int found_idx = -1;
uint64_t min_pass = 0; // sum of currently selected spots, try to get the least recently used pair
for (int j = 0; j < sc - 1; j++) {
uint64_t pass = 0;
if (sarr[j].owner.is_valid()) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *sli = light_instance_owner.get_or_null(sarr[j].owner);
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
ERR_CONTINUE(!sli);
if (sli->last_scene_pass == scene_pass) {
continue;
}
//was just allocated, don't kill it so soon, wait a bit..
if (p_tick - sarr[j].alloc_tick < shadow_atlas_realloc_tolerance_msec) {
continue;
}
pass += sli->last_scene_pass;
}
if (sarr[j + 1].owner.is_valid()) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *sli = light_instance_owner.get_or_null(sarr[j + 1].owner);
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
ERR_CONTINUE(!sli);
if (sli->last_scene_pass == scene_pass) {
continue;
}
//was just allocated, don't kill it so soon, wait a bit..
if (p_tick - sarr[j + 1].alloc_tick < shadow_atlas_realloc_tolerance_msec) {
continue;
}
pass += sli->last_scene_pass;
}
if (found_idx == -1 || pass < min_pass) {
found_idx = j;
min_pass = pass;
// we found two empty spots, no need to check the rest
if (pass == 0) {
break;
}
}
}
if (found_idx == -1) {
continue; //nothing found
}
r_quadrant = qidx;
r_shadow = found_idx;
return true;
}
return false;
}
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
bool RendererSceneRenderRD::shadow_atlas_update_light(RID p_atlas, RID p_light_instance, float p_coverage, uint64_t p_light_version) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(!shadow_atlas, false);
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
LightInstance *li = light_instance_owner.get_or_null(p_light_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(!li, false);
if (shadow_atlas->size == 0 || shadow_atlas->smallest_subdiv == 0) {
return false;
}
uint32_t quad_size = shadow_atlas->size >> 1;
int desired_fit = MIN(quad_size / shadow_atlas->smallest_subdiv, next_power_of_2(quad_size * p_coverage));
int valid_quadrants[4];
int valid_quadrant_count = 0;
int best_size = -1; //best size found
int best_subdiv = -1; //subdiv for the best size
//find the quadrants this fits into, and the best possible size it can fit into
for (int i = 0; i < 4; i++) {
int q = shadow_atlas->size_order[i];
int sd = shadow_atlas->quadrants[q].subdivision;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (sd == 0) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
continue; //unused
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
int max_fit = quad_size / sd;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
if (best_size != -1 && max_fit > best_size) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
break; //too large
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 16:41:43 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
valid_quadrants[valid_quadrant_count++] = q;
best_subdiv = sd;
if (max_fit >= desired_fit) {
best_size = max_fit;
}
}
ERR_FAIL_COND_V(valid_quadrant_count == 0, false);
uint64_t tick = OS::get_singleton()->get_ticks_msec();
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
uint32_t old_key = ShadowAtlas::SHADOW_INVALID;
uint32_t old_quadrant = ShadowAtlas::SHADOW_INVALID;
uint32_t old_shadow = ShadowAtlas::SHADOW_INVALID;
int old_subdivision = -1;
bool should_realloc = false;
bool should_redraw = false;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
if (shadow_atlas->shadow_owners.has(p_light_instance)) {
old_key = shadow_atlas->shadow_owners[p_light_instance];
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
old_quadrant = (old_key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
old_shadow = old_key & ShadowAtlas::SHADOW_INDEX_MASK;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
should_realloc = shadow_atlas->quadrants[old_quadrant].subdivision != (uint32_t)best_subdiv && (shadow_atlas->quadrants[old_quadrant].shadows[old_shadow].alloc_tick - tick > shadow_atlas_realloc_tolerance_msec);
should_redraw = shadow_atlas->quadrants[old_quadrant].shadows[old_shadow].version != p_light_version;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
if (!should_realloc) {
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
shadow_atlas->quadrants[old_quadrant].shadows.write[old_shadow].version = p_light_version;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
//already existing, see if it should redraw or it's just OK
return should_redraw;
}
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
old_subdivision = shadow_atlas->quadrants[old_quadrant].subdivision;
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
bool is_omni = li->light_type == RS::LIGHT_OMNI;
bool found_shadow = false;
int new_quadrant = -1;
int new_shadow = -1;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
if (is_omni) {
found_shadow = _shadow_atlas_find_omni_shadows(shadow_atlas, valid_quadrants, valid_quadrant_count, old_subdivision, tick, new_quadrant, new_shadow);
} else {
found_shadow = _shadow_atlas_find_shadow(shadow_atlas, valid_quadrants, valid_quadrant_count, old_subdivision, tick, new_quadrant, new_shadow);
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
if (found_shadow) {
if (old_quadrant != ShadowAtlas::SHADOW_INVALID) {
shadow_atlas->quadrants[old_quadrant].shadows.write[old_shadow].version = 0;
shadow_atlas->quadrants[old_quadrant].shadows.write[old_shadow].owner = RID();
if (old_key & ShadowAtlas::OMNI_LIGHT_FLAG) {
shadow_atlas->quadrants[old_quadrant].shadows.write[old_shadow + 1].version = 0;
shadow_atlas->quadrants[old_quadrant].shadows.write[old_shadow + 1].owner = RID();
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
uint32_t new_key = new_quadrant << ShadowAtlas::QUADRANT_SHIFT;
new_key |= new_shadow;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
ShadowAtlas::Quadrant::Shadow *sh = &shadow_atlas->quadrants[new_quadrant].shadows.write[new_shadow];
_shadow_atlas_invalidate_shadow(sh, p_atlas, shadow_atlas, new_quadrant, new_shadow);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
sh->owner = p_light_instance;
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
sh->alloc_tick = tick;
sh->version = p_light_version;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
if (is_omni) {
new_key |= ShadowAtlas::OMNI_LIGHT_FLAG;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
int new_omni_shadow = new_shadow + 1;
ShadowAtlas::Quadrant::Shadow *extra_sh = &shadow_atlas->quadrants[new_quadrant].shadows.write[new_omni_shadow];
_shadow_atlas_invalidate_shadow(extra_sh, p_atlas, shadow_atlas, new_quadrant, new_omni_shadow);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
extra_sh->owner = p_light_instance;
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
extra_sh->alloc_tick = tick;
extra_sh->version = p_light_version;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
li->shadow_atlases.insert(p_atlas);
//update it in map
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
shadow_atlas->shadow_owners[p_light_instance] = new_key;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
//make it dirty, as it should redraw anyway
return true;
}
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
return should_redraw;
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
void RendererSceneRenderRD::_shadow_atlas_invalidate_shadow(RendererSceneRenderRD::ShadowAtlas::Quadrant::Shadow *p_shadow, RID p_atlas, RendererSceneRenderRD::ShadowAtlas *p_shadow_atlas, uint32_t p_quadrant, uint32_t p_shadow_idx) {
if (p_shadow->owner.is_valid()) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *sli = light_instance_owner.get_or_null(p_shadow->owner);
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
uint32_t old_key = p_shadow_atlas->shadow_owners[p_shadow->owner];
if (old_key & ShadowAtlas::OMNI_LIGHT_FLAG) {
uint32_t s = old_key & ShadowAtlas::SHADOW_INDEX_MASK;
uint32_t omni_shadow_idx = p_shadow_idx + (s == (uint32_t)p_shadow_idx ? 1 : -1);
RendererSceneRenderRD::ShadowAtlas::Quadrant::Shadow *omni_shadow = &p_shadow_atlas->quadrants[p_quadrant].shadows.write[omni_shadow_idx];
omni_shadow->version = 0;
omni_shadow->owner = RID();
}
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
p_shadow_atlas->shadow_owners.erase(p_shadow->owner);
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
p_shadow->version = 0;
p_shadow->owner = RID();
sli->shadow_atlases.erase(p_atlas);
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
void RendererSceneRenderRD::_update_directional_shadow_atlas() {
if (directional_shadow.depth.is_null() && directional_shadow.size > 0) {
RD::TextureFormat tf;
tf.format = directional_shadow.use_16_bits ? RD::DATA_FORMAT_D16_UNORM : RD::DATA_FORMAT_D32_SFLOAT;
tf.width = directional_shadow.size;
tf.height = directional_shadow.size;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
directional_shadow.depth = RD::get_singleton()->texture_create(tf, RD::TextureView());
Vector<RID> fb_tex;
fb_tex.push_back(directional_shadow.depth);
directional_shadow.fb = RD::get_singleton()->framebuffer_create(fb_tex);
}
}
void RendererSceneRenderRD::directional_shadow_atlas_set_size(int p_size, bool p_16_bits) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
p_size = nearest_power_of_2_templated(p_size);
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
if (directional_shadow.size == p_size && directional_shadow.use_16_bits == p_16_bits) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
return;
}
Directional lights and shadow mapping are functional.
2019-09-07 19:38:17 +02:00
directional_shadow.size = p_size;
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
directional_shadow.use_16_bits = p_16_bits;
Directional lights and shadow mapping are functional.
2019-09-07 19:38:17 +02:00
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
if (directional_shadow.depth.is_valid()) {
RD::get_singleton()->free(directional_shadow.depth);
directional_shadow.depth = RID();
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
_base_uniforms_changed();
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::set_directional_shadow_count(int p_count) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
directional_shadow.light_count = p_count;
directional_shadow.current_light = 0;
}
Directional lights and shadow mapping are functional.
2019-09-07 19:38:17 +02:00
static Rect2i _get_directional_shadow_rect(int p_size, int p_shadow_count, int p_shadow_index) {
int split_h = 1;
int split_v = 1;
while (split_h * split_v < p_shadow_count) {
if (split_h == split_v) {
split_h <<= 1;
} else {
split_v <<= 1;
}
}
Rect2i rect(0, 0, p_size, p_size);
rect.size.width /= split_h;
rect.size.height /= split_v;
rect.position.x = rect.size.width * (p_shadow_index % split_h);
rect.position.y = rect.size.height * (p_shadow_index / split_h);
return rect;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
int RendererSceneRenderRD::get_directional_light_shadow_size(RID p_light_intance) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(directional_shadow.light_count == 0, 0);
Directional lights and shadow mapping are functional.
2019-09-07 19:38:17 +02:00
Rect2i r = _get_directional_shadow_rect(directional_shadow.size, directional_shadow.light_count, 0);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(p_light_intance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND_V(!light_instance, 0);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
switch (RSG::light_storage->light_directional_get_shadow_mode(light_instance->light)) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
case RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL:
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
break; //none
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 13:00:47 +02:00
case RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS:
r.size.height /= 2;
break;
case RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS:
r.size /= 2;
break;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Directional lights and shadow mapping are functional.
2019-09-07 19:38:17 +02:00
return MAX(r.size.width, r.size.height);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
//////////////////////////////////////////////////
Make Servers truly Thread Safe -Rendering server now uses a split RID allocate/initialize internally, this allows generating RIDs immediately but initialization to happen later on the proper thread (as rendering APIs generally requiere to call on the right thread). -RenderingServerWrapMT is no more, multithreading is done in RenderingServerDefault. -Some functions like texture or mesh creation, when renderer supports it, can register and return immediately (so no waiting for server API to flush, and saving staging and command buffer memory). -3D physics server changed to be made multithread friendly. -Added PhysicsServer3DWrapMT to use 3D physics server from multiple threads. -Disablet Bullet (too much effort to make multithread friendly, this needs to be fixed eventually).
2021-02-09 17:19:03 +01:00
RID RendererSceneRenderRD::camera_effects_allocate() {
return camera_effects_owner.allocate_rid();
}
void RendererSceneRenderRD::camera_effects_initialize(RID p_rid) {
camera_effects_owner.initialize_rid(p_rid, CameraEffects());
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::camera_effects_set_dof_blur_quality(RS::DOFBlurQuality p_quality, bool p_use_jitter) {
DOF fully implemented, can be edited on the fly.
2020-01-16 01:23:21 +01:00
dof_blur_quality = p_quality;
dof_blur_use_jitter = p_use_jitter;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape p_shape) {
DOF fully implemented, can be edited on the fly.
2020-01-16 01:23:21 +01:00
dof_blur_bokeh_shape = p_shape;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
CameraEffects *camfx = camera_effects_owner.get_or_null(p_camera_effects);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
ERR_FAIL_COND(!camfx);
camfx->dof_blur_far_enabled = p_far_enable;
camfx->dof_blur_far_distance = p_far_distance;
camfx->dof_blur_far_transition = p_far_transition;
camfx->dof_blur_near_enabled = p_near_enable;
camfx->dof_blur_near_distance = p_near_distance;
camfx->dof_blur_near_transition = p_near_transition;
camfx->dof_blur_amount = p_amount;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
CameraEffects *camfx = camera_effects_owner.get_or_null(p_camera_effects);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
ERR_FAIL_COND(!camfx);
camfx->override_exposure_enabled = p_enable;
camfx->override_exposure = p_exposure;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::light_instance_create(RID p_light) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
RID li = light_instance_owner.make_rid(LightInstance());
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(li);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
light_instance->self = li;
light_instance->light = p_light;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_instance->light_type = RSG::light_storage->light_get_type(p_light);
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
if (light_instance->light_type != RS::LIGHT_DIRECTIONAL) {
light_instance->forward_id = _allocate_forward_id(light_instance->light_type == RS::LIGHT_OMNI ? FORWARD_ID_TYPE_OMNI_LIGHT : FORWARD_ID_TYPE_SPOT_LIGHT);
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
return li;
}
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::light_instance_set_transform(RID p_light_instance, const Transform3D &p_transform) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND(!light_instance);
light_instance->transform = p_transform;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND(!light_instance);
light_instance->aabb = p_aabb;
}
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform3D &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale, float p_range_begin, const Vector2 &p_uv_scale) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND(!light_instance);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
ERR_FAIL_INDEX(p_pass, 6);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
light_instance->shadow_transform[p_pass].camera = p_projection;
light_instance->shadow_transform[p_pass].transform = p_transform;
light_instance->shadow_transform[p_pass].farplane = p_far;
light_instance->shadow_transform[p_pass].split = p_split;
light_instance->shadow_transform[p_pass].bias_scale = p_bias_scale;
Support light size and soft shadows
2020-04-09 20:11:15 +02:00
light_instance->shadow_transform[p_pass].range_begin = p_range_begin;
Refactored shadowmapping. - Made shadow bias size independent, so it will remain when changing light or camera size. - Implemented normal offset bias, which greatly enhances quality. - Added transmission to subsurface scattering - Reimplemented shadow filter modes Closes #17260
2020-04-08 03:51:52 +02:00
light_instance->shadow_transform[p_pass].shadow_texel_size = p_shadow_texel_size;
Support light size and soft shadows
2020-04-09 20:11:15 +02:00
light_instance->shadow_transform[p_pass].uv_scale = p_uv_scale;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::light_instance_mark_visible(RID p_light_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND(!light_instance);
light_instance->last_scene_pass = scene_pass;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererSceneRenderRD::ShadowCubemap *RendererSceneRenderRD::_get_shadow_cubemap(int p_size) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
if (!shadow_cubemaps.has(p_size)) {
ShadowCubemap sc;
{
RD::TextureFormat tf;
tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D32_SFLOAT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D32_SFLOAT : RD::DATA_FORMAT_X8_D24_UNORM_PACK32;
tf.width = p_size;
tf.height = p_size;
Rename RD texture "type" to "texture_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-11-27 04:50:05 +01:00
tf.texture_type = RD::TEXTURE_TYPE_CUBE;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
tf.array_layers = 6;
tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
sc.cubemap = RD::get_singleton()->texture_create(tf, RD::TextureView());
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
for (int i = 0; i < 6; i++) {
RID side_texture = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), sc.cubemap, i, 0);
Vector<RID> fbtex;
fbtex.push_back(side_texture);
sc.side_fb[i] = RD::get_singleton()->framebuffer_create(fbtex);
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
shadow_cubemaps[p_size] = sc;
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
return &shadow_cubemaps[p_size];
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
//////////////////////////
GIProbes working.
2019-10-03 22:39:08 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
RID RendererSceneRenderRD::decal_instance_create(RID p_decal) {
DecalInstance di;
di.decal = p_decal;
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
di.forward_id = _allocate_forward_id(FORWARD_ID_TYPE_DECAL);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
return decal_instance_owner.make_rid(di);
}
GIProbes working.
2019-10-03 22:39:08 +02:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::decal_instance_set_transform(RID p_decal, const Transform3D &p_transform) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
DecalInstance *di = decal_instance_owner.get_or_null(p_decal);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND(!di);
di->transform = p_transform;
}
GIProbes working.
2019-10-03 22:39:08 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
/////////////////////////////////
GIProbes working.
2019-10-03 22:39:08 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
RID RendererSceneRenderRD::lightmap_instance_create(RID p_lightmap) {
LightmapInstance li;
li.lightmap = p_lightmap;
return lightmap_instance_owner.make_rid(li);
}
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::lightmap_instance_set_transform(RID p_lightmap, const Transform3D &p_transform) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightmapInstance *li = lightmap_instance_owner.get_or_null(p_lightmap);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND(!li);
li->transform = p_transform;
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
/////////////////////////////////
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
RID RendererSceneRenderRD::voxel_gi_instance_create(RID p_base) {
return gi.voxel_gi_instance_create(p_base);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
void RendererSceneRenderRD::voxel_gi_instance_set_transform_to_data(RID p_probe, const Transform3D &p_xform) {
gi.voxel_gi_instance_set_transform_to_data(p_probe, p_xform);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
bool RendererSceneRenderRD::voxel_gi_needs_update(RID p_probe) const {
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 13:06:48 +02:00
if (!is_dynamic_gi_supported()) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
return false;
GIProbes working.
2019-10-03 22:39:08 +02:00
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
return gi.voxel_gi_needs_update(p_probe);
GIProbes working.
2019-10-03 22:39:08 +02:00
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
void RendererSceneRenderRD::voxel_gi_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, const PagedArray<GeometryInstance *> &p_dynamic_objects) {
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 13:06:48 +02:00
if (!is_dynamic_gi_supported()) {
GIProbes working.
2019-10-03 22:39:08 +02:00
return;
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
gi.voxel_gi_update(p_probe, p_update_light_instances, p_light_instances, p_dynamic_objects, this);
GIProbes working.
2019-10-03 22:39:08 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_debug_sdfgi_probes(RID p_render_buffers, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND(!rb);
if (!rb->sdfgi) {
return; //nothing to debug
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
rb->sdfgi->debug_probes(p_draw_list, p_framebuffer, p_camera_with_transform);
GIProbes working.
2019-10-03 22:39:08 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
////////////////////////////////
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::render_buffers_create() {
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
RenderBuffers rb;
rb.data = _create_render_buffer_data();
return render_buffers_owner.make_rid(rb);
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_allocate_blur_textures(RenderBuffers *rb) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
ERR_FAIL_COND(!rb->blur[0].texture.is_null());
uint32_t mipmaps_required = Image::get_image_required_mipmaps(rb->width, rb->height, Image::FORMAT_RGBAH);
RD::TextureFormat tf;
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
tf.format = _render_buffers_get_color_format(); // RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tf.width = rb->internal_width;
tf.height = rb->internal_height;
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
tf.texture_type = rb->view_count > 1 ? RD::TEXTURE_TYPE_2D_ARRAY : RD::TEXTURE_TYPE_2D;
tf.array_layers = rb->view_count;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
if (_render_buffers_can_be_storage()) {
tf.usage_bits += RD::TEXTURE_USAGE_STORAGE_BIT;
} else {
tf.usage_bits += RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
tf.mipmaps = mipmaps_required;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
rb->sss_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
tf.width = rb->internal_width;
tf.height = rb->internal_height;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
rb->blur[0].texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
//the second one is smaller (only used for separatable part of blur)
tf.width >>= 1;
tf.height >>= 1;
tf.mipmaps--;
rb->blur[1].texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
for (uint32_t l = 0; l < rb->view_count; l++) {
RenderBuffers::Blur::Layer ll[2];
int base_width = rb->internal_width;
int base_height = rb->internal_height;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
for (uint32_t i = 0; i < mipmaps_required; i++) {
RenderBuffers::Blur::Mipmap mm;
mm.texture = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->blur[0].texture, l, i);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
mm.width = base_width;
mm.height = base_height;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (!_render_buffers_can_be_storage()) {
Vector<RID> fb;
fb.push_back(mm.texture);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
mm.fb = RD::get_singleton()->framebuffer_create(fb);
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (!_render_buffers_can_be_storage()) {
// and half texture, this is an intermediate result so just allocate a texture, is this good enough?
tf.width = MAX(1, base_width >> 1);
tf.height = base_height;
tf.texture_type = RD::TEXTURE_TYPE_2D;
tf.array_layers = 1;
tf.mipmaps = 1;
mm.half_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
Vector<RID> half_fb;
half_fb.push_back(mm.half_texture);
mm.half_fb = RD::get_singleton()->framebuffer_create(half_fb);
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
ll[0].mipmaps.push_back(mm);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (i > 0) {
mm.texture = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->blur[1].texture, l, i - 1);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (!_render_buffers_can_be_storage()) {
Vector<RID> fb;
fb.push_back(mm.texture);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
mm.fb = RD::get_singleton()->framebuffer_create(fb);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
// We can re-use the half texture here as it is an intermediate result
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
ll[1].mipmaps.push_back(mm);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
base_width = MAX(1, base_width >> 1);
base_height = MAX(1, base_height >> 1);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
rb->blur[0].layers.push_back(ll[0]);
rb->blur[1].layers.push_back(ll[1]);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
if (!_render_buffers_can_be_storage()) {
// create 4 weight textures, 2 full size, 2 half size
tf.format = RD::DATA_FORMAT_R16_SFLOAT; // We could probably use DATA_FORMAT_R8_SNORM if we don't pre-multiply by blur_size but that depends on whether we can remove DEPTH_GAP
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tf.width = rb->internal_width;
tf.height = rb->internal_height;
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
tf.texture_type = RD::TEXTURE_TYPE_2D;
tf.array_layers = 1; // Our DOF effect handles one eye per turn
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
tf.mipmaps = 1;
for (uint32_t i = 0; i < 4; i++) {
// associated blur texture
RID texture;
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (i == 1) {
texture = rb->blur[0].layers[0].mipmaps[0].texture;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
} else if (i == 2) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
texture = rb->blur[1].layers[0].mipmaps[0].texture;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
} else if (i == 3) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
texture = rb->blur[0].layers[0].mipmaps[1].texture;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
}
// create weight texture
rb->weight_buffers[i].weight = RD::get_singleton()->texture_create(tf, RD::TextureView());
// create frame buffer
Vector<RID> fb;
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (i != 0) {
fb.push_back(texture);
}
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
fb.push_back(rb->weight_buffers[i].weight);
rb->weight_buffers[i].fb = RD::get_singleton()->framebuffer_create(fb);
if (i == 1) {
// next 2 are half size
Change some math macros to constexpr Changes `MAX`, `MIN`, `ABS`, `CLAMP` and `SIGN`.
2022-03-08 15:10:48 +01:00
tf.width = MAX(1u, tf.width >> 1);
tf.height = MAX(1u, tf.height >> 1);
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
}
}
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
void RendererSceneRenderRD::_allocate_depth_backbuffer_textures(RenderBuffers *rb) {
ERR_FAIL_COND(!rb->depth_back_texture.is_null());
{
RD::TextureFormat tf;
if (rb->view_count > 1) {
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
}
// We're not using this as a depth stencil, just copying our data into this. May need to look into using a different format on mobile, maybe R16?
tf.format = RD::DATA_FORMAT_R32_SFLOAT;
tf.width = rb->width;
tf.height = rb->height;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
tf.array_layers = rb->view_count; // create a layer for every view
tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
tf.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT; // set this as color attachment because we're copying data into it, it's not actually used as a depth buffer
rb->depth_back_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
}
if (!_render_buffers_can_be_storage()) {
// create framebuffer so we can write into this...
Vector<RID> fb;
fb.push_back(rb->depth_back_texture);
rb->depth_back_fb = RD::get_singleton()->framebuffer_create(fb, RD::INVALID_ID, rb->view_count);
}
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_allocate_luminance_textures(RenderBuffers *rb) {
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
ERR_FAIL_COND(!rb->luminance.current.is_null());
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
int w = rb->internal_width;
int h = rb->internal_height;
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
while (true) {
w = MAX(w / 8, 1);
h = MAX(h / 8, 1);
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R32_SFLOAT;
tf.width = w;
tf.height = h;
bool final = w == 1 && h == 1;
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (_render_buffers_can_be_storage()) {
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
if (final) {
tf.usage_bits |= RD::TEXTURE_USAGE_SAMPLING_BIT;
}
} else {
tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
}
RID texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
rb->luminance.reduce.push_back(texture);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (!_render_buffers_can_be_storage()) {
Vector<RID> fb;
fb.push_back(texture);
rb->luminance.fb.push_back(RD::get_singleton()->framebuffer_create(fb));
}
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
if (final) {
rb->luminance.current = RD::get_singleton()->texture_create(tf, RD::TextureView());
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (!_render_buffers_can_be_storage()) {
Vector<RID> fb;
fb.push_back(rb->luminance.current);
rb->luminance.current_fb = RD::get_singleton()->framebuffer_create(fb);
}
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
break;
}
}
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_free_render_buffer_data(RenderBuffers *rb) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (rb->views.size() > 1) { // if 1 these are copies ofs rb->internal_texture, rb->depth_texture and rb->texture_fb
for (int i = 0; i < rb->views.size(); i++) {
if (rb->views[i].view_fb.is_valid()) {
RD::get_singleton()->free(rb->views[i].view_fb);
}
if (rb->views[i].view_texture.is_valid()) {
RD::get_singleton()->free(rb->views[i].view_texture);
}
if (rb->views[i].view_depth.is_valid()) {
RD::get_singleton()->free(rb->views[i].view_depth);
}
}
}
rb->views.clear();
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (rb->texture_fb.is_valid()) {
RD::get_singleton()->free(rb->texture_fb);
rb->texture_fb = RID();
}
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
if (rb->internal_texture == rb->texture && rb->internal_texture.is_valid()) {
RD::get_singleton()->free(rb->internal_texture);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
rb->texture = RID();
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
rb->internal_texture = RID();
rb->upscale_texture = RID();
} else {
if (rb->texture.is_valid()) {
RD::get_singleton()->free(rb->texture);
rb->texture = RID();
}
if (rb->internal_texture.is_valid()) {
RD::get_singleton()->free(rb->internal_texture);
rb->internal_texture = RID();
}
if (rb->upscale_texture.is_valid()) {
RD::get_singleton()->free(rb->upscale_texture);
rb->upscale_texture = RID();
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
}
if (rb->depth_texture.is_valid()) {
RD::get_singleton()->free(rb->depth_texture);
rb->depth_texture = RID();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
if (rb->depth_back_fb.is_valid()) {
RD::get_singleton()->free(rb->depth_back_fb);
rb->depth_back_fb = RID();
}
if (rb->depth_back_texture.is_valid()) {
RD::get_singleton()->free(rb->depth_back_texture);
rb->depth_back_texture = RID();
}
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
if (rb->sss_texture.is_valid()) {
RD::get_singleton()->free(rb->sss_texture);
rb->sss_texture = RID();
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
for (int i = 0; i < 2; i++) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
for (int l = 0; l < rb->blur[i].layers.size(); l++) {
for (int m = 0; m < rb->blur[i].layers[l].mipmaps.size(); m++) {
// do we free the texture slice here? or is it enough to free the main texture?
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
// do free the mobile extra stuff
if (rb->blur[i].layers[l].mipmaps[m].fb.is_valid()) {
RD::get_singleton()->free(rb->blur[i].layers[l].mipmaps[m].fb);
Fix _free_render_buffer_data freeing shared half_texture and half_fb
2022-02-10 11:04:18 +01:00
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
// texture and framebuffer in both blur mipmaps are shared, so only free from the first one
if (i == 0) {
if (rb->blur[i].layers[l].mipmaps[m].half_fb.is_valid()) {
RD::get_singleton()->free(rb->blur[i].layers[l].mipmaps[m].half_fb);
}
if (rb->blur[i].layers[l].mipmaps[m].half_texture.is_valid()) {
RD::get_singleton()->free(rb->blur[i].layers[l].mipmaps[m].half_texture);
}
Fix _free_render_buffer_data freeing shared half_texture and half_fb
2022-02-10 11:04:18 +01:00
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
}
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
rb->blur[i].layers.clear();
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
if (rb->blur[i].texture.is_valid()) {
RD::get_singleton()->free(rb->blur[i].texture);
rb->blur[i].texture = RID();
}
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
for (int i = 0; i < rb->luminance.fb.size(); i++) {
RD::get_singleton()->free(rb->luminance.fb[i]);
}
rb->luminance.fb.clear();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
for (int i = 0; i < rb->luminance.reduce.size(); i++) {
RD::get_singleton()->free(rb->luminance.reduce[i]);
}
rb->luminance.reduce.clear();
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (rb->luminance.current_fb.is_valid()) {
RD::get_singleton()->free(rb->luminance.current_fb);
rb->luminance.current_fb = RID();
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
if (rb->luminance.current.is_valid()) {
RD::get_singleton()->free(rb->luminance.current);
rb->luminance.current = RID();
}
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
if (rb->ss_effects.linear_depth.is_valid()) {
RD::get_singleton()->free(rb->ss_effects.linear_depth);
rb->ss_effects.linear_depth = RID();
rb->ss_effects.linear_depth_slices.clear();
}
if (rb->ss_effects.ssao.ao_final.is_valid()) {
RD::get_singleton()->free(rb->ss_effects.ssao.ao_deinterleaved);
RD::get_singleton()->free(rb->ss_effects.ssao.ao_pong);
RD::get_singleton()->free(rb->ss_effects.ssao.ao_final);
RD::get_singleton()->free(rb->ss_effects.ssao.importance_map[0]);
RD::get_singleton()->free(rb->ss_effects.ssao.importance_map[1]);
rb->ss_effects.ssao.ao_deinterleaved = RID();
rb->ss_effects.ssao.ao_pong = RID();
rb->ss_effects.ssao.ao_final = RID();
rb->ss_effects.ssao.importance_map[0] = RID();
rb->ss_effects.ssao.importance_map[1] = RID();
rb->ss_effects.ssao.ao_deinterleaved_slices.clear();
rb->ss_effects.ssao.ao_pong_slices.clear();
}
if (rb->ss_effects.ssil.ssil_final.is_valid()) {
RD::get_singleton()->free(rb->ss_effects.ssil.ssil_final);
RD::get_singleton()->free(rb->ss_effects.ssil.deinterleaved);
RD::get_singleton()->free(rb->ss_effects.ssil.pong);
RD::get_singleton()->free(rb->ss_effects.ssil.edges);
RD::get_singleton()->free(rb->ss_effects.ssil.importance_map[0]);
RD::get_singleton()->free(rb->ss_effects.ssil.importance_map[1]);
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
rb->ss_effects.ssil.ssil_final = RID();
rb->ss_effects.ssil.deinterleaved = RID();
rb->ss_effects.ssil.pong = RID();
rb->ss_effects.ssil.edges = RID();
rb->ss_effects.ssil.deinterleaved_slices.clear();
rb->ss_effects.ssil.pong_slices.clear();
rb->ss_effects.ssil.edges_slices.clear();
rb->ss_effects.ssil.importance_map[0] = RID();
rb->ss_effects.ssil.importance_map[1] = RID();
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
RD::get_singleton()->free(rb->ss_effects.last_frame);
rb->ss_effects.last_frame = RID();
rb->ss_effects.last_frame_slices.clear();
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
if (rb->ssr.blur_radius[0].is_valid()) {
RD::get_singleton()->free(rb->ssr.blur_radius[0]);
RD::get_singleton()->free(rb->ssr.blur_radius[1]);
rb->ssr.blur_radius[0] = RID();
rb->ssr.blur_radius[1] = RID();
}
if (rb->ssr.depth_scaled.is_valid()) {
RD::get_singleton()->free(rb->ssr.depth_scaled);
rb->ssr.depth_scaled = RID();
RD::get_singleton()->free(rb->ssr.normal_scaled);
rb->ssr.normal_scaled = RID();
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
if (rb->taa.history.is_valid()) {
RD::get_singleton()->free(rb->taa.history);
rb->taa.history = RID();
}
if (rb->taa.temp.is_valid()) {
RD::get_singleton()->free(rb->taa.temp);
rb->taa.temp = RID();
}
if (rb->taa.prev_velocity.is_valid()) {
RD::get_singleton()->free(rb->taa.prev_velocity);
rb->taa.prev_velocity = RID();
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
if (rb->ambient_buffer.is_valid()) {
RD::get_singleton()->free(rb->ambient_buffer);
RD::get_singleton()->free(rb->reflection_buffer);
rb->ambient_buffer = RID();
rb->reflection_buffer = RID();
}
Fix errors on quitting from an empty project
2021-10-18 13:23:10 +02:00
if (rb->gi.voxel_gi_buffer.is_valid()) {
RD::get_singleton()->free(rb->gi.voxel_gi_buffer);
rb->gi.voxel_gi_buffer = RID();
}
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_process_sss(RID p_render_buffers, const CameraMatrix &p_camera) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Re-implement subsurface scattering. The size settings are more "just works", with default scale and depth scale values that don't need much tweaking. Additionally, a "skin" mode was added so skin looks better. EDIT: Cleaned up SSR filter shader a bit.
2020-04-04 04:42:26 +02:00
ERR_FAIL_COND(!rb);
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
bool can_use_effects = rb->internal_width >= 8 && rb->internal_height >= 8;
Re-implement subsurface scattering. The size settings are more "just works", with default scale and depth scale values that don't need much tweaking. Additionally, a "skin" mode was added so skin looks better. EDIT: Cleaned up SSR filter shader a bit.
2020-04-04 04:42:26 +02:00
if (!can_use_effects) {
//just copy
return;
}
if (rb->blur[0].texture.is_null()) {
_allocate_blur_textures(rb);
}
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
storage->get_effects()->sub_surface_scattering(rb->internal_texture, rb->sss_texture, rb->depth_texture, p_camera, Size2i(rb->internal_width, rb->internal_height), sss_scale, sss_depth_scale, sss_quality);
Re-implement subsurface scattering. The size settings are more "just works", with default scale and depth scale values that don't need much tweaking. Additionally, a "skin" mode was added so skin looks better. EDIT: Cleaned up SSR filter shader a bit.
2020-04-04 04:42:26 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffer, RID p_normal_buffer, RID p_specular_buffer, RID p_metallic, const Color &p_metallic_mask, RID p_environment, const CameraMatrix &p_projection, bool p_use_additive) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
ERR_FAIL_COND(!rb);
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
bool can_use_effects = rb->internal_width >= 8 && rb->internal_height >= 8;
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
if (!can_use_effects) {
//just copy
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
storage->get_effects()->merge_specular(p_dest_framebuffer, p_specular_buffer, p_use_additive ? RID() : rb->internal_texture, RID());
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
return;
}
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
ERR_FAIL_COND(!env);
ERR_FAIL_COND(!env->ssr_enabled);
if (rb->ssr.depth_scaled.is_null()) {
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R32_SFLOAT;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tf.width = rb->internal_width / 2;
tf.height = rb->internal_height / 2;
Rename RD texture "type" to "texture_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-11-27 04:50:05 +01:00
tf.texture_type = RD::TEXTURE_TYPE_2D;
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
rb->ssr.depth_scaled = RD::get_singleton()->texture_create(tf, RD::TextureView());
tf.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
rb->ssr.normal_scaled = RD::get_singleton()->texture_create(tf, RD::TextureView());
}
Fix typo in SSR roughness quality enum value names
2022-02-28 01:06:26 +01:00
if (ssr_roughness_quality != RS::ENV_SSR_ROUGHNESS_QUALITY_DISABLED && !rb->ssr.blur_radius[0].is_valid()) {
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R8_UNORM;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tf.width = rb->internal_width / 2;
tf.height = rb->internal_height / 2;
Rename RD texture "type" to "texture_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-11-27 04:50:05 +01:00
tf.texture_type = RD::TEXTURE_TYPE_2D;
Re-Added screen space reflection.
2020-04-02 04:24:52 +02:00
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
rb->ssr.blur_radius[0] = RD::get_singleton()->texture_create(tf, RD::TextureView());
rb->ssr.blur_radius[1] = RD::get_singleton()->texture_create(tf, RD::TextureView());
}
if (rb->blur[0].texture.is_null()) {
_allocate_blur_textures(rb);
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
storage->get_effects()->screen_space_reflection(rb->internal_texture, p_normal_buffer, ssr_roughness_quality, rb->ssr.blur_radius[0], rb->ssr.blur_radius[1], p_metallic, p_metallic_mask, rb->depth_texture, rb->ssr.depth_scaled, rb->ssr.normal_scaled, rb->blur[0].layers[0].mipmaps[1].texture, rb->blur[1].layers[0].mipmaps[0].texture, Size2i(rb->internal_width / 2, rb->internal_height / 2), env->ssr_max_steps, env->ssr_fade_in, env->ssr_fade_out, env->ssr_depth_tolerance, p_projection);
storage->get_effects()->merge_specular(p_dest_framebuffer, p_specular_buffer, p_use_additive ? RID() : rb->internal_texture, rb->blur[0].layers[0].mipmaps[1].texture);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_process_ssao(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const CameraMatrix &p_projection) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
ERR_FAIL_COND(!rb);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
ERR_FAIL_COND(!env);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
RENDER_TIMESTAMP("Process SSAO");
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
if (rb->ss_effects.ssao.ao_final.is_valid() && ssao_using_half_size != ssao_half_size) {
RD::get_singleton()->free(rb->ss_effects.ssao.ao_deinterleaved);
RD::get_singleton()->free(rb->ss_effects.ssao.ao_pong);
RD::get_singleton()->free(rb->ss_effects.ssao.ao_final);
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
RD::get_singleton()->free(rb->ss_effects.ssao.importance_map[0]);
RD::get_singleton()->free(rb->ss_effects.ssao.importance_map[1]);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
rb->ss_effects.ssao.ao_deinterleaved = RID();
rb->ss_effects.ssao.ao_pong = RID();
rb->ss_effects.ssao.ao_final = RID();
rb->ss_effects.ssao.importance_map[0] = RID();
rb->ss_effects.ssao.importance_map[1] = RID();
rb->ss_effects.ssao.ao_deinterleaved_slices.clear();
rb->ss_effects.ssao.ao_pong_slices.clear();
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
}
int buffer_width;
int buffer_height;
int half_width;
int half_height;
if (ssao_half_size) {
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
buffer_width = (rb->internal_width + 3) / 4;
buffer_height = (rb->internal_height + 3) / 4;
half_width = (rb->internal_width + 7) / 8;
half_height = (rb->internal_height + 7) / 8;
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
} else {
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
buffer_width = (rb->internal_width + 1) / 2;
buffer_height = (rb->internal_height + 1) / 2;
half_width = (rb->internal_width + 3) / 4;
half_height = (rb->internal_height + 3) / 4;
Revert "Replace SAO implementation with MSSAO"
2020-10-19 00:27:51 +02:00
}
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
bool uniform_sets_are_invalid = false;
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
if (rb->ss_effects.ssao.ao_deinterleaved.is_null()) {
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
{
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
rb->ss_effects.ssao.depth_texture_view = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.linear_depth, 0, ssao_half_size ? 1 : 0, 4, RD::TEXTURE_SLICE_2D_ARRAY);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
{
RD::TextureFormat tf;
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
tf.format = RD::DATA_FORMAT_R8G8_UNORM;
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
tf.width = buffer_width;
tf.height = buffer_height;
tf.array_layers = 4;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
rb->ss_effects.ssao.ao_deinterleaved = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssao.ao_deinterleaved, "SSAO De-interleaved Array");
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
for (uint32_t i = 0; i < 4; i++) {
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
RID slice = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.ssao.ao_deinterleaved, i, 0);
rb->ss_effects.ssao.ao_deinterleaved_slices.push_back(slice);
RD::get_singleton()->set_resource_name(slice, "SSAO De-interleaved Array Layer " + itos(i) + " ");
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
}
}
{
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R8G8_UNORM;
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
tf.width = buffer_width;
tf.height = buffer_height;
tf.array_layers = 4;
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
rb->ss_effects.ssao.ao_pong = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssao.ao_pong, "SSAO De-interleaved Array Pong");
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
for (uint32_t i = 0; i < 4; i++) {
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
RID slice = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.ssao.ao_pong, i, 0);
rb->ss_effects.ssao.ao_pong_slices.push_back(slice);
RD::get_singleton()->set_resource_name(slice, "SSAO De-interleaved Array Layer " + itos(i) + " Pong");
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
}
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
{
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R8_UNORM;
tf.width = half_width;
tf.height = half_height;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
rb->ss_effects.ssao.importance_map[0] = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssao.importance_map[0], "SSAO Importance Map");
rb->ss_effects.ssao.importance_map[1] = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssao.importance_map[1], "SSAO Importance Map Pong");
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
}
{
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
RD::TextureFormat tf;
Revert "Replace SAO implementation with MSSAO"
2020-10-19 00:27:51 +02:00
tf.format = RD::DATA_FORMAT_R8_UNORM;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tf.width = rb->internal_width;
tf.height = rb->internal_height;
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
rb->ss_effects.ssao.ao_final = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssao.ao_final, "SSAO Final");
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
ssao_using_half_size = ssao_half_size;
uniform_sets_are_invalid = true;
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
EffectsRD::SSAOSettings settings;
settings.radius = env->ssao_radius;
settings.intensity = env->ssao_intensity;
settings.power = env->ssao_power;
settings.detail = env->ssao_detail;
settings.horizon = env->ssao_horizon;
settings.sharpness = env->ssao_sharpness;
settings.quality = ssao_quality;
settings.half_size = ssao_half_size;
settings.adaptive_target = ssao_adaptive_target;
settings.blur_passes = ssao_blur_passes;
settings.fadeout_from = ssao_fadeout_from;
settings.fadeout_to = ssao_fadeout_to;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
settings.full_screen_size = Size2i(rb->internal_width, rb->internal_height);
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
settings.half_screen_size = Size2i(buffer_width, buffer_height);
SSAO cleanup and fixes
2020-12-31 19:33:38 +01:00
settings.quarter_screen_size = Size2i(half_width, half_height);
Port ASSAO to Godot to replace SAO
2020-12-08 06:37:09 +01:00
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
storage->get_effects()->generate_ssao(p_normal_buffer, rb->ss_effects.ssao.depth_texture_view, rb->ss_effects.ssao.ao_deinterleaved, rb->ss_effects.ssao.ao_deinterleaved_slices, rb->ss_effects.ssao.ao_pong, rb->ss_effects.ssao.ao_pong_slices, rb->ss_effects.ssao.ao_final, rb->ss_effects.ssao.importance_map[0], rb->ss_effects.ssao.importance_map[1], p_projection, settings, uniform_sets_are_invalid, rb->ss_effects.ssao.gather_uniform_set, rb->ss_effects.ssao.importance_map_uniform_set);
}
void RendererSceneRenderRD::_process_ssil(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const CameraMatrix &p_projection, const Transform3D &p_transform) {
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
ERR_FAIL_COND(!rb);
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
ERR_FAIL_COND(!env);
RENDER_TIMESTAMP("Process SSIL");
if (rb->ss_effects.ssil.ssil_final.is_valid() && ssil_using_half_size != ssil_half_size) {
RD::get_singleton()->free(rb->ss_effects.ssil.ssil_final);
RD::get_singleton()->free(rb->ss_effects.ssil.deinterleaved);
RD::get_singleton()->free(rb->ss_effects.ssil.pong);
RD::get_singleton()->free(rb->ss_effects.ssil.edges);
RD::get_singleton()->free(rb->ss_effects.ssil.importance_map[0]);
RD::get_singleton()->free(rb->ss_effects.ssil.importance_map[1]);
rb->ss_effects.ssil.ssil_final = RID();
rb->ss_effects.ssil.deinterleaved = RID();
rb->ss_effects.ssil.pong = RID();
rb->ss_effects.ssil.edges = RID();
rb->ss_effects.ssil.deinterleaved_slices.clear();
rb->ss_effects.ssil.pong_slices.clear();
rb->ss_effects.ssil.edges_slices.clear();
rb->ss_effects.ssil.importance_map[0] = RID();
rb->ss_effects.ssil.importance_map[1] = RID();
}
int buffer_width;
int buffer_height;
int half_width;
int half_height;
if (ssil_half_size) {
buffer_width = (rb->width + 3) / 4;
buffer_height = (rb->height + 3) / 4;
half_width = (rb->width + 7) / 8;
half_height = (rb->height + 7) / 8;
} else {
buffer_width = (rb->width + 1) / 2;
buffer_height = (rb->height + 1) / 2;
half_width = (rb->width + 3) / 4;
half_height = (rb->height + 3) / 4;
}
bool uniform_sets_are_invalid = false;
if (rb->ss_effects.ssil.ssil_final.is_null()) {
{
rb->ss_effects.ssil.depth_texture_view = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.linear_depth, 0, ssil_half_size ? 1 : 0, 4, RD::TEXTURE_SLICE_2D_ARRAY);
}
{
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
tf.width = rb->width;
tf.height = rb->height;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
rb->ss_effects.ssil.ssil_final = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssil.ssil_final, "SSIL texture");
RD::get_singleton()->texture_clear(rb->ss_effects.ssil.ssil_final, Color(0, 0, 0, 0), 0, 1, 0, 1);
if (rb->ss_effects.last_frame.is_null()) {
tf.mipmaps = 6;
rb->ss_effects.last_frame = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.last_frame, "Last Frame Radiance");
RD::get_singleton()->texture_clear(rb->ss_effects.last_frame, Color(0, 0, 0, 0), 0, tf.mipmaps, 0, 1);
for (uint32_t i = 0; i < 6; i++) {
RID slice = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.last_frame, 0, i);
rb->ss_effects.last_frame_slices.push_back(slice);
RD::get_singleton()->set_resource_name(slice, "Last Frame Radiance Mip " + itos(i) + " ");
}
}
}
{
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
tf.width = buffer_width;
tf.height = buffer_height;
tf.array_layers = 4;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
rb->ss_effects.ssil.deinterleaved = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssil.deinterleaved, "SSIL deinterleaved buffer");
for (uint32_t i = 0; i < 4; i++) {
RID slice = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.ssil.deinterleaved, i, 0);
rb->ss_effects.ssil.deinterleaved_slices.push_back(slice);
RD::get_singleton()->set_resource_name(slice, "SSIL deinterleaved buffer array " + itos(i) + " ");
}
}
{
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
tf.width = buffer_width;
tf.height = buffer_height;
tf.array_layers = 4;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
rb->ss_effects.ssil.pong = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssil.pong, "SSIL deinterleaved pong buffer");
for (uint32_t i = 0; i < 4; i++) {
RID slice = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.ssil.pong, i, 0);
rb->ss_effects.ssil.pong_slices.push_back(slice);
RD::get_singleton()->set_resource_name(slice, "SSIL deinterleaved buffer pong array " + itos(i) + " ");
}
}
{
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R8_UNORM;
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
tf.width = buffer_width;
tf.height = buffer_height;
tf.array_layers = 4;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
rb->ss_effects.ssil.edges = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssil.edges, "SSIL edges buffer");
for (uint32_t i = 0; i < 4; i++) {
RID slice = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.ssil.edges, i, 0);
rb->ss_effects.ssil.edges_slices.push_back(slice);
RD::get_singleton()->set_resource_name(slice, "SSIL edges buffer slice " + itos(i) + " ");
}
}
{
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R8_UNORM;
tf.width = half_width;
tf.height = half_height;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
rb->ss_effects.ssil.importance_map[0] = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssil.importance_map[0], "SSIL Importance Map");
rb->ss_effects.ssil.importance_map[1] = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.ssil.importance_map[1], "SSIL Importance Map Pong");
}
uniform_sets_are_invalid = true;
ssil_using_half_size = ssil_half_size;
}
EffectsRD::SSILSettings settings;
settings.radius = env->ssil_radius;
settings.intensity = env->ssil_intensity;
settings.sharpness = env->ssil_sharpness;
settings.normal_rejection = env->ssil_normal_rejection;
settings.quality = ssil_quality;
settings.half_size = ssil_half_size;
settings.adaptive_target = ssil_adaptive_target;
settings.blur_passes = ssil_blur_passes;
settings.fadeout_from = ssil_fadeout_from;
settings.fadeout_to = ssil_fadeout_to;
settings.full_screen_size = Size2i(rb->width, rb->height);
settings.half_screen_size = Size2i(buffer_width, buffer_height);
settings.quarter_screen_size = Size2i(half_width, half_height);
CameraMatrix correction;
correction.set_depth_correction(true);
CameraMatrix projection = correction * p_projection;
Transform3D transform = p_transform;
transform.set_origin(Vector3(0.0, 0.0, 0.0));
CameraMatrix last_frame_projection = rb->ss_effects.last_frame_projection * CameraMatrix(rb->ss_effects.last_frame_transform.affine_inverse()) * CameraMatrix(transform) * projection.inverse();
storage->get_effects()->screen_space_indirect_lighting(rb->ss_effects.last_frame, rb->ss_effects.ssil.ssil_final, p_normal_buffer, rb->ss_effects.ssil.depth_texture_view, rb->ss_effects.ssil.deinterleaved, rb->ss_effects.ssil.deinterleaved_slices, rb->ss_effects.ssil.pong, rb->ss_effects.ssil.pong_slices, rb->ss_effects.ssil.importance_map[0], rb->ss_effects.ssil.importance_map[1], rb->ss_effects.ssil.edges, rb->ss_effects.ssil.edges_slices, p_projection, last_frame_projection, settings, uniform_sets_are_invalid, rb->ss_effects.ssil.gather_uniform_set, rb->ss_effects.ssil.importance_map_uniform_set, rb->ss_effects.ssil.projection_uniform_set);
rb->ss_effects.last_frame_projection = projection;
rb->ss_effects.last_frame_transform = transform;
}
void RendererSceneRenderRD::_copy_framebuffer_to_ssil(RID p_render_buffers) {
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
ERR_FAIL_COND(!rb);
if (rb->ss_effects.last_frame.is_valid()) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_rect(rb->texture, rb->ss_effects.last_frame, Rect2i(0, 0, rb->width, rb->height));
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
int width = rb->width;
int height = rb->height;
for (int i = 0; i < rb->ss_effects.last_frame_slices.size() - 1; i++) {
width = MAX(1, width >> 1);
height = MAX(1, height >> 1);
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->make_mipmap(rb->ss_effects.last_frame_slices[i], rb->ss_effects.last_frame_slices[i + 1], Size2i(width, height));
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
}
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
void RendererSceneRenderRD::_process_taa(RID p_render_buffers, RID p_velocity_buffer, float p_z_near, float p_z_far) {
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
ERR_FAIL_COND(!rb);
bool just_allocated = false;
if (rb->taa.history.is_null()) {
RD::TextureFormat tf;
if (rb->view_count > 1) {
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
}
tf.format = _render_buffers_get_color_format();
tf.width = rb->internal_width;
tf.height = rb->internal_height;
tf.array_layers = rb->view_count; // create a layer for every view
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | (_render_buffers_can_be_storage() ? RD::TEXTURE_USAGE_STORAGE_BIT : 0);
rb->taa.history = RD::get_singleton()->texture_create(tf, RD::TextureView());
rb->taa.temp = RD::get_singleton()->texture_create(tf, RD::TextureView());
tf.format = RD::DATA_FORMAT_R16G16_SFLOAT;
rb->taa.prev_velocity = RD::get_singleton()->texture_create(tf, RD::TextureView());
just_allocated = true;
}
RD::get_singleton()->draw_command_begin_label("TAA");
if (!just_allocated) {
storage->get_effects()->taa_resolve(rb->internal_texture, rb->taa.temp, rb->depth_texture, p_velocity_buffer, rb->taa.prev_velocity, rb->taa.history, Size2(rb->internal_width, rb->internal_height), p_z_near, p_z_far);
copy_effects->copy_to_rect(rb->taa.temp, rb->internal_texture, Rect2(0, 0, rb->internal_width, rb->internal_height));
}
copy_effects->copy_to_rect(rb->internal_texture, rb->taa.history, Rect2(0, 0, rb->internal_width, rb->internal_height));
copy_effects->copy_to_rect(p_velocity_buffer, rb->taa.prev_velocity, Rect2(0, 0, rb->width, rb->height));
RD::get_singleton()->draw_command_end_label();
}
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
void RendererSceneRenderRD::_render_buffers_copy_screen_texture(const RenderDataRD *p_render_data) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
ERR_FAIL_COND(!rb);
RD::get_singleton()->draw_command_begin_label("Copy screen texture");
if (rb->blur[0].texture.is_null()) {
_allocate_blur_textures(rb);
}
bool can_use_storage = _render_buffers_can_be_storage();
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
for (uint32_t v = 0; v < rb->view_count; v++) {
if (can_use_storage) {
copy_effects->copy_to_rect(rb->views[v].view_texture, rb->blur[0].layers[v].mipmaps[0].texture, Rect2i(0, 0, rb->width, rb->height));
for (int i = 1; i < rb->blur[0].layers[v].mipmaps.size(); i++) {
copy_effects->make_mipmap(rb->blur[0].layers[v].mipmaps[i - 1].texture, rb->blur[0].layers[v].mipmaps[i].texture, Size2i(rb->blur[0].layers[v].mipmaps[i].width, rb->blur[0].layers[v].mipmaps[i].height));
}
} else {
copy_effects->copy_to_fb_rect(rb->views[v].view_texture, rb->blur[0].layers[v].mipmaps[0].fb, Rect2i(0, 0, rb->width, rb->height));
for (int i = 1; i < rb->blur[0].layers[v].mipmaps.size(); i++) {
copy_effects->make_mipmap_raster(rb->blur[0].layers[v].mipmaps[i - 1].texture, rb->blur[0].layers[v].mipmaps[i].fb, Size2i(rb->blur[0].layers[v].mipmaps[i].width, rb->blur[0].layers[v].mipmaps[i].height));
}
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
}
}
RD::get_singleton()->draw_command_end_label();
}
void RendererSceneRenderRD::_render_buffers_copy_depth_texture(const RenderDataRD *p_render_data) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
ERR_FAIL_COND(!rb);
RD::get_singleton()->draw_command_begin_label("Copy depth texture");
if (rb->depth_back_texture.is_null()) {
_allocate_depth_backbuffer_textures(rb);
}
// @TODO IMPLEMENT MULTIVIEW, all effects need to support stereo buffers or effects are only applied to the left eye
bool can_use_storage = _render_buffers_can_be_storage();
if (can_use_storage) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_rect(rb->depth_texture, rb->depth_back_texture, Rect2i(0, 0, rb->width, rb->height));
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
} else {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(rb->depth_texture, rb->depth_back_fb, Rect2i(0, 0, rb->width, rb->height));
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
}
RD::get_singleton()->draw_command_end_label();
}
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
void RendererSceneRenderRD::_render_buffers_post_process_and_tonemap(const RenderDataRD *p_render_data) {
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
ERR_FAIL_COND(!rb);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_render_data->environment);
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
// Glow and override exposure (if enabled).
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
CameraEffects *camfx = camera_effects_owner.get_or_null(p_render_data->camera_effects);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
bool can_use_effects = rb->width >= 8 && rb->height >= 8;
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
bool can_use_storage = _render_buffers_can_be_storage();
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
if (can_use_effects && camfx && (camfx->dof_blur_near_enabled || camfx->dof_blur_far_enabled) && camfx->dof_blur_amount > 0.0) {
Add timestamps to some rendering effects
2022-05-21 17:39:49 +02:00
RENDER_TIMESTAMP("Depth of Field");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
RD::get_singleton()->draw_command_begin_label("DOF");
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
if (rb->blur[0].texture.is_null()) {
_allocate_blur_textures(rb);
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
RendererRD::BokehDOF::BokehBuffers buffers;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
// Textures we use
buffers.base_texture_size = Size2i(rb->internal_width, rb->internal_height);
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
buffers.secondary_texture = rb->blur[0].layers[0].mipmaps[0].texture;
buffers.half_texture[0] = rb->blur[1].layers[0].mipmaps[0].texture;
buffers.half_texture[1] = rb->blur[0].layers[0].mipmaps[1].texture;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
float bokeh_size = camfx->dof_blur_amount * 64.0;
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (can_use_storage) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
for (uint32_t i = 0; i < rb->view_count; i++) {
buffers.base_texture = rb->views[i].view_texture;
buffers.depth_texture = rb->views[i].view_depth;
// In stereo p_render_data->z_near and p_render_data->z_far can be offset for our combined frustrum
float z_near = p_render_data->view_projection[i].get_z_near();
float z_far = p_render_data->view_projection[i].get_z_far();
bokeh_dof->bokeh_dof_compute(buffers, camfx->dof_blur_far_enabled, camfx->dof_blur_far_distance, camfx->dof_blur_far_transition, camfx->dof_blur_near_enabled, camfx->dof_blur_near_distance, camfx->dof_blur_near_transition, bokeh_size, dof_blur_bokeh_shape, dof_blur_quality, dof_blur_use_jitter, z_near, z_far, p_render_data->cam_orthogonal);
};
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
} else {
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
// Set framebuffers.
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
buffers.secondary_fb = rb->weight_buffers[1].fb;
buffers.half_fb[0] = rb->weight_buffers[2].fb;
buffers.half_fb[1] = rb->weight_buffers[3].fb;
buffers.weight_texture[0] = rb->weight_buffers[0].weight;
buffers.weight_texture[1] = rb->weight_buffers[1].weight;
buffers.weight_texture[2] = rb->weight_buffers[2].weight;
buffers.weight_texture[3] = rb->weight_buffers[3].weight;
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
// Set weight buffers.
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
buffers.base_weight_fb = rb->weight_buffers[0].fb;
for (uint32_t i = 0; i < rb->view_count; i++) {
buffers.base_texture = rb->views[i].view_texture;
buffers.depth_texture = rb->views[i].view_depth;
buffers.base_fb = rb->views[i].view_fb;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 09:43:17 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
// In stereo p_render_data->z_near and p_render_data->z_far can be offset for our combined frustrum
float z_near = p_render_data->view_projection[i].get_z_near();
float z_far = p_render_data->view_projection[i].get_z_far();
bokeh_dof->bokeh_dof_raster(buffers, camfx->dof_blur_far_enabled, camfx->dof_blur_far_distance, camfx->dof_blur_far_transition, camfx->dof_blur_near_enabled, camfx->dof_blur_near_distance, camfx->dof_blur_near_transition, bokeh_size, dof_blur_bokeh_shape, dof_blur_quality, z_near, z_far, p_render_data->cam_orthogonal);
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
}
RD::get_singleton()->draw_command_end_label();
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
}
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
if (can_use_effects && env && env->auto_exposure) {
Add timestamps to some rendering effects
2022-05-21 17:39:49 +02:00
RENDER_TIMESTAMP("Auto exposure");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
RD::get_singleton()->draw_command_begin_label("Auto exposure");
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
if (rb->luminance.current.is_null()) {
_allocate_luminance_textures(rb);
}
bool set_immediate = env->auto_exposure_version != rb->auto_exposure_version;
rb->auto_exposure_version = env->auto_exposure_version;
double step = env->auto_exp_speed * time_step;
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (can_use_storage) {
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
storage->get_effects()->luminance_reduction(rb->internal_texture, Size2i(rb->internal_width, rb->internal_height), rb->luminance.reduce, rb->luminance.current, env->min_luminance, env->max_luminance, step, set_immediate);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
} else {
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
storage->get_effects()->luminance_reduction_raster(rb->internal_texture, Size2i(rb->internal_width, rb->internal_height), rb->luminance.reduce, rb->luminance.fb, rb->luminance.current, env->min_luminance, env->max_luminance, step, set_immediate);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
}
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
// Swap final reduce with prev luminance.
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
SWAP(rb->luminance.current, rb->luminance.reduce.write[rb->luminance.reduce.size() - 1]);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
if (!can_use_storage) {
SWAP(rb->luminance.current_fb, rb->luminance.fb.write[rb->luminance.fb.size() - 1]);
}
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
RenderingServerDefault::redraw_request(); // Redraw all the time if auto exposure rendering is on.
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
RD::get_singleton()->draw_command_end_label();
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
int max_glow_level = -1;
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
if (can_use_effects && env && env->glow_enabled) {
Add timestamps to some rendering effects
2022-05-21 17:39:49 +02:00
RENDER_TIMESTAMP("Glow");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
RD::get_singleton()->draw_command_begin_label("Gaussian Glow");
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
/* see that blur textures are allocated */
Optimize Glow with local memory
2020-09-20 00:02:32 +02:00
if (rb->blur[1].texture.is_null()) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
_allocate_blur_textures(rb);
}
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
for (int i = 0; i < RS::MAX_GLOW_LEVELS; i++) {
Optimize Glow with local memory
2020-09-20 00:02:32 +02:00
if (env->glow_levels[i] > 0.0) {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (i >= rb->blur[1].layers[0].mipmaps.size()) {
max_glow_level = rb->blur[1].layers[0].mipmaps.size() - 1;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
} else {
max_glow_level = i;
}
}
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
float luminance_multiplier = _render_buffers_get_luminance_multiplier();
for (uint32_t l = 0; l < rb->view_count; l++) {
for (int i = 0; i < (max_glow_level + 1); i++) {
int vp_w = rb->blur[1].layers[l].mipmaps[i].width;
int vp_h = rb->blur[1].layers[l].mipmaps[i].height;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (i == 0) {
RID luminance_texture;
if (env->auto_exposure && rb->luminance.current.is_valid()) {
luminance_texture = rb->luminance.current;
}
if (can_use_storage) {
copy_effects->gaussian_glow(rb->views[l].view_texture, rb->blur[1].layers[l].mipmaps[i].texture, Size2i(vp_w, vp_h), env->glow_strength, glow_high_quality, true, env->glow_hdr_luminance_cap, env->exposure, env->glow_bloom, env->glow_hdr_bleed_threshold, env->glow_hdr_bleed_scale, luminance_texture, env->auto_exp_scale);
} else {
copy_effects->gaussian_glow_raster(rb->views[l].view_texture, luminance_multiplier, rb->blur[1].layers[l].mipmaps[i].half_fb, rb->blur[1].layers[l].mipmaps[i].half_texture, rb->blur[1].layers[l].mipmaps[i].fb, Size2i(vp_w, vp_h), env->glow_strength, glow_high_quality, true, env->glow_hdr_luminance_cap, env->exposure, env->glow_bloom, env->glow_hdr_bleed_threshold, env->glow_hdr_bleed_scale, luminance_texture, env->auto_exp_scale);
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
} else {
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (can_use_storage) {
copy_effects->gaussian_glow(rb->blur[1].layers[l].mipmaps[i - 1].texture, rb->blur[1].layers[l].mipmaps[i].texture, Size2i(vp_w, vp_h), env->glow_strength, glow_high_quality);
} else {
copy_effects->gaussian_glow_raster(rb->blur[1].layers[l].mipmaps[i - 1].texture, luminance_multiplier, rb->blur[1].layers[l].mipmaps[i].half_fb, rb->blur[1].layers[l].mipmaps[i].half_texture, rb->blur[1].layers[l].mipmaps[i].fb, Size2i(vp_w, vp_h), env->glow_strength, glow_high_quality);
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
RD::get_singleton()->draw_command_end_label();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
{
Add timestamps to some rendering effects
2022-05-21 17:39:49 +02:00
RENDER_TIMESTAMP("Tonemap");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
RD::get_singleton()->draw_command_begin_label("Tonemap");
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
RendererRD::ToneMapper::TonemapSettings tonemap;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
if (can_use_effects && env && env->auto_exposure && rb->luminance.current.is_valid()) {
tonemap.use_auto_exposure = true;
tonemap.exposure_texture = rb->luminance.current;
tonemap.auto_exposure_grey = env->auto_exp_scale;
} else {
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.exposure_texture = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_WHITE);
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
}
if (can_use_effects && env && env->glow_enabled) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
tonemap.use_glow = true;
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
tonemap.glow_mode = RendererRD::ToneMapper::TonemapSettings::GlowMode(env->glow_blend_mode);
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
tonemap.glow_intensity = env->glow_blend_mode == RS::ENV_GLOW_BLEND_MODE_MIX ? env->glow_mix : env->glow_intensity;
Optimize Glow with local memory
2020-09-20 00:02:32 +02:00
for (int i = 0; i < RS::MAX_GLOW_LEVELS; i++) {
tonemap.glow_levels[i] = env->glow_levels[i];
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
tonemap.glow_texture_size.x = rb->blur[1].layers[0].mipmaps[0].width;
tonemap.glow_texture_size.y = rb->blur[1].layers[0].mipmaps[0].height;
Move glow upscale quality to a global setting, for consistency
2020-03-30 15:46:03 +02:00
tonemap.glow_use_bicubic_upscale = glow_bicubic_upscale;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
tonemap.glow_texture = rb->blur[1].texture;
add support for glow maps
2022-01-20 16:47:25 +01:00
if (env->glow_map.is_valid()) {
tonemap.glow_map_strength = env->glow_map_strength;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.glow_map = texture_storage->texture_get_rd_texture(env->glow_map);
add support for glow maps
2022-01-20 16:47:25 +01:00
} else {
tonemap.glow_map_strength = 0.0f;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_WHITE);
add support for glow maps
2022-01-20 16:47:25 +01:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
} else {
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.glow_texture = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_BLACK);
tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_WHITE);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Add screen space AA option, with FXAA implementation.
2020-04-12 06:49:10 +02:00
if (rb->screen_space_aa == RS::VIEWPORT_SCREEN_SPACE_AA_FXAA) {
tonemap.use_fxaa = true;
}
Add a debanding property to Viewport It can be enabled in the Project Settings (`rendering/quality/screen_filters/use_debanding`). It's disabled by default as it has a small performance impact and can make PNG screenshots much larger (due to how dithering works). It will also slightly brighten the scene's dark areas. As a result, it should be enabled only when banding is noticeable enough. This closes #17006.
2020-04-20 23:34:47 +02:00
tonemap.use_debanding = rb->use_debanding;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tonemap.texture_size = Vector2i(rb->internal_width, rb->internal_height);
Add screen space AA option, with FXAA implementation.
2020-04-12 06:49:10 +02:00
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
if (env) {
tonemap.tonemap_mode = env->tone_mapper;
tonemap.white = env->white;
tonemap.exposure = env->exposure;
}
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
if (camfx && camfx->override_exposure_enabled) {
tonemap.exposure = camfx->override_exposure;
}
Refactored Mesh internals and formats. -Changed how mesh data is organized, hoping to make it more efficient on Vulkan and GLES. -Removed compression, it now always uses the most efficient format. -Added support for custom arrays (up to 8 custom formats) -Added support for 8 weights in skeleton data. -Added a simple optional versioning system for imported assets, to reimport if binary is newer -Fixes #43979 (I needed to test) WARNING: -NOT backwards compatible with previous 4.x-devel, will most likely never be, but it will force reimport scenes due to version change. -NOT backwards compatible with 3.x scenes, this will be eventually re-added. -Skeletons not working any longer, will fix in next PR.
2020-12-02 02:40:47 +01:00
tonemap.use_color_correction = false;
tonemap.use_1d_color_correction = false;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.color_correction_texture = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_3D_WHITE);
Refactored Mesh internals and formats. -Changed how mesh data is organized, hoping to make it more efficient on Vulkan and GLES. -Removed compression, it now always uses the most efficient format. -Added support for custom arrays (up to 8 custom formats) -Added support for 8 weights in skeleton data. -Added a simple optional versioning system for imported assets, to reimport if binary is newer -Fixes #43979 (I needed to test) WARNING: -NOT backwards compatible with previous 4.x-devel, will most likely never be, but it will force reimport scenes due to version change. -NOT backwards compatible with 3.x scenes, this will be eventually re-added. -Skeletons not working any longer, will fix in next PR.
2020-12-02 02:40:47 +01:00
Environment brightness, contrast, saturation restore with color correction. Allow gradients and 2d images. Use shader versions for LUT in tonemap Co-authored-by: alex-poe <3957610+CptPotato@users.noreply.github.com> Co-authored-by: QbieShay <cislaghi.ilaria@gmail.com> Co-authored-by: Clay John <claynjohn@gmail.com>
2020-11-23 02:51:31 +01:00
if (can_use_effects && env) {
tonemap.use_bcs = env->adjustments_enabled;
tonemap.brightness = env->adjustments_brightness;
tonemap.contrast = env->adjustments_contrast;
tonemap.saturation = env->adjustments_saturation;
if (env->adjustments_enabled && env->color_correction.is_valid()) {
tonemap.use_color_correction = true;
Refactored Mesh internals and formats. -Changed how mesh data is organized, hoping to make it more efficient on Vulkan and GLES. -Removed compression, it now always uses the most efficient format. -Added support for custom arrays (up to 8 custom formats) -Added support for 8 weights in skeleton data. -Added a simple optional versioning system for imported assets, to reimport if binary is newer -Fixes #43979 (I needed to test) WARNING: -NOT backwards compatible with previous 4.x-devel, will most likely never be, but it will force reimport scenes due to version change. -NOT backwards compatible with 3.x scenes, this will be eventually re-added. -Skeletons not working any longer, will fix in next PR.
2020-12-02 02:40:47 +01:00
tonemap.use_1d_color_correction = env->use_1d_color_correction;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.color_correction_texture = texture_storage->texture_get_rd_texture(env->color_correction);
Environment brightness, contrast, saturation restore with color correction. Allow gradients and 2d images. Use shader versions for LUT in tonemap Co-authored-by: alex-poe <3957610+CptPotato@users.noreply.github.com> Co-authored-by: QbieShay <cislaghi.ilaria@gmail.com> Co-authored-by: Clay John <claynjohn@gmail.com>
2020-11-23 02:51:31 +01:00
}
}
Scale color output in the mobile renderer to provide HDR support
2021-07-26 13:31:15 +02:00
tonemap.luminance_multiplier = _render_buffers_get_luminance_multiplier();
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
tonemap.view_count = p_render_data->view_count;
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
tone_mapper->tonemapper(rb->internal_texture, texture_storage->render_target_get_rd_framebuffer(rb->render_target), tonemap);
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
RD::get_singleton()->draw_command_end_label();
}
if (can_use_effects && can_use_storage && (rb->internal_width != rb->width || rb->internal_height != rb->height)) {
Rename remaining references of FSR to FSR 1.0 With FSR 2.0 around the corner, we should avoid any ambiguity by explicitly stating the version number.
2022-05-12 18:22:17 +02:00
RD::get_singleton()->draw_command_begin_label("FSR 1.0 Upscale");
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
storage->get_effects()->fsr_upscale(rb->internal_texture, rb->upscale_texture, rb->texture, Size2i(rb->internal_width, rb->internal_height), Size2i(rb->width, rb->height), rb->fsr_sharpness);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
RD::get_singleton()->draw_command_end_label();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
texture_storage->render_target_disable_clear_request(rb->render_target);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
void RendererSceneRenderRD::_post_process_subpass(RID p_source_texture, RID p_framebuffer, const RenderDataRD *p_render_data) {
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
RD::get_singleton()->draw_command_begin_label("Post Process Subpass");
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
ERR_FAIL_COND(!rb);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_render_data->environment);
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
// Override exposure (if enabled).
CameraEffects *camfx = camera_effects_owner.get_or_null(p_render_data->camera_effects);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
bool can_use_effects = rb->width >= 8 && rb->height >= 8;
RD::DrawListID draw_list = RD::get_singleton()->draw_list_switch_to_next_pass();
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
RendererRD::ToneMapper::TonemapSettings tonemap;
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
if (env) {
tonemap.tonemap_mode = env->tone_mapper;
tonemap.exposure = env->exposure;
tonemap.white = env->white;
}
Implement CameraEffects override_exposure
2021-11-08 10:08:02 +01:00
if (camfx && camfx->override_exposure_enabled) {
tonemap.exposure = camfx->override_exposure;
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
// We don't support glow or auto exposure here, if they are needed, don't use subpasses!
// The problem is that we need to use the result so far and process them before we can
// apply this to our results.
if (can_use_effects && env && env->glow_enabled) {
ERR_FAIL_MSG("Glow is not supported when using subpasses.");
}
if (can_use_effects && env && env->auto_exposure) {
ERR_FAIL_MSG("Glow is not supported when using subpasses.");
}
tonemap.use_glow = false;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.glow_texture = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_BLACK);
tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_WHITE);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
tonemap.use_auto_exposure = false;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.exposure_texture = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_WHITE);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
tonemap.use_color_correction = false;
tonemap.use_1d_color_correction = false;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.color_correction_texture = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_3D_WHITE);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
if (can_use_effects && env) {
tonemap.use_bcs = env->adjustments_enabled;
tonemap.brightness = env->adjustments_brightness;
tonemap.contrast = env->adjustments_contrast;
tonemap.saturation = env->adjustments_saturation;
if (env->adjustments_enabled && env->color_correction.is_valid()) {
tonemap.use_color_correction = true;
tonemap.use_1d_color_correction = env->use_1d_color_correction;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
tonemap.color_correction_texture = texture_storage->texture_get_rd_texture(env->color_correction);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
}
}
tonemap.use_debanding = rb->use_debanding;
tonemap.texture_size = Vector2i(rb->width, rb->height);
Scale color output in the mobile renderer to provide HDR support
2021-07-26 13:31:15 +02:00
tonemap.luminance_multiplier = _render_buffers_get_luminance_multiplier();
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
tonemap.view_count = p_render_data->view_count;
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
tone_mapper->tonemapper(draw_list, p_source_texture, RD::get_singleton()->framebuffer_get_format(p_framebuffer), tonemap);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
RD::get_singleton()->draw_command_end_label();
}
void RendererSceneRenderRD::_disable_clear_request(const RenderDataRD *p_render_data) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
ERR_FAIL_COND(!rb);
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
texture_storage->render_target_disable_clear_request(rb->render_target);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
}
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 18:40:24 +02:00
void RendererSceneRenderRD::_render_buffers_debug_draw(RID p_render_buffers, RID p_shadow_atlas, RID p_occlusion_buffer) {
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
ERR_FAIL_COND(!rb);
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SHADOW_ATLAS) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
if (p_shadow_atlas.is_valid()) {
RID shadow_atlas_texture = shadow_atlas_get_texture(p_shadow_atlas);
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
if (shadow_atlas_texture.is_null()) {
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
shadow_atlas_texture = texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_BLACK);
Minor fixes to shadow atlases: * Erase shadow owner *before* setting it to RID(). * Add default texture in shadow atlas debug view to avoid error spam when no atlas is present. * Fix typo.
2022-01-24 15:55:32 +01:00
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(shadow_atlas_texture, texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2i(Vector2(), rtsize / 2), false, true);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
}
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 19:21:27 +01:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
if (directional_shadow_get_texture().is_valid()) {
RID shadow_atlas_texture = directional_shadow_get_texture();
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(shadow_atlas_texture, texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2i(Vector2(), rtsize / 2), false, true);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
}
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
Implement decals Also implemented decal atlas, so projectors and other stuff can be added. Sidenote: Had to make RID hashable, so some unrelated includes changed in order to include it in hashfuncs.h
2020-04-14 05:05:21 +02:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_DECAL_ATLAS) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RID decal_atlas = RendererRD::TextureStorage::get_singleton()->decal_atlas_get_texture();
Implement decals Also implemented decal atlas, so projectors and other stuff can be added. Sidenote: Had to make RID hashable, so some unrelated includes changed in order to include it in hashfuncs.h
2020-04-14 05:05:21 +02:00
if (decal_atlas.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Implement decals Also implemented decal atlas, so projectors and other stuff can be added. Sidenote: Had to make RID hashable, so some unrelated includes changed in order to include it in hashfuncs.h
2020-04-14 05:05:21 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(decal_atlas, texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2i(Vector2(), rtsize / 2), false, false, true);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SCENE_LUMINANCE) {
if (rb->luminance.current.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(rb->luminance.current, texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2(Vector2(), rtsize / 8), false, true);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
}
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SSAO && rb->ss_effects.ssao.ao_final.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(rb->ss_effects.ssao.ao_final, texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2(Vector2(), rtsize), false, true);
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
}
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SSIL && rb->ss_effects.ssil.ssil_final.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(rb->ss_effects.ssil.ssil_final, texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2(Vector2(), rtsize), false, false);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER && _render_buffers_get_normal_texture(p_render_buffers).is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(_render_buffers_get_normal_texture(p_render_buffers), texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2(Vector2(), rtsize), false, false);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_GI_BUFFER && rb->ambient_buffer.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
RID ambient_texture = rb->ambient_buffer;
RID reflection_texture = rb->reflection_buffer;
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(ambient_texture, texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2(Vector2(), rtsize), false, false, false, true, reflection_texture);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 18:40:24 +02:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_OCCLUDERS) {
if (p_occlusion_buffer.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
copy_effects->copy_to_fb_rect(texture_storage->texture_get_rd_texture(p_occlusion_buffer), texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2i(Vector2(), rtsize), true, false);
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 18:40:24 +02:00
}
}
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_MOTION_VECTORS && _render_buffers_get_velocity_texture(p_render_buffers).is_valid()) {
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
copy_effects->copy_to_fb_rect(_render_buffers_get_velocity_texture(p_render_buffers), texture_storage->render_target_get_rd_framebuffer(rb->render_target), Rect2(Vector2(), rtsize), false, false);
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
void RendererSceneRenderRD::environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, bool p_use_1d_color_correction, RID p_color_correction) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND(!env);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
env->adjustments_enabled = p_enable;
env->adjustments_brightness = p_brightness;
env->adjustments_contrast = p_contrast;
env->adjustments_saturation = p_saturation;
env->use_1d_color_correction = p_use_1d_color_correction;
env->color_correction = p_color_correction;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::render_buffers_get_back_buffer_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
ERR_FAIL_COND_V(!rb, RID());
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
if (!rb->blur[0].texture.is_valid()) {
return RID(); //not valid at the moment
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
return rb->blur[0].texture;
}
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
RID RendererSceneRenderRD::render_buffers_get_back_depth_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Fix read from screen and depth texture
2021-08-11 13:00:12 +02:00
ERR_FAIL_COND_V(!rb, RID());
if (!rb->depth_back_texture.is_valid()) {
return RID(); //not valid at the moment
}
return rb->depth_back_texture;
}
Fix access to render target texture for XR interfaces
2021-09-20 10:51:37 +02:00
RID RendererSceneRenderRD::render_buffers_get_depth_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Fix access to render target texture for XR interfaces
2021-09-20 10:51:37 +02:00
ERR_FAIL_COND_V(!rb, RID());
return rb->depth_texture;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::render_buffers_get_ao_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
ERR_FAIL_COND_V(!rb, RID());
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
return rb->ss_effects.ssao.ao_final;
}
RID RendererSceneRenderRD::render_buffers_get_ssil_texture(RID p_render_buffers) {
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
ERR_FAIL_COND_V(!rb, RID());
return rb->ss_effects.ssil.ssil_final;
Re-implemented screen space ambient occlusion
2020-01-25 11:18:55 +01:00
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
RID RendererSceneRenderRD::render_buffers_get_voxel_gi_buffer(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, RID());
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
if (rb->gi.voxel_gi_buffer.is_null()) {
rb->gi.voxel_gi_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(RendererSceneGIRD::VoxelGIData) * RendererSceneGIRD::MAX_VOXEL_GI_INSTANCES);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
return rb->gi.voxel_gi_buffer;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
RID RendererSceneRenderRD::render_buffers_get_default_voxel_gi_buffer() {
return gi.default_voxel_gi_buffer;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
RID RendererSceneRenderRD::render_buffers_get_gi_ambient_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
ERR_FAIL_COND_V(!rb, RID());
return rb->ambient_buffer;
}
RID RendererSceneRenderRD::render_buffers_get_gi_reflection_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
ERR_FAIL_COND_V(!rb, RID());
return rb->reflection_buffer;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_count(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
return rb->sdfgi->cascades.size();
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::render_buffers_is_sdfgi_enabled(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, false);
return rb->sdfgi != nullptr;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::render_buffers_get_sdfgi_irradiance_probes(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, RID());
ERR_FAIL_COND_V(!rb->sdfgi, RID());
return rb->sdfgi->lightprobe_texture;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
Vector3 RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_offset(RID p_render_buffers, uint32_t p_cascade) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, Vector3());
ERR_FAIL_COND_V(!rb->sdfgi, Vector3());
ERR_FAIL_UNSIGNED_INDEX_V(p_cascade, rb->sdfgi->cascades.size(), Vector3());
return Vector3((Vector3i(1, 1, 1) * -int32_t(rb->sdfgi->cascade_size >> 1) + rb->sdfgi->cascades[p_cascade].position)) * rb->sdfgi->cascades[p_cascade].cell_size;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
Vector3i RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_offset(RID p_render_buffers, uint32_t p_cascade) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, Vector3i());
ERR_FAIL_COND_V(!rb->sdfgi, Vector3i());
ERR_FAIL_UNSIGNED_INDEX_V(p_cascade, rb->sdfgi->cascades.size(), Vector3i());
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
int32_t probe_divisor = rb->sdfgi->cascade_size / RendererSceneGIRD::SDFGI::PROBE_DIVISOR;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
return rb->sdfgi->cascades[p_cascade].position / probe_divisor;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::render_buffers_get_sdfgi_normal_bias(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
return rb->sdfgi->normal_bias;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_size(RID p_render_buffers, uint32_t p_cascade) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
ERR_FAIL_UNSIGNED_INDEX_V(p_cascade, rb->sdfgi->cascades.size(), 0);
return float(rb->sdfgi->cascade_size) * rb->sdfgi->cascades[p_cascade].cell_size / float(rb->sdfgi->probe_axis_count - 1);
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_count(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
return rb->sdfgi->probe_axis_count;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_size(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
return rb->sdfgi->cascade_size;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::render_buffers_is_sdfgi_using_occlusion(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, false);
ERR_FAIL_COND_V(!rb->sdfgi, false);
return rb->sdfgi->uses_occlusion;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::render_buffers_get_sdfgi_energy(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Static analyzer fixes: Removes unused code in OS. Fixes return types. Fixes few typos.
2020-12-08 19:58:49 +01:00
ERR_FAIL_COND_V(!rb, 0.0);
ERR_FAIL_COND_V(!rb->sdfgi, 0.0);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
return rb->sdfgi->energy;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::render_buffers_get_sdfgi_occlusion_texture(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
ERR_FAIL_COND_V(!rb, RID());
ERR_FAIL_COND_V(!rb->sdfgi, RID());
return rb->sdfgi->occlusion_texture;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::render_buffers_has_volumetric_fog(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
ERR_FAIL_COND_V(!rb, false);
return rb->volumetric_fog != nullptr;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, RID());
return rb->volumetric_fog->fog_map;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_sky_uniform_set(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Add fog to sky shaders
2020-08-18 06:12:51 +02:00
ERR_FAIL_COND_V(!rb, RID());
if (!rb->volumetric_fog) {
return RID();
}
return rb->volumetric_fog->sky_uniform_set;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::render_buffers_get_volumetric_fog_end(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, 0);
return rb->volumetric_fog->length;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::render_buffers_get_volumetric_fog_detail_spread(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, 0);
return rb->volumetric_fog->spread;
}
Scale color output in the mobile renderer to provide HDR support
2021-07-26 13:31:15 +02:00
float RendererSceneRenderRD::_render_buffers_get_luminance_multiplier() {
return 1.0;
}
Use 32bit instead of 64bit 3D render buffer on mobile
2021-06-17 12:37:08 +02:00
RD::DataFormat RendererSceneRenderRD::_render_buffers_get_color_format() {
return RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
}
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
bool RendererSceneRenderRD::_render_buffers_can_be_storage() {
return true;
}
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
void RendererSceneRenderRD::render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_internal_width, int p_internal_height, int p_width, int p_height, float p_fsr_sharpness, float p_fsr_mipmap_bias, RS::ViewportMSAA p_msaa, RenderingServer::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_taa, bool p_use_debanding, uint32_t p_view_count) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Fix various typos with codespell Found via `codespell -q 3 -S ./thirdparty,*.po,./DONORS.md -L ackward,ang,ans,ba,beng,cas,childs,childrens,dof,doubleclick,fave,findn,hist,inout,leapyear,lod,nd,numer,ois,ony,paket,seeked,sinc,switchs,te,uint`
2021-07-07 17:17:32 +02:00
ERR_FAIL_COND_MSG(p_view_count == 0, "Must have at least 1 view");
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
if (!_render_buffers_can_be_storage()) {
p_internal_height = p_height;
p_internal_width = p_width;
}
if (p_width != p_internal_width) {
float fsr_mipmap_bias = -log2f(p_width / p_internal_width) + p_fsr_mipmap_bias;
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
material_storage->sampler_rd_configure_custom(fsr_mipmap_bias);
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
update_uniform_sets();
}
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Optionally scale 3D render content
2021-08-19 03:52:06 +02:00
// Should we add an overrule per viewport?
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
rb->internal_width = p_internal_width;
rb->internal_height = p_internal_height;
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
rb->width = p_width;
rb->height = p_height;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
rb->fsr_sharpness = p_fsr_sharpness;
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
rb->render_target = p_render_target;
rb->msaa = p_msaa;
Add screen space AA option, with FXAA implementation.
2020-04-12 06:49:10 +02:00
rb->screen_space_aa = p_screen_space_aa;
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
rb->use_taa = p_use_taa;
Add a debanding property to Viewport It can be enabled in the Project Settings (`rendering/quality/screen_filters/use_debanding`). It's disabled by default as it has a small performance impact and can make PNG screenshots much larger (due to how dithering works). It will also slightly brighten the scene's dark areas. As a result, it should be enabled only when banding is noticeable enough. This closes #17006.
2020-04-20 23:34:47 +02:00
rb->use_debanding = p_use_debanding;
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
rb->view_count = p_view_count;
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
if (is_clustered_enabled()) {
if (rb->cluster_builder == nullptr) {
rb->cluster_builder = memnew(ClusterBuilderRD);
}
rb->cluster_builder->set_shared(&cluster_builder_shared);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
_free_render_buffer_data(rb);
{
RD::TextureFormat tf;
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
if (rb->view_count > 1) {
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
}
Use 32bit instead of 64bit 3D render buffer on mobile
2021-06-17 12:37:08 +02:00
tf.format = _render_buffers_get_color_format();
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tf.width = rb->internal_width; // If set to rb->width, msaa won't crash
tf.height = rb->internal_height; // If set to rb->width, msaa won't crash
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
tf.array_layers = rb->view_count; // create a layer for every view
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | (_render_buffers_can_be_storage() ? RD::TEXTURE_USAGE_STORAGE_BIT : 0) | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
Implement MSAA
2020-04-12 20:33:57 +02:00
if (rb->msaa != RS::VIEWPORT_MSAA_DISABLED) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
Implement MSAA
2020-04-12 20:33:57 +02:00
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
tf.usage_bits |= RD::TEXTURE_USAGE_INPUT_ATTACHMENT_BIT; // only needed when using subpasses in the mobile renderer
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
rb->internal_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
if ((p_internal_width != p_width || p_internal_height != p_height)) {
tf.width = rb->width;
tf.height = rb->height;
rb->texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
rb->upscale_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
} else {
rb->texture = rb->internal_texture;
rb->upscale_texture = rb->internal_texture;
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
{
RD::TextureFormat tf;
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
if (rb->view_count > 1) {
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
if (rb->msaa == RS::VIEWPORT_MSAA_DISABLED) {
tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D24_UNORM_S8_UINT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D24_UNORM_S8_UINT : RD::DATA_FORMAT_D32_SFLOAT_S8_UINT;
} else {
tf.format = RD::DATA_FORMAT_R32_SFLOAT;
}
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 22:16:03 +01:00
tf.width = rb->internal_width;
tf.height = rb->internal_height;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
tf.array_layers = rb->view_count; // create a layer for every view
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Implement MSAA
2020-04-12 20:33:57 +02:00
if (rb->msaa != RS::VIEWPORT_MSAA_DISABLED) {
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
} else {
tf.usage_bits |= RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
Implement MSAA
2020-04-12 20:33:57 +02:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
rb->depth_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
}
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
{
if (!_render_buffers_can_be_storage()) {
// ONLY USED ON MOBILE RENDERER, ONLY USED FOR POST EFFECTS!
Vector<RID> fb;
fb.push_back(rb->internal_texture);
rb->texture_fb = RD::get_singleton()->framebuffer_create(fb, RenderingDevice::INVALID_ID, rb->view_count);
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
rb->views.clear(); // JIC
if (rb->view_count == 1) {
// copy as a convenience
RenderBuffers::View view;
view.view_texture = rb->internal_texture;
view.view_depth = rb->depth_texture;
view.view_fb = rb->texture_fb;
rb->views.push_back(view);
} else {
for (uint32_t i = 0; i < rb->view_count; i++) {
RenderBuffers::View view;
view.view_texture = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->internal_texture, i, 0);
view.view_depth = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->depth_texture, i, 0);
if (!_render_buffers_can_be_storage()) {
Vector<RID> fb;
fb.push_back(view.view_texture);
view.view_fb = RD::get_singleton()->framebuffer_create(fb, RenderingDevice::INVALID_ID, 1);
}
rb->views.push_back(view);
}
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 13:40:16 +02:00
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RID target_texture = texture_storage->render_target_get_rd_texture(rb->render_target);
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
rb->data->configure(rb->internal_texture, rb->depth_texture, target_texture, p_internal_width, p_internal_height, p_msaa, p_use_taa, p_view_count);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
if (is_clustered_enabled()) {
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
rb->cluster_builder->setup(Size2i(p_internal_width, p_internal_height), max_cluster_elements, rb->depth_texture, RendererRD::MaterialStorage::get_singleton()->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED), rb->internal_texture);
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
}
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
void RendererSceneRenderRD::gi_set_use_half_resolution(bool p_enable) {
gi.half_resolution = p_enable;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::sub_surface_scattering_set_quality(RS::SubSurfaceScatteringQuality p_quality) {
Re-implement subsurface scattering. The size settings are more "just works", with default scale and depth scale values that don't need much tweaking. Additionally, a "skin" mode was added so skin looks better. EDIT: Cleaned up SSR filter shader a bit.
2020-04-04 04:42:26 +02:00
sss_quality = p_quality;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RS::SubSurfaceScatteringQuality RendererSceneRenderRD::sub_surface_scattering_get_quality() const {
Re-implement subsurface scattering. The size settings are more "just works", with default scale and depth scale values that don't need much tweaking. Additionally, a "skin" mode was added so skin looks better. EDIT: Cleaned up SSR filter shader a bit.
2020-04-04 04:42:26 +02:00
return sss_quality;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::sub_surface_scattering_set_scale(float p_scale, float p_depth_scale) {
Re-implement subsurface scattering. The size settings are more "just works", with default scale and depth scale values that don't need much tweaking. Additionally, a "skin" mode was added so skin looks better. EDIT: Cleaned up SSR filter shader a bit.
2020-04-04 04:42:26 +02:00
sss_scale = p_scale;
sss_depth_scale = p_depth_scale;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::shadows_quality_set(RS::ShadowQuality p_quality) {
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
if (shadows_quality != p_quality) {
shadows_quality = p_quality;
switch (shadows_quality) {
case RS::SHADOW_QUALITY_HARD: {
penumbra_shadow_samples = 4;
Add Soft Very Low shadow quality mode for 3D This can be used to improve 3D shadow rendering quality at little performance cost. Unlike the existing Hard setting which is limited to variable shadow blur only, it works with both fixed blur and variable blur.
2021-10-19 16:52:57 +02:00
soft_shadow_samples = 0;
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
shadows_quality_radius = 1.0;
} break;
Add Soft Very Low shadow quality mode for 3D This can be used to improve 3D shadow rendering quality at little performance cost. Unlike the existing Hard setting which is limited to variable shadow blur only, it works with both fixed blur and variable blur.
2021-10-19 16:52:57 +02:00
case RS::SHADOW_QUALITY_SOFT_VERY_LOW: {
penumbra_shadow_samples = 4;
soft_shadow_samples = 1;
shadows_quality_radius = 1.5;
} break;
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
case RS::SHADOW_QUALITY_SOFT_LOW: {
penumbra_shadow_samples = 8;
soft_shadow_samples = 4;
shadows_quality_radius = 2.0;
} break;
case RS::SHADOW_QUALITY_SOFT_MEDIUM: {
penumbra_shadow_samples = 12;
soft_shadow_samples = 8;
shadows_quality_radius = 2.0;
} break;
case RS::SHADOW_QUALITY_SOFT_HIGH: {
penumbra_shadow_samples = 24;
soft_shadow_samples = 16;
shadows_quality_radius = 3.0;
} break;
case RS::SHADOW_QUALITY_SOFT_ULTRA: {
penumbra_shadow_samples = 32;
soft_shadow_samples = 32;
shadows_quality_radius = 4.0;
} break;
case RS::SHADOW_QUALITY_MAX:
break;
}
get_vogel_disk(penumbra_shadow_kernel, penumbra_shadow_samples);
get_vogel_disk(soft_shadow_kernel, soft_shadow_samples);
}
Implement more rendering options as specialization constants * Shadow quality settings now specialization constant. * Decal and light projector filters can be set. * Changing those settings forces re-creation of the pipelines. These changes should help improve performance related to shadow mapping, and allows improving performance by sacrificing decal and light projector quality.
2021-07-19 21:41:55 +02:00
_update_shader_quality_settings();
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::directional_shadow_quality_set(RS::ShadowQuality p_quality) {
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
if (directional_shadow_quality != p_quality) {
directional_shadow_quality = p_quality;
switch (directional_shadow_quality) {
case RS::SHADOW_QUALITY_HARD: {
directional_penumbra_shadow_samples = 4;
Add Soft Very Low shadow quality mode for 3D This can be used to improve 3D shadow rendering quality at little performance cost. Unlike the existing Hard setting which is limited to variable shadow blur only, it works with both fixed blur and variable blur.
2021-10-19 16:52:57 +02:00
directional_soft_shadow_samples = 0;
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
directional_shadow_quality_radius = 1.0;
} break;
Add Soft Very Low shadow quality mode for 3D This can be used to improve 3D shadow rendering quality at little performance cost. Unlike the existing Hard setting which is limited to variable shadow blur only, it works with both fixed blur and variable blur.
2021-10-19 16:52:57 +02:00
case RS::SHADOW_QUALITY_SOFT_VERY_LOW: {
directional_penumbra_shadow_samples = 4;
directional_soft_shadow_samples = 1;
directional_shadow_quality_radius = 1.5;
} break;
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
case RS::SHADOW_QUALITY_SOFT_LOW: {
directional_penumbra_shadow_samples = 8;
directional_soft_shadow_samples = 4;
directional_shadow_quality_radius = 2.0;
} break;
case RS::SHADOW_QUALITY_SOFT_MEDIUM: {
directional_penumbra_shadow_samples = 12;
directional_soft_shadow_samples = 8;
directional_shadow_quality_radius = 2.0;
} break;
case RS::SHADOW_QUALITY_SOFT_HIGH: {
directional_penumbra_shadow_samples = 24;
directional_soft_shadow_samples = 16;
directional_shadow_quality_radius = 3.0;
} break;
case RS::SHADOW_QUALITY_SOFT_ULTRA: {
directional_penumbra_shadow_samples = 32;
directional_soft_shadow_samples = 32;
directional_shadow_quality_radius = 4.0;
} break;
case RS::SHADOW_QUALITY_MAX:
break;
}
get_vogel_disk(directional_penumbra_shadow_kernel, directional_penumbra_shadow_samples);
get_vogel_disk(directional_soft_shadow_kernel, directional_soft_shadow_samples);
}
Implement more rendering options as specialization constants * Shadow quality settings now specialization constant. * Decal and light projector filters can be set. * Changing those settings forces re-creation of the pipelines. These changes should help improve performance related to shadow mapping, and allows improving performance by sacrificing decal and light projector quality.
2021-07-19 21:41:55 +02:00
_update_shader_quality_settings();
}
void RendererSceneRenderRD::decals_set_filter(RenderingServer::DecalFilter p_filter) {
if (decals_filter == p_filter) {
return;
}
decals_filter = p_filter;
_update_shader_quality_settings();
}
void RendererSceneRenderRD::light_projectors_set_filter(RenderingServer::LightProjectorFilter p_filter) {
if (light_projectors_filter == p_filter) {
return;
}
light_projectors_filter = p_filter;
_update_shader_quality_settings();
Refactored shadowmapping. - Made shadow bias size independent, so it will remain when changing light or camera size. - Implemented normal offset bias, which greatly enhances quality. - Added transmission to subsurface scattering - Reimplemented shadow filter modes Closes #17260
2020-04-08 03:51:52 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
int RendererSceneRenderRD::get_roughness_layers() const {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
return sky.roughness_layers;
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::is_using_radiance_cubemap_array() const {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
return sky.sky_use_cubemap_array;
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererSceneRenderRD::RenderBufferData *RendererSceneRenderRD::render_buffers_get_data(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Replace NULL with nullptr
2020-04-02 01:20:12 +02:00
ERR_FAIL_COND_V(!rb, nullptr);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
return rb->data;
}
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::_setup_reflections(const PagedArray<RID> &p_reflections, const Transform3D &p_camera_inverse_transform, RID p_environment) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.reflection_count = 0;
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
for (uint32_t i = 0; i < (uint32_t)p_reflections.size(); i++) {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.reflection_count == cluster.max_reflections) {
break;
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_reflections[i]);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (!rpi) {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
continue;
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.reflection_sort[cluster.reflection_count].instance = rpi;
cluster.reflection_sort[cluster.reflection_count].depth = -p_camera_inverse_transform.xform(rpi->transform.origin).z;
cluster.reflection_count++;
}
if (cluster.reflection_count > 0) {
SortArray<Cluster::InstanceSort<ReflectionProbeInstance>> sort_array;
sort_array.sort(cluster.reflection_sort, cluster.reflection_count);
}
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
bool using_forward_ids = _uses_forward_ids();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
for (uint32_t i = 0; i < cluster.reflection_count; i++) {
ReflectionProbeInstance *rpi = cluster.reflection_sort[i].instance;
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
if (using_forward_ids) {
_map_forward_id(FORWARD_ID_TYPE_REFLECTION_PROBE, rpi->forward_id, i);
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RID base_probe = rpi->probe;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Cluster::ReflectionData &reflection_ubo = cluster.reflections[i];
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
Vector3 extents = light_storage->reflection_probe_get_extents(base_probe);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
rpi->cull_mask = light_storage->reflection_probe_get_cull_mask(base_probe);
Create mobile renderer
2021-03-10 12:23:55 +01:00
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
reflection_ubo.box_extents[0] = extents.x;
reflection_ubo.box_extents[1] = extents.y;
reflection_ubo.box_extents[2] = extents.z;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
reflection_ubo.index = rpi->atlas_index;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
Vector3 origin_offset = light_storage->reflection_probe_get_origin_offset(base_probe);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
reflection_ubo.box_offset[0] = origin_offset.x;
reflection_ubo.box_offset[1] = origin_offset.y;
reflection_ubo.box_offset[2] = origin_offset.z;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
reflection_ubo.mask = light_storage->reflection_probe_get_cull_mask(base_probe);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
reflection_ubo.intensity = light_storage->reflection_probe_get_intensity(base_probe);
reflection_ubo.ambient_mode = light_storage->reflection_probe_get_ambient_mode(base_probe);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
reflection_ubo.exterior = !light_storage->reflection_probe_is_interior(base_probe);
reflection_ubo.box_project = light_storage->reflection_probe_is_box_projection(base_probe);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
Color ambient_linear = light_storage->reflection_probe_get_ambient_color(base_probe).srgb_to_linear();
float interior_ambient_energy = light_storage->reflection_probe_get_ambient_color_energy(base_probe);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
reflection_ubo.ambient[0] = ambient_linear.r * interior_ambient_energy;
reflection_ubo.ambient[1] = ambient_linear.g * interior_ambient_energy;
reflection_ubo.ambient[2] = ambient_linear.b * interior_ambient_energy;
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D transform = rpi->transform;
Transform3D proj = (p_camera_inverse_transform * transform).inverse();
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererStorageRD::store_transform(proj, reflection_ubo.local_matrix);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Create mobile renderer
2021-03-10 12:23:55 +01:00
if (current_cluster_builder != nullptr) {
current_cluster_builder->add_box(ClusterBuilderRD::BOX_TYPE_REFLECTION_PROBE, transform, extents);
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
rpi->last_pass = RSG::rasterizer->get_frame_number();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.reflection_count) {
Fix reflection probe
2021-04-20 15:59:46 +02:00
RD::get_singleton()->buffer_update(cluster.reflection_buffer, 0, cluster.reflection_count * sizeof(Cluster::ReflectionData), cluster.reflections, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
}
Use specialization constants in clustered renderer * Keep track of when projector, softshadow or directional sofshadow were enabled. * Enable them via specializaton constant where it makes sense. * Re-implements soft shadows. * Re-implements light projectors.
2021-07-13 01:32:05 +02:00
void RendererSceneRenderRD::_setup_lights(const PagedArray<RID> &p_lights, const Transform3D &p_camera_transform, RID p_shadow_atlas, bool p_using_shadows, uint32_t &r_directional_light_count, uint32_t &r_positional_light_count, bool &r_directional_light_soft_shadows) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
Extract Decal and Decal atlas from Storage class
2022-03-20 12:28:24 +01:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D inverse_transform = p_camera_transform.affine_inverse();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
r_directional_light_count = 0;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
r_positional_light_count = 0;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 14:50:35 +02:00
Plane camera_plane(-p_camera_transform.basis.get_column(Vector3::AXIS_Z).normalized(), p_camera_transform.origin);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.omni_light_count = 0;
cluster.spot_light_count = 0;
Use specialization constants in clustered renderer * Keep track of when projector, softshadow or directional sofshadow were enabled. * Enable them via specializaton constant where it makes sense. * Re-implements soft shadows. * Re-implements light projectors.
2021-07-13 01:32:05 +02:00
r_directional_light_soft_shadows = false;
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
for (int i = 0; i < (int)p_lights.size(); i++) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *li = light_instance_owner.get_or_null(p_lights[i]);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (!li) {
continue;
}
RID base = li->light;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
ERR_CONTINUE(base.is_null());
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
RS::LightType type = light_storage->light_get_type(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
switch (type) {
case RS::LIGHT_DIRECTIONAL: {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (r_directional_light_count >= cluster.max_directional_lights || light_storage->light_directional_get_sky_mode(base) == RS::LIGHT_DIRECTIONAL_SKY_MODE_SKY_ONLY) {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
continue;
}
Cluster::DirectionalLightData &light_data = cluster.directional_lights[r_directional_light_count];
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D light_transform = li->transform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Vector3 direction = inverse_transform.basis.xform(light_transform.basis.xform(Vector3(0, 0, 1))).normalized();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
light_data.direction[0] = direction.x;
light_data.direction[1] = direction.y;
light_data.direction[2] = direction.z;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float sign = light_storage->light_is_negative(base) ? -1 : 1;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.energy = sign * light_storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY) * Math_PI;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
Color linear_col = light_storage->light_get_color(base).srgb_to_linear();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
light_data.color[0] = linear_col.r;
light_data.color[1] = linear_col.g;
light_data.color[2] = linear_col.b;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.specular = light_storage->light_get_param(base, RS::LIGHT_PARAM_SPECULAR);
light_data.mask = light_storage->light_get_cull_mask(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float size = light_storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
light_data.size = 1.0 - Math::cos(Math::deg2rad(size)); //angle to cosine offset
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_PSSM_SPLITS) {
Remove unused `shadow_color` property from Light3D This shadow color property was no longer effective since the shaders were optimized to improve occupancy.
2021-06-08 23:20:09 +02:00
WARN_PRINT_ONCE("The DirectionalLight3D PSSM splits debug draw mode is not reimplemented yet.");
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.shadow_enabled = p_using_shadows && light_storage->light_has_shadow(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float angular_diameter = light_storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
if (angular_diameter > 0.0) {
// I know tan(0) is 0, but let's not risk it with numerical precision.
// technically this will keep expanding until reaching the sun, but all we care
// is expand until we reach the radius of the near plane (there can't be more occluders than that)
angular_diameter = Math::tan(Math::deg2rad(angular_diameter));
Tweak Light3D property hints for greater flexibility - Specular can now be set above 1.0. - Blur can be set to 0 to disable shadow blurring entirely, which is useful on lights that have a non-zero size. - When shadow blurring is disabled, lights that have a non-zero size will not use PCSS-like soft shadows, speeding up shadow rendering considerably. - Some property hints now allow more precise values.
2021-07-16 03:33:10 +02:00
if (light_storage->light_has_shadow(base) && light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BLUR) > 0.0) {
// Only enable PCSS-like soft shadows if blurring is enabled.
// Otherwise, performance would decrease with no visual difference.
Update Sky lights in sky setup function
2022-01-24 00:06:49 +01:00
r_directional_light_soft_shadows = true;
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
} else {
angular_diameter = 0.0;
}
if (light_data.shadow_enabled) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
RS::LightDirectionalShadowMode smode = light_storage->light_directional_get_shadow_mode(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
int limit = smode == RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL ? 0 : (smode == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS ? 1 : 3);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.blend_splits = (smode != RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL) && light_storage->light_directional_get_blend_splits(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
for (int j = 0; j < 4; j++) {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Rect2 atlas_rect = li->shadow_transform[j].atlas_rect;
CameraMatrix matrix = li->shadow_transform[j].camera;
float split = li->shadow_transform[MIN(limit, j)].split;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
CameraMatrix bias;
bias.set_light_bias();
CameraMatrix rectm;
rectm.set_light_atlas_rect(atlas_rect);
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D modelview = (inverse_transform * li->shadow_transform[j].transform).inverse();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
CameraMatrix shadow_mtx = rectm * bias * matrix * modelview;
light_data.shadow_split_offsets[j] = split;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
float bias_scale = li->shadow_transform[j].bias_scale;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.shadow_bias[j] = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) / 100.0 * bias_scale;
light_data.shadow_normal_bias[j] = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * li->shadow_transform[j].shadow_texel_size;
light_data.shadow_transmittance_bias[j] = light_storage->light_get_transmittance_bias(base) * bias_scale;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.shadow_z_range[j] = li->shadow_transform[j].farplane;
light_data.shadow_range_begin[j] = li->shadow_transform[j].range_begin;
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererStorageRD::store_camera(shadow_mtx, light_data.shadow_matrices[j]);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Vector2 uv_scale = li->shadow_transform[j].uv_scale;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
uv_scale *= atlas_rect.size; //adapt to atlas size
switch (j) {
case 0: {
light_data.uv_scale1[0] = uv_scale.x;
light_data.uv_scale1[1] = uv_scale.y;
} break;
case 1: {
light_data.uv_scale2[0] = uv_scale.x;
light_data.uv_scale2[1] = uv_scale.y;
} break;
case 2: {
light_data.uv_scale3[0] = uv_scale.x;
light_data.uv_scale3[1] = uv_scale.y;
} break;
case 3: {
light_data.uv_scale4[0] = uv_scale.x;
light_data.uv_scale4[1] = uv_scale.y;
} break;
}
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float fade_start = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_FADE_START);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
light_data.fade_from = -light_data.shadow_split_offsets[3] * MIN(fade_start, 0.999); //using 1.0 would break smoothstep
light_data.fade_to = -light_data.shadow_split_offsets[3];
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.shadow_volumetric_fog_fade = 1.0 / light_storage->light_get_shadow_volumetric_fog_fade(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.soft_shadow_scale = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BLUR);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
light_data.softshadow_angle = angular_diameter;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.bake_mode = light_storage->light_get_bake_mode(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
if (angular_diameter <= 0.0) {
light_data.soft_shadow_scale *= directional_shadow_quality_radius_get(); // Only use quality radius for PCF
}
}
r_directional_light_count++;
} break;
case RS::LIGHT_OMNI: {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.omni_light_count >= cluster.max_lights) {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
continue;
}
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
const real_t distance = camera_plane.distance_to(li->transform.origin);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (light_storage->light_is_distance_fade_enabled(li->light)) {
const float fade_begin = light_storage->light_get_distance_fade_begin(li->light);
const float fade_length = light_storage->light_get_distance_fade_length(li->light);
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
if (distance > fade_begin) {
if (distance > fade_begin + fade_length) {
// Out of range, don't draw this light to improve performance.
continue;
}
}
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.omni_light_sort[cluster.omni_light_count].instance = li;
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
cluster.omni_light_sort[cluster.omni_light_count].depth = distance;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.omni_light_count++;
} break;
case RS::LIGHT_SPOT: {
if (cluster.spot_light_count >= cluster.max_lights) {
continue;
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
const real_t distance = camera_plane.distance_to(li->transform.origin);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (light_storage->light_is_distance_fade_enabled(li->light)) {
const float fade_begin = light_storage->light_get_distance_fade_begin(li->light);
const float fade_length = light_storage->light_get_distance_fade_length(li->light);
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
if (distance > fade_begin) {
if (distance > fade_begin + fade_length) {
// Out of range, don't draw this light to improve performance.
continue;
}
}
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.spot_light_sort[cluster.spot_light_count].instance = li;
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
cluster.spot_light_sort[cluster.spot_light_count].depth = distance;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.spot_light_count++;
} break;
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
li->last_pass = RSG::rasterizer->get_frame_number();
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.omni_light_count) {
SortArray<Cluster::InstanceSort<LightInstance>> sorter;
sorter.sort(cluster.omni_light_sort, cluster.omni_light_count);
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.spot_light_count) {
SortArray<Cluster::InstanceSort<LightInstance>> sorter;
sorter.sort(cluster.spot_light_sort, cluster.spot_light_count);
}
Shader optimizations to reduce VGPR usage and increase occupancy
2021-01-08 17:03:09 +01:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
ShadowAtlas *shadow_atlas = nullptr;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (p_shadow_atlas.is_valid() && p_using_shadows) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
bool using_forward_ids = _uses_forward_ids();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
for (uint32_t i = 0; i < (cluster.omni_light_count + cluster.spot_light_count); i++) {
uint32_t index = (i < cluster.omni_light_count) ? i : i - (cluster.omni_light_count);
Cluster::LightData &light_data = (i < cluster.omni_light_count) ? cluster.omni_lights[index] : cluster.spot_lights[index];
RS::LightType type = (i < cluster.omni_light_count) ? RS::LIGHT_OMNI : RS::LIGHT_SPOT;
LightInstance *li = (i < cluster.omni_light_count) ? cluster.omni_light_sort[index].instance : cluster.spot_light_sort[index].instance;
RID base = li->light;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
if (using_forward_ids) {
_map_forward_id(type == RS::LIGHT_OMNI ? FORWARD_ID_TYPE_OMNI_LIGHT : FORWARD_ID_TYPE_SPOT_LIGHT, li->forward_id, index);
}
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D light_transform = li->transform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float sign = light_storage->light_is_negative(base) ? -1 : 1;
Color linear_col = light_storage->light_get_color(base).srgb_to_linear();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.attenuation = light_storage->light_get_param(base, RS::LIGHT_PARAM_ATTENUATION);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
// Reuse fade begin, fade length and distance for shadow LOD determination later.
float fade_begin = 0.0;
float fade_length = 0.0;
real_t distance = 0.0;
float fade = 1.0;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (light_storage->light_is_distance_fade_enabled(li->light)) {
fade_begin = light_storage->light_get_distance_fade_begin(li->light);
fade_length = light_storage->light_get_distance_fade_length(li->light);
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
distance = camera_plane.distance_to(li->transform.origin);
if (distance > fade_begin) {
// Use `smoothstep()` to make opacity changes more gradual and less noticeable to the player.
fade = Math::smoothstep(0.0f, 1.0f, 1.0f - float(distance - fade_begin) / fade_length);
}
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float energy = sign * light_storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY) * Math_PI * fade;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.color[0] = linear_col.r * energy;
light_data.color[1] = linear_col.g * energy;
light_data.color[2] = linear_col.b * energy;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.specular_amount = light_storage->light_get_param(base, RS::LIGHT_PARAM_SPECULAR) * 2.0;
light_data.bake_mode = light_storage->light_get_bake_mode(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float radius = MAX(0.001, light_storage->light_get_param(base, RS::LIGHT_PARAM_RANGE));
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.inv_radius = 1.0 / radius;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Vector3 pos = inverse_transform.xform(light_transform.origin);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.position[0] = pos.x;
light_data.position[1] = pos.y;
light_data.position[2] = pos.z;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Vector3 direction = inverse_transform.basis.xform(light_transform.basis.xform(Vector3(0, 0, -1))).normalized();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.direction[0] = direction.x;
light_data.direction[1] = direction.y;
light_data.direction[2] = direction.z;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
float size = light_storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.size = size;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.inv_spot_attenuation = 1.0f / light_storage->light_get_param(base, RS::LIGHT_PARAM_SPOT_ATTENUATION);
float spot_angle = light_storage->light_get_param(base, RS::LIGHT_PARAM_SPOT_ANGLE);
Invert spotlight angle attenuation Inverted the spotlight angle attenuation so a higher value results in a dimmer light, this makes it more consistent with the distance attenuation. Also changed the way spotlighs are computed in SDFGI and GIPorbes and GPU lightmapper, now it matches the falloff used in the scene rendering code.
2021-02-06 21:39:08 +01:00
light_data.cos_spot_angle = Math::cos(Math::deg2rad(spot_angle));
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.mask = light_storage->light_get_cull_mask(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.atlas_rect[0] = 0;
light_data.atlas_rect[1] = 0;
light_data.atlas_rect[2] = 0;
light_data.atlas_rect[3] = 0;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
RID projector = light_storage->light_get_projector(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (projector.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Rect2 rect = texture_storage->decal_atlas_get_texture_rect(projector);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (type == RS::LIGHT_SPOT) {
light_data.projector_rect[0] = rect.position.x;
light_data.projector_rect[1] = rect.position.y + rect.size.height; //flip because shadow is flipped
light_data.projector_rect[2] = rect.size.width;
light_data.projector_rect[3] = -rect.size.height;
} else {
light_data.projector_rect[0] = rect.position.x;
light_data.projector_rect[1] = rect.position.y;
light_data.projector_rect[2] = rect.size.width;
light_data.projector_rect[3] = rect.size.height * 0.5; //used by dp, so needs to be half
}
} else {
light_data.projector_rect[0] = 0;
light_data.projector_rect[1] = 0;
light_data.projector_rect[2] = 0;
light_data.projector_rect[3] = 0;
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
const bool needs_shadow = shadow_atlas && shadow_atlas->shadow_owners.has(li->self);
bool in_shadow_range = true;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (needs_shadow && light_storage->light_is_distance_fade_enabled(li->light)) {
if (distance > light_storage->light_get_distance_fade_shadow(li->light)) {
Implement distance fade properties in OmniLight3D and SpotLight3D This can be used to fade lights and their shadows in the distance, similar to Decal nodes. This can bring significant performance improvements, especially for lights with shadows enabled and when using higher-than-default shadow quality settings. While lights can be smoothly faded out over distance, shadows are currently "all or nothing" since per-light shadow color is no longer customizable in the Vulkan renderer. This may result in noticeable pop-in when leaving the shadow cutoff distance, but depending on the scene, it may not always be that noticeable.
2022-02-24 22:55:14 +01:00
// Out of range, don't draw shadows to improve performance.
in_shadow_range = false;
}
}
if (needs_shadow && in_shadow_range) {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
// fill in the shadow information
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.shadow_enabled = true;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
float shadow_texel_size = light_instance_get_shadow_texel_size(li->self, p_shadow_atlas);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.shadow_normal_bias = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS) * shadow_texel_size * 10.0;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
if (type == RS::LIGHT_SPOT) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.shadow_bias = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS) / 100.0;
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
} else { //omni
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.shadow_bias = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BIAS);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.transmittance_bias = light_storage->light_get_transmittance_bias(base);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
Vector2i omni_offset;
Rect2 rect = light_instance_get_shadow_atlas_rect(li->self, p_shadow_atlas, omni_offset);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.atlas_rect[0] = rect.position.x;
light_data.atlas_rect[1] = rect.position.y;
light_data.atlas_rect[2] = rect.size.width;
light_data.atlas_rect[3] = rect.size.height;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
light_data.soft_shadow_scale = light_storage->light_get_param(base, RS::LIGHT_PARAM_SHADOW_BLUR);
light_data.shadow_volumetric_fog_fade = 1.0 / light_storage->light_get_shadow_volumetric_fog_fade(base);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (type == RS::LIGHT_OMNI) {
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D proj = (inverse_transform * light_transform).inverse();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RendererStorageRD::store_transform(proj, light_data.shadow_matrix);
Tweak Light3D property hints for greater flexibility - Specular can now be set above 1.0. - Blur can be set to 0 to disable shadow blurring entirely, which is useful on lights that have a non-zero size. - When shadow blurring is disabled, lights that have a non-zero size will not use PCSS-like soft shadows, speeding up shadow rendering considerably. - Some property hints now allow more precise values.
2021-07-16 03:33:10 +02:00
if (size > 0.0 && light_data.soft_shadow_scale > 0.0) {
// Only enable PCSS-like soft shadows if blurring is enabled.
// Otherwise, performance would decrease with no visual difference.
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.soft_shadow_size = size;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
} else {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
light_data.soft_shadow_size = 0.0;
light_data.soft_shadow_scale *= shadows_quality_radius_get(); // Only use quality radius for PCF
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
light_data.direction[0] = omni_offset.x * float(rect.size.width);
light_data.direction[1] = omni_offset.y * float(rect.size.height);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
} else if (type == RS::LIGHT_SPOT) {
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D modelview = (inverse_transform * light_transform).inverse();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
CameraMatrix bias;
bias.set_light_bias();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
CameraMatrix shadow_mtx = bias * li->shadow_transform[0].camera * modelview;
RendererStorageRD::store_camera(shadow_mtx, light_data.shadow_matrix);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Tweak Light3D property hints for greater flexibility - Specular can now be set above 1.0. - Blur can be set to 0 to disable shadow blurring entirely, which is useful on lights that have a non-zero size. - When shadow blurring is disabled, lights that have a non-zero size will not use PCSS-like soft shadows, speeding up shadow rendering considerably. - Some property hints now allow more precise values.
2021-07-16 03:33:10 +02:00
if (size > 0.0 && light_data.soft_shadow_scale > 0.0) {
// Only enable PCSS-like soft shadows if blurring is enabled.
// Otherwise, performance would decrease with no visual difference.
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
CameraMatrix cm = li->shadow_transform[0].camera;
float half_np = cm.get_z_near() * Math::tan(Math::deg2rad(spot_angle));
light_data.soft_shadow_size = (size * 0.5 / radius) / (half_np / cm.get_z_near()) * rect.size.width;
} else {
light_data.soft_shadow_size = 0.0;
light_data.soft_shadow_scale *= shadows_quality_radius_get(); // Only use quality radius for PCF
}
}
} else {
light_data.shadow_enabled = false;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
li->cull_mask = light_storage->light_get_cull_mask(base);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Create mobile renderer
2021-03-10 12:23:55 +01:00
if (current_cluster_builder != nullptr) {
current_cluster_builder->add_light(type == RS::LIGHT_SPOT ? ClusterBuilderRD::LIGHT_TYPE_SPOT : ClusterBuilderRD::LIGHT_TYPE_OMNI, light_transform, radius, spot_angle);
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
r_positional_light_count++;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
//update without barriers
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.omni_light_count) {
Fixes to get Godot running again on Intel IGP -Fixed strange bug with shadowed instance_param (this should not have worked anywhere, odd..) -Cleaned up barrier usage further.
2021-02-05 04:02:06 +01:00
RD::get_singleton()->buffer_update(cluster.omni_light_buffer, 0, sizeof(Cluster::LightData) * cluster.omni_light_count, cluster.omni_lights, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
if (cluster.spot_light_count) {
Fixes to get Godot running again on Intel IGP -Fixed strange bug with shadowed instance_param (this should not have worked anywhere, odd..) -Cleaned up barrier usage further.
2021-02-05 04:02:06 +01:00
RD::get_singleton()->buffer_update(cluster.spot_light_buffer, 0, sizeof(Cluster::LightData) * cluster.spot_light_count, cluster.spot_lights, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
if (r_directional_light_count) {
Fixes to get Godot running again on Intel IGP -Fixed strange bug with shadowed instance_param (this should not have worked anywhere, odd..) -Cleaned up barrier usage further.
2021-02-05 04:02:06 +01:00
RD::get_singleton()->buffer_update(cluster.directional_light_buffer, 0, sizeof(Cluster::DirectionalLightData) * r_directional_light_count, cluster.directional_lights, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
}
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::_setup_decals(const PagedArray<RID> &p_decals, const Transform3D &p_camera_inverse_xform) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Extract Decal and Decal atlas from Storage class
2022-03-20 12:28:24 +01:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D uv_xform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
uv_xform.basis.scale(Vector3(2.0, 1.0, 2.0));
uv_xform.origin = Vector3(-1.0, 0.0, -1.0);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
uint32_t decal_count = p_decals.size();
cluster.decal_count = 0;
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
for (uint32_t i = 0; i < decal_count; i++) {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.decal_count == cluster.max_decals) {
break;
}
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
DecalInstance *di = decal_instance_owner.get_or_null(p_decals[i]);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (!di) {
continue;
}
RID decal = di->decal;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D xform = di->transform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
real_t distance = -p_camera_inverse_xform.xform(xform.origin).z;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
if (texture_storage->decal_is_distance_fade_enabled(decal)) {
float fade_begin = texture_storage->decal_get_distance_fade_begin(decal);
float fade_length = texture_storage->decal_get_distance_fade_length(decal);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
if (distance > fade_begin) {
if (distance > fade_begin + fade_length) {
continue; // do not use this decal, its invisible
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.decal_sort[cluster.decal_count].instance = di;
cluster.decal_sort[cluster.decal_count].depth = distance;
cluster.decal_count++;
}
if (cluster.decal_count > 0) {
SortArray<Cluster::InstanceSort<DecalInstance>> sort_array;
sort_array.sort(cluster.decal_sort, cluster.decal_count);
}
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
bool using_forward_ids = _uses_forward_ids();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
for (uint32_t i = 0; i < cluster.decal_count; i++) {
DecalInstance *di = cluster.decal_sort[i].instance;
RID decal = di->decal;
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
if (using_forward_ids) {
_map_forward_id(FORWARD_ID_TYPE_DECAL, di->forward_id, i);
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
di->cull_mask = texture_storage->decal_get_cull_mask(decal);
Create mobile renderer
2021-03-10 12:23:55 +01:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D xform = di->transform;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
float fade = 1.0;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
if (texture_storage->decal_is_distance_fade_enabled(decal)) {
Make Decal distance fade smoother `smoothstep()` avoids the sudden transparency jump when entering or leaving a decal's distance fade margin distance. This in turn helps make opacity transitions less noticeable to the player, as it's less likely to catch the player's eye.
2022-02-18 22:36:03 +01:00
const real_t distance = -p_camera_inverse_xform.xform(xform.origin).z;
const float fade_begin = texture_storage->decal_get_distance_fade_begin(decal);
const float fade_length = texture_storage->decal_get_distance_fade_length(decal);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (distance > fade_begin) {
Make Decal distance fade smoother `smoothstep()` avoids the sudden transparency jump when entering or leaving a decal's distance fade margin distance. This in turn helps make opacity transitions less noticeable to the player, as it's less likely to catch the player's eye.
2022-02-18 22:36:03 +01:00
// Use `smoothstep()` to make opacity changes more gradual and less noticeable to the player.
fade = Math::smoothstep(0.0f, 1.0f, 1.0f - float(distance - fade_begin) / fade_length);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Cluster::DecalData &dd = cluster.decals[i];
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Vector3 decal_extents = texture_storage->decal_get_extents(decal);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D scale_xform;
Construct values only when necessary.
2021-09-23 16:58:43 +02:00
scale_xform.basis.scale(decal_extents);
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D to_decal_xform = (p_camera_inverse_xform * di->transform * scale_xform * uv_xform).affine_inverse();
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererStorageRD::store_transform(to_decal_xform, dd.xform);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 14:50:35 +02:00
Vector3 normal = xform.basis.get_column(Vector3::AXIS_Y).normalized();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
normal = p_camera_inverse_xform.basis.xform(normal); //camera is normalized, so fine
dd.normal[0] = normal.x;
dd.normal[1] = normal.y;
dd.normal[2] = normal.z;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
dd.normal_fade = texture_storage->decal_get_normal_fade(decal);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RID albedo_tex = texture_storage->decal_get_texture(decal, RS::DECAL_TEXTURE_ALBEDO);
RID emission_tex = texture_storage->decal_get_texture(decal, RS::DECAL_TEXTURE_EMISSION);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
if (albedo_tex.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Rect2 rect = texture_storage->decal_atlas_get_texture_rect(albedo_tex);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
dd.albedo_rect[0] = rect.position.x;
dd.albedo_rect[1] = rect.position.y;
dd.albedo_rect[2] = rect.size.x;
dd.albedo_rect[3] = rect.size.y;
} else {
if (!emission_tex.is_valid()) {
continue; //no albedo, no emission, no decal.
}
dd.albedo_rect[0] = 0;
dd.albedo_rect[1] = 0;
dd.albedo_rect[2] = 0;
dd.albedo_rect[3] = 0;
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RID normal_tex = texture_storage->decal_get_texture(decal, RS::DECAL_TEXTURE_NORMAL);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
if (normal_tex.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Rect2 rect = texture_storage->decal_atlas_get_texture_rect(normal_tex);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
dd.normal_rect[0] = rect.position.x;
dd.normal_rect[1] = rect.position.y;
dd.normal_rect[2] = rect.size.x;
dd.normal_rect[3] = rect.size.y;
Basis normal_xform = p_camera_inverse_xform.basis * xform.basis.orthonormalized();
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererStorageRD::store_basis_3x4(normal_xform, dd.normal_xform);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
} else {
dd.normal_rect[0] = 0;
dd.normal_rect[1] = 0;
dd.normal_rect[2] = 0;
dd.normal_rect[3] = 0;
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RID orm_tex = texture_storage->decal_get_texture(decal, RS::DECAL_TEXTURE_ORM);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
if (orm_tex.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Rect2 rect = texture_storage->decal_atlas_get_texture_rect(orm_tex);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
dd.orm_rect[0] = rect.position.x;
dd.orm_rect[1] = rect.position.y;
dd.orm_rect[2] = rect.size.x;
dd.orm_rect[3] = rect.size.y;
} else {
dd.orm_rect[0] = 0;
dd.orm_rect[1] = 0;
dd.orm_rect[2] = 0;
dd.orm_rect[3] = 0;
}
if (emission_tex.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Rect2 rect = texture_storage->decal_atlas_get_texture_rect(emission_tex);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
dd.emission_rect[0] = rect.position.x;
dd.emission_rect[1] = rect.position.y;
dd.emission_rect[2] = rect.size.x;
dd.emission_rect[3] = rect.size.y;
} else {
dd.emission_rect[0] = 0;
dd.emission_rect[1] = 0;
dd.emission_rect[2] = 0;
dd.emission_rect[3] = 0;
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
Color modulate = texture_storage->decal_get_modulate(decal);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
dd.modulate[0] = modulate.r;
dd.modulate[1] = modulate.g;
dd.modulate[2] = modulate.b;
dd.modulate[3] = modulate.a * fade;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
dd.emission_energy = texture_storage->decal_get_emission_energy(decal) * fade;
dd.albedo_mix = texture_storage->decal_get_albedo_mix(decal);
dd.mask = texture_storage->decal_get_cull_mask(decal);
dd.upper_fade = texture_storage->decal_get_upper_fade(decal);
dd.lower_fade = texture_storage->decal_get_lower_fade(decal);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Create mobile renderer
2021-03-10 12:23:55 +01:00
if (current_cluster_builder != nullptr) {
current_cluster_builder->add_box(ClusterBuilderRD::BOX_TYPE_DECAL, xform, decal_extents);
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (cluster.decal_count > 0) {
Fixes to get Godot running again on Intel IGP -Fixed strange bug with shadowed instance_param (this should not have worked anywhere, odd..) -Cleaned up barrier usage further.
2021-02-05 04:02:06 +01:00
RD::get_singleton()->buffer_update(cluster.decal_buffer, 0, sizeof(Cluster::DecalData) * cluster.decal_count, cluster.decals, RD::BARRIER_MASK_RASTER | RD::BARRIER_MASK_COMPUTE);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
////////////////////////////////////////////////////////////////////////////////
// FOG SHADER
void RendererSceneRenderRD::FogShaderData::set_code(const String &p_code) {
//compile
code = p_code;
valid = false;
ubo_size = 0;
uniforms.clear();
Replace String comparisons with "", String() to is_empty() Also: - Adds two stress tests to test_string.h - Changes to .empty() on std::strings
2021-12-09 10:42:46 +01:00
if (code.is_empty()) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
return; //just invalid, but no error
}
New OpenGL batching canvas renderer
2021-11-16 16:25:42 +01:00
ShaderCompiler::GeneratedCode gen_code;
ShaderCompiler::IdentifierActions actions;
actions.entry_point_stages["fog"] = ShaderCompiler::STAGE_COMPUTE;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uses_time = false;
actions.usage_flag_pointers["TIME"] = &uses_time;
actions.uniforms = &uniforms;
Fix some issues found by cppcheck.
2022-04-05 12:40:26 +02:00
RendererSceneRenderRD *scene_singleton = static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
Error err = scene_singleton->volumetric_fog.compiler.compile(RS::SHADER_FOG, code, &actions, path, gen_code);
ERR_FAIL_COND_MSG(err != OK, "Fog shader compilation failed.");
if (version.is_null()) {
version = scene_singleton->volumetric_fog.shader.version_create();
}
New OpenGL batching canvas renderer
2021-11-16 16:25:42 +01:00
scene_singleton->volumetric_fog.shader.version_set_compute_code(version, gen_code.code, gen_code.uniforms, gen_code.stage_globals[ShaderCompiler::STAGE_COMPUTE], gen_code.defines);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
ERR_FAIL_COND(!scene_singleton->volumetric_fog.shader.version_is_valid(version));
ubo_size = gen_code.uniform_total_size;
ubo_offsets = gen_code.uniform_offsets;
texture_uniforms = gen_code.texture_uniforms;
pipeline = RD::get_singleton()->compute_pipeline_create(scene_singleton->volumetric_fog.shader.version_get_shader(version, 0));
valid = true;
}
Fix default_texture_param in shader pipeline to support uniform arrays
2021-10-17 13:38:26 +02:00
void RendererSceneRenderRD::FogShaderData::set_default_texture_param(const StringName &p_name, RID p_texture, int p_index) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
if (!p_texture.is_valid()) {
Fix default_texture_param in shader pipeline to support uniform arrays
2021-10-17 13:38:26 +02:00
if (default_texture_params.has(p_name) && default_texture_params[p_name].has(p_index)) {
default_texture_params[p_name].erase(p_index);
if (default_texture_params[p_name].is_empty()) {
default_texture_params.erase(p_name);
}
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
} else {
Fix default_texture_param in shader pipeline to support uniform arrays
2021-10-17 13:38:26 +02:00
if (!default_texture_params.has(p_name)) {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
default_texture_params[p_name] = HashMap<int, RID>();
Fix default_texture_param in shader pipeline to support uniform arrays
2021-10-17 13:38:26 +02:00
}
default_texture_params[p_name][p_index] = p_texture;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
}
}
void RendererSceneRenderRD::FogShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
RBMap<int, StringName> order;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
if (E.value.scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_GLOBAL || E.value.scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
continue;
}
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
if (E.value.texture_order >= 0) {
order[E.value.texture_order + 100000] = E.key;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
} else {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
order[E.value.order] = E.key;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
}
}
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
for (const KeyValue<int, StringName> &E : order) {
PropertyInfo pi = ShaderLanguage::uniform_to_property_info(uniforms[E.value]);
pi.name = E.value;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
p_param_list->push_back(pi);
}
}
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
void RendererSceneRenderRD::FogShaderData::get_instance_param_list(List<RendererMaterialStorage::InstanceShaderParam> *p_param_list) const {
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
for (const KeyValue<StringName, ShaderLanguage::ShaderNode::Uniform> &E : uniforms) {
if (E.value.scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
continue;
}
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererMaterialStorage::InstanceShaderParam p;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
p.info = ShaderLanguage::uniform_to_property_info(E.value);
p.info.name = E.key; //supply name
p.index = E.value.instance_index;
p.default_value = ShaderLanguage::constant_value_to_variant(E.value.default_value, E.value.type, E.value.array_size, E.value.hint);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
p_param_list->push_back(p);
}
}
bool RendererSceneRenderRD::FogShaderData::is_param_texture(const StringName &p_param) const {
if (!uniforms.has(p_param)) {
return false;
}
return uniforms[p_param].texture_order >= 0;
}
bool RendererSceneRenderRD::FogShaderData::is_animated() const {
return false;
}
bool RendererSceneRenderRD::FogShaderData::casts_shadows() const {
return false;
}
Variant RendererSceneRenderRD::FogShaderData::get_default_parameter(const StringName &p_parameter) const {
if (uniforms.has(p_parameter)) {
ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
Fix crash when opening a converted `FogMaterial`
2021-10-29 13:10:22 +02:00
return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.array_size, uniform.hint);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
}
return Variant();
}
RS::ShaderNativeSourceCode RendererSceneRenderRD::FogShaderData::get_native_source_code() const {
Fix some issues found by cppcheck.
2022-04-05 12:40:26 +02:00
RendererSceneRenderRD *scene_singleton = static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
return scene_singleton->volumetric_fog.shader.version_get_native_source_code(version);
}
RendererSceneRenderRD::FogShaderData::~FogShaderData() {
Fix some issues found by cppcheck.
2022-04-05 12:40:26 +02:00
RendererSceneRenderRD *scene_singleton = static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
ERR_FAIL_COND(!scene_singleton);
//pipeline variants will clear themselves if shader is gone
if (version.is_valid()) {
scene_singleton->volumetric_fog.shader.version_free(version);
}
}
////////////////////////////////////////////////////////////////////////////////
// Fog material
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 15:04:37 +02:00
bool RendererSceneRenderRD::FogMaterialData::update_parameters(const HashMap<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
Fix some issues found by cppcheck.
2022-04-05 12:40:26 +02:00
RendererSceneRenderRD *scene_singleton = static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniform_set_updated = true;
return update_parameters_uniform_set(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, uniform_set, scene_singleton->volumetric_fog.shader.version_get_shader(shader_data->version, 0), VolumetricFogShader::FogSet::FOG_SET_MATERIAL);
}
RendererSceneRenderRD::FogMaterialData::~FogMaterialData() {
free_parameters_uniform_set(uniform_set);
}
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::ShaderData *RendererSceneRenderRD::_create_fog_shader_func() {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
FogShaderData *shader_data = memnew(FogShaderData);
return shader_data;
}
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::ShaderData *RendererSceneRenderRD::_create_fog_shader_funcs() {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->_create_fog_shader_func();
};
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::MaterialData *RendererSceneRenderRD::_create_fog_material_func(FogShaderData *p_shader) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
FogMaterialData *material_data = memnew(FogMaterialData);
material_data->shader_data = p_shader;
//update will happen later anyway so do nothing.
return material_data;
}
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::MaterialData *RendererSceneRenderRD::_create_fog_material_funcs(RendererRD::ShaderData *p_shader) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->_create_fog_material_func(static_cast<FogShaderData *>(p_shader));
};
////////////////////////////////////////////////////////////////////////////////
// Volumetric Fog
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
ERR_FAIL_COND(!rb->volumetric_fog);
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
RD::get_singleton()->free(rb->volumetric_fog->prev_light_density_map);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
RD::get_singleton()->free(rb->volumetric_fog->light_density_map);
RD::get_singleton()->free(rb->volumetric_fog->fog_map);
Fix volumetric fog memory leak on resize
2022-01-18 06:30:48 +01:00
RD::get_singleton()->free(rb->volumetric_fog->density_map);
RD::get_singleton()->free(rb->volumetric_fog->light_map);
RD::get_singleton()->free(rb->volumetric_fog->emissive_map);
Add fog to sky shaders
2020-08-18 06:12:51 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
if (rb->volumetric_fog->fog_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->fog_uniform_set)) {
RD::get_singleton()->free(rb->volumetric_fog->fog_uniform_set);
Add fog to sky shaders
2020-08-18 06:12:51 +02:00
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
if (rb->volumetric_fog->process_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->process_uniform_set)) {
RD::get_singleton()->free(rb->volumetric_fog->process_uniform_set);
}
if (rb->volumetric_fog->process_uniform_set2.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->process_uniform_set2)) {
RD::get_singleton()->free(rb->volumetric_fog->process_uniform_set2);
Add fog to sky shaders
2020-08-18 06:12:51 +02:00
}
if (rb->volumetric_fog->sdfgi_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->sdfgi_uniform_set)) {
RD::get_singleton()->free(rb->volumetric_fog->sdfgi_uniform_set);
}
if (rb->volumetric_fog->sky_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->sky_uniform_set)) {
RD::get_singleton()->free(rb->volumetric_fog->sky_uniform_set);
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
memdelete(rb->volumetric_fog);
Add fog to sky shaders
2020-08-18 06:12:51 +02:00
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
rb->volumetric_fog = nullptr;
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
Vector3i RendererSceneRenderRD::_point_get_position_in_froxel_volume(const Vector3 &p_point, float fog_end, const Vector2 &fog_near_size, const Vector2 &fog_far_size, float volumetric_fog_detail_spread, const Vector3 &fog_size, const Transform3D &p_cam_transform) {
Vector3 view_position = p_cam_transform.affine_inverse().xform(p_point);
view_position.z = MIN(view_position.z, -0.01); // Clamp to the front of camera
Vector3 fog_position = Vector3(0, 0, 0);
view_position.y = -view_position.y;
fog_position.z = -view_position.z / fog_end;
fog_position.x = (view_position.x / (2 * (fog_near_size.x * (1.0 - fog_position.z) + fog_far_size.x * fog_position.z))) + 0.5;
fog_position.y = (view_position.y / (2 * (fog_near_size.y * (1.0 - fog_position.z) + fog_far_size.y * fog_position.z))) + 0.5;
fog_position.z = Math::pow(float(fog_position.z), float(1.0 / volumetric_fog_detail_spread));
fog_position = fog_position * fog_size - Vector3(0.5, 0.5, 0.5);
fog_position.x = CLAMP(fog_position.x, 0.0, fog_size.x);
fog_position.y = CLAMP(fog_position.y, 0.0, fog_size.y);
fog_position.z = CLAMP(fog_position.z, 0.0, fog_size.z);
return Vector3i(fog_position);
}
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const CameraMatrix &p_cam_projection, const Transform3D &p_cam_transform, const Transform3D &p_prev_cam_inv_transform, RID p_shadow_atlas, int p_directional_light_count, bool p_use_directional_shadows, int p_positional_light_count, int p_voxel_gi_count, const PagedArray<RID> &p_fog_volumes) {
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
ERR_FAIL_COND(!is_clustered_enabled()); // can't use volumetric fog without clustered
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
ERR_FAIL_COND(!rb);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_environment);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
float ratio = float(rb->width) / float((rb->width + rb->height) / 2);
uint32_t target_width = uint32_t(float(volumetric_fog_size) * ratio);
uint32_t target_height = uint32_t(float(volumetric_fog_size) / ratio);
if (rb->volumetric_fog) {
//validate
if (!env || !env->volumetric_fog_enabled || rb->volumetric_fog->width != target_width || rb->volumetric_fog->height != target_height || rb->volumetric_fog->depth != volumetric_fog_depth) {
_volumetric_fog_erase(rb);
}
}
if (!env || !env->volumetric_fog_enabled) {
//no reason to enable or update, bye
return;
}
Tweak render timestamp names for explicitness and consistency - Add 2D and 3D in timestamp names when needed to avoid ambiguity. - Use present tense in all render timestamp names. - Add a space after ">" (begin) and "<" (end) symbols. - Remove redundant "End" in render timestamp names (indicated by "<").
2022-03-04 08:44:29 +01:00
RENDER_TIMESTAMP("> Volumetric Fog");
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->draw_command_begin_label("Volumetric Fog");
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
if (env && env->volumetric_fog_enabled && !rb->volumetric_fog) {
//required volumetric fog but not existing, create
rb->volumetric_fog = memnew(VolumetricFog);
rb->volumetric_fog->width = target_width;
rb->volumetric_fog->height = target_height;
rb->volumetric_fog->depth = volumetric_fog_depth;
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
tf.width = target_width;
tf.height = target_height;
tf.depth = volumetric_fog_depth;
Rename RD texture "type" to "texture_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-11-27 04:50:05 +01:00
tf.texture_type = RD::TEXTURE_TYPE_3D;
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
rb->volumetric_fog->light_density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->set_resource_name(rb->volumetric_fog->light_density_map, "Fog light-density map");
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
rb->volumetric_fog->prev_light_density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->set_resource_name(rb->volumetric_fog->prev_light_density_map, "Fog previous light-density map");
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
RD::get_singleton()->texture_clear(rb->volumetric_fog->prev_light_density_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
rb->volumetric_fog->fog_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->set_resource_name(rb->volumetric_fog->fog_map, "Fog map");
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#if defined(OSX_ENABLED) || defined(IPHONE_ENABLED)
Vector<uint8_t> dm;
dm.resize(target_width * target_height * volumetric_fog_depth * 4);
dm.fill(0);
rb->volumetric_fog->density_map = RD::get_singleton()->storage_buffer_create(dm.size(), dm);
RD::get_singleton()->set_resource_name(rb->volumetric_fog->density_map, "Fog density map");
rb->volumetric_fog->light_map = RD::get_singleton()->storage_buffer_create(dm.size(), dm);
RD::get_singleton()->set_resource_name(rb->volumetric_fog->light_map, "Fog light map");
rb->volumetric_fog->emissive_map = RD::get_singleton()->storage_buffer_create(dm.size(), dm);
RD::get_singleton()->set_resource_name(rb->volumetric_fog->emissive_map, "Fog emissive map");
#else
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
tf.format = RD::DATA_FORMAT_R32_UINT;
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
rb->volumetric_fog->density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->volumetric_fog->density_map, "Fog density map");
RD::get_singleton()->texture_clear(rb->volumetric_fog->density_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
rb->volumetric_fog->light_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->volumetric_fog->light_map, "Fog light map");
RD::get_singleton()->texture_clear(rb->volumetric_fog->light_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
rb->volumetric_fog->emissive_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->volumetric_fog->emissive_map, "Fog emissive map");
RD::get_singleton()->texture_clear(rb->volumetric_fog->emissive_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#endif
Add fog to sky shaders
2020-08-18 06:12:51 +02:00
Vector<RD::Uniform> uniforms;
{
RD::Uniform u;
u.binding = 0;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->fog_map);
Add fog to sky shaders
2020-08-18 06:12:51 +02:00
uniforms.push_back(u);
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
rb->volumetric_fog->sky_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, sky.sky_shader.default_shader_rd, RendererSceneSkyRD::SKY_SET_FOG);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
if (p_fog_volumes.size() > 0) {
RD::get_singleton()->draw_command_begin_label("Render Volumetric Fog Volumes");
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Tweak render timestamp names for explicitness and consistency - Add 2D and 3D in timestamp names when needed to avoid ambiguity. - Use present tense in all render timestamp names. - Add a space after ">" (begin) and "<" (end) symbols. - Remove redundant "End" in render timestamp names (indicated by "<").
2022-03-04 08:44:29 +01:00
RENDER_TIMESTAMP("Render FogVolumes");
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
VolumetricFogShader::VolumeUBO params;
Vector2 frustum_near_size = p_cam_projection.get_viewport_half_extents();
Vector2 frustum_far_size = p_cam_projection.get_far_plane_half_extents();
float z_near = p_cam_projection.get_z_near();
float z_far = p_cam_projection.get_z_far();
float fog_end = env->volumetric_fog_length;
Vector2 fog_far_size = frustum_near_size.lerp(frustum_far_size, (fog_end - z_near) / (z_far - z_near));
Vector2 fog_near_size;
if (p_cam_projection.is_orthogonal()) {
fog_near_size = fog_far_size;
} else {
fog_near_size = Vector2();
}
params.fog_frustum_size_begin[0] = fog_near_size.x;
params.fog_frustum_size_begin[1] = fog_near_size.y;
params.fog_frustum_size_end[0] = fog_far_size.x;
params.fog_frustum_size_end[1] = fog_far_size.y;
params.fog_frustum_end = fog_end;
params.z_near = z_near;
params.z_far = z_far;
params.time = time;
params.fog_volume_size[0] = rb->volumetric_fog->width;
params.fog_volume_size[1] = rb->volumetric_fog->height;
params.fog_volume_size[2] = rb->volumetric_fog->depth;
params.use_temporal_reprojection = env->volumetric_fog_temporal_reprojection;
params.temporal_frame = RSG::rasterizer->get_frame_number() % VolumetricFog::MAX_TEMPORAL_FRAMES;
params.detail_spread = env->volumetric_fog_detail_spread;
params.temporal_blend = env->volumetric_fog_temporal_reprojection_amount;
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
Transform3D to_prev_cam_view = p_prev_cam_inv_transform * p_cam_transform;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
storage->store_transform(to_prev_cam_view, params.to_prev_view);
storage->store_transform(p_cam_transform, params.transform);
RD::get_singleton()->buffer_update(volumetric_fog.volume_ubo, 0, sizeof(VolumetricFogShader::VolumeUBO), &params, RD::BARRIER_MASK_COMPUTE);
if (rb->volumetric_fog->fog_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->fog_uniform_set)) {
Vector<RD::Uniform> uniforms;
{
RD::Uniform u;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#if defined(OSX_ENABLED) || defined(IPHONE_ENABLED)
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
#else
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#endif
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.binding = 1;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->emissive_map);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
{
RD::Uniform u;
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
u.binding = 2;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(volumetric_fog.volume_ubo);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
{
RD::Uniform u;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#if defined(OSX_ENABLED) || defined(IPHONE_ENABLED)
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
#else
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#endif
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.binding = 3;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->density_map);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
{
RD::Uniform u;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#if defined(OSX_ENABLED) || defined(IPHONE_ENABLED)
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
#else
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#endif
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.binding = 4;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->light_map);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
rb->volumetric_fog->fog_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.default_shader_rd, VolumetricFogShader::FogSet::FOG_SET_UNIFORMS);
}
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
bool any_uses_time = false;
for (int i = 0; i < (int)p_fog_volumes.size(); i++) {
FogVolumeInstance *fog_volume_instance = fog_volume_instance_owner.get_or_null(p_fog_volumes[i]);
ERR_FAIL_COND(!fog_volume_instance);
RID fog_volume = fog_volume_instance->volume;
RID fog_material = storage->fog_volume_get_material(fog_volume);
FogMaterialData *material = nullptr;
if (fog_material.is_valid()) {
Fix some issues found by cppcheck.
2022-04-05 12:40:26 +02:00
material = static_cast<FogMaterialData *>(material_storage->material_get_data(fog_material, RendererRD::SHADER_TYPE_FOG));
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
if (!material || !material->shader_data->valid) {
material = nullptr;
}
}
if (!material) {
fog_material = volumetric_fog.default_material;
Fix some issues found by cppcheck.
2022-04-05 12:40:26 +02:00
material = static_cast<FogMaterialData *>(material_storage->material_get_data(fog_material, RendererRD::SHADER_TYPE_FOG));
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
}
ERR_FAIL_COND(!material);
FogShaderData *shader_data = material->shader_data;
ERR_FAIL_COND(!shader_data);
any_uses_time |= shader_data->uses_time;
Vector3i min = Vector3i();
Vector3i max = Vector3i();
Vector3i kernel_size = Vector3i();
Vector3 position = fog_volume_instance->transform.get_origin();
RS::FogVolumeShape volume_type = storage->fog_volume_get_shape(fog_volume);
Vector3 extents = storage->fog_volume_get_extents(fog_volume);
Add Cone and Cylinder shapes to FogVolume This complements the existing Ellipsoid and Box local fog shapes. This can be used to represent a light cone coming from a SpotLight.
2022-05-21 12:17:49 +02:00
if (volume_type != RS::FOG_VOLUME_SHAPE_WORLD) {
// Local fog volume.
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
Vector3i points[8];
points[0] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
points[1] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
points[2] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
points[3] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
points[4] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
points[5] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
points[6] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
points[7] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
min = Vector3i(int32_t(rb->volumetric_fog->width) - 1, int32_t(rb->volumetric_fog->height) - 1, int32_t(rb->volumetric_fog->depth) - 1);
max = Vector3i(1, 1, 1);
for (int j = 0; j < 8; j++) {
min = Vector3i(MIN(min.x, points[j].x), MIN(min.y, points[j].y), MIN(min.z, points[j].z));
max = Vector3i(MAX(max.x, points[j].x), MAX(max.y, points[j].y), MAX(max.z, points[j].z));
}
kernel_size = max - min;
} else {
// Volume type global runs on all cells
extents = Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
min = Vector3i(0, 0, 0);
kernel_size = Vector3i(int32_t(rb->volumetric_fog->width), int32_t(rb->volumetric_fog->height), int32_t(rb->volumetric_fog->depth));
}
Disallow compute dispatch with zero dimensions.
2021-10-29 23:10:48 +02:00
if (kernel_size.x == 0 || kernel_size.y == 0 || kernel_size.z == 0) {
continue;
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
volumetric_fog.push_constant.position[0] = position.x;
volumetric_fog.push_constant.position[1] = position.y;
volumetric_fog.push_constant.position[2] = position.z;
volumetric_fog.push_constant.extents[0] = extents.x;
volumetric_fog.push_constant.extents[1] = extents.y;
volumetric_fog.push_constant.extents[2] = extents.z;
volumetric_fog.push_constant.corner[0] = min.x;
volumetric_fog.push_constant.corner[1] = min.y;
volumetric_fog.push_constant.corner[2] = min.z;
volumetric_fog.push_constant.shape = uint32_t(storage->fog_volume_get_shape(fog_volume));
storage->store_transform(fog_volume_instance->transform.affine_inverse(), volumetric_fog.push_constant.transform);
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, shader_data->pipeline);
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->fog_uniform_set, VolumetricFogShader::FogSet::FOG_SET_UNIFORMS);
RD::get_singleton()->compute_list_set_push_constant(compute_list, &volumetric_fog.push_constant, sizeof(VolumetricFogShader::FogPushConstant));
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, volumetric_fog.base_uniform_set, VolumetricFogShader::FogSet::FOG_SET_BASE);
if (material->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(material->uniform_set)) { // Material may not have a uniform set.
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, material->uniform_set, VolumetricFogShader::FogSet::FOG_SET_MATERIAL);
}
RD::get_singleton()->compute_list_dispatch_threads(compute_list, kernel_size.x, kernel_size.y, kernel_size.z);
}
if (any_uses_time || env->volumetric_fog_temporal_reprojection) {
RenderingServerDefault::redraw_request();
}
RD::get_singleton()->draw_command_end_label();
RD::get_singleton()->compute_list_end();
}
if (rb->volumetric_fog->process_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->process_uniform_set)) {
//re create uniform set if needed
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Vector<RD::Uniform> uniforms;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
Vector<RD::Uniform> copy_uniforms;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 1;
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
Simplify Volumetric Fog -Always use temporal reproject, it just loos way better than any other filter. -By always using termporal reproject, the shadowmap reduction can be done away with, massively improving performance. -Disadvantage of temporal reproject is update latency so.. -Made sure a gaussian filter runs in XY after fog, this allows to keep stability and lower latency.
2021-02-06 15:51:56 +01:00
if (shadow_atlas == nullptr || shadow_atlas->depth.is_null()) {
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
u.append_id(texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_BLACK));
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
} else {
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(shadow_atlas->depth);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 2;
Simplify Volumetric Fog -Always use temporal reproject, it just loos way better than any other filter. -By always using termporal reproject, the shadowmap reduction can be done away with, massively improving performance. -Disadvantage of temporal reproject is update latency so.. -Made sure a gaussian filter runs in XY after fog, this allows to keep stability and lower latency.
2021-02-06 15:51:56 +01:00
if (directional_shadow.depth.is_valid()) {
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(directional_shadow.depth);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
} else {
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
u.append_id(texture_storage->texture_rd_get_default(RendererRD::DEFAULT_RD_TEXTURE_BLACK));
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 3;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(get_omni_light_buffer());
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 4;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(get_spot_light_buffer());
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 5;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(get_directional_light_buffer());
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 6;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->cluster_builder->get_cluster_buffer());
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 7;
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
u.append_id(material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 8;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->light_density_map);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 9;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->fog_map);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
{
RD::Uniform u;
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
u.binding = 9;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->prev_light_density_map);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 10;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(shadow_sampler);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 11;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(render_buffers_get_voxel_gi_buffer(p_render_buffers));
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 12;
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
for (int i = 0; i < RendererSceneGIRD::MAX_VOXEL_GI_INSTANCES; i++) {
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->gi.voxel_gi_textures[i]);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 13;
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
u.append_id(material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
{
RD::Uniform u;
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
u.binding = 14;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(volumetric_fog.params_ubo);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
uniforms.push_back(u);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
copy_uniforms.push_back(u);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
{
RD::Uniform u;
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
u.binding = 15;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->prev_light_density_map);
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
uniforms.push_back(u);
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
{
RD::Uniform u;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#if defined(OSX_ENABLED) || defined(IPHONE_ENABLED)
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
#else
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#endif
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.binding = 16;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->density_map);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
{
RD::Uniform u;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#if defined(OSX_ENABLED) || defined(IPHONE_ENABLED)
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
#else
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#endif
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.binding = 17;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->light_map);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
{
RD::Uniform u;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#if defined(OSX_ENABLED) || defined(IPHONE_ENABLED)
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
#else
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
[macOS / iOS] Use storage buffers instead of unsupported images for the volumetric fog on MoltenVK.
2021-11-24 08:14:19 +01:00
#endif
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
u.binding = 18;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->volumetric_fog->emissive_map);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
{
RD::Uniform u;
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
u.binding = 19;
Split dummy renderer classes into separate files Split canvas_texture_storage and texture_storage from render_storage class
2022-03-12 12:19:59 +01:00
RID radiance_texture = texture_storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RendererRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
Fix error spammed to output if `FogVolume` is setted to scene
2021-10-29 22:11:52 +02:00
RID sky_texture = env->sky.is_valid() ? sky.sky_get_radiance_texture_rd(env->sky) : RID();
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(sky_texture.is_valid() ? sky_texture : radiance_texture);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
rb->volumetric_fog->copy_uniform_set = RD::get_singleton()->uniform_set_create(copy_uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_COPY), 0);
rb->volumetric_fog->process_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY), 0);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
RID aux7 = uniforms.write[7].get_id(0);
RID aux8 = uniforms.write[8].get_id(0);
uniforms.write[7].set_id(0, aux8);
uniforms.write[8].set_id(0, aux7);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
rb->volumetric_fog->process_uniform_set2 = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, 0), 0);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
bool using_sdfgi = env->volumetric_fog_gi_inject > 0.0001 && env->sdfgi_enabled && (rb->sdfgi != nullptr);
if (using_sdfgi) {
if (rb->volumetric_fog->sdfgi_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->sdfgi_uniform_set)) {
Vector<RD::Uniform> uniforms;
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 0;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(gi.sdfgi_ubo);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 1;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->sdfgi->ambient_texture);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
}
{
RD::Uniform u;
Rename RD uniform "type" to "uniform_type" "type" isn't very descriptive for exposed code, and this variable is exposed via RD_SETGET.
2020-10-17 03:19:21 +02:00
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
u.binding = 2;
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
u.append_id(rb->sdfgi->occlusion_texture);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uniforms.push_back(u);
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
rb->volumetric_fog->sdfgi_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY_WITH_SDFGI), 1);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
}
rb->volumetric_fog->length = env->volumetric_fog_length;
rb->volumetric_fog->spread = env->volumetric_fog_detail_spread;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
VolumetricFogShader::ParamsUBO params;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Vector2 frustum_near_size = p_cam_projection.get_viewport_half_extents();
Vector2 frustum_far_size = p_cam_projection.get_far_plane_half_extents();
float z_near = p_cam_projection.get_z_near();
float z_far = p_cam_projection.get_z_far();
float fog_end = env->volumetric_fog_length;
Vector2 fog_far_size = frustum_near_size.lerp(frustum_far_size, (fog_end - z_near) / (z_far - z_near));
Vector2 fog_near_size;
if (p_cam_projection.is_orthogonal()) {
fog_near_size = fog_far_size;
} else {
fog_near_size = Vector2();
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.fog_frustum_size_begin[0] = fog_near_size.x;
params.fog_frustum_size_begin[1] = fog_near_size.y;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.fog_frustum_size_end[0] = fog_far_size.x;
params.fog_frustum_size_end[1] = fog_far_size.y;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
params.ambient_inject = env->volumetric_fog_ambient_inject * env->ambient_light_energy;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.z_far = z_far;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.fog_frustum_end = fog_end;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Color: Rename `to_srgb`/`to_linear` to include base color space This helps reduce confusion around sRGB <> Linear conversions by making both input and output color spaces explicit.
2022-04-13 10:37:22 +02:00
Color ambient_color = env->ambient_light.srgb_to_linear();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
params.ambient_color[0] = ambient_color.r;
params.ambient_color[1] = ambient_color.g;
params.ambient_color[2] = ambient_color.b;
params.sky_contribution = env->ambient_sky_contribution;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.fog_volume_size[0] = rb->volumetric_fog->width;
params.fog_volume_size[1] = rb->volumetric_fog->height;
params.fog_volume_size[2] = rb->volumetric_fog->depth;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.directional_light_count = p_directional_light_count;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Color: Rename `to_srgb`/`to_linear` to include base color space This helps reduce confusion around sRGB <> Linear conversions by making both input and output color spaces explicit.
2022-04-13 10:37:22 +02:00
Color emission = env->volumetric_fog_emission.srgb_to_linear();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
params.base_emission[0] = emission.r * env->volumetric_fog_emission_energy;
params.base_emission[1] = emission.g * env->volumetric_fog_emission_energy;
params.base_emission[2] = emission.b * env->volumetric_fog_emission_energy;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.base_density = env->volumetric_fog_density;
Color: Rename `to_srgb`/`to_linear` to include base color space This helps reduce confusion around sRGB <> Linear conversions by making both input and output color spaces explicit.
2022-04-13 10:37:22 +02:00
Color base_scattering = env->volumetric_fog_scattering.srgb_to_linear();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
params.base_scattering[0] = base_scattering.r;
params.base_scattering[1] = base_scattering.g;
params.base_scattering[2] = base_scattering.b;
params.phase_g = env->volumetric_fog_anisotropy;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.detail_spread = env->volumetric_fog_detail_spread;
params.gi_inject = env->volumetric_fog_gi_inject;
params.cam_rotation[0] = p_cam_transform.basis[0][0];
params.cam_rotation[1] = p_cam_transform.basis[1][0];
params.cam_rotation[2] = p_cam_transform.basis[2][0];
params.cam_rotation[3] = 0;
params.cam_rotation[4] = p_cam_transform.basis[0][1];
params.cam_rotation[5] = p_cam_transform.basis[1][1];
params.cam_rotation[6] = p_cam_transform.basis[2][1];
params.cam_rotation[7] = 0;
params.cam_rotation[8] = p_cam_transform.basis[0][2];
params.cam_rotation[9] = p_cam_transform.basis[1][2];
params.cam_rotation[10] = p_cam_transform.basis[2][2];
params.cam_rotation[11] = 0;
params.filter_axis = 0;
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
params.max_voxel_gi_instances = env->volumetric_fog_gi_inject > 0.001 ? p_voxel_gi_count : 0;
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
params.temporal_frame = RSG::rasterizer->get_frame_number() % VolumetricFog::MAX_TEMPORAL_FRAMES;
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
Transform3D to_prev_cam_view = p_prev_cam_inv_transform * p_cam_transform;
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
storage->store_transform(to_prev_cam_view, params.to_prev_view);
params.use_temporal_reprojection = env->volumetric_fog_temporal_reprojection;
params.temporal_blend = env->volumetric_fog_temporal_reprojection_amount;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
{
uint32_t cluster_size = rb->cluster_builder->get_cluster_size();
params.cluster_shift = get_shift_from_power_of_2(cluster_size);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
uint32_t cluster_screen_width = (rb->width - 1) / cluster_size + 1;
uint32_t cluster_screen_height = (rb->height - 1) / cluster_size + 1;
params.max_cluster_element_count_div_32 = max_cluster_elements / 32;
Fix volumetric fog in combination with spotlights
2021-12-08 22:17:09 +01:00
params.cluster_type_size = cluster_screen_width * cluster_screen_height * (params.max_cluster_element_count_div_32 + 32);
params.cluster_width = cluster_screen_width;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.screen_size[0] = rb->width;
params.screen_size[1] = rb->height;
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
Basis sky_transform = env->sky_orientation;
sky_transform = sky_transform.inverse() * p_cam_transform.basis;
RendererStorageRD::store_transform_3x3(sky_transform, params.radiance_inverse_xform);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->draw_command_begin_label("Render Volumetric Fog");
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RENDER_TIMESTAMP("Render Fog");
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->buffer_update(volumetric_fog.params_ubo, 0, sizeof(VolumetricFogShader::ParamsUBO), &params, RD::BARRIER_MASK_COMPUTE);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[using_sdfgi ? VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY_WITH_SDFGI : VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY]);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set, 0);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
if (using_sdfgi) {
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->sdfgi_uniform_set, 1);
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->compute_list_add_barrier(compute_list);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
// Copy fog to history buffer
if (env->volumetric_fog_temporal_reprojection) {
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_COPY]);
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->copy_uniform_set, 0);
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
RD::get_singleton()->compute_list_add_barrier(compute_list);
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->draw_command_end_label();
Added temporal reprojection to Volumetric Fog -It's an option, just enable it -Just works, don't have to do anything else.
2021-02-05 14:51:49 +01:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
if (volumetric_fog_filter_active) {
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->draw_command_begin_label("Filter Fog");
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RENDER_TIMESTAMP("Filter Fog");
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FILTER]);
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set, 0);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RD::get_singleton()->compute_list_end();
//need restart for buffer update
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
params.filter_axis = 1;
Reorganize RenderingDevice barriers -Removed sync to draw, now everything syncs to draw by default. -Fixed many validation layer errors. -Added support for VkImageViewUsageCreateInfo to fix validation layer warnings. -Texture, buffer, raster and compute functions now all allow spcifying which barriers will be used.
2021-01-26 01:52:58 +01:00
RD::get_singleton()->buffer_update(volumetric_fog.params_ubo, 0, sizeof(VolumetricFogShader::ParamsUBO), &params);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
compute_list = RD::get_singleton()->compute_list_begin();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FILTER]);
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set2, 0);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
RD::get_singleton()->compute_list_add_barrier(compute_list);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->draw_command_end_label();
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RENDER_TIMESTAMP("Integrate Fog");
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->draw_command_begin_label("Integrate Fog");
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FOG]);
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set, 0);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, 1);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->compute_list_end(RD::BARRIER_MASK_RASTER);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Tweak render timestamp names for explicitness and consistency - Add 2D and 3D in timestamp names when needed to avoid ambiguity. - Use present tense in all render timestamp names. - Add a space after ">" (begin) and "<" (end) symbols. - Remove redundant "End" in render timestamp names (indicated by "<").
2022-03-04 08:44:29 +01:00
RENDER_TIMESTAMP("< Volumetric Fog");
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
RD::get_singleton()->draw_command_end_label();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
RD::get_singleton()->draw_command_end_label();
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
bool RendererSceneRenderRD::_needs_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) {
if (p_render_data->render_buffers.is_valid()) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (rb->sdfgi != nullptr) {
return true;
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
return false;
}
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
void RendererSceneRenderRD::_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) {
if (p_render_data->render_buffers.is_valid()) {
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (p_use_gi) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND(rb == nullptr);
if (rb->sdfgi == nullptr) {
return;
}
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_render_data->environment);
rb->sdfgi->update_probes(env, sky.sky_owner.get_or_null(env->sky));
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
void RendererSceneRenderRD::_pre_resolve_render(RenderDataRD *p_render_data, bool p_use_gi) {
if (p_render_data->render_buffers.is_valid()) {
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (p_use_gi) {
RD::get_singleton()->compute_list_end();
}
}
}
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
void RendererSceneRenderRD::_pre_opaque_render(RenderDataRD *p_render_data, bool p_use_ssao, bool p_use_ssil, bool p_use_gi, RID p_normal_roughness_buffer, RID p_voxel_gi_buffer) {
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
// Render shadows while GI is rendering, due to how barriers are handled, this should happen at the same time
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
if (p_render_data->render_buffers.is_valid() && p_use_gi) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND(rb == nullptr);
Fix VoxelGI (works again). It was broken due to #46046, this makes it work again.
2021-06-13 01:37:56 +02:00
if (rb->sdfgi != nullptr) {
rb->sdfgi->store_probes();
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
render_state.cube_shadows.clear();
render_state.shadows.clear();
render_state.directional_shadows.clear();
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 14:50:35 +02:00
Plane camera_plane(-p_render_data->cam_transform.basis.get_column(Vector3::AXIS_Z), p_render_data->cam_transform.origin);
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
float lod_distance_multiplier = p_render_data->cam_projection.get_lod_multiplier();
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
{
for (int i = 0; i < render_state.render_shadow_count; i++) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *li = light_instance_owner.get_or_null(render_state.render_shadows[i].light);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (light_storage->light_get_type(li->light) == RS::LIGHT_DIRECTIONAL) {
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
render_state.directional_shadows.push_back(i);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
} else if (light_storage->light_get_type(li->light) == RS::LIGHT_OMNI && light_storage->light_omni_get_shadow_mode(li->light) == RS::LIGHT_OMNI_SHADOW_CUBE) {
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
render_state.cube_shadows.push_back(i);
} else {
render_state.shadows.push_back(i);
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
//cube shadows are rendered in their own way
for (uint32_t i = 0; i < render_state.cube_shadows.size(); i++) {
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
_render_shadow_pass(render_state.render_shadows[render_state.cube_shadows[i]].light, p_render_data->shadow_atlas, render_state.render_shadows[render_state.cube_shadows[i]].pass, render_state.render_shadows[render_state.cube_shadows[i]].instances, camera_plane, lod_distance_multiplier, p_render_data->screen_mesh_lod_threshold, true, true, true, p_render_data->render_info);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
if (render_state.directional_shadows.size()) {
//open the pass for directional shadows
_update_directional_shadow_atlas();
RD::get_singleton()->draw_list_begin(directional_shadow.fb, RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_CONTINUE);
RD::get_singleton()->draw_list_end();
}
}
// Render GI
bool render_shadows = render_state.directional_shadows.size() || render_state.shadows.size();
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
bool render_gi = p_render_data->render_buffers.is_valid() && p_use_gi;
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (render_shadows && render_gi) {
Tweak render timestamp names for explicitness and consistency - Add 2D and 3D in timestamp names when needed to avoid ambiguity. - Use present tense in all render timestamp names. - Add a space after ">" (begin) and "<" (end) symbols. - Remove redundant "End" in render timestamp names (indicated by "<").
2022-03-04 08:44:29 +01:00
RENDER_TIMESTAMP("Render GI + Render Shadows (Parallel)");
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
} else if (render_shadows) {
RENDER_TIMESTAMP("Render Shadows");
} else if (render_gi) {
RENDER_TIMESTAMP("Render GI");
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
//prepare shadow rendering
if (render_shadows) {
_render_shadow_begin();
//render directional shadows
for (uint32_t i = 0; i < render_state.directional_shadows.size(); i++) {
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
_render_shadow_pass(render_state.render_shadows[render_state.directional_shadows[i]].light, p_render_data->shadow_atlas, render_state.render_shadows[render_state.directional_shadows[i]].pass, render_state.render_shadows[render_state.directional_shadows[i]].instances, camera_plane, lod_distance_multiplier, p_render_data->screen_mesh_lod_threshold, false, i == render_state.directional_shadows.size() - 1, false, p_render_data->render_info);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
//render positional shadows
for (uint32_t i = 0; i < render_state.shadows.size(); i++) {
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
_render_shadow_pass(render_state.render_shadows[render_state.shadows[i]].light, p_render_data->shadow_atlas, render_state.render_shadows[render_state.shadows[i]].pass, render_state.render_shadows[render_state.shadows[i]].instances, camera_plane, lod_distance_multiplier, p_render_data->screen_mesh_lod_threshold, i == 0, i == render_state.shadows.size() - 1, true, p_render_data->render_info);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
_render_shadow_process();
}
//start GI
if (render_gi) {
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
gi.process_gi(p_render_data->render_buffers, p_normal_roughness_buffer, p_voxel_gi_buffer, p_render_data->environment, p_render_data->cam_projection, p_render_data->cam_transform, *p_render_data->voxel_gi_instances, this);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
//Do shadow rendering (in parallel with GI)
if (render_shadows) {
_render_shadow_end(RD::BARRIER_MASK_NO_BARRIER);
}
if (render_gi) {
RD::get_singleton()->compute_list_end(RD::BARRIER_MASK_NO_BARRIER); //use a later barrier
}
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
if (p_render_data->render_buffers.is_valid()) {
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
if (p_use_ssao || p_use_ssil) {
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
ERR_FAIL_COND(!rb);
bool invalidate_uniform_set = false;
if (rb->ss_effects.linear_depth.is_null()) {
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R16_SFLOAT;
tf.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
tf.width = (rb->width + 1) / 2;
tf.height = (rb->height + 1) / 2;
tf.mipmaps = 5;
tf.array_layers = 4;
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
rb->ss_effects.linear_depth = RD::get_singleton()->texture_create(tf, RD::TextureView());
RD::get_singleton()->set_resource_name(rb->ss_effects.linear_depth, "SS Effects Depth");
for (uint32_t i = 0; i < tf.mipmaps; i++) {
RID slice = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->ss_effects.linear_depth, 0, i, 1, RD::TEXTURE_SLICE_2D_ARRAY);
rb->ss_effects.linear_depth_slices.push_back(slice);
RD::get_singleton()->set_resource_name(slice, "SS Effects Depth Mip " + itos(i) + " ");
}
invalidate_uniform_set = true;
}
storage->get_effects()->downsample_depth(rb->depth_texture, rb->ss_effects.linear_depth_slices, ssao_quality, ssil_quality, invalidate_uniform_set, ssao_half_size, ssil_half_size, Size2i(rb->width, rb->height), p_render_data->cam_projection);
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (p_use_ssao) {
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
_process_ssao(p_render_data->render_buffers, p_render_data->environment, p_normal_roughness_buffer, p_render_data->cam_projection);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
if (p_use_ssil) {
_process_ssil(p_render_data->render_buffers, p_render_data->environment, p_normal_roughness_buffer, p_render_data->cam_projection, p_render_data->cam_transform);
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
Fixes to get Godot running again on Intel IGP -Fixed strange bug with shadowed instance_param (this should not have worked anywhere, odd..) -Cleaned up barrier usage further.
2021-02-05 04:02:06 +01:00
//full barrier here, we need raster, transfer and compute and it depends from the previous work
RD::get_singleton()->barrier(RD::BARRIER_MASK_ALL, RD::BARRIER_MASK_ALL);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (current_cluster_builder) {
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
current_cluster_builder->begin(p_render_data->cam_transform, p_render_data->cam_projection, !p_render_data->reflection_probe.is_valid());
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
bool using_shadows = true;
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
if (p_render_data->reflection_probe.is_valid()) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (!RSG::light_storage->reflection_probe_renders_shadows(reflection_probe_instance_get_probe(p_render_data->reflection_probe))) {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
using_shadows = false;
}
} else {
//do not render reflections when rendering a reflection probe
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
_setup_reflections(*p_render_data->reflection_probes, p_render_data->cam_transform.affine_inverse(), p_render_data->environment);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
uint32_t directional_light_count = 0;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
uint32_t positional_light_count = 0;
Use specialization constants in clustered renderer * Keep track of when projector, softshadow or directional sofshadow were enabled. * Enable them via specializaton constant where it makes sense. * Re-implements soft shadows. * Re-implements light projectors.
2021-07-13 01:32:05 +02:00
_setup_lights(*p_render_data->lights, p_render_data->cam_transform, p_render_data->shadow_atlas, using_shadows, directional_light_count, positional_light_count, p_render_data->directional_light_soft_shadows);
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
_setup_decals(*p_render_data->decals, p_render_data->cam_transform.affine_inverse());
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
p_render_data->directional_light_count = directional_light_count;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (current_cluster_builder) {
current_cluster_builder->bake_cluster();
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
if (p_render_data->render_buffers.is_valid()) {
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
bool directional_shadows = false;
for (uint32_t i = 0; i < directional_light_count; i++) {
if (cluster.directional_lights[i].shadow_enabled) {
directional_shadows = true;
break;
}
}
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
if (is_volumetric_supported()) {
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
_update_volumetric_fog(p_render_data->render_buffers, p_render_data->environment, p_render_data->cam_projection, p_render_data->cam_transform, p_render_data->prev_cam_transform.affine_inverse(), p_render_data->shadow_atlas, directional_light_count, directional_shadows, positional_light_count, render_state.voxel_gi_count, *p_render_data->fog_volumes);
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
}
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData *p_camera_data, const CameraData *p_prev_camera_data, const PagedArray<GeometryInstance *> &p_instances, const PagedArray<RID> &p_lights, const PagedArray<RID> &p_reflection_probes, const PagedArray<RID> &p_voxel_gi_instances, const PagedArray<RID> &p_decals, const PagedArray<RID> &p_lightmaps, const PagedArray<RID> &p_fog_volumes, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_occluder_debug_tex, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_mesh_lod_threshold, const RenderShadowData *p_render_shadows, int p_render_shadow_count, const RenderSDFGIData *p_render_sdfgi_regions, int p_render_sdfgi_region_count, const RenderSDFGIUpdateData *p_sdfgi_update_data, RendererScene::RenderInfo *r_render_info) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
// getting this here now so we can direct call a bunch of things more easily
RenderBuffers *rb = nullptr;
if (p_render_buffers.is_valid()) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
rb = render_buffers_owner.get_or_null(p_render_buffers);
Create mobile renderer
2021-03-10 12:23:55 +01:00
ERR_FAIL_COND(!rb);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
//assign render data
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
RenderDataRD render_data;
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
{
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
render_data.render_buffers = p_render_buffers;
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
// Our first camera is used by default
render_data.cam_transform = p_camera_data->main_transform;
render_data.cam_projection = p_camera_data->main_projection;
render_data.view_projection[0] = p_camera_data->main_projection;
Fix "ortogonal" -> "orthogonal" typo in rasterizer code
2022-04-26 21:49:44 +02:00
render_data.cam_orthogonal = p_camera_data->is_orthogonal;
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
render_data.taa_jitter = p_camera_data->taa_jitter;
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
render_data.view_count = p_camera_data->view_count;
for (uint32_t v = 0; v < p_camera_data->view_count; v++) {
render_data.view_projection[v] = p_camera_data->view_projection[v];
}
Initial TAA implementation Initial TAA support based on the implementation in Spartan Engine. Motion vectors are correctly generated for camera and mesh movement, but there is no support for other things like particles or skeleton deformations.
2022-04-04 16:10:22 +02:00
render_data.prev_cam_transform = p_prev_camera_data->main_transform;
render_data.prev_cam_projection = p_prev_camera_data->main_projection;
render_data.prev_taa_jitter = p_prev_camera_data->taa_jitter;
for (uint32_t v = 0; v < p_camera_data->view_count; v++) {
render_data.prev_view_projection[v] = p_prev_camera_data->view_projection[v];
}
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
render_data.z_near = p_camera_data->main_projection.get_z_near();
render_data.z_far = p_camera_data->main_projection.get_z_far();
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
render_data.instances = &p_instances;
render_data.lights = &p_lights;
render_data.reflection_probes = &p_reflection_probes;
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
render_data.voxel_gi_instances = &p_voxel_gi_instances;
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
render_data.decals = &p_decals;
render_data.lightmaps = &p_lightmaps;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
render_data.fog_volumes = &p_fog_volumes;
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
render_data.environment = p_environment;
render_data.camera_effects = p_camera_effects;
render_data.shadow_atlas = p_shadow_atlas;
render_data.reflection_atlas = p_reflection_atlas;
render_data.reflection_probe = p_reflection_probe;
render_data.reflection_probe_pass = p_reflection_probe_pass;
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
// this should be the same for all cameras..
render_data.lod_distance_multiplier = p_camera_data->main_projection.get_lod_multiplier();
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 14:50:35 +02:00
render_data.lod_camera_plane = Plane(-p_camera_data->main_transform.basis.get_column(Vector3::AXIS_Z), p_camera_data->main_transform.get_origin());
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_DISABLE_LOD) {
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
render_data.screen_mesh_lod_threshold = 0.0;
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
} else {
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
render_data.screen_mesh_lod_threshold = p_screen_mesh_lod_threshold;
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
render_state.render_shadows = p_render_shadows;
render_state.render_shadow_count = p_render_shadow_count;
render_state.render_sdfgi_regions = p_render_sdfgi_regions;
render_state.render_sdfgi_region_count = p_render_sdfgi_region_count;
render_state.sdfgi_update_data = p_sdfgi_update_data;
Fix Render Info * Fixed and redone the process to obtain render information from a viewport * Some stats, such as material changes are too difficult to guess on Vulkan, were removed. * Separated visible and shadow stats, which causes confusion. * Texture, buffer and general video memory can be queried now. * Fixed the performance metrics too.
2021-07-03 01:14:19 +02:00
render_data.render_info = r_render_info;
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
PagedArray<RID> empty;
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
render_data.lights = &empty;
render_data.reflection_probes = &empty;
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
render_data.voxel_gi_instances = &empty;
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
//sdfgi first
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (rb != nullptr && rb->sdfgi != nullptr) {
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
for (int i = 0; i < render_state.render_sdfgi_region_count; i++) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
rb->sdfgi->render_region(p_render_buffers, render_state.render_sdfgi_regions[i].region, render_state.render_sdfgi_regions[i].instances, this);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
if (render_state.sdfgi_update_data->update_static) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
rb->sdfgi->render_static_lights(p_render_buffers, render_state.sdfgi_update_data->static_cascade_count, p_sdfgi_update_data->static_cascade_indices, render_state.sdfgi_update_data->static_positional_lights, this);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
}
Color clear_color;
if (p_render_buffers.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 16:00:51 +02:00
clear_color = texture_storage->render_target_get_clear_request_color(rb->render_target);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
} else {
clear_color = storage->get_default_clear_color();
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
//assign render indices to voxel_gi_instances
Create mobile renderer
2021-03-10 12:23:55 +01:00
if (is_dynamic_gi_supported()) {
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
for (uint32_t i = 0; i < (uint32_t)p_voxel_gi_instances.size(); i++) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneGIRD::VoxelGIInstance *voxel_gi_inst = gi.voxel_gi_instance_owner.get_or_null(p_voxel_gi_instances[i]);
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
if (voxel_gi_inst) {
voxel_gi_inst->render_index = i;
Create mobile renderer
2021-03-10 12:23:55 +01:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
}
}
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
if (render_buffers_owner.owns(render_data.render_buffers)) {
// render_data.render_buffers == p_render_buffers so we can use our already retrieved rb
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
current_cluster_builder = rb->cluster_builder;
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
} else if (reflection_probe_instance_owner.owns(render_data.reflection_probe)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(render_data.reflection_probe);
ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(rpi->atlas);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
if (!ra) {
ERR_PRINT("reflection probe has no reflection atlas! Bug?");
current_cluster_builder = nullptr;
} else {
current_cluster_builder = ra->cluster_builder;
}
} else {
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
ERR_PRINT("No render buffer nor reflection atlas, bug"); //should never happen, will crash
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
current_cluster_builder = nullptr;
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
render_state.voxel_gi_count = 0;
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
Fixes to mobile renderer * Make sure shaders are named, to aid in debug in case of failure * SceneRenderRD was being wrongly initialized (virtual functions being called when derivative class not initialized). * Fixed some bugs resulting on the above being corrected.
2021-08-16 19:51:29 +02:00
if (rb != nullptr && is_dynamic_gi_supported()) {
Fix VoxelGI (works again). It was broken due to #46046, this makes it work again.
2021-06-13 01:37:56 +02:00
if (rb->sdfgi) {
rb->sdfgi->update_cascades();
Add stereoscopic rendering through multiview
2021-05-07 15:19:04 +02:00
rb->sdfgi->pre_process_gi(render_data.cam_transform, &render_data, this);
Fix VoxelGI (works again). It was broken due to #46046, this makes it work again.
2021-06-13 01:37:56 +02:00
rb->sdfgi->update_light();
}
Fix SDFGI * Broken by 7513b73902f3ed7ac45aa9aefc2f6f333ae731ff, fixes #49631
2021-07-04 02:24:37 +02:00
gi.setup_voxel_gi_instances(render_data.render_buffers, render_data.cam_transform, *render_data.voxel_gi_instances, render_state.voxel_gi_count, this);
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
render_state.depth_prepass_used = false;
//calls _pre_opaque_render between depth pre-pass and opaque pass
Create mobile renderer
2021-03-10 12:23:55 +01:00
if (current_cluster_builder != nullptr) {
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
render_data.cluster_buffer = current_cluster_builder->get_cluster_buffer();
render_data.cluster_size = current_cluster_builder->get_cluster_size();
render_data.cluster_max_elements = current_cluster_builder->get_max_cluster_elements();
Create mobile renderer
2021-03-10 12:23:55 +01:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 07:41:12 +02:00
_render_scene(&render_data, clear_color);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
if (p_render_buffers.is_valid()) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
/*
_debug_draw_cluster(p_render_buffers);
_render_buffers_post_process_and_tonemap(&render_data);
*/
_render_buffers_debug_draw(p_render_buffers, p_shadow_atlas, p_occluder_debug_tex);
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SDFGI && rb != nullptr && rb->sdfgi != nullptr) {
rb->sdfgi->debug_draw(render_data.cam_projection, render_data.cam_transform, rb->width, rb->height, rb->render_target, rb->texture);
}
}
}
void RendererSceneRenderRD::_debug_draw_cluster(RID p_render_buffers) {
if (p_render_buffers.is_valid() && current_cluster_builder != nullptr) {
RS::ViewportDebugDraw dd = get_debug_draw_mode();
if (dd == RS::VIEWPORT_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS || dd == RS::VIEWPORT_DEBUG_DRAW_CLUSTER_SPOT_LIGHTS || dd == RS::VIEWPORT_DEBUG_DRAW_CLUSTER_DECALS || dd == RS::VIEWPORT_DEBUG_DRAW_CLUSTER_REFLECTION_PROBES) {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
ClusterBuilderRD::ElementType elem_type = ClusterBuilderRD::ELEMENT_TYPE_MAX;
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
switch (dd) {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
case RS::VIEWPORT_DEBUG_DRAW_CLUSTER_OMNI_LIGHTS:
elem_type = ClusterBuilderRD::ELEMENT_TYPE_OMNI_LIGHT;
break;
case RS::VIEWPORT_DEBUG_DRAW_CLUSTER_SPOT_LIGHTS:
elem_type = ClusterBuilderRD::ELEMENT_TYPE_SPOT_LIGHT;
break;
case RS::VIEWPORT_DEBUG_DRAW_CLUSTER_DECALS:
elem_type = ClusterBuilderRD::ELEMENT_TYPE_DECAL;
break;
case RS::VIEWPORT_DEBUG_DRAW_CLUSTER_REFLECTION_PROBES:
elem_type = ClusterBuilderRD::ELEMENT_TYPE_REFLECTION_PROBE;
break;
default: {
}
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 12:49:25 +02:00
current_cluster_builder->debug(elem_type);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
void RendererSceneRenderRD::_render_shadow_pass(RID p_light, RID p_shadow_atlas, int p_pass, const PagedArray<GeometryInstance *> &p_instances, const Plane &p_camera_plane, float p_lod_distance_multiplier, float p_screen_mesh_lod_threshold, bool p_open_pass, bool p_close_pass, bool p_clear_region, RendererScene::RenderInfo *p_render_info) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(p_light);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_FAIL_COND(!light_instance);
Rect2i atlas_rect;
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
uint32_t atlas_size;
RID atlas_fb;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
bool using_dual_paraboloid = false;
bool using_dual_paraboloid_flip = false;
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
Vector2i dual_paraboloid_offset;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
RID render_fb;
RID render_texture;
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
float zfar;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Refactored shadowmapping. - Made shadow bias size independent, so it will remain when changing light or camera size. - Implemented normal offset bias, which greatly enhances quality. - Added transmission to subsurface scattering - Reimplemented shadow filter modes Closes #17260
2020-04-08 03:51:52 +02:00
bool use_pancake = false;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
bool render_cubemap = false;
bool finalize_cubemap = false;
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
bool flip_y = false;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
CameraMatrix light_projection;
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D light_transform;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->light_get_type(light_instance->light) == RS::LIGHT_DIRECTIONAL) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
//set pssm stuff
if (light_instance->last_scene_shadow_pass != scene_pass) {
Directional lights and shadow mapping are functional.
2019-09-07 19:38:17 +02:00
light_instance->directional_rect = _get_directional_shadow_rect(directional_shadow.size, directional_shadow.light_count, directional_shadow.current_light);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
directional_shadow.current_light++;
Directional lights and shadow mapping are functional.
2019-09-07 19:38:17 +02:00
light_instance->last_scene_shadow_pass = scene_pass;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
use_pancake = RSG::light_storage->light_get_param(light_instance->light, RS::LIGHT_PARAM_SHADOW_PANCAKE_SIZE) > 0;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
light_projection = light_instance->shadow_transform[p_pass].camera;
light_transform = light_instance->shadow_transform[p_pass].transform;
Construct values only when necessary.
2021-09-25 11:01:45 +02:00
atlas_rect = light_instance->directional_rect;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->light_directional_get_shadow_mode(light_instance->light) == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
atlas_rect.size.width /= 2;
atlas_rect.size.height /= 2;
if (p_pass == 1) {
atlas_rect.position.x += atlas_rect.size.width;
} else if (p_pass == 2) {
atlas_rect.position.y += atlas_rect.size.height;
} else if (p_pass == 3) {
Construct values only when necessary.
2021-09-25 11:01:45 +02:00
atlas_rect.position += atlas_rect.size;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
} else if (RSG::light_storage->light_directional_get_shadow_mode(light_instance->light) == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
atlas_rect.size.height /= 2;
if (p_pass == 0) {
} else {
atlas_rect.position.y += atlas_rect.size.height;
}
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
light_instance->shadow_transform[p_pass].atlas_rect = atlas_rect;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
light_instance->shadow_transform[p_pass].atlas_rect.position /= directional_shadow.size;
light_instance->shadow_transform[p_pass].atlas_rect.size /= directional_shadow.size;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
zfar = RSG::light_storage->light_get_param(light_instance->light, RS::LIGHT_PARAM_RANGE);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
render_fb = directional_shadow.fb;
render_texture = RID();
flip_y = true;
Implement GPU Particle Collisions -Sphere Attractor -Box Attractor -Vector Field -Sphere Collider -Box Collider -Baked SDF Collider -Heightmap Collider
2020-10-08 02:29:49 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
} else {
//set from shadow atlas
Implement GPU Particle Collisions -Sphere Attractor -Box Attractor -Vector Field -Sphere Collider -Box Collider -Baked SDF Collider -Heightmap Collider
2020-10-08 02:29:49 +02:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_COND(!shadow_atlas);
ERR_FAIL_COND(!shadow_atlas->shadow_owners.has(p_light));
Implement GPU Particle Collisions -Sphere Attractor -Box Attractor -Vector Field -Sphere Collider -Box Collider -Baked SDF Collider -Heightmap Collider
2020-10-08 02:29:49 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
_update_shadow_atlas(shadow_atlas);
Implement GPU Particle Collisions -Sphere Attractor -Box Attractor -Vector Field -Sphere Collider -Box Collider -Baked SDF Collider -Heightmap Collider
2020-10-08 02:29:49 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
uint32_t key = shadow_atlas->shadow_owners[p_light];
Implement GPU Particle Collisions -Sphere Attractor -Box Attractor -Vector Field -Sphere Collider -Box Collider -Baked SDF Collider -Heightmap Collider
2020-10-08 02:29:49 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ERR_FAIL_INDEX((int)shadow, shadow_atlas->quadrants[quadrant].shadows.size());
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
uint32_t quadrant_size = shadow_atlas->size >> 1;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
atlas_rect.position.x = (quadrant & 1) * quadrant_size;
atlas_rect.position.y = (quadrant >> 1) * quadrant_size;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
atlas_rect.position.x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
atlas_rect.position.y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
atlas_rect.size.width = shadow_size;
atlas_rect.size.height = shadow_size;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
zfar = RSG::light_storage->light_get_param(light_instance->light, RS::LIGHT_PARAM_RANGE);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->light_get_type(light_instance->light) == RS::LIGHT_OMNI) {
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
bool wrap = (shadow + 1) % shadow_atlas->quadrants[quadrant].subdivision == 0;
dual_paraboloid_offset = wrap ? Vector2i(1 - shadow_atlas->quadrants[quadrant].subdivision, 1) : Vector2i(1, 0);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
if (RSG::light_storage->light_omni_get_shadow_mode(light_instance->light) == RS::LIGHT_OMNI_SHADOW_CUBE) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
ShadowCubemap *cubemap = _get_shadow_cubemap(shadow_size / 2);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
render_fb = cubemap->side_fb[p_pass];
render_texture = cubemap->cubemap;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
light_projection = light_instance->shadow_transform[p_pass].camera;
light_transform = light_instance->shadow_transform[p_pass].transform;
render_cubemap = true;
finalize_cubemap = p_pass == 5;
atlas_fb = shadow_atlas->fb;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
atlas_size = shadow_atlas->size;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (p_pass == 0) {
_render_shadow_begin();
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
} else {
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
atlas_rect.position.x += 1;
atlas_rect.position.y += 1;
atlas_rect.size.x -= 2;
atlas_rect.size.y -= 2;
atlas_rect.position += p_pass * atlas_rect.size * dual_paraboloid_offset;
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
light_projection = light_instance->shadow_transform[0].camera;
light_transform = light_instance->shadow_transform[0].transform;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
using_dual_paraboloid = true;
using_dual_paraboloid_flip = p_pass == 1;
render_fb = shadow_atlas->fb;
flip_y = true;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 11:34:31 +02:00
} else if (RSG::light_storage->light_get_type(light_instance->light) == RS::LIGHT_SPOT) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
light_projection = light_instance->shadow_transform[0].camera;
light_transform = light_instance->shadow_transform[0].transform;
render_fb = shadow_atlas->fb;
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
flip_y = true;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (render_cubemap) {
//rendering to cubemap
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
_render_shadow_append(render_fb, p_instances, light_projection, light_transform, zfar, 0, 0, false, false, use_pancake, p_camera_plane, p_lod_distance_multiplier, p_screen_mesh_lod_threshold, Rect2(), false, true, true, true, p_render_info);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (finalize_cubemap) {
_render_shadow_process();
_render_shadow_end();
//reblit
Rect2 atlas_rect_norm = atlas_rect;
Construct values only when necessary.
2021-09-25 11:01:45 +02:00
atlas_rect_norm.position /= float(atlas_size);
atlas_rect_norm.size /= float(atlas_size);
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
storage->get_effects()->copy_cubemap_to_dp(render_texture, atlas_fb, atlas_rect_norm, atlas_rect.size, light_projection.get_z_near(), light_projection.get_z_far(), false);
atlas_rect_norm.position += Vector2(dual_paraboloid_offset) * atlas_rect_norm.size;
storage->get_effects()->copy_cubemap_to_dp(render_texture, atlas_fb, atlas_rect_norm, atlas_rect.size, light_projection.get_z_near(), light_projection.get_z_far(), true);
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
//restore transform so it can be properly used
light_instance_set_shadow_transform(p_light, CameraMatrix(), light_instance->transform, zfar, 0, 0, 0);
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
} else {
//render shadow
Rename Lod Threshold to Mesh Lod Threshold This makes it more obvious that the setting only affects mesh LOD, not manual (H)LOD achieved using visibility ranges.
2021-12-29 00:10:41 +01:00
_render_shadow_append(render_fb, p_instances, light_projection, light_transform, zfar, 0, 0, using_dual_paraboloid, using_dual_paraboloid_flip, use_pancake, p_camera_plane, p_lod_distance_multiplier, p_screen_mesh_lod_threshold, atlas_rect, flip_y, p_clear_region, p_open_pass, p_close_pass, p_render_info);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
Fix "ortogonal" -> "orthogonal" typo in rasterizer code
2022-04-26 21:49:44 +02:00
void RendererSceneRenderRD::render_material(const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, const PagedArray<GeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) {
_render_material(p_cam_transform, p_cam_projection, p_cam_orthogonal, p_instances, p_framebuffer, p_region);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
}
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
void RendererSceneRenderRD::render_particle_collider_heightfield(RID p_collider, const Transform3D &p_transform, const PagedArray<GeometryInstance *> &p_instances) {
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
RendererRD::ParticlesStorage *particles_storage = RendererRD::ParticlesStorage::get_singleton();
ERR_FAIL_COND(!particles_storage->particles_collision_is_heightfield(p_collider));
Vector3 extents = particles_storage->particles_collision_get_extents(p_collider) * p_transform.basis.get_scale();
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
CameraMatrix cm;
cm.set_orthogonal(-extents.x, extents.x, -extents.z, extents.z, 0, extents.y * 2.0);
Several GI related optimizations and fixes -SDFGI direct light is done over many frames -SDFGI Changed settings for rays/frame -SDFGI Misc optimizations -SDFGI Bug fix on probe scroll -GIProbe was not working, got it to work again -GIProbe dynamic objects were not working, fixed -Added a half size GI option.
2021-01-23 00:50:24 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
Vector3 cam_pos = p_transform.origin;
cam_pos.y += extents.y;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Rename Transform to Transform3D in core
2020-10-17 07:08:21 +02:00
Transform3D cam_xform;
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 14:50:35 +02:00
cam_xform.set_look_at(cam_pos, cam_pos - p_transform.basis.get_column(Vector3::AXIS_Y), -p_transform.basis.get_column(Vector3::AXIS_Z).normalized());
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
RID fb = particles_storage->particles_collision_get_heightfield_framebuffer(p_collider);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
_render_particle_collider_heightfield(fb, cam_xform, cm, p_instances);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::free(RID p_rid) {
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
if (render_buffers_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_rid);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
_free_render_buffer_data(rb);
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
memdelete(rb->data);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
if (rb->sdfgi) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
rb->sdfgi->erase();
memdelete(rb->sdfgi);
rb->sdfgi = nullptr;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
if (rb->volumetric_fog) {
_volumetric_fog_erase(rb);
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (rb->cluster_builder) {
memdelete(rb->cluster_builder);
}
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
render_buffers_owner.free(p_rid);
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
} else if (environment_owner.owns(p_rid)) {
//not much to delete, just free it
environment_owner.free(p_rid);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 19:37:24 +01:00
} else if (camera_effects_owner.owns(p_rid)) {
//not much to delete, just free it
camera_effects_owner.free(p_rid);
Reflection probes working
2019-09-09 22:50:51 +02:00
} else if (reflection_atlas_owner.owns(p_rid)) {
reflection_atlas_set_size(p_rid, 0, 0);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_rid);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
if (ra->cluster_builder) {
memdelete(ra->cluster_builder);
}
Reflection probes working
2019-09-09 22:50:51 +02:00
reflection_atlas_owner.free(p_rid);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
} else if (reflection_probe_instance_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_rid);
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
_free_forward_id(FORWARD_ID_TYPE_REFLECTION_PROBE, rpi->forward_id);
Reflection probes working
2019-09-09 22:50:51 +02:00
reflection_probe_release_atlas_index(p_rid);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
reflection_probe_instance_owner.free(p_rid);
Implement decals Also implemented decal atlas, so projectors and other stuff can be added. Sidenote: Had to make RID hashable, so some unrelated includes changed in order to include it in hashfuncs.h
2020-04-14 05:05:21 +02:00
} else if (decal_instance_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
DecalInstance *di = decal_instance_owner.get_or_null(p_rid);
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
_free_forward_id(FORWARD_ID_TYPE_DECAL, di->forward_id);
Implement decals Also implemented decal atlas, so projectors and other stuff can be added. Sidenote: Had to make RID hashable, so some unrelated includes changed in order to include it in hashfuncs.h
2020-04-14 05:05:21 +02:00
decal_instance_owner.free(p_rid);
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 13:42:56 +01:00
} else if (lightmap_instance_owner.owns(p_rid)) {
lightmap_instance_owner.free(p_rid);
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
} else if (gi.voxel_gi_instance_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
RendererSceneGIRD::VoxelGIInstance *voxel_gi = gi.voxel_gi_instance_owner.get_or_null(p_rid);
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
if (voxel_gi->texture.is_valid()) {
RD::get_singleton()->free(voxel_gi->texture);
RD::get_singleton()->free(voxel_gi->write_buffer);
GIProbes working.
2019-10-03 22:39:08 +02:00
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
for (int i = 0; i < voxel_gi->dynamic_maps.size(); i++) {
RD::get_singleton()->free(voxel_gi->dynamic_maps[i].texture);
RD::get_singleton()->free(voxel_gi->dynamic_maps[i].depth);
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 04:14:56 +02:00
}
Rename GI Classes * GIProbe is now VoxelGI * BakedLightmap is now LightmapGI As godot adds more ways to provide GI (as an example, SDFGI in 4.0), the different techniques (which have different pros/cons) need to be properly named to avoid confusion.
2021-06-05 00:47:26 +02:00
gi.voxel_gi_instance_owner.free(p_rid);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
} else if (sky.sky_owner.owns(p_rid)) {
sky.update_dirty_skys();
sky.free_sky(p_rid);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
} else if (light_instance_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 19:08:41 +02:00
LightInstance *light_instance = light_instance_owner.get_or_null(p_rid);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
//remove from shadow atlases..
Use range iterators for RBSet in most cases
2022-05-19 01:43:40 +02:00
for (const RID &E : light_instance->shadow_atlases) {
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(E);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
ERR_CONTINUE(!shadow_atlas->shadow_owners.has(p_rid));
uint32_t key = shadow_atlas->shadow_owners[p_rid];
uint32_t q = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x3;
uint32_t s = key & ShadowAtlas::SHADOW_INDEX_MASK;
shadow_atlas->quadrants[q].shadows.write[s].owner = RID();
Improvements to SpotLight3D and OmniLight3D's shadows OmniLight3D: * Fixed lack of precision in cube map mode by scaling the projection's znear. * Fixed aliasing issues by making the paraboloids use two square regions instead of two half squares. * Fixed shadowmap atlas bleeding by adding padding. * Fixed sihadow blur's inconsistent radius and unclamped sampling. SpotLight3D: * Fixed lack of precision by scaling the projection's znear. * Fixed normal biasing. Both: * Tweaked biasing to make sure it works out of the box in most situations.
2021-08-04 17:18:06 +02:00
if (key & ShadowAtlas::OMNI_LIGHT_FLAG) {
// Omni lights use two atlas spots, make sure to clear the other as well
shadow_atlas->quadrants[q].shadows.write[s + 1].owner = RID();
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
shadow_atlas->shadow_owners.erase(p_rid);
}
Fixes to forward mobile * use valid format for framebuffer: VK_FORMAT_A2B10G10R10_UNORM_PACK32 * Unfortunately cant be used for compute. * Mobile will need to do refprobe, sky, mipmapblurring using raster.
2021-07-15 22:06:33 +02:00
if (light_instance->light_type != RS::LIGHT_DIRECTIONAL) {
_free_forward_id(light_instance->light_type == RS::LIGHT_OMNI ? FORWARD_ID_TYPE_OMNI_LIGHT : FORWARD_ID_TYPE_SPOT_LIGHT, light_instance->forward_id);
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
light_instance_owner.free(p_rid);
} else if (shadow_atlas_owner.owns(p_rid)) {
shadow_atlas_set_size(p_rid, 0);
shadow_atlas_owner.free(p_rid);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
} else if (fog_volume_instance_owner.owns(p_rid)) {
fog_volume_instance_owner.free(p_rid);
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
} else {
return false;
}
return true;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 01:40:26 +01:00
debug_draw = p_debug_draw;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::update() {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
sky.update_dirty_skys();
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::set_time(double p_time, double p_step) {
Working sky shader implementation
2020-03-20 01:32:19 +01:00
time = p_time;
Auto exposure re-implemented in Vulkan
2020-01-12 02:26:52 +01:00
time_step = p_step;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) {
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
screen_space_roughness_limiter = p_enable;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
screen_space_roughness_limiter_amount = p_amount;
screen_space_roughness_limiter_limit = p_limit;
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
bool RendererSceneRenderRD::screen_space_roughness_limiter_is_active() const {
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
return screen_space_roughness_limiter;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::screen_space_roughness_limiter_get_amount() const {
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
return screen_space_roughness_limiter_amount;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
float RendererSceneRenderRD::screen_space_roughness_limiter_get_limit() const {
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
return screen_space_roughness_limiter_limit;
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-27 00:09:40 +01:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
TypedArray<Image> RendererSceneRenderRD::bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) {
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
RD::TextureFormat tf;
tf.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
tf.width = p_image_size.width; // Always 64x64
tf.height = p_image_size.height;
tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
RID albedo_alpha_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
RID normal_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
RID orm_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
RID emission_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
tf.format = RD::DATA_FORMAT_R32_SFLOAT;
RID depth_write_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D32_SFLOAT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D32_SFLOAT : RD::DATA_FORMAT_X8_D24_UNORM_PACK32;
RID depth_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
Vector<RID> fb_tex;
fb_tex.push_back(albedo_alpha_tex);
fb_tex.push_back(normal_tex);
fb_tex.push_back(orm_tex);
fb_tex.push_back(emission_tex);
fb_tex.push_back(depth_write_tex);
fb_tex.push_back(depth_tex);
RID fb = RD::get_singleton()->framebuffer_create(fb_tex);
//RID sampled_light;
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 13:42:56 +01:00
GeometryInstance *gi = geometry_instance_create(p_base);
Move storage for Mesh, MeshInstance, MultiMesh and Skeleton into MeshStorage
2022-04-02 07:29:04 +02:00
uint32_t sc = RSG::mesh_storage->mesh_get_surface_count(p_base);
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 13:42:56 +01:00
Vector<RID> materials;
materials.resize(sc);
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 13:42:56 +01:00
for (uint32_t i = 0; i < sc; i++) {
if (i < (uint32_t)p_material_overrides.size()) {
materials.write[i] = p_material_overrides[i];
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
}
}
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 13:42:56 +01:00
geometry_instance_set_surface_materials(gi, materials);
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
if (cull_argument.size() == 0) {
cull_argument.push_back(nullptr);
}
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 13:42:56 +01:00
cull_argument[0] = gi;
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
_render_uv2(cull_argument, fb, Rect2i(0, 0, p_image_size.width, p_image_size.height));
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 13:42:56 +01:00
geometry_instance_free(gi);
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
TypedArray<Image> ret;
{
PackedByteArray data = RD::get_singleton()->texture_get_data(albedo_alpha_tex, 0);
Ref<Image> img;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
img.instantiate();
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
img->create(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBA8, data);
RD::get_singleton()->free(albedo_alpha_tex);
ret.push_back(img);
}
{
PackedByteArray data = RD::get_singleton()->texture_get_data(normal_tex, 0);
Ref<Image> img;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
img.instantiate();
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
img->create(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBA8, data);
RD::get_singleton()->free(normal_tex);
ret.push_back(img);
}
{
PackedByteArray data = RD::get_singleton()->texture_get_data(orm_tex, 0);
Ref<Image> img;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
img.instantiate();
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
img->create(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBA8, data);
RD::get_singleton()->free(orm_tex);
ret.push_back(img);
}
{
PackedByteArray data = RD::get_singleton()->texture_get_data(emission_tex, 0);
Ref<Image> img;
Rename `instance()`->`instantiate()` when it's a verb
2021-06-18 00:03:09 +02:00
img.instantiate();
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 14:34:23 +02:00
img->create(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBAH, data);
RD::get_singleton()->free(emission_tex);
ret.push_back(img);
}
RD::get_singleton()->free(depth_write_tex);
RD::get_singleton()->free(depth_tex);
return ret;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
void RendererSceneRenderRD::sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
gi.sdfgi_debug_probe_pos = p_position;
gi.sdfgi_debug_probe_dir = p_dir;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererSceneRenderRD *RendererSceneRenderRD::singleton = nullptr;
Working sky shader implementation
2020-03-20 01:32:19 +01:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::get_reflection_probe_buffer() {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
return cluster.reflection_buffer;
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RID RendererSceneRenderRD::get_omni_light_buffer() {
return cluster.omni_light_buffer;
}
RID RendererSceneRenderRD::get_spot_light_buffer() {
return cluster.spot_light_buffer;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::get_directional_light_buffer() {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
return cluster.directional_light_buffer;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RID RendererSceneRenderRD::get_decal_buffer() {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
return cluster.decal_buffer;
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
int RendererSceneRenderRD::get_max_directional_lights() const {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
return cluster.max_directional_lights;
}
Move clustered renderer functionality
2021-03-23 11:46:31 +01:00
bool RendererSceneRenderRD::is_dynamic_gi_supported() const {
// usable by default (unless low end = true)
return true;
}
bool RendererSceneRenderRD::is_clustered_enabled() const {
// used by default.
return true;
}
bool RendererSceneRenderRD::is_volumetric_supported() const {
// usable by default (unless low end = true)
return true;
Add support for low-end 3D rendering. -Reduce number of uniform sets from 6 to 4. -Remove features in low end mode, in order to reduce the number of texture units fit to 16.
2020-12-07 22:27:38 +01:00
}
Create mobile renderer
2021-03-10 12:23:55 +01:00
uint32_t RendererSceneRenderRD::get_max_elements() const {
return GLOBAL_GET("rendering/limits/cluster_builder/max_clustered_elements");
}
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererSceneRenderRD::RendererSceneRenderRD(RendererStorageRD *p_storage) {
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
storage = p_storage;
Working sky shader implementation
2020-03-20 01:32:19 +01:00
singleton = this;
Fixes to mobile renderer * Make sure shaders are named, to aid in debug in case of failure * SceneRenderRD was being wrongly initialized (virtual functions being called when derivative class not initialized). * Fixed some bugs resulting on the above being corrected.
2021-08-16 19:51:29 +02:00
}
void RendererSceneRenderRD::init() {
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
Fixes to mobile renderer * Make sure shaders are named, to aid in debug in case of failure * SceneRenderRD was being wrongly initialized (virtual functions being called when derivative class not initialized). * Fixed some bugs resulting on the above being corrected.
2021-08-16 19:51:29 +02:00
max_cluster_elements = get_max_elements();
Environment sky more or less working.
2019-08-26 22:43:58 +02:00
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
directional_shadow.size = GLOBAL_GET("rendering/shadows/directional_shadow/size");
directional_shadow.use_16_bits = GLOBAL_GET("rendering/shadows/directional_shadow/16_bits");
Shadow map rendering optimization -All shadow rendering is done with raster now (no compute) -All shadow rendering is done by rendering directly to the shadow atlas -Improved how buffer clearing is done to optimize the above. -Ability to set shadows as 16 bits.
2021-01-24 20:00:20 +01:00
Working sky shader implementation
2020-03-20 01:32:19 +01:00
/* SKY SHADER */
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
sky.init(storage);
Working sky shader implementation
2020-03-20 01:32:19 +01:00
Combine init_gi and init_sdfgi into a single init
2021-03-11 04:35:05 +01:00
/* GI */
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 13:06:48 +02:00
if (is_dynamic_gi_supported()) {
Combine init_gi and init_sdfgi into a single init
2021-03-11 04:35:05 +01:00
gi.init(storage, &sky);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
}
Don't use trashy max_decals value to prevent crashes
2021-02-01 21:43:08 +01:00
{ //decals
cluster.max_decals = max_cluster_elements;
uint32_t decal_buffer_size = cluster.max_decals * sizeof(Cluster::DecalData);
cluster.decals = memnew_arr(Cluster::DecalData, cluster.max_decals);
cluster.decal_sort = memnew_arr(Cluster::InstanceSort<DecalInstance>, cluster.max_decals);
cluster.decal_buffer = RD::get_singleton()->storage_buffer_create(decal_buffer_size);
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
{ //reflections
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.max_reflections = max_cluster_elements;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
cluster.reflections = memnew_arr(Cluster::ReflectionData, cluster.max_reflections);
Rewrote how barriers work for faster rendering -Added more finegrained control in RenderingDevice API -Optimized barriers (use less ones for thee same) -General optimizations -Shadows render all together unbarriered -GI can render together with shadows. -SDFGI can render together with depth-preoass. -General fixes -Added GPU detection
2021-02-02 20:51:36 +01:00
cluster.reflection_sort = memnew_arr(Cluster::InstanceSort<ReflectionProbeInstance>, cluster.max_reflections);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.reflection_buffer = RD::get_singleton()->storage_buffer_create(sizeof(Cluster::ReflectionData) * cluster.max_reflections);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
{ //lights
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.max_lights = max_cluster_elements;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
uint32_t light_buffer_size = cluster.max_lights * sizeof(Cluster::LightData);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
cluster.omni_lights = memnew_arr(Cluster::LightData, cluster.max_lights);
cluster.omni_light_buffer = RD::get_singleton()->storage_buffer_create(light_buffer_size);
cluster.omni_light_sort = memnew_arr(Cluster::InstanceSort<LightInstance>, cluster.max_lights);
cluster.spot_lights = memnew_arr(Cluster::LightData, cluster.max_lights);
cluster.spot_light_buffer = RD::get_singleton()->storage_buffer_create(light_buffer_size);
cluster.spot_light_sort = memnew_arr(Cluster::InstanceSort<LightInstance>, cluster.max_lights);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
//defines += "\n#define MAX_LIGHT_DATA_STRUCTS " + itos(cluster.max_lights) + "\n";
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
Rewrite culling to be more cache/thread friendly. -Uses a single array with all data -Massive performance improvement -Does not support threads yet, but code is now thread friendly
2020-12-26 13:05:36 +01:00
cluster.max_directional_lights = MAX_DIRECTIONAL_LIGHTS;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
uint32_t directional_light_buffer_size = cluster.max_directional_lights * sizeof(Cluster::DirectionalLightData);
cluster.directional_lights = memnew_arr(Cluster::DirectionalLightData, cluster.max_directional_lights);
cluster.directional_light_buffer = RD::get_singleton()->uniform_buffer_create(directional_light_buffer_size);
}
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 13:06:48 +02:00
if (is_volumetric_supported()) {
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
{
// Initialize local fog shader
Vector<String> volumetric_fog_modes;
volumetric_fog_modes.push_back("");
volumetric_fog.shader.initialize(volumetric_fog_modes);
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
material_storage->shader_set_data_request_function(RendererRD::SHADER_TYPE_FOG, _create_fog_shader_funcs);
material_storage->material_set_data_request_function(RendererRD::SHADER_TYPE_FOG, _create_fog_material_funcs);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
volumetric_fog.volume_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::VolumeUBO));
}
{
New OpenGL batching canvas renderer
2021-11-16 16:25:42 +01:00
ShaderCompiler::DefaultIdentifierActions actions;
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
actions.renames["TIME"] = "scene_params.time";
actions.renames["PI"] = _MKSTR(Math_PI);
actions.renames["TAU"] = _MKSTR(Math_TAU);
actions.renames["E"] = _MKSTR(Math_E);
actions.renames["WORLD_POSITION"] = "world.xyz";
actions.renames["OBJECT_POSITION"] = "params.position";
actions.renames["UVW"] = "uvw";
actions.renames["EXTENTS"] = "params.extents";
actions.renames["ALBEDO"] = "albedo";
actions.renames["DENSITY"] = "density";
actions.renames["EMISSION"] = "emission";
actions.renames["SDF"] = "sdf";
actions.usage_defines["SDF"] = "#define SDF_USED\n";
actions.usage_defines["DENSITY"] = "#define DENSITY_USED\n";
actions.usage_defines["ALBEDO"] = "#define ALBEDO_USED\n";
actions.usage_defines["EMISSION"] = "#define EMISSION_USED\n";
actions.sampler_array_name = "material_samplers";
actions.base_texture_binding_index = 1;
actions.texture_layout_set = VolumetricFogShader::FogSet::FOG_SET_MATERIAL;
actions.base_uniform_string = "material.";
actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
actions.default_repeat = ShaderLanguage::REPEAT_DISABLE;
actions.global_buffer_array_variable = "global_variables.data";
volumetric_fog.compiler.initialize(actions);
}
{
// default material and shader for fog shader
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
volumetric_fog.default_shader = material_storage->shader_allocate();
material_storage->shader_initialize(volumetric_fog.default_shader);
material_storage->shader_set_code(volumetric_fog.default_shader, R"(
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
// Default fog shader.
shader_type fog;
void fog() {
DENSITY = 1.0;
ALBEDO = vec3(1.0);
}
)");
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
volumetric_fog.default_material = material_storage->material_allocate();
material_storage->material_initialize(volumetric_fog.default_material);
material_storage->material_set_shader(volumetric_fog.default_material, volumetric_fog.default_shader);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
Fix some issues found by cppcheck.
2022-04-05 12:40:26 +02:00
FogMaterialData *md = static_cast<FogMaterialData *>(material_storage->material_get_data(volumetric_fog.default_material, RendererRD::SHADER_TYPE_FOG));
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
volumetric_fog.default_shader_rd = volumetric_fog.shader.version_get_shader(md->shader_data->version, 0);
Vector<RD::Uniform> uniforms;
{
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
Vector<RID> ids;
ids.resize(12);
RID *ids_ptr = ids.ptrw();
Moved particles into ParticlesStorage
2022-04-12 13:41:50 +02:00
ids_ptr[0] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
ids_ptr[1] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
ids_ptr[2] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
ids_ptr[3] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
ids_ptr[4] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
ids_ptr[5] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
ids_ptr[6] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
ids_ptr[7] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
ids_ptr[8] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
ids_ptr[9] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
ids_ptr[10] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
ids_ptr[11] = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
Add a UniformSet cache * Changed syntax usage for RD::Uniform to create faster with a single RID * Converted render pass setup to use this in clustered renderer to test. This is the first step into creating a proper uniform set cache system to simplify large parts of the codebase.
2022-03-06 12:57:09 +01:00
RD::Uniform u(RD::UNIFORM_TYPE_SAMPLER, 1, ids);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
{
RD::Uniform u;
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
u.binding = 2;
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
u.append_id(RendererRD::MaterialStorage::get_singleton()->global_variables_get_storage_buffer());
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
uniforms.push_back(u);
}
volumetric_fog.base_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.default_shader_rd, VolumetricFogShader::FogSet::FOG_SET_BASE);
}
{
String defines = "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(cluster.max_directional_lights) + "\n";
defines += "\n#define MAX_SKY_LOD " + itos(get_roughness_layers() - 1) + ".0\n";
if (is_using_radiance_cubemap_array()) {
defines += "\n#define USE_RADIANCE_CUBEMAP_ARRAY \n";
}
Vector<String> volumetric_fog_modes;
volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n");
volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n#define ENABLE_SDFGI\n");
volumetric_fog_modes.push_back("\n#define MODE_FILTER\n");
volumetric_fog_modes.push_back("\n#define MODE_FOG\n");
volumetric_fog_modes.push_back("\n#define MODE_COPY\n");
volumetric_fog.process_shader.initialize(volumetric_fog_modes, defines);
volumetric_fog.process_shader_version = volumetric_fog.process_shader.version_create();
for (int i = 0; i < VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX; i++) {
volumetric_fog.process_pipelines[i] = RD::get_singleton()->compute_pipeline_create(volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, i));
}
volumetric_fog.params_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::ParamsUBO));
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
}
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 15:33:28 +02:00
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
{
RD::SamplerState sampler;
Refactored 2D shader and lighting system -Removed normal/specular properties from nodes -Create CanvasTexture, which can contain normal/specular channels -Refactored, optimized and simplified 2D shaders -Use atlas for light textures. -Use a shadow atlas for shadow textures. -Use both items aboves to make light rendering stateless (faster). -Reorganized uniform sets for more efficiency.
2020-10-24 17:15:43 +02:00
sampler.mag_filter = RD::SAMPLER_FILTER_NEAREST;
sampler.min_filter = RD::SAMPLER_FILTER_NEAREST;
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
sampler.enable_compare = true;
sampler.compare_op = RD::COMPARE_OP_LESS;
shadow_sampler = RD::get_singleton()->sampler_create(sampler);
}
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape(int(GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_bokeh_shape"))));
camera_effects_set_dof_blur_quality(RS::DOFBlurQuality(int(GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_bokeh_quality"))), GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_use_jitter"));
environment_set_ssao_quality(RS::EnvironmentSSAOQuality(int(GLOBAL_GET("rendering/environment/ssao/quality"))), GLOBAL_GET("rendering/environment/ssao/half_size"), GLOBAL_GET("rendering/environment/ssao/adaptive_target"), GLOBAL_GET("rendering/environment/ssao/blur_passes"), GLOBAL_GET("rendering/environment/ssao/fadeout_from"), GLOBAL_GET("rendering/environment/ssao/fadeout_to"));
screen_space_roughness_limiter = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/enabled");
screen_space_roughness_limiter_amount = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/amount");
screen_space_roughness_limiter_limit = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/limit");
glow_bicubic_upscale = int(GLOBAL_GET("rendering/environment/glow/upscale_mode")) > 0;
glow_high_quality = GLOBAL_GET("rendering/environment/glow/use_high_quality");
ssr_roughness_quality = RS::EnvironmentSSRRoughnessQuality(int(GLOBAL_GET("rendering/environment/screen_space_reflection/roughness_quality")));
sss_quality = RS::SubSurfaceScatteringQuality(int(GLOBAL_GET("rendering/environment/subsurface_scattering/subsurface_scattering_quality")));
sss_scale = GLOBAL_GET("rendering/environment/subsurface_scattering/subsurface_scattering_scale");
sss_depth_scale = GLOBAL_GET("rendering/environment/subsurface_scattering/subsurface_scattering_depth_scale");
Added SSIL post processing effect
2021-08-03 09:07:32 +02:00
environment_set_ssil_quality(RS::EnvironmentSSILQuality(int(GLOBAL_GET("rendering/environment/ssil/quality"))), GLOBAL_GET("rendering/environment/ssil/half_size"), GLOBAL_GET("rendering/environment/ssil/adaptive_target"), GLOBAL_GET("rendering/environment/ssil/blur_passes"), GLOBAL_GET("rendering/environment/ssil/fadeout_from"), GLOBAL_GET("rendering/environment/ssil/fadeout_to"));
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
directional_penumbra_shadow_kernel = memnew_arr(float, 128);
directional_soft_shadow_kernel = memnew_arr(float, 128);
penumbra_shadow_kernel = memnew_arr(float, 128);
soft_shadow_kernel = memnew_arr(float, 128);
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
shadows_quality_set(RS::ShadowQuality(int(GLOBAL_GET("rendering/shadows/shadows/soft_shadow_quality"))));
directional_shadow_quality_set(RS::ShadowQuality(int(GLOBAL_GET("rendering/shadows/directional_shadow/soft_shadow_quality"))));
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
Reorganize Project Settings -Advanced Settings toggle also hides advanced properties when disabled -Simplified Advanced Bar (errors were just plain redundant) -Reorganized rendering quality settings. -Reorganized miscelaneous settings for clean up.
2021-02-17 17:44:49 +01:00
environment_set_volumetric_fog_volume_size(GLOBAL_GET("rendering/environment/volumetric_fog/volume_size"), GLOBAL_GET("rendering/environment/volumetric_fog/volume_depth"));
environment_set_volumetric_fog_filter_active(GLOBAL_GET("rendering/environment/volumetric_fog/use_filter"));
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
Implement more rendering options as specialization constants * Shadow quality settings now specialization constant. * Decal and light projector filters can be set. * Changing those settings forces re-creation of the pipelines. These changes should help improve performance related to shadow mapping, and allows improving performance by sacrificing decal and light projector quality.
2021-07-19 21:41:55 +02:00
decals_set_filter(RS::DecalFilter(int(GLOBAL_GET("rendering/textures/decals/filter"))));
light_projectors_set_filter(RS::LightProjectorFilter(int(GLOBAL_GET("rendering/textures/light_projectors/filter"))));
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
cull_argument.set_page_pool(&cull_argument_pool);
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
bool can_use_storage = _render_buffers_can_be_storage();
bokeh_dof = memnew(RendererRD::BokehDOF(!can_use_storage));
copy_effects = memnew(RendererRD::CopyEffects(!can_use_storage));
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
tone_mapper = memnew(RendererRD::ToneMapper);
Base 3D engine done, still untested, though.
2019-08-19 00:40:52 +02:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
RenderingServer reorganization
2020-12-04 19:26:24 +01:00
RendererSceneRenderRD::~RendererSceneRenderRD() {
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
Split out bokeh_dof and copy effects
2022-04-29 09:10:54 +02:00
if (bokeh_dof) {
memdelete(bokeh_dof);
}
if (copy_effects) {
memdelete(copy_effects);
}
Splitting tonemapper into its own class
2022-04-27 05:42:50 +02:00
if (tone_mapper) {
memdelete(tone_mapper);
}
Use range iterators for `Map`
2021-08-09 22:13:42 +02:00
for (const KeyValue<int, ShadowCubemap> &E : shadow_cubemaps) {
RD::get_singleton()->free(E.value.cubemap);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
GIProbes working.
2019-10-03 22:39:08 +02:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
if (sky.sky_scene_state.uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sky.sky_scene_state.uniform_set)) {
RD::get_singleton()->free(sky.sky_scene_state.uniform_set);
Working sky shader implementation
2020-03-20 01:32:19 +01:00
}
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 13:06:48 +02:00
if (is_dynamic_gi_supported()) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 13:08:08 +01:00
gi.free();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
}
Fixes recently introduced shader leaks
2020-06-27 15:08:20 +02:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 13:28:55 +02:00
if (is_volumetric_supported()) {
volumetric_fog.process_shader.version_free(volumetric_fog.process_shader_version);
RD::get_singleton()->free(volumetric_fog.volume_ubo);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RD::get_singleton()->free(volumetric_fog.params_ubo);
Extract global variable, shader and material storage
2022-03-21 12:25:25 +01:00
material_storage->shader_free(volumetric_fog.default_shader);
material_storage->material_free(volumetric_fog.default_material);
}
Add proper quality settings to soft shadows
2020-04-10 11:30:36 +02:00
memdelete_arr(directional_penumbra_shadow_kernel);
memdelete_arr(directional_soft_shadow_kernel);
memdelete_arr(penumbra_shadow_kernel);
memdelete_arr(soft_shadow_kernel);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
{
RD::get_singleton()->free(cluster.directional_light_buffer);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
RD::get_singleton()->free(cluster.omni_light_buffer);
RD::get_singleton()->free(cluster.spot_light_buffer);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
RD::get_singleton()->free(cluster.reflection_buffer);
RD::get_singleton()->free(cluster.decal_buffer);
memdelete_arr(cluster.directional_lights);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
memdelete_arr(cluster.omni_lights);
memdelete_arr(cluster.spot_lights);
memdelete_arr(cluster.omni_light_sort);
memdelete_arr(cluster.spot_light_sort);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
memdelete_arr(cluster.reflections);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
memdelete_arr(cluster.reflection_sort);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
memdelete_arr(cluster.decals);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 17:25:38 +01:00
memdelete_arr(cluster.decal_sort);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-23 01:39:09 +02:00
}
Added volumetric fog effect.
2020-08-13 03:21:01 +02:00
RD::get_singleton()->free(shadow_sampler);
directional_shadow_atlas_set_size(0);
Replace Octree by DynamicBVH in cull code -Much greater pairing/unpairing performance -For now, using it for culling too, but this will change in a couple of days. -Added a paged allocator, to efficiently alloc/free some types of objects.
2020-12-23 17:52:58 +01:00
cull_argument.reset(); //avoid exit error
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 03:51:27 +02:00
}
Reference in a new issue Copy permalink