godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp

4484 lines
177 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 11:01:00 +00:00
/*************************************************************************/
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 11:01:00 +00: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 20:27:34 +00: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 11:01:00 +00: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 18:26:24 +00: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 08:59:06 +00: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 22:33:38 +00:00
#include "core/config/project_settings.h"
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
#include "core/os/os.h"
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
#include "renderer_compositor_rd.h"
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
#include "servers/rendering/renderer_rd/environment/fog.h"
Extract global variable, shader and material storage
2022-03-21 11:25:25 +00: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 21:09:47 +00: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 12:18:13 +00:00
Add proper quality settings to soft shadows
2020-04-10 09:30:36 +00: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 18:26:24 +00: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 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
bool needs_sdfgi = p_environment.is_valid() && environment_get_sdfgi_enabled(p_environment);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
if (!needs_sdfgi) {
if (rb->sdfgi != nullptr) {
//erase it
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00: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 12:08:08 +00: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 13:33:28 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (rb->sdfgi && (rb->sdfgi->num_cascades != environment_get_sdfgi_cascades(p_environment) || rb->sdfgi->min_cell_size != environment_get_sdfgi_min_cell_size(p_environment) || requested_history_size != rb->sdfgi->history_size || rb->sdfgi->uses_occlusion != environment_get_sdfgi_use_occlusion(p_environment) || rb->sdfgi->y_scale_mode != environment_get_sdfgi_y_scale(p_environment))) {
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
//configuration changed, erase
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
}
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
RendererRD::GI::SDFGI *sdfgi = rb->sdfgi;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
if (sdfgi == nullptr) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
// re-create
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
rb->sdfgi = gi.create_sdfgi(p_environment, p_world_position, requested_history_size);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
} else {
//check for updates
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
rb->sdfgi->update(p_environment, p_world_position);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
}
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
int RendererSceneRenderRD::sdfgi_get_pending_region_count(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
if (rb->sdfgi == nullptr) {
return 0;
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
int dirty_count = 0;
for (uint32_t i = 0; i < rb->sdfgi->cascades.size(); i++) {
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
const RendererRD::GI::SDFGI::Cascade &c = rb->sdfgi->cascades[i];
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
if (c.dirty_regions == RendererRD::GI::SDFGI::Cascade::DIRTY_ALL) {
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
dirty_count++;
} else {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
for (int j = 0; j < 3; j++) {
if (c.dirty_regions[j] != 0) {
dirty_count++;
}
}
Working sky shader implementation
2020-03-20 00:32:19 +00:00
}
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
return dirty_count;
}
Working sky shader implementation
2020-03-20 00:32:19 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 17:08:41 +00: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 12:08:08 +00:00
ERR_FAIL_COND_V(rb == nullptr, AABB());
ERR_FAIL_COND_V(rb->sdfgi == nullptr, AABB());
Working sky shader implementation
2020-03-20 00:32:19 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:32:19 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 17:08:41 +00: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 12:08:08 +00:00
ERR_FAIL_COND_V(rb == nullptr, -1);
ERR_FAIL_COND_V(rb->sdfgi == nullptr, -1);
Working sky shader implementation
2020-03-20 00:32:19 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
return rb->sdfgi->get_pending_region_data(p_region, from, size, bounds);
}
Working sky shader implementation
2020-03-20 00:32:19 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:32:19 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:32:19 +00:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:32:19 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:32:19 +00:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:32:19 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 13:46:03 +00:00
glow_bicubic_upscale = p_enable;
Tonemapping ported (not all parameters supported yet, only enough to get correct color)
2019-08-27 18:27:35 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::environment_glow_set_use_high_quality(bool p_enable) {
Add high quality glow mode
2020-09-01 06:04:45 +00:00
glow_high_quality = p_enable;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
volumetric_fog_size = p_size;
volumetric_fog_depth = p_depth;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::environment_set_volumetric_fog_filter_active(bool p_enable) {
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
volumetric_fog_filter_active = p_enable;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 12:08:08 +00: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 13:33:28 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 12:08:08 +00: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 13:33:28 +00: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-22 23:50:24 +00: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 12:08:08 +00: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-22 23:50:24 +00:00
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) {
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
ssr_roughness_quality = p_quality;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RS::EnvironmentSSRRoughnessQuality RendererSceneRenderRD::environment_get_ssr_roughness_quality() const {
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
return ssr_roughness_quality;
}
Port ASSAO to Godot to replace SAO
2020-12-08 05:37:09 +00: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 10:18:55 +00:00
ssao_quality = p_quality;
Revert "Replace SAO implementation with MSSAO"
2020-10-18 22:27:51 +00:00
ssao_half_size = p_half_size;
Port ASSAO to Godot to replace SAO
2020-12-08 05:37:09 +00: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 10:18:55 +00:00
}
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
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 18:26:24 +00:00
Ref<Image> RendererSceneRenderRD::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
ERR_FAIL_COND_V(p_env.is_null(), Ref<Image>());
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 12:34:23 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
RS::EnvironmentBG environment_background = environment_get_background(p_env);
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 14:47:42 +00:00
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 12:34:23 +00:00
return Ref<Image>(); //nothing to bake
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
RS::EnvironmentAmbientSource ambient_source = environment_get_ambient_source(p_env);
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 14:47:42 +00:00
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;
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
use_cube_map = use_cube_map || (environment_background == RS::ENV_BG_SKY && environment_get_sky(p_env).is_valid());
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 14:47:42 +00:00
Color ambient_color;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
float ambient_color_sky_mix = 0.0;
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 14:47:42 +00:00
if (use_ambient_light) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
ambient_color_sky_mix = environment_get_ambient_sky_contribution(p_env);
const float ambient_energy = environment_get_ambient_light_energy(p_env);
ambient_color = environment_get_ambient_light(p_env);
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 08:37:22 +00: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 14:47:42 +00:00
ambient_color.r *= ambient_energy;
ambient_color.g *= ambient_energy;
ambient_color.b *= ambient_energy;
}
if (use_cube_map) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
Ref<Image> panorama = sky_bake_panorama(environment_get_sky(p_env), environment_get_bg_energy(p_env), p_bake_irradiance, p_size);
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 14:47:42 +00:00
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 12:34:23 +00: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 14:47:42 +00:00
return panorama;
} else {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
const float bg_energy = environment_get_bg_energy(p_env);
Color panorama_color = ((environment_background == RS::ENV_BG_CLEAR_COLOR) ? RSG::texture_storage->get_default_clear_color() : environment_get_bg_color(p_env));
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 08:37:22 +00: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 14:47:42 +00: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 12:34:23 +00: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 14:47:42 +00: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 11:58:15 +00: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 14:47:42 +00: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 12:34:23 +00:00
}
return Ref<Image>();
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
////////////////////////////////////////////////////////////
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
RID RendererSceneRenderRD::fog_volume_instance_create(RID p_fog_volume) {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
return RendererRD::Fog::get_singleton()->fog_volume_instance_create(p_fog_volume);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
}
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
void RendererSceneRenderRD::fog_volume_instance_set_transform(RID p_fog_volume_instance, const Transform3D &p_transform) {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
RendererRD::Fog::FogVolumeInstance *fvi = RendererRD::Fog::get_singleton()->get_fog_volume_instance(p_fog_volume_instance);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
ERR_FAIL_COND(!fvi);
fvi->transform = p_transform;
}
void RendererSceneRenderRD::fog_volume_instance_set_active(RID p_fog_volume_instance, bool p_active) {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
RendererRD::Fog::FogVolumeInstance *fvi = RendererRD::Fog::get_singleton()->get_fog_volume_instance(p_fog_volume_instance);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
ERR_FAIL_COND(!fvi);
fvi->active = p_active;
}
RID RendererSceneRenderRD::fog_volume_instance_get_volume(RID p_fog_volume_instance) const {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
RendererRD::Fog::FogVolumeInstance *fvi = RendererRD::Fog::get_singleton()->get_fog_volume_instance(p_fog_volume_instance);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
ERR_FAIL_COND_V(!fvi, RID());
return fvi->volume;
}
Vector3 RendererSceneRenderRD::fog_volume_instance_get_position(RID p_fog_volume_instance) const {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
RendererRD::Fog::FogVolumeInstance *fvi = RendererRD::Fog::get_singleton()->get_fog_volume_instance(p_fog_volume_instance);
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
ERR_FAIL_COND_V(!fvi, Vector3());
return fvi->transform.get_origin();
}
////////////////////////////////////////////////////////////
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::reflection_atlas_create() {
Reflection probes working
2019-09-09 20:50:51 +00: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 16:44:49 +00: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 20:50:51 +00:00
Move clustered renderer functionality
2021-03-23 10:46:31 +00: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 16:25:38 +00:00
Reflection probes working
2019-09-09 20:50:51 +00:00
return reflection_atlas_owner.make_rid(ra);
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00:00
ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_ref_atlas);
Reflection probes working
2019-09-09 20:50:51 +00: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 10:46:31 +00: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 16:25:38 +00:00
Basic fast filtering implementation
2020-02-20 23:27:34 +00:00
ra->size = p_reflection_size;
ra->count = p_reflection_count;
Reflection probes working
2019-09-09 20:50:51 +00: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 07:26:57 +00:00
RD::get_singleton()->free(ra->depth_buffer);
ra->depth_buffer = RID();
Reflection probes working
2019-09-09 20:50:51 +00:00
for (int i = 0; i < ra->reflections.size(); i++) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
ra->reflections.write[i].data.clear_reflection_data();
Reflection probes working
2019-09-09 20:50:51 +00: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 18:56:59 +00:00
int RendererSceneRenderRD::reflection_atlas_get_size(RID p_ref_atlas) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 18:56:59 +00:00
ERR_FAIL_COND_V(!ra, 0);
return ra->size;
}
Reflection probes working
2019-09-09 20:50:51 +00:00
////////////////////////
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::reflection_probe_instance_create(RID p_probe) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 20:06:33 +00: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 01:51:27 +00:00
return reflection_probe_instance_owner.make_rid(rpi);
}
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 17:08:41 +00: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 01:51:27 +00:00
ERR_FAIL_COND(!rpi);
rpi->transform = p_transform;
rpi->dirty = true;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::reflection_probe_release_atlas_index(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Reflection probes working
2019-09-09 20:50:51 +00: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 17:08:41 +00:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 20:50:51 +00: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 18:26:24 +00:00
bool RendererSceneRenderRD::reflection_probe_instance_needs_redraw(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 01:51:27 +00: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 09:34:31 +00: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 01:51:27 +00:00
return true;
}
Reflection probes working
2019-09-09 20:50:51 +00:00
return rpi->atlas_index == -1;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
bool RendererSceneRenderRD::reflection_probe_instance_has_reflection(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Reflection probes working
2019-09-09 20:50:51 +00:00
ERR_FAIL_COND_V(!rpi, false);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
Reflection probes working
2019-09-09 20:50:51 +00:00
return rpi->atlas.is_valid();
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_reflection_atlas);
Reflection probes working
2019-09-09 20:50:51 +00:00
ERR_FAIL_COND_V(!atlas, false);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
Basic fast filtering implementation
2020-02-20 23:27:34 +00:00
ERR_FAIL_COND_V(!rpi, false);
Porting cubemap compute shaders to raster for the mobile renderer
2021-07-27 13:33:47 +00:00
RD::get_singleton()->draw_command_begin_label("Reflection probe render");
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 00:32:19 +00: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-20 23:27:34 +00:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 01:16:50 +00: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 20:50:51 +00:00
if (atlas->reflection.is_null()) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 09:34:31 +00: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 01:51:27 +00:00
{
Reflection probes working
2019-09-09 20:50:51 +00:00
//reflection atlas was unused, create:
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
RD::TextureFormat tf;
Reflection probes working
2019-09-09 20:50:51 +00:00
tf.array_layers = 6 * atlas->count;
Use 32bit instead of 64bit 3D render buffer on mobile
2021-06-17 10:37:08 +00: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 03:50:05 +00:00
tf.texture_type = RD::TEXTURE_TYPE_CUBE_ARRAY;
Basic fast filtering implementation
2020-02-20 23:27:34 +00:00
tf.mipmaps = mipmaps;
Reflection probes working
2019-09-09 20:50:51 +00: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 20:06:33 +00: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 20:50:51 +00: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 01:51:27 +00:00
}
Reflection probes working
2019-09-09 20:50:51 +00:00
atlas->reflections.resize(atlas->count);
for (int i = 0; i < atlas->count; i++) {
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
atlas->reflections.write[i].data.update_reflection_data(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 20:50:51 +00:00
for (int j = 0; j < 6; j++) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00: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 20:50:51 +00:00
}
}
GIProbes working.
2019-10-03 20:39:08 +00: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 20:50:51 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
Reflection probes working
2019-09-09 20:50:51 +00: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 17:08:41 +00:00
ReflectionProbeInstance *rpi2 = reflection_probe_instance_owner.get_or_null(atlas->reflections[i].owner);
Reflection probes working
2019-09-09 20:50:51 +00: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 01:51:27 +00:00
}
}
Reflection probes working
2019-09-09 20:50:51 +00:00
Fix indexing of multiple reflection probes
2021-07-06 03:00:33 +00: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 20:50:51 +00:00
rpi->atlas = p_reflection_atlas;
rpi->rendering = true;
rpi->dirty = false;
Improve cubemap importance sampling
2020-03-01 01:16:50 +00:00
rpi->processing_layer = 1;
Reflection probes working
2019-09-09 20:50:51 +00:00
rpi->processing_side = 0;
Porting cubemap compute shaders to raster for the mobile renderer
2021-07-27 13:33:47 +00:00
RD::get_singleton()->draw_command_end_label();
Reflection probes working
2019-09-09 20:50:51 +00:00
return true;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00: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 18:26:24 +00:00
bool RendererSceneRenderRD::reflection_probe_instance_postprocess_step(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 01:51:27 +00:00
ERR_FAIL_COND_V(!rpi, false);
ERR_FAIL_COND_V(!rpi->rendering, false);
Reflection probes working
2019-09-09 20:50:51 +00:00
ERR_FAIL_COND_V(rpi->atlas.is_null(), false);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 20:50:51 +00: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 01:51:27 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00:00
if (RSG::light_storage->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS) {
Working sky shader implementation
2020-03-20 00:32:19 +00:00
// Using real time reflections, all roughness is done in one step
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
atlas->reflections.write[rpi->atlas_index].data.create_reflection_fast_filter(false);
Working sky shader implementation
2020-03-20 00:32:19 +00:00
rpi->rendering = false;
rpi->processing_side = 0;
rpi->processing_layer = 1;
return true;
}
Improve cubemap importance sampling
2020-03-01 01:16:50 +00:00
if (rpi->processing_layer > 1) {
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
atlas->reflections.write[rpi->atlas_index].data.create_reflection_importance_sample(false, 10, rpi->processing_layer, sky.sky_ggx_samples_quality);
Improve cubemap importance sampling
2020-03-01 01:16:50 +00: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 {
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
atlas->reflections.write[rpi->atlas_index].data.create_reflection_importance_sample(false, rpi->processing_side, rpi->processing_layer, sky.sky_ggx_samples_quality);
Basic fast filtering implementation
2020-02-20 23:27:34 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
rpi->processing_side++;
if (rpi->processing_side == 6) {
rpi->processing_side = 0;
Improve cubemap importance sampling
2020-03-01 01:16:50 +00:00
rpi->processing_layer++;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
Improve cubemap importance sampling
2020-03-01 01:16:50 +00:00
return false;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
uint32_t RendererSceneRenderRD::reflection_probe_instance_get_resolution(RID p_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 01:51:27 +00:00
ERR_FAIL_COND_V(!rpi, 0);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 20:50:51 +00:00
ERR_FAIL_COND_V(!atlas, 0);
return atlas->size;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 01:51:27 +00: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 17:08:41 +00:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
Reflection probes working
2019-09-09 20:50:51 +00: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 01:51:27 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00:00
ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);
GIProbes working.
2019-10-03 20:39:08 +00: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 17:08:41 +00:00
ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas);
GIProbes working.
2019-10-03 20:39:08 +00: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 01:51:27 +00:00
///////////////////////////////////////////////////////////
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::shadow_atlas_create() {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 19:00:20 +00: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 17:08:41 +00: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 01:51:27 +00: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 19:00:20 +00: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 01:51:27 +00: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 14:41:43 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 18:19:13 +00:00
shadow_atlas->quadrants[i].shadows.clear();
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 20:13:42 +00: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 01:51:27 +00: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 15:18:06 +00:00
shadow_atlas->use_16_bits = p_16_bits;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 01:51:27 +00: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 14:41:43 +00:00
if (shadow_atlas->quadrants[p_quadrant].subdivision == subdiv) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 14:41:43 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 17:08:41 +00: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 01:51:27 +00: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 18:19:13 +00:00
shadow_atlas->quadrants[p_quadrant].shadows.clear();
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 18:26:24 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 17:08:41 +00: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 01:51:27 +00: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 14:41:43 +00: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 01:51:27 +00: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 14:41:43 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 14:41:43 +00:00
if (found_free_idx == -1 && found_used_idx == -1) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 14:41:43 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00: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 17:08:41 +00: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 15:18:06 +00: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 17:08:41 +00: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 15:18:06 +00: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 14:55:32 +00: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 17:08:41 +00: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 01:51:27 +00: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 14:55:32 +00: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 01:51:27 +00: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 14:41:43 +00:00
if (sd == 0) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 14:41:43 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 14:41:43 +00:00
if (best_size != -1 && max_fit > best_size) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 14:41:43 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 14:55:32 +00: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 15:18:06 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 15:18:06 +00:00
old_subdivision = shadow_atlas->quadrants[old_quadrant].subdivision;
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 14:55:32 +00: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 15:18:06 +00:00
sh->alloc_tick = tick;
sh->version = p_light_version;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00:00
if (is_omni) {
new_key |= ShadowAtlas::OMNI_LIGHT_FLAG;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 14:55:32 +00: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 15:18:06 +00: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 01:51:27 +00: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 14:55:32 +00:00
shadow_atlas->shadow_owners[p_light_instance] = new_key;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00:00
return should_redraw;
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00: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 17:08:41 +00: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 15:18:06 +00: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 14:55:32 +00: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 15:18:06 +00: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 01:51:27 +00: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 19:00:20 +00: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 01:51:27 +00: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 19:00:20 +00: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 01:51:27 +00:00
return;
}
Directional lights and shadow mapping are functional.
2019-09-07 17:38:17 +00: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 15:18:06 +00:00
directional_shadow.use_16_bits = p_16_bits;
Directional lights and shadow mapping are functional.
2019-09-07 17:38:17 +00:00
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 19:00:20 +00:00
_base_uniforms_changed();
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::set_directional_shadow_count(int p_count) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
directional_shadow.light_count = p_count;
directional_shadow.current_light = 0;
}
Directional lights and shadow mapping are functional.
2019-09-07 17:38:17 +00: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 18:26:24 +00: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 01:51:27 +00:00
ERR_FAIL_COND_V(directional_shadow.light_count == 0, 0);
Directional lights and shadow mapping are functional.
2019-09-07 17:38:17 +00: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 01:51:27 +00:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 01:51:27 +00:00
ERR_FAIL_COND_V(!light_instance, 0);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 18:21:27 +00:00
case RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL:
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
break; //none
Style: clang-format: Disable AllowShortCaseLabelsOnASingleLine Part of #33027.
2020-05-10 11:00:47 +00: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 01:51:27 +00:00
}
Directional lights and shadow mapping are functional.
2019-09-07 17:38:17 +00:00
return MAX(r.size.width, r.size.height);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 16:19:03 +00: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 18:37:24 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 00:23:21 +00:00
dof_blur_quality = p_quality;
dof_blur_use_jitter = p_use_jitter;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 00:23:21 +00:00
dof_blur_bokeh_shape = p_shape;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00:00
CameraEffects *camfx = camera_effects_owner.get_or_null(p_camera_effects);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00: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 18:26:24 +00: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 17:08:41 +00:00
CameraEffects *camfx = camera_effects_owner.get_or_null(p_camera_effects);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
ERR_FAIL_COND(!camfx);
camfx->override_exposure_enabled = p_enable;
camfx->override_exposure = p_exposure;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::light_instance_create(RID p_light) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
RID li = light_instance_owner.make_rid(LightInstance());
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 01:51:27 +00:00
light_instance->self = li;
light_instance->light = p_light;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 20:06:33 +00: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 01:51:27 +00:00
return li;
}
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 17:08:41 +00: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 01:51:27 +00:00
ERR_FAIL_COND(!light_instance);
light_instance->transform = p_transform;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND(!light_instance);
light_instance->aabb = p_aabb;
}
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
void RendererSceneRenderRD::light_instance_set_shadow_transform(RID p_light_instance, const Projection &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 17:08:41 +00: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 01:51:27 +00: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 19:51:36 +00:00
ERR_FAIL_INDEX(p_pass, 6);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 18:11:15 +00: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 01:51:52 +00:00
light_instance->shadow_transform[p_pass].shadow_texel_size = p_shadow_texel_size;
Support light size and soft shadows
2020-04-09 18:11:15 +00: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 01:51:27 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::light_instance_mark_visible(RID p_light_instance) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 01:51:27 +00:00
ERR_FAIL_COND(!light_instance);
light_instance->last_scene_pass = scene_pass;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RendererSceneRenderRD::ShadowCubemap *RendererSceneRenderRD::_get_shadow_cubemap(int p_size) {
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 03:50:05 +00:00
tf.texture_type = RD::TEXTURE_TYPE_CUBE;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 12:08:08 +00: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 02:14:56 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
shadow_cubemaps[p_size] = sc;
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 02:14:56 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
return &shadow_cubemaps[p_size];
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 02:14:56 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
//////////////////////////
GIProbes working.
2019-10-03 20:39:08 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 20:06:33 +00:00
di.forward_id = _allocate_forward_id(FORWARD_ID_TYPE_DECAL);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
return decal_instance_owner.make_rid(di);
}
GIProbes working.
2019-10-03 20:39:08 +00:00
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 17:08:41 +00:00
DecalInstance *di = decal_instance_owner.get_or_null(p_decal);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
ERR_FAIL_COND(!di);
di->transform = p_transform;
}
GIProbes working.
2019-10-03 20:39:08 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
/////////////////////////////////
GIProbes working.
2019-10-03 20:39:08 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 05:08:21 +00: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 17:08:41 +00:00
LightmapInstance *li = lightmap_instance_owner.get_or_null(p_lightmap);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
ERR_FAIL_COND(!li);
li->transform = p_transform;
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 02:14:56 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
/////////////////////////////////
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 02:14:56 +00: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-04 22:47:26 +00: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 12:08:08 +00:00
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 02:14:56 +00: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-04 22:47:26 +00: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 12:08:08 +00:00
}
Dynamic object support for GI Probes (a bit buggy still)
2019-10-11 02:14:56 +00: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-04 22:47:26 +00: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 11:06:48 +00:00
if (!is_dynamic_gi_supported()) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
return false;
GIProbes working.
2019-10-03 20:39:08 +00: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-04 22:47:26 +00:00
return gi.voxel_gi_needs_update(p_probe);
GIProbes working.
2019-10-03 20:39:08 +00:00
}
Change RendererSceneRender::GeometryInstance so more code is shared among renderers
2022-07-23 14:01:53 +00:00
void RendererSceneRenderRD::voxel_gi_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, const PagedArray<RenderGeometryInstance *> &p_dynamic_objects) {
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 11:06:48 +00:00
if (!is_dynamic_gi_supported()) {
GIProbes working.
2019-10-03 20:39:08 +00: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-04 22:47:26 +00:00
gi.voxel_gi_update(p_probe, p_update_light_instances, p_light_instances, p_dynamic_objects, this);
GIProbes working.
2019-10-03 20:39:08 +00:00
}
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
void RendererSceneRenderRD::_debug_sdfgi_probes(RID p_render_buffers, RID p_framebuffer, const uint32_t p_view_count, const Projection *p_camera_with_transforms, bool p_will_continue_color, bool p_will_continue_depth) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND(!rb);
if (!rb->sdfgi) {
return; //nothing to debug
}
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
rb->sdfgi->debug_probes(p_framebuffer, p_view_count, p_camera_with_transforms, p_will_continue_color, p_will_continue_depth);
GIProbes working.
2019-10-03 20:39:08 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
////////////////////////////////
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::render_buffers_create() {
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
RenderBuffers rb;
rb.data = _create_render_buffer_data();
return render_buffers_owner.make_rid(rb);
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::_allocate_blur_textures(RenderBuffers *rb) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00: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 11:40:16 +00: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 21:16:03 +00: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 11:40:16 +00: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 00:40:26 +00:00
tf.mipmaps = mipmaps_required;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00: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 00:40:26 +00: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 07:10:54 +00: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 00:40:26 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
mm.width = base_width;
mm.height = base_height;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
mm.fb = RD::get_singleton()->framebuffer_create(fb);
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
ll[0].mipmaps.push_back(mm);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
mm.fb = RD::get_singleton()->framebuffer_create(fb);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
ll[1].mipmaps.push_back(mm);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
}
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 07:43:17 +00: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 21:16:03 +00:00
tf.width = rb->internal_width;
tf.height = rb->internal_height;
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 07:43:17 +00: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 07:10:54 +00: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 07:43:17 +00:00
} else if (i == 2) {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
texture = rb->blur[1].layers[0].mipmaps[0].texture;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 07:43:17 +00:00
} else if (i == 3) {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
texture = rb->blur[0].layers[0].mipmaps[1].texture;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 07:43:17 +00: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 07:10:54 +00:00
if (i != 0) {
fb.push_back(texture);
}
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 07:43:17 +00: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 14:10:48 +00: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 07:43:17 +00:00
}
}
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
}
Fix read from screen and depth texture
2021-08-11 11:00:12 +00: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 18:26:24 +00:00
void RendererSceneRenderRD::_allocate_luminance_textures(RenderBuffers *rb) {
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
ERR_FAIL_COND(!rb->luminance.current.is_null());
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00:00
int w = rb->internal_width;
int h = rb->internal_height;
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00: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 11:40:16 +00: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 01:26:52 +00: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 11:40:16 +00: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 01:26:52 +00: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 11:40:16 +00: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 01:26:52 +00:00
break;
}
}
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::_free_render_buffer_data(RenderBuffers *rb) {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00: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 21:16:03 +00: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 18:37:24 +00:00
rb->texture = RID();
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00: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 18:37:24 +00: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 00:40:26 +00:00
}
Fix read from screen and depth texture
2021-08-11 11:00:12 +00: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 21:16:03 +00:00
if (rb->sss_texture.is_valid()) {
RD::get_singleton()->free(rb->sss_texture);
rb->sss_texture = RID();
}
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
if (rb->vrs_fb.is_valid()) {
RD::get_singleton()->free(rb->vrs_fb);
rb->vrs_fb = RID();
}
if (rb->vrs_texture.is_valid()) {
RD::get_singleton()->free(rb->vrs_texture);
rb->vrs_texture = RID();
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
for (int i = 0; i < 2; i++) {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 10:04:18 +00:00
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 10:04:18 +00:00
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
}
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
rb->blur[i].layers.clear();
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00: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 11:40:16 +00: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 00:40:26 +00: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 11:40:16 +00: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 00:40:26 +00: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 10:18:55 +00:00
Added SSIL post processing effect
2021-08-03 07:07:32 +00: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();
}
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
ss_effects->ssao_free(rb->ss_effects.ssao);
ss_effects->ssil_free(rb->ss_effects.ssil);
ss_effects->ssr_free(rb->ssr);
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-22 23:50:24 +00: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 14:10:22 +00: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();
}
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
rb->rbgi.free();
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
}
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
void RendererSceneRenderRD::_process_sss(RID p_render_buffers, const Projection &p_camera) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 02:42:26 +00:00
ERR_FAIL_COND(!rb);
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00: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 02:42:26 +00:00
if (!can_use_effects) {
//just copy
return;
}
if (rb->blur[0].texture.is_null()) {
_allocate_blur_textures(rb);
}
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererCompositorRD::singleton->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 02:42:26 +00:00
}
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
void RendererSceneRenderRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffer, const RID *p_normal_slices, RID p_specular_buffer, const RID *p_metallic_slices, const Color &p_metallic_mask, RID p_environment, const Projection *p_projections, const Vector3 *p_eye_offsets, bool p_use_additive) {
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
ERR_FAIL_NULL(ss_effects);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
ERR_FAIL_COND(!rb);
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00:00
bool can_use_effects = rb->internal_width >= 8 && rb->internal_height >= 8;
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
if (!can_use_effects) {
//just copy
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
copy_effects->merge_specular(p_dest_framebuffer, p_specular_buffer, p_use_additive ? RID() : rb->internal_texture, RID(), rb->view_count);
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
return;
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
ERR_FAIL_COND(p_environment.is_null());
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
ERR_FAIL_COND(!environment_get_ssr_enabled(p_environment));
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
Size2i half_size = Size2i(rb->internal_width / 2, rb->internal_height / 2);
if (rb->ssr.output.is_null()) {
ss_effects->ssr_allocate_buffers(rb->ssr, _render_buffers_get_color_format(), ssr_roughness_quality, half_size, rb->view_count);
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
}
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
RID texture_slices[RendererSceneRender::MAX_RENDER_VIEWS];
RID depth_slices[RendererSceneRender::MAX_RENDER_VIEWS];
for (uint32_t v = 0; v < rb->view_count; v++) {
texture_slices[v] = rb->views[v].view_texture;
depth_slices[v] = rb->views[v].view_depth;
Re-Added screen space reflection.
2020-04-02 02:24:52 +00:00
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
ss_effects->screen_space_reflection(rb->ssr, texture_slices, p_normal_slices, ssr_roughness_quality, p_metallic_slices, p_metallic_mask, depth_slices, half_size, environment_get_ssr_max_steps(p_environment), environment_get_ssr_fade_in(p_environment), environment_get_ssr_fade_out(p_environment), environment_get_ssr_depth_tolerance(p_environment), rb->view_count, p_projections, p_eye_offsets);
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
copy_effects->merge_specular(p_dest_framebuffer, p_specular_buffer, p_use_additive ? RID() : rb->internal_texture, rb->ssr.output, rb->view_count);
Re-implemented screen space ambient occlusion
2020-01-25 10:18:55 +00:00
}
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
void RendererSceneRenderRD::_process_ssao(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const Projection &p_projection) {
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
ERR_FAIL_NULL(ss_effects);
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Re-implemented screen space ambient occlusion
2020-01-25 10:18:55 +00:00
ERR_FAIL_COND(!rb);
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
ERR_FAIL_COND(p_environment.is_null());
Re-implemented screen space ambient occlusion
2020-01-25 10:18:55 +00:00
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
RENDER_TIMESTAMP("Process SSAO");
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
RendererRD::SSEffects::SSAOSettings settings;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
settings.radius = environment_get_ssao_radius(p_environment);
settings.intensity = environment_get_ssao_intensity(p_environment);
settings.power = environment_get_ssao_power(p_environment);
settings.detail = environment_get_ssao_detail(p_environment);
settings.horizon = environment_get_ssao_horizon(p_environment);
settings.sharpness = environment_get_ssao_sharpness(p_environment);
Port ASSAO to Godot to replace SAO
2020-12-08 05:37:09 +00:00
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 21:16:03 +00:00
settings.full_screen_size = Size2i(rb->internal_width, rb->internal_height);
Port ASSAO to Godot to replace SAO
2020-12-08 05:37:09 +00:00
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
ss_effects->ssao_allocate_buffers(rb->ss_effects.ssao, settings, rb->ss_effects.linear_depth);
ss_effects->generate_ssao(rb->ss_effects.ssao, p_normal_buffer, p_projection, settings);
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
}
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
void RendererSceneRenderRD::_process_ssil(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const Projection &p_projection, const Transform3D &p_transform) {
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
ERR_FAIL_NULL(ss_effects);
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
ERR_FAIL_COND(!rb);
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
ERR_FAIL_COND(p_environment.is_null());
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
RENDER_TIMESTAMP("Process SSIL");
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
RendererRD::SSEffects::SSILSettings settings;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
settings.radius = environment_get_ssil_radius(p_environment);
settings.intensity = environment_get_ssil_intensity(p_environment);
settings.sharpness = environment_get_ssil_sharpness(p_environment);
settings.normal_rejection = environment_get_ssil_normal_rejection(p_environment);
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
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);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection correction;
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
correction.set_depth_correction(true);
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection projection = correction * p_projection;
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
Transform3D transform = p_transform;
transform.set_origin(Vector3(0.0, 0.0, 0.0));
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection last_frame_projection = rb->ss_effects.last_frame_projection * Projection(rb->ss_effects.last_frame_transform.affine_inverse()) * Projection(transform) * projection.inverse();
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
ss_effects->ssil_allocate_buffers(rb->ss_effects.ssil, settings, rb->ss_effects.linear_depth);
ss_effects->screen_space_indirect_lighting(rb->ss_effects.ssil, p_normal_buffer, p_projection, last_frame_projection, settings);
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
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);
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
if (rb->ss_effects.ssil.last_frame.is_valid()) {
copy_effects->copy_to_rect(rb->texture, rb->ss_effects.ssil.last_frame, Rect2i(0, 0, rb->width, rb->height));
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
int width = rb->width;
int height = rb->height;
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
for (int i = 0; i < rb->ss_effects.ssil.last_frame_slices.size() - 1; i++) {
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
width = MAX(1, width >> 1);
height = MAX(1, height >> 1);
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
copy_effects->make_mipmap(rb->ss_effects.ssil.last_frame_slices[i], rb->ss_effects.ssil.last_frame_slices[i + 1], Size2i(width, height));
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
}
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00: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 14:10:22 +00: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) {
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererCompositorRD::singleton->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);
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 14:10:22 +00:00
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 11:00:12 +00:00
void RendererSceneRenderRD::_render_buffers_copy_screen_texture(const RenderDataRD *p_render_data) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Fix read from screen and depth texture
2021-08-11 11:00:12 +00: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 07:10:54 +00: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 11:00:12 +00: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 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_data->render_buffers);
Fix read from screen and depth texture
2021-08-11 11:00:12 +00: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 07:10:54 +00: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 11:00:12 +00:00
} else {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:00:12 +00: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 05:41:12 +00:00
void RendererSceneRenderRD::_render_buffers_post_process_and_tonemap(const RenderDataRD *p_render_data) {
Extract global variable, shader and material storage
2022-03-21 11:25:25 +00:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 00:40:26 +00:00
ERR_FAIL_COND(!rb);
Implement CameraEffects override_exposure
2021-11-08 09:08:02 +00:00
// Glow and override exposure (if enabled).
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 00:40:26 +00:00
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00: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 11:40:16 +00:00
bool can_use_storage = _render_buffers_can_be_storage();
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00: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 15:39:49 +00:00
RENDER_TIMESTAMP("Depth of Field");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
RD::get_singleton()->draw_command_begin_label("DOF");
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
if (rb->blur[0].texture.is_null()) {
_allocate_blur_textures(rb);
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
RendererRD::BokehDOF::BokehBuffers buffers;
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 07:43:17 +00:00
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00: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 07:10:54 +00: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 07:43:17 +00: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 11:40:16 +00:00
if (can_use_storage) {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00:00
} else {
Implement CameraEffects override_exposure
2021-11-08 09:08:02 +00:00
// Set framebuffers.
Implemented raster versions of bokeh shaders to replace broken gaussian implementation
2021-07-29 07:43:17 +00: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 09:08:02 +00:00
// Set weight buffers.
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 07:43:17 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00:00
}
RD::get_singleton()->draw_command_end_label();
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid() && environment_get_auto_exposure(p_render_data->environment)) {
Add timestamps to some rendering effects
2022-05-21 15:39:49 +00:00
RENDER_TIMESTAMP("Auto exposure");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
RD::get_singleton()->draw_command_begin_label("Auto exposure");
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
if (rb->luminance.current.is_null()) {
_allocate_luminance_textures(rb);
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
bool set_immediate = environment_get_auto_exposure_version(p_render_data->environment) != rb->auto_exposure_version;
rb->auto_exposure_version = environment_get_auto_exposure_version(p_render_data->environment);
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
double step = environment_get_auto_exp_speed(p_render_data->environment) * time_step;
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
if (can_use_storage) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
RendererCompositorRD::singleton->get_effects()->luminance_reduction(rb->internal_texture, Size2i(rb->internal_width, rb->internal_height), rb->luminance.reduce, rb->luminance.current, environment_get_min_luminance(p_render_data->environment), environment_get_max_luminance(p_render_data->environment), step, set_immediate);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
} else {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
RendererCompositorRD::singleton->get_effects()->luminance_reduction_raster(rb->internal_texture, Size2i(rb->internal_width, rb->internal_height), rb->luminance.reduce, rb->luminance.fb, rb->luminance.current, environment_get_min_luminance(p_render_data->environment), environment_get_max_luminance(p_render_data->environment), step, set_immediate);
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
}
Implement CameraEffects override_exposure
2021-11-08 09:08:02 +00:00
// Swap final reduce with prev luminance.
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00: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 11:40:16 +00: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 09:08:02 +00: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 11:40:16 +00:00
RD::get_singleton()->draw_command_end_label();
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
int max_glow_level = -1;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid() && environment_get_glow_enabled(p_render_data->environment)) {
Add timestamps to some rendering effects
2022-05-21 15:39:49 +00:00
RENDER_TIMESTAMP("Glow");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00: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 00:40:26 +00:00
/* see that blur textures are allocated */
Optimize Glow with local memory
2020-09-19 22:02:32 +00:00
if (rb->blur[1].texture.is_null()) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00: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 18:21:27 +00:00
for (int i = 0; i < RS::MAX_GLOW_LEVELS; i++) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (environment_get_glow_levels(p_render_data->environment)[i] > 0.0) {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
} else {
max_glow_level = i;
}
}
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
if (i == 0) {
RID luminance_texture;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (environment_get_auto_exposure(p_render_data->environment) && rb->luminance.current.is_valid()) {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
luminance_texture = rb->luminance.current;
}
if (can_use_storage) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
copy_effects->gaussian_glow(rb->views[l].view_texture, rb->blur[1].layers[l].mipmaps[i].texture, Size2i(vp_w, vp_h), environment_get_glow_strength(p_render_data->environment), glow_high_quality, true, environment_get_glow_hdr_luminance_cap(p_render_data->environment), environment_get_exposure(p_render_data->environment), environment_get_glow_bloom(p_render_data->environment), environment_get_glow_hdr_bleed_threshold(p_render_data->environment), environment_get_glow_hdr_bleed_scale(p_render_data->environment), luminance_texture, environment_get_auto_exp_scale(p_render_data->environment));
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
} else {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
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), environment_get_glow_strength(p_render_data->environment), glow_high_quality, true, environment_get_glow_hdr_luminance_cap(p_render_data->environment), environment_get_exposure(p_render_data->environment), environment_get_glow_bloom(p_render_data->environment), environment_get_glow_hdr_bleed_threshold(p_render_data->environment), environment_get_glow_hdr_bleed_scale(p_render_data->environment), luminance_texture, environment_get_auto_exp_scale(p_render_data->environment));
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
} else {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
if (can_use_storage) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
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), environment_get_glow_strength(p_render_data->environment), glow_high_quality);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
} else {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
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), environment_get_glow_strength(p_render_data->environment), glow_high_quality);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
}
}
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
RD::get_singleton()->draw_command_end_label();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
}
{
Add timestamps to some rendering effects
2022-05-21 15:39:49 +00:00
RENDER_TIMESTAMP("Tonemap");
Use fragment shader instead of compute shader for effects for mobile renderer
2021-07-20 11:40:16 +00:00
RD::get_singleton()->draw_command_begin_label("Tonemap");
Splitting tonemapper into its own class
2022-04-27 03:42:50 +00:00
RendererRD::ToneMapper::TonemapSettings tonemap;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid() && environment_get_auto_exposure(p_render_data->environment) && rb->luminance.current.is_valid()) {
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
tonemap.use_auto_exposure = true;
tonemap.exposure_texture = rb->luminance.current;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
tonemap.auto_exposure_grey = environment_get_auto_exp_scale(p_render_data->environment);
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
} else {
Changed storage structs to private
2022-08-01 01:59:14 +00:00
tonemap.exposure_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid() && environment_get_glow_enabled(p_render_data->environment)) {
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
tonemap.use_glow = true;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
tonemap.glow_mode = RendererRD::ToneMapper::TonemapSettings::GlowMode(environment_get_glow_blend_mode(p_render_data->environment));
tonemap.glow_intensity = environment_get_glow_blend_mode(p_render_data->environment) == RS::ENV_GLOW_BLEND_MODE_MIX ? environment_get_glow_mix(p_render_data->environment) : environment_get_glow_intensity(p_render_data->environment);
Optimize Glow with local memory
2020-09-19 22:02:32 +00:00
for (int i = 0; i < RS::MAX_GLOW_LEVELS; i++) {
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
tonemap.glow_levels[i] = environment_get_glow_levels(p_render_data->environment)[i];
Optimize Glow with local memory
2020-09-19 22:02:32 +00:00
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 13:46:03 +00:00
tonemap.glow_use_bicubic_upscale = glow_bicubic_upscale;
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
tonemap.glow_texture = rb->blur[1].texture;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (environment_get_glow_map(p_render_data->environment).is_valid()) {
tonemap.glow_map_strength = environment_get_glow_map_strength(p_render_data->environment);
tonemap.glow_map = texture_storage->texture_get_rd_texture(environment_get_glow_map(p_render_data->environment));
add support for glow maps
2022-01-20 15:47:25 +00:00
} else {
tonemap.glow_map_strength = 0.0f;
Changed storage structs to private
2022-08-01 01:59:14 +00:00
tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
add support for glow maps
2022-01-20 15:47:25 +00:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
} else {
Changed storage structs to private
2022-08-01 01:59:14 +00:00
tonemap.glow_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_BLACK);
tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
}
Add screen space AA option, with FXAA implementation.
2020-04-12 04:49:10 +00: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 21:34:47 +00:00
tonemap.use_debanding = rb->use_debanding;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00:00
tonemap.texture_size = Vector2i(rb->internal_width, rb->internal_height);
Add screen space AA option, with FXAA implementation.
2020-04-12 04:49:10 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (p_render_data->environment.is_valid()) {
tonemap.tonemap_mode = environment_get_tone_mapper(p_render_data->environment);
tonemap.white = environment_get_white(p_render_data->environment);
tonemap.exposure = environment_get_exposure(p_render_data->environment);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
}
Implement CameraEffects override_exposure
2021-11-08 09:08:02 +00: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 01:40:47 +00:00
tonemap.use_color_correction = false;
tonemap.use_1d_color_correction = false;
Changed storage structs to private
2022-08-01 01:59:14 +00:00
tonemap.color_correction_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::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 01:40:47 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid()) {
tonemap.use_bcs = environment_get_adjustments_enabled(p_render_data->environment);
tonemap.brightness = environment_get_adjustments_brightness(p_render_data->environment);
tonemap.contrast = environment_get_adjustments_contrast(p_render_data->environment);
tonemap.saturation = environment_get_adjustments_saturation(p_render_data->environment);
if (environment_get_adjustments_enabled(p_render_data->environment) && environment_get_color_correction(p_render_data->environment).is_valid()) {
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 01:51:31 +00:00
tonemap.use_color_correction = true;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
tonemap.use_1d_color_correction = environment_get_use_1d_color_correction(p_render_data->environment);
tonemap.color_correction_texture = texture_storage->texture_get_rd_texture(environment_get_color_correction(p_render_data->environment));
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 01:51:31 +00:00
}
}
Scale color output in the mobile renderer to provide HDR support
2021-07-26 11:31:15 +00:00
tonemap.luminance_multiplier = _render_buffers_get_luminance_multiplier();
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00:00
tonemap.view_count = p_render_data->view_count;
Splitting tonemapper into its own class
2022-04-27 03:42:50 +00: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 21:16:03 +00: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 16:22:17 +00: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 21:16:03 +00:00
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererCompositorRD::singleton->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 11:40:16 +00:00
RD::get_singleton()->draw_command_end_label();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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 00:40:26 +00:00
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00: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 11:25:25 +00:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
RD::get_singleton()->draw_command_begin_label("Post Process Subpass");
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 10:49:25 +00:00
ERR_FAIL_COND(!rb);
Implement CameraEffects override_exposure
2021-11-08 09:08:02 +00: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 10:49:25 +00: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 03:42:50 +00:00
RendererRD::ToneMapper::TonemapSettings tonemap;
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (p_render_data->environment.is_valid()) {
tonemap.tonemap_mode = environment_get_tone_mapper(p_render_data->environment);
tonemap.exposure = environment_get_exposure(p_render_data->environment);
tonemap.white = environment_get_white(p_render_data->environment);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
}
Implement CameraEffects override_exposure
2021-11-08 09:08:02 +00: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 10:49:25 +00: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.
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid() && environment_get_glow_enabled(p_render_data->environment)) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
ERR_FAIL_MSG("Glow is not supported when using subpasses.");
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid() && environment_get_auto_exposure(p_render_data->environment)) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
ERR_FAIL_MSG("Glow is not supported when using subpasses.");
}
tonemap.use_glow = false;
Changed storage structs to private
2022-08-01 01:59:14 +00:00
tonemap.glow_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_BLACK);
tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
tonemap.use_auto_exposure = false;
Changed storage structs to private
2022-08-01 01:59:14 +00:00
tonemap.exposure_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
tonemap.use_color_correction = false;
tonemap.use_1d_color_correction = false;
Changed storage structs to private
2022-08-01 01:59:14 +00:00
tonemap.color_correction_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_3D_WHITE);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (can_use_effects && p_render_data->environment.is_valid()) {
tonemap.use_bcs = environment_get_adjustments_enabled(p_render_data->environment);
tonemap.brightness = environment_get_adjustments_brightness(p_render_data->environment);
tonemap.contrast = environment_get_adjustments_contrast(p_render_data->environment);
tonemap.saturation = environment_get_adjustments_saturation(p_render_data->environment);
if (environment_get_adjustments_enabled(p_render_data->environment) && environment_get_color_correction(p_render_data->environment).is_valid()) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
tonemap.use_color_correction = true;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
tonemap.use_1d_color_correction = environment_get_use_1d_color_correction(p_render_data->environment);
tonemap.color_correction_texture = texture_storage->texture_get_rd_texture(environment_get_color_correction(p_render_data->environment));
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00: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 11:31:15 +00:00
tonemap.luminance_multiplier = _render_buffers_get_luminance_multiplier();
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
tonemap.view_count = p_render_data->view_count;
Splitting tonemapper into its own class
2022-04-27 03:42:50 +00: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 10:49:25 +00: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 17:08:41 +00: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 10:49:25 +00:00
ERR_FAIL_COND(!rb);
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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 10:49:25 +00: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 16:40:24 +00: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 11:25:25 +00:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 00:40:26 +00: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 18:21:27 +00: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 00:40:26 +00: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 14:55:32 +00:00
if (shadow_atlas_texture.is_null()) {
Changed storage structs to private
2022-08-01 01:59:14 +00:00
shadow_atlas_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::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 14:55:32 +00:00
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
}
}
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00: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 00:40:26 +00: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 14:00:51 +00: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 00:40:26 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 00:40:26 +00:00
}
}
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00: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 03:05:21 +00:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_DECAL_ATLAS) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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 03:05:21 +00:00
if (decal_atlas.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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 03:05:21 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 13:33:28 +00:00
}
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 14:00:51 +00: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 12:08:08 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 12:08:08 +00:00
}
}
Added SSIL post processing effect
2021-08-03 07:07:32 +00: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 14:00:51 +00:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 07:07:32 +00: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 14:00:51 +00:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 12:08:08 +00: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 14:00:51 +00:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 12:08:08 +00:00
}
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_GI_BUFFER && rb->rbgi.ambient_buffer.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
RID ambient_texture = rb->rbgi.ambient_buffer;
RID reflection_texture = rb->rbgi.reflection_buffer;
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, rb->view_count > 1);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 16:40:24 +00: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 14:00:51 +00:00
Size2 rtsize = texture_storage->render_target_get_size(rb->render_target);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 16:40:24 +00: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 14:10:22 +00: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 12:08:08 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::render_buffers_get_back_buffer_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 00:40:26 +00:00
ERR_FAIL_COND_V(!rb, RID());
Re-implemented screen space ambient occlusion
2020-01-25 10:18:55 +00: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 00:40:26 +00:00
return rb->blur[0].texture;
}
Fix read from screen and depth texture
2021-08-11 11:00:12 +00:00
RID RendererSceneRenderRD::render_buffers_get_back_depth_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Fix read from screen and depth texture
2021-08-11 11:00:12 +00: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 08:51:37 +00:00
RID RendererSceneRenderRD::render_buffers_get_depth_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Fix access to render target texture for XR interfaces
2021-09-20 08:51:37 +00:00
ERR_FAIL_COND_V(!rb, RID());
return rb->depth_texture;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::render_buffers_get_ao_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Re-implemented screen space ambient occlusion
2020-01-25 10:18:55 +00:00
ERR_FAIL_COND_V(!rb, RID());
Added SSIL post processing effect
2021-08-03 07:07:32 +00: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 10:18:55 +00: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-04 22:47:26 +00:00
RID RendererSceneRenderRD::render_buffers_get_voxel_gi_buffer(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, RID());
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
if (rb->rbgi.voxel_gi_buffer.is_null()) {
rb->rbgi.voxel_gi_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(RendererRD::GI::VoxelGIData) * RendererRD::GI::MAX_VOXEL_GI_INSTANCES);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
}
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
return rb->rbgi.voxel_gi_buffer;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00: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-04 22:47:26 +00: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 13:33:28 +00: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-22 23:50:24 +00:00
RID RendererSceneRenderRD::render_buffers_get_gi_ambient_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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-22 23:50:24 +00:00
ERR_FAIL_COND_V(!rb, RID());
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
return rb->rbgi.ambient_buffer;
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-22 23:50:24 +00:00
}
RID RendererSceneRenderRD::render_buffers_get_gi_reflection_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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-22 23:50:24 +00:00
ERR_FAIL_COND_V(!rb, RID());
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
return rb->rbgi.reflection_buffer;
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-22 23:50:24 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
return rb->sdfgi->cascades.size();
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
bool RendererSceneRenderRD::render_buffers_is_sdfgi_enabled(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, false);
return rb->sdfgi != nullptr;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, RID());
ERR_FAIL_COND_V(!rb->sdfgi, RID());
return rb->sdfgi->lightprobe_texture;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00: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 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00: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());
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
int32_t probe_divisor = rb->sdfgi->cascade_size / RendererRD::GI::SDFGI::PROBE_DIVISOR;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
return rb->sdfgi->cascades[p_cascade].position / probe_divisor;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
return rb->sdfgi->normal_bias;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00: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 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00: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 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, 0);
ERR_FAIL_COND_V(!rb->sdfgi, 0);
return rb->sdfgi->cascade_size;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, false);
ERR_FAIL_COND_V(!rb->sdfgi, false);
return rb->sdfgi->uses_occlusion;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
float RendererSceneRenderRD::render_buffers_get_sdfgi_energy(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 18:58:49 +00: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 13:33:28 +00:00
return rb->sdfgi->energy;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00: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 13:33:28 +00:00
ERR_FAIL_COND_V(!rb, RID());
ERR_FAIL_COND_V(!rb->sdfgi, RID());
return rb->sdfgi->occlusion_texture;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
bool RendererSceneRenderRD::render_buffers_has_volumetric_fog(RID p_render_buffers) const {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
ERR_FAIL_COND_V(!rb, false);
return rb->volumetric_fog != nullptr;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_texture(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, RID());
return rb->volumetric_fog->fog_map;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Add fog to sky shaders
2020-08-18 04:12:51 +00: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 18:26:24 +00:00
float RendererSceneRenderRD::render_buffers_get_volumetric_fog_end(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, 0);
return rb->volumetric_fog->length;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 17:08:41 +00:00
const RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 01:21:01 +00: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 11:31:15 +00:00
float RendererSceneRenderRD::_render_buffers_get_luminance_multiplier() {
return 1.0;
}
Use 32bit instead of 64bit 3D render buffer on mobile
2021-06-17 10:37:08 +00: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 20:06:33 +00:00
bool RendererSceneRenderRD::_render_buffers_can_be_storage() {
return true;
}
Allow changing mipmap LOD bias when FSR 1.0 scaling is not used Mipmap LOD bias can be useful to improve the appearance of distant textures without increasing anisotropic filtering (or in situations where anisotropic filtering is not effective). `fsr_mipmap_bias` was renamed to `texture_mipmap_bias` accordingly. The property hint now allows for greater precision as well.
2022-06-11 23:49:59 +00: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_texture_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 14:00:51 +00:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Moved particles into ParticlesStorage
2022-04-12 11:41:50 +00:00
RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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 15:17:32 +00:00
ERR_FAIL_COND_MSG(p_view_count == 0, "Must have at least 1 view");
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00:00
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00:00
if (!_render_buffers_can_be_storage()) {
p_internal_height = p_height;
p_internal_width = p_width;
}
Allow changing mipmap LOD bias when FSR 1.0 scaling is not used Mipmap LOD bias can be useful to improve the appearance of distant textures without increasing anisotropic filtering (or in situations where anisotropic filtering is not effective). `fsr_mipmap_bias` was renamed to `texture_mipmap_bias` accordingly. The property hint now allows for greater precision as well.
2022-06-11 23:49:59 +00:00
const float texture_mipmap_bias = -log2f(p_width / p_internal_width) + p_texture_mipmap_bias;
material_storage->sampler_rd_configure_custom(texture_mipmap_bias);
update_uniform_sets();
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Optionally scale 3D render content
2021-08-19 01:52:06 +00:00
// Should we add an overrule per viewport?
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00:00
rb->internal_width = p_internal_width;
rb->internal_height = p_internal_height;
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
rb->width = p_width;
rb->height = p_height;
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00:00
rb->fsr_sharpness = p_fsr_sharpness;
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
rb->render_target = p_render_target;
rb->msaa = p_msaa;
Add screen space AA option, with FXAA implementation.
2020-04-12 04:49:10 +00: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 14:10:22 +00: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 21:34:47 +00:00
rb->use_debanding = p_use_debanding;
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00:00
rb->view_count = p_view_count;
Move clustered renderer functionality
2021-03-23 10:46:31 +00: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 16:25:38 +00:00
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
_free_render_buffer_data(rb);
{
RD::TextureFormat tf;
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00: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 10:37:08 +00:00
tf.format = _render_buffers_get_color_format();
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00: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 13:19:04 +00: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 10:49:25 +00: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 18:33:57 +00:00
if (rb->msaa != RS::VIEWPORT_MSAA_DISABLED) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
Implement MSAA
2020-04-12 18:33:57 +00:00
}
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00: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 00:40:26 +00:00
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00: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 00:40:26 +00:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
{
RD::TextureFormat tf;
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00: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 13:33:28 +00:00
if (rb->msaa == RS::VIEWPORT_MSAA_DISABLED) {
Rationalize certain cases of texture usage flags - Check for exhaustive usage flags for depth buffer - Remove uneeded storage flag from normal-roughness buffer
2022-06-27 08:42:24 +00:00
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::TEXTURE_USAGE_SAMPLING_BIT)) ? RD::DATA_FORMAT_D24_UNORM_S8_UINT : RD::DATA_FORMAT_D32_SFLOAT_S8_UINT;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
} else {
tf.format = RD::DATA_FORMAT_R32_SFLOAT;
}
Implemented AMD's FSR as a computer shader for upscaling 3D scenes
2021-11-23 21:16:03 +00: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 13:33:28 +00:00
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00: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 13:33:28 +00:00
Implement MSAA
2020-04-12 18:33:57 +00: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 13:33:28 +00: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 18:33:57 +00:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
rb->depth_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
}
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 11:40:16 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
rb->views.clear(); // JIC
if (rb->view_count == 1) {
// copy as a convenience
RenderBuffers::View view;
Fixed FSR. Before, it was commiting the raw render to the screen. Now, it commits the fsr upscaled image
2022-06-27 23:59:27 +00:00
view.view_texture = rb->texture;
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
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;
Fixed FSR. Before, it was commiting the raw render to the screen. Now, it commits the fsr upscaled image
2022-06-27 23:59:27 +00:00
view.view_texture = RD::get_singleton()->texture_create_shared_from_slice(RD::TextureView(), rb->texture, i, 0);
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
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 11:40:16 +00:00
}
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
RS::ViewportVRSMode vrs_mode = texture_storage->render_target_get_vrs_mode(rb->render_target);
if (is_vrs_supported() && vrs_mode != RS::VIEWPORT_VRS_DISABLED) {
vrs->create_vrs_texture(p_internal_width, p_internal_height, p_view_count, rb->vrs_texture, rb->vrs_fb);
}
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00:00
RID target_texture = texture_storage->render_target_get_rd_texture(rb->render_target);
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00: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, rb->vrs_texture);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
Move clustered renderer functionality
2021-03-23 10:46:31 +00:00
if (is_clustered_enabled()) {
Moved particles into ParticlesStorage
2022-04-12 11:41:50 +00: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 10:46:31 +00:00
}
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00: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-22 23:50:24 +00:00
void RendererSceneRenderRD::gi_set_use_half_resolution(bool p_enable) {
gi.half_resolution = p_enable;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 02:42:26 +00:00
sss_quality = p_quality;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 02:42:26 +00:00
return sss_quality;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 02:42:26 +00:00
sss_scale = p_scale;
sss_depth_scale = p_depth_scale;
}
Rename soft shadow quality project settings for easier searching `rendering/quality/shadows` is now `rendering/quality/positional_shadow` to explicitly denote that the settings only affect positional light shadows, not directional light shadows. Shadow atlas settings now contain the word "atlas" for easier searching. Soft shadow quality settings were renamed to contain the word "filter". This makes the settings appear when searching for "filter" in the project settings dialog, like in Godot 3.x.
2022-04-30 23:40:30 +00:00
void RendererSceneRenderRD::positional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) {
Add proper quality settings to soft shadows
2020-04-10 09:30:36 +00: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 14:52:57 +00:00
soft_shadow_samples = 0;
Add proper quality settings to soft shadows
2020-04-10 09:30:36 +00: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 14:52:57 +00: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 09:30:36 +00: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 19:41:55 +00:00
_update_shader_quality_settings();
Add proper quality settings to soft shadows
2020-04-10 09:30:36 +00:00
}
Rename soft shadow quality project settings for easier searching `rendering/quality/shadows` is now `rendering/quality/positional_shadow` to explicitly denote that the settings only affect positional light shadows, not directional light shadows. Shadow atlas settings now contain the word "atlas" for easier searching. Soft shadow quality settings were renamed to contain the word "filter". This makes the settings appear when searching for "filter" in the project settings dialog, like in Godot 3.x.
2022-04-30 23:40:30 +00:00
void RendererSceneRenderRD::directional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) {
Add proper quality settings to soft shadows
2020-04-10 09:30:36 +00: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 14:52:57 +00:00
directional_soft_shadow_samples = 0;
Add proper quality settings to soft shadows
2020-04-10 09:30:36 +00: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 14:52:57 +00: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 09:30:36 +00: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 19:41:55 +00: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 01:51:52 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
int RendererSceneRenderRD::get_roughness_layers() const {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
return sky.roughness_layers;
Environment sky more or less working.
2019-08-26 20:43:58 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
bool RendererSceneRenderRD::is_using_radiance_cubemap_array() const {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
return sky.sky_use_cubemap_array;
Environment sky more or less working.
2019-08-26 20:43:58 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RendererSceneRenderRD::RenderBufferData *RendererSceneRenderRD::render_buffers_get_data(RID p_render_buffers) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Replace NULL with nullptr
2020-04-01 23:20:12 +00:00
ERR_FAIL_COND_V(!rb, nullptr);
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00:00
return rb->data;
}
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 09:34:31 +00: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 16:25:38 +00: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 16:52:58 +00: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 16:25:38 +00: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-22 23:39:09 +00:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 16:25:38 +00:00
if (!rpi) {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
continue;
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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 20:06:33 +00: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 16:25:38 +00: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 20:06:33 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
RID base_probe = rpi->probe;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Cluster::ReflectionData &reflection_ubo = cluster.reflections[i];
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00:00
rpi->cull_mask = light_storage->reflection_probe_get_cull_mask(base_probe);
Create mobile renderer
2021-03-10 11:23:55 +00:00
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 16:25:38 +00:00
reflection_ubo.index = rpi->atlas_index;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 05:08:21 +00:00
Transform3D transform = rpi->transform;
Transform3D proj = (p_camera_inverse_transform * transform).inverse();
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererRD::MaterialStorage::store_transform(proj, reflection_ubo.local_matrix);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Create mobile renderer
2021-03-10 11:23:55 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
if (cluster.reflection_count) {
Fix reflection probe
2021-04-20 13:59:46 +00: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-22 23:39:09 +00: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-12 23:32:05 +00: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 14:00:51 +00:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00:00
RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
Extract Decal and Decal atlas from Storage class
2022-03-20 11:28:24 +00:00
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 16:25:38 +00:00
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
r_directional_light_count = 0;
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
r_positional_light_count = 0;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 12:50:35 +00: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 16:25:38 +00: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-12 23:32:05 +00: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 16:52:58 +00:00
for (int i = 0; i < (int)p_lights.size(); i++) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 16:25:38 +00:00
if (!li) {
continue;
}
RID base = li->light;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
ERR_CONTINUE(base.is_null());
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
switch (type) {
case RS::LIGHT_DIRECTIONAL: {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
continue;
}
Cluster::DirectionalLightData &light_data = cluster.directional_lights[r_directional_light_count];
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D light_transform = li->transform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00: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 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 21:20:09 +00: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-22 23:39:09 +00:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 01:33:10 +00: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-23 23:06:49 +00:00
r_directional_light_soft_shadows = true;
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
} else {
angular_diameter = 0.0;
}
if (light_data.shadow_enabled) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 09:34:31 +00: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-22 23:39:09 +00: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 16:25:38 +00:00
Rect2 atlas_rect = li->shadow_transform[j].atlas_rect;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection matrix = li->shadow_transform[j].camera;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
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-22 23:39:09 +00:00
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection bias;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
bias.set_light_bias();
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection rectm;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
rectm.set_light_atlas_rect(atlas_rect);
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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-22 23:39:09 +00:00
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection shadow_mtx = rectm * bias * matrix * modelview;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
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 16:25:38 +00:00
float bias_scale = li->shadow_transform[j].bias_scale;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 16:25:38 +00:00
light_data.shadow_z_range[j] = li->shadow_transform[j].farplane;
light_data.shadow_range_begin[j] = li->shadow_transform[j].range_begin;
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererRD::MaterialStorage::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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00: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 09:34:31 +00: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-22 23:39:09 +00: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 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
light_data.softshadow_angle = angular_diameter;
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 16:25:38 +00: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-22 23:39:09 +00: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 21:55:14 +00:00
const real_t distance = camera_plane.distance_to(li->transform.origin);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 21:55:14 +00: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 16:25:38 +00: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 21:55:14 +00: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 16:25:38 +00: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-22 23:39:09 +00: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 21:55:14 +00:00
const real_t distance = camera_plane.distance_to(li->transform.origin);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 21:55:14 +00: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 16:25:38 +00: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 21:55:14 +00: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 16:25:38 +00:00
cluster.spot_light_count++;
} break;
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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 16:03:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
ShadowAtlas *shadow_atlas = nullptr;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
if (p_shadow_atlas.is_valid() && p_using_shadows) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 16:25:38 +00:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 20:06:33 +00: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 16:25:38 +00: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-22 23:39:09 +00: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 20:06:33 +00: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 05:08:21 +00:00
Transform3D light_transform = li->transform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 21:55:14 +00: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 09:34:31 +00: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 21:55:14 +00: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 09:34:31 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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 09:34:31 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 16:25:38 +00:00
light_data.inv_radius = 1.0 / radius;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
light_data.size = size;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 20:39:08 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
if (projector.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00: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 21:55:14 +00: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 09:34:31 +00: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 21:55:14 +00: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 16:25:38 +00:00
// fill in the shadow information
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
light_data.shadow_enabled = true;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 15:18:06 +00: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 09:34:31 +00: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-22 23:39:09 +00: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 15:18:06 +00:00
if (type == RS::LIGHT_SPOT) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 15:18:06 +00:00
} else { //omni
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 16:25:38 +00:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 15:18:06 +00: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 16:25:38 +00: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 09:34:31 +00: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 16:25:38 +00:00
if (type == RS::LIGHT_OMNI) {
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 16:25:38 +00:00
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererRD::MaterialStorage::store_transform(proj, light_data.shadow_matrix);
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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 01:33:10 +00: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 16:25:38 +00:00
light_data.soft_shadow_size = size;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
} else {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00: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 15:18:06 +00: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 16:25:38 +00:00
} else if (type == RS::LIGHT_SPOT) {
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D modelview = (inverse_transform * light_transform).inverse();
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection bias;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
bias.set_light_bias();
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection shadow_mtx = bias * li->shadow_transform[0].camera * modelview;
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererRD::MaterialStorage::store_camera(shadow_mtx, light_data.shadow_matrix);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 01:33:10 +00: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.
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection cm = li->shadow_transform[0].camera;
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
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-22 23:39:09 +00:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 16:25:38 +00:00
Create mobile renderer
2021-03-10 11:23:55 +00: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-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
r_positional_light_count++;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 19:51:36 +00: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 16:25:38 +00: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 03:02:06 +00: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 16:25:38 +00: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 03:02:06 +00: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-22 23:39:09 +00: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 03:02:06 +00: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-22 23:39:09 +00:00
}
}
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 14:00:51 +00:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Extract Decal and Decal atlas from Storage class
2022-03-20 11:28:24 +00:00
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D uv_xform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 16:25:38 +00: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 16:52:58 +00: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 16:25:38 +00:00
if (cluster.decal_count == cluster.max_decals) {
break;
}
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 16:25:38 +00:00
if (!di) {
continue;
}
RID decal = di->decal;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D xform = di->transform;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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-22 23:39:09 +00:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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-22 23:39:09 +00: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 16:25:38 +00:00
}
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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 20:06:33 +00: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 16:25:38 +00: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 20:06:33 +00: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 14:00:51 +00:00
di->cull_mask = texture_storage->decal_get_cull_mask(decal);
Create mobile renderer
2021-03-10 11:23:55 +00:00
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00: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 16:25:38 +00:00
float fade = 1.0;
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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 21:36:03 +00: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 16:25:38 +00: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 21:36:03 +00: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-22 23:39:09 +00:00
}
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
Cluster::DecalData &dd = cluster.decals[i];
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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-22 23:39:09 +00:00
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D scale_xform;
Construct values only when necessary.
2021-09-23 14:58:43 +00:00
scale_xform.basis.scale(decal_extents);
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D to_decal_xform = (p_camera_inverse_xform * di->transform * scale_xform * uv_xform).affine_inverse();
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererRD::MaterialStorage::store_transform(to_decal_xform, dd.xform);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 12:50:35 +00: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-22 23:39:09 +00: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 14:00:51 +00: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-22 23:39:09 +00:00
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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-22 23:39:09 +00:00
if (albedo_tex.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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-22 23:39:09 +00: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 14:00:51 +00: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-22 23:39:09 +00:00
if (normal_tex.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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-22 23:39:09 +00: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();
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererRD::MaterialStorage::store_basis_3x4(normal_xform, dd.normal_xform);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 14:00:51 +00: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-22 23:39:09 +00:00
if (orm_tex.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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-22 23:39:09 +00: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 14:00:51 +00: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-22 23:39:09 +00: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 14:00:51 +00: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-22 23:39:09 +00: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 14:00:51 +00: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-22 23:39:09 +00:00
Create mobile renderer
2021-03-10 11:23:55 +00: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-22 23:39:09 +00:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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 03:02:06 +00: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-22 23:39:09 +00:00
}
}
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
////////////////////////////////////////////////////////////////////////////////
// FOG SHADER
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const Projection &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) {
Move clustered renderer functionality
2021-03-23 10:46:31 +00: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 17:08:41 +00:00
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
ERR_FAIL_COND(!rb);
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
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (p_environment.is_null() || !environment_get_volumetric_fog_enabled(p_environment) || rb->volumetric_fog->width != target_width || rb->volumetric_fog->height != target_height || rb->volumetric_fog->depth != volumetric_fog_depth) {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
memdelete(rb->volumetric_fog);
rb->volumetric_fog = nullptr;
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
}
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (p_environment.is_null() || !environment_get_volumetric_fog_enabled(p_environment)) {
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
//no reason to enable or update, bye
return;
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
if (p_environment.is_valid() && environment_get_volumetric_fog_enabled(p_environment) && !rb->volumetric_fog) {
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
//required volumetric fog but not existing, create
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
rb->volumetric_fog = memnew(RendererRD::Fog::VolumetricFog(Vector3i(target_width, target_height, volumetric_fog_depth), sky.sky_shader.default_shader_rd));
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
}
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
if (rb->volumetric_fog) {
RendererRD::Fog::VolumetricFogSettings settings;
settings.rb_size = Vector2i(rb->width, rb->height);
settings.time = time;
settings.is_using_radiance_cubemap_array = is_using_radiance_cubemap_array();
settings.max_cluster_elements = max_cluster_elements;
settings.volumetric_fog_filter_active = volumetric_fog_filter_active;
settings.shadow_sampler = shadow_sampler;
ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas);
settings.shadow_atlas_depth = shadow_atlas ? shadow_atlas->depth : RID();
settings.voxel_gl_buffer = render_buffers_get_voxel_gi_buffer(p_render_buffers);
settings.omni_light_buffer = get_omni_light_buffer();
settings.spot_light_buffer = get_spot_light_buffer();
settings.directional_shadow_depth = directional_shadow.depth;
settings.directional_light_buffer = get_directional_light_buffer();
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
settings.vfog = rb->volumetric_fog;
settings.cluster_builder = rb->cluster_builder;
settings.rbgi = &rb->rbgi;
settings.sdfgi = rb->sdfgi;
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
settings.env = p_environment;
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
settings.sky = &sky;
settings.gi = &gi;
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
RendererRD::Fog::get_singleton()->volumetric_fog_update(settings, p_cam_projection, p_cam_transform, p_prev_cam_inv_transform, p_shadow_atlas, p_directional_light_count, p_use_directional_shadows, p_positional_light_count, p_voxel_gi_count, p_fog_volumes);
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
}
}
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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 17:08:41 +00: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 19:51:36 +00:00
if (rb->sdfgi != nullptr) {
return true;
}
-Refactored post processing, re-added glow and added a mix blend mode.
2020-01-10 00:40:26 +00: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 19:51:36 +00:00
return false;
}
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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 19:51:36 +00:00
if (p_use_gi) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 12:08:08 +00:00
ERR_FAIL_COND(rb == nullptr);
if (rb->sdfgi == nullptr) {
return;
}
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
rb->sdfgi->update_probes(p_render_data->environment, sky.sky_owner.get_or_null(environment_get_sky(p_render_data->environment)));
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00: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 19:51:36 +00:00
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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 19:51:36 +00: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 16:52:58 +00:00
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
void RendererSceneRenderRD::_pre_opaque_render(RenderDataRD *p_render_data, bool p_use_ssao, bool p_use_ssil, bool p_use_gi, const RID *p_normal_roughness_slices, RID p_voxel_gi_buffer, const RID *p_vrs_slices) {
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 19:51:36 +00: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 09:34:31 +00: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 16:52:58 +00:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00:00
if (p_render_data->render_buffers.is_valid() && p_use_gi) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 12:08:08 +00:00
ERR_FAIL_COND(rb == nullptr);
Fix VoxelGI (works again). It was broken due to #46046, this makes it work again.
2021-06-12 23:37:56 +00:00
if (rb->sdfgi != nullptr) {
rb->sdfgi->store_probes();
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 19:51:36 +00: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 12:50:35 +00: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 05:41:12 +00: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 19:51:36 +00:00
{
for (int i = 0; i < render_state.render_shadow_count; i++) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 19:51:36 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 19:51:36 +00:00
render_state.directional_shadows.push_back(i);
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 19:51:36 +00: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 16:25:38 +00: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 19:51:36 +00: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-28 23:10:41 +00: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 19:51:36 +00: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 05:41:12 +00: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 19:51:36 +00: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 07:44:29 +00: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 19:51:36 +00: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 16:25:38 +00: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 19:51:36 +00: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-28 23:10:41 +00: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 19:51:36 +00: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-28 23:10:41 +00: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 19:51:36 +00:00
}
_render_shadow_process();
}
//start GI
if (render_gi) {
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
gi.process_gi(p_render_data->render_buffers, p_normal_roughness_slices, p_voxel_gi_buffer, p_vrs_slices, p_render_data->environment, p_render_data->view_count, p_render_data->view_projection, p_render_data->view_eye_offset, 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 19:51:36 +00: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
}
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
if (p_render_data->render_buffers.is_valid() && ss_effects) {
Added SSIL post processing effect
2021-08-03 07:07:32 +00: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;
}
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
ss_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);
Added SSIL post processing effect
2021-08-03 07:07:32 +00: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 19:51:36 +00:00
if (p_use_ssao) {
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
// TODO make these proper stereo
_process_ssao(p_render_data->render_buffers, p_render_data->environment, p_normal_roughness_slices[0], 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 19:51:36 +00:00
}
Added SSIL post processing effect
2021-08-03 07:07:32 +00:00
if (p_use_ssil) {
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
// TODO make these proper stereo
_process_ssil(p_render_data->render_buffers, p_render_data->environment, p_normal_roughness_slices[0], p_render_data->cam_projection, p_render_data->cam_transform);
Added SSIL post processing effect
2021-08-03 07:07:32 +00: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 19:51:36 +00: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 03:02:06 +00: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 19:51:36 +00:00
if (current_cluster_builder) {
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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 19:51:36 +00:00
}
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
bool using_shadows = true;
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00:00
if (p_render_data->reflection_probe.is_valid()) {
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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-22 23:39:09 +00: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 05:41:12 +00: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-22 23:39:09 +00:00
}
uint32_t directional_light_count = 0;
Added volumetric fog effect.
2020-08-13 01:21:01 +00: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-12 23:32:05 +00: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 05:41:12 +00: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 16:25:38 +00:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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-22 23:39:09 +00: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 19:51:36 +00: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 16:25:38 +00:00
}
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00:00
if (p_render_data->render_buffers.is_valid()) {
Added volumetric fog effect.
2020-08-13 01:21:01 +00: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 10:46:31 +00: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 14:10:22 +00: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 10:46:31 +00: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 19:51:36 +00:00
}
}
Change RendererSceneRender::GeometryInstance so more code is shared among renderers
2022-07-23 14:01:53 +00:00
void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData *p_camera_data, const CameraData *p_prev_camera_data, const PagedArray<RenderGeometryInstance *> &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 14:00:51 +00:00
RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 17:08:41 +00:00
rb = render_buffers_owner.get_or_null(p_render_buffers);
Create mobile renderer
2021-03-10 11:23:55 +00:00
ERR_FAIL_COND(!rb);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 19:51:36 +00:00
//assign render data
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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 19:51:36 +00:00
{
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00:00
render_data.render_buffers = p_render_buffers;
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00: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;
Fix "ortogonal" -> "orthogonal" typo in rasterizer code
2022-04-26 19:49:44 +00: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 14:10:22 +00:00
render_data.taa_jitter = p_camera_data->taa_jitter;
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00:00
render_data.view_count = p_camera_data->view_count;
for (uint32_t v = 0; v < p_camera_data->view_count; v++) {
Introduce eye_offset for correcting stereoscopic reflections Use view instead of vertex for reflections.
2022-06-16 12:02:18 +00:00
render_data.view_eye_offset[v] = p_camera_data->view_offset[v].origin;
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00:00
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 14:10:22 +00: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 13:19:04 +00: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 05:41:12 +00: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-04 22:47:26 +00: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 05:41:12 +00: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 11:28:55 +00: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 05:41:12 +00: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 13:19:04 +00: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 12:50:35 +00: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 05:41:12 +00: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-28 23:10:41 +00: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 05:41:12 +00: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-28 23:10:41 +00: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 05:41:12 +00: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 19:51:36 +00: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-02 23:14:19 +00: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 19:51:36 +00: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 05:41:12 +00: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-04 22:47:26 +00: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 19:51:36 +00:00
}
//sdfgi first
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 19:51:36 +00: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 12:08:08 +00: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 19:51:36 +00:00
}
if (render_state.sdfgi_update_data->update_static) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 19:51:36 +00:00
}
}
Color clear_color;
if (p_render_buffers.is_valid()) {
Merge canvas and decal into TextureStorage and add render target
2022-04-07 14:00:51 +00: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 19:51:36 +00:00
} else {
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
clear_color = RSG::texture_storage->get_default_clear_color();
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 19:51:36 +00: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-04 22:47:26 +00:00
//assign render indices to voxel_gi_instances
Create mobile renderer
2021-03-10 11:23:55 +00: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-04 22:47:26 +00:00
for (uint32_t i = 0; i < (uint32_t)p_voxel_gi_instances.size(); i++) {
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
RendererRD::GI::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-04 22:47:26 +00:00
if (voxel_gi_inst) {
voxel_gi_inst->render_index = i;
Create mobile renderer
2021-03-10 11:23:55 +00: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 19:51:36 +00:00
}
}
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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 10:46:31 +00: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 05:41:12 +00:00
} else if (reflection_probe_instance_owner.owns(render_data.reflection_probe)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 19:51:36 +00: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 10:46:31 +00: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 19:51:36 +00: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-04 22:47:26 +00:00
render_state.voxel_gi_count = 0;
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 17:51:29 +00: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-12 23:37:56 +00:00
if (rb->sdfgi) {
rb->sdfgi->update_cascades();
Add stereoscopic rendering through multiview
2021-05-07 13:19:04 +00: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-12 23:37:56 +00:00
rb->sdfgi->update_light();
}
Fix SDFGI * Broken by 7513b73902f3ed7ac45aa9aefc2f6f333ae731ff, fixes #49631
2021-07-04 00:24:37 +00: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 01:21:01 +00: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 19:51:36 +00:00
render_state.depth_prepass_used = false;
//calls _pre_opaque_render between depth pre-pass and opaque pass
Create mobile renderer
2021-03-10 11:23:55 +00:00
if (current_cluster_builder != nullptr) {
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00: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 11:23:55 +00:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
if (rb != nullptr && rb->vrs_fb.is_valid()) {
// vrs_fb will only be valid if vrs is enabled
vrs->update_vrs_texture(rb->vrs_fb, rb->render_target);
}
Split RenderDataRD struct from RenderState struct to simplify passing our render data around the renderer.
2021-05-05 05:41:12 +00:00
_render_scene(&render_data, clear_color);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
if (p_render_buffers.is_valid()) {
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00: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) {
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
Vector<RID> view_rids;
for (int v = 0; v < rb->views.size(); v++) {
view_rids.push_back(rb->views[v].view_texture);
}
rb->sdfgi->debug_draw(render_data.view_count, render_data.view_projection, render_data.cam_transform, rb->width, rb->height, rb->render_target, rb->texture, view_rids);
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
}
}
}
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 16:25:38 +00:00
ClusterBuilderRD::ElementType elem_type = ClusterBuilderRD::ELEMENT_TYPE_MAX;
Use subpasses to do 3D rendering and resolve in mobile renderer
2021-06-26 10:49:25 +00:00
switch (dd) {
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00: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 10:49:25 +00:00
current_cluster_builder->debug(elem_type);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
}
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
Change RendererSceneRender::GeometryInstance so more code is shared among renderers
2022-07-23 14:01:53 +00:00
void RendererSceneRenderRD::_render_shadow_pass(RID p_light, RID p_shadow_atlas, int p_pass, const PagedArray<RenderGeometryInstance *> &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 17:08:41 +00: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 01:51:27 +00: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 19:00:20 +00:00
uint32_t atlas_size;
RID atlas_fb;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 15:18:06 +00:00
Vector2i dual_paraboloid_offset;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 19:00:20 +00:00
float zfar;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 01:51:52 +00:00
bool use_pancake = false;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 19:00:20 +00:00
bool flip_y = false;
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection light_projection;
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D light_transform;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 01:51:27 +00:00
//set pssm stuff
if (light_instance->last_scene_shadow_pass != scene_pass) {
Directional lights and shadow mapping are functional.
2019-09-07 17:38:17 +00: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 01:51:27 +00:00
directional_shadow.current_light++;
Directional lights and shadow mapping are functional.
2019-09-07 17:38:17 +00:00
light_instance->last_scene_shadow_pass = scene_pass;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 01:51:27 +00: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 09:01:45 +00:00
atlas_rect = light_instance->directional_rect;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 01:51:27 +00: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 09:01:45 +00:00
atlas_rect.position += atlas_rect.size;
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 01:51:27 +00: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 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:29:49 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:29:49 +00:00
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 12:08:08 +00: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 00:29:49 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:29:49 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:29:49 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 19:51:36 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 13:33:28 +00:00
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 15:18:06 +00: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 09:34:31 +00: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 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
atlas_size = shadow_atlas->size;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 15:18:06 +00: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 12:08:08 +00: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 13:33:28 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
}
Move light, reflection probe and lightmap into LightStorage
2022-04-09 09:34:31 +00: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 12:08:08 +00: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-22 23:50:24 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
flip_y = true;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00: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-22 23:50:24 +00:00
}
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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-28 23:10:41 +00: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 12:08:08 +00: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 09:01:45 +00:00
atlas_rect_norm.position /= float(atlas_size);
atlas_rect_norm.size /= float(atlas_size);
Moved cube_to_dp and cubemap logic into CopyEffects
2022-06-17 03:55:23 +00:00
copy_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);
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 15:18:06 +00:00
atlas_rect_norm.position += Vector2(dual_paraboloid_offset) * atlas_rect_norm.size;
Moved cube_to_dp and cubemap logic into CopyEffects
2022-06-17 03:55:23 +00:00
copy_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-22 23:50:24 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
//restore transform so it can be properly used
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
light_instance_set_shadow_transform(p_light, Projection(), light_instance->transform, zfar, 0, 0, 0);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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-22 23:50:24 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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-28 23:10:41 +00: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 12:08:08 +00: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-22 23:50:24 +00:00
Change RendererSceneRender::GeometryInstance so more code is shared among renderers
2022-07-23 14:01:53 +00:00
void RendererSceneRenderRD::render_material(const Transform3D &p_cam_transform, const Projection &p_cam_projection, bool p_cam_orthogonal, const PagedArray<RenderGeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) {
Fix "ortogonal" -> "orthogonal" typo in rasterizer code
2022-04-26 19:49:44 +00:00
_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 12:08:08 +00: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-22 23:50:24 +00:00
Change RendererSceneRender::GeometryInstance so more code is shared among renderers
2022-07-23 14:01:53 +00:00
void RendererSceneRenderRD::render_particle_collider_heightfield(RID p_collider, const Transform3D &p_transform, const PagedArray<RenderGeometryInstance *> &p_instances) {
Moved particles into ParticlesStorage
2022-04-12 11:41:50 +00: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();
Implement Vector4, Vector4i, Projection Implement built-in classes Vector4, Vector4i and Projection. * Two versions of Vector4 (float and integer). * A Projection class, which is a 4x4 matrix specialized in projection types. These types have been requested for a long time, but given they were very corner case they were not added before. Because in Godot 4, reimplementing parts of the rendering engine is now possible, access to these types (heavily used by the rendering code) becomes a necessity. **Q**: Why Projection and not Matrix4? **A**: Godot does not use Matrix2, Matrix3, Matrix4x3, etc. naming convention because, within the engine, these types always have a *purpose*. As such, Godot names them: Transform2D, Transform3D or Basis. In this case, this 4x4 matrix is _always_ used as a _Projection_, hence the naming.
2022-07-19 23:11:13 +00:00
Projection cm;
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
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-22 23:50:24 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D cam_xform;
Rename Basis get_axis to get_column, remove redundant methods
2022-05-03 12:50:35 +00: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 13:33:28 +00:00
Moved particles into ParticlesStorage
2022-04-12 11:41:50 +00: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 19:51:36 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
bool RendererSceneRenderRD::free(RID p_rid) {
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
if (render_buffers_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 00:40:26 +00:00
_free_render_buffer_data(rb);
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
memdelete(rb->data);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
if (rb->sdfgi) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 13:33:28 +00:00
}
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
if (rb->volumetric_fog) {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
memdelete(rb->volumetric_fog);
rb->volumetric_fog = nullptr;
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
if (rb->cluster_builder) {
memdelete(rb->cluster_builder);
}
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
render_buffers_owner.free(p_rid);
Restructure environment in render implementation
2022-07-27 06:14:23 +00:00
} else if (is_environment(p_rid)) {
environment_free(p_rid);
WIP CameraEffects implementation (bokeh not working for now)
2020-01-13 18:37:24 +00: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 20:50:51 +00: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 17:08:41 +00: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 16:25:38 +00:00
if (ra->cluster_builder) {
memdelete(ra->cluster_builder);
}
Reflection probes working
2019-09-09 20:50:51 +00:00
reflection_atlas_owner.free(p_rid);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
} else if (reflection_probe_instance_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 20:06:33 +00:00
_free_forward_id(FORWARD_ID_TYPE_REFLECTION_PROBE, rpi->forward_id);
Reflection probes working
2019-09-09 20:50:51 +00:00
reflection_probe_release_atlas_index(p_rid);
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00: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 03:05:21 +00:00
} else if (decal_instance_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 20:06:33 +00: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 03:05:21 +00:00
decal_instance_owner.free(p_rid);
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 12:42:56 +00: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-04 22:47:26 +00:00
} else if (gi.voxel_gi_instance_owner.owns(p_rid)) {
Split GI effects and fix stereoscopic rendering of GI effects
2022-05-20 02:52:19 +00:00
RendererRD::GI::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-04 22:47:26 +00: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 20:39:08 +00: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-04 22:47:26 +00: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 02:14:56 +00: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-04 22:47:26 +00:00
gi.voxel_gi_instance_owner.free(p_rid);
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 01:51:27 +00:00
} else if (light_instance_owner.owns(p_rid)) {
Rename RID's `getornull()` to `get_or_null()`
2021-09-29 17:08:41 +00: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 01:51:27 +00:00
//remove from shadow atlases..
Use range iterators for RBSet in most cases
2022-05-18 23:43:40 +00: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 01:51:27 +00: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 15:18:06 +00: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 01:51:27 +00: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 20:06:33 +00: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 01:51:27 +00: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);
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
} else if (RendererRD::Fog::get_singleton()->owns_fog_volume_instance(p_rid)) {
RendererRD::Fog::get_singleton()->fog_instance_free(p_rid);
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
} else {
return false;
}
return true;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 00:40:26 +00:00
debug_draw = p_debug_draw;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::update() {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
sky.update_dirty_skys();
Environment sky more or less working.
2019-08-26 20:43:58 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
void RendererSceneRenderRD::set_time(double p_time, double p_step) {
Working sky shader implementation
2020-03-20 00:32:19 +00:00
time = p_time;
Auto exposure re-implemented in Vulkan
2020-01-12 01:26:52 +00:00
time_step = p_step;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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-26 23:09:40 +00:00
screen_space_roughness_limiter = p_enable;
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00: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-26 23:09:40 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
bool RendererSceneRenderRD::screen_space_roughness_limiter_is_active() const {
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-26 23:09:40 +00:00
return screen_space_roughness_limiter;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 13:33:28 +00:00
return screen_space_roughness_limiter_amount;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 13:33:28 +00:00
return screen_space_roughness_limiter_limit;
Added normalmap guided roughness mipmap generator, and a global roughness limiter.
2020-01-26 23:09:40 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00: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 12:34:23 +00: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;
Change RendererSceneRender::GeometryInstance so more code is shared among renderers
2022-07-23 14:01:53 +00:00
RenderGeometryInstance *gi = geometry_instance_create(p_base);
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 12:42:56 +00:00
Move storage for Mesh, MeshInstance, MultiMesh and Skeleton into MeshStorage
2022-04-02 05:29:04 +00: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 12:42:56 +00: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 12:34:23 +00:00
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 12:42:56 +00: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 12:34:23 +00:00
}
}
Change RendererSceneRender::GeometryInstance so more code is shared among renderers
2022-07-23 14:01:53 +00:00
gi->set_surface_materials(materials);
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 12:42:56 +00:00
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 16:52:58 +00: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 12:42:56 +00: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 16:52:58 +00: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 12:34:23 +00:00
Reorganize renderer code. So it can hopefully be made more cache efficient afterwards.
2020-12-31 12:42:56 +00: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 12:34:23 +00: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-17 22:03:09 +00: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 12:34:23 +00: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-17 22:03:09 +00: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 12:34:23 +00: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-17 22:03:09 +00: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 12:34:23 +00: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-17 22:03:09 +00: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 12:34:23 +00: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 18:26:24 +00: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 12:08:08 +00: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 13:33:28 +00:00
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RendererSceneRenderRD *RendererSceneRenderRD::singleton = nullptr;
Working sky shader implementation
2020-03-20 00:32:19 +00:00
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::get_reflection_probe_buffer() {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 16:25:38 +00: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-22 23:39:09 +00:00
}
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::get_directional_light_buffer() {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
return cluster.directional_light_buffer;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RID RendererSceneRenderRD::get_decal_buffer() {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
return cluster.decal_buffer;
}
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
int RendererSceneRenderRD::get_max_directional_lights() const {
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
return cluster.max_directional_lights;
}
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
bool RendererSceneRenderRD::is_vrs_supported() const {
return RD::get_singleton()->has_feature(RD::SUPPORTS_ATTACHMENT_VRS);
}
Move clustered renderer functionality
2021-03-23 10:46:31 +00: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 21:27:38 +00:00
}
Create mobile renderer
2021-03-10 11:23:55 +00:00
uint32_t RendererSceneRenderRD::get_max_elements() const {
return GLOBAL_GET("rendering/limits/cluster_builder/max_clustered_elements");
}
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
RendererSceneRenderRD::RendererSceneRenderRD() {
Working sky shader implementation
2020-03-20 00:32:19 +00: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 17:51:29 +00:00
}
void RendererSceneRenderRD::init() {
max_cluster_elements = get_max_elements();
Environment sky more or less working.
2019-08-26 20:43:58 +00: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 16:44:49 +00: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 19:00:20 +00:00
Working sky shader implementation
2020-03-20 00:32:19 +00:00
/* SKY SHADER */
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
sky.init();
Working sky shader implementation
2020-03-20 00:32:19 +00:00
Combine init_gi and init_sdfgi into a single init
2021-03-11 03:35:05 +00:00
/* GI */
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 11:06:48 +00:00
if (is_dynamic_gi_supported()) {
Split dependency logic Split FOG Split visibility notifier Final cleanup of storage classes
2022-06-21 00:08:33 +00:00
gi.init(&sky);
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
}
Don't use trashy max_decals value to prevent crashes
2021-02-01 20:43:08 +00: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-22 23:39:09 +00:00
{ //reflections
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
cluster.max_reflections = max_cluster_elements;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 19:51:36 +00: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 16:25:38 +00: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-22 23:39:09 +00:00
}
{ //lights
Added GPU based cluster builder Clustering is now GPU based, uses an implementation based on the Activision algorithm.
2021-01-17 16:25:38 +00:00
cluster.max_lights = max_cluster_elements;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 16:25:38 +00: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-22 23:39:09 +00: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 16:25:38 +00: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 12:05:36 +00:00
cluster.max_directional_lights = MAX_DIRECTIONAL_LIGHTS;
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 11:06:48 +00:00
if (is_volumetric_supported()) {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
RendererRD::Fog::get_singleton()->init_fog_shader(cluster.max_directional_lights, get_roughness_layers(), is_using_radiance_cubemap_array());
Added volumetric fog effect.
2020-08-13 01:21:01 +00:00
}
Addition of SDFGI for open world global illumination Move GI to a deferred pass
2020-06-25 13:33:28 +00:00
Added volumetric fog effect.
2020-08-13 01:21:01 +00: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 15:15:43 +00:00
sampler.mag_filter = RD::SAMPLER_FILTER_NEAREST;
sampler.min_filter = RD::SAMPLER_FILTER_NEAREST;
Added volumetric fog effect.
2020-08-13 01:21:01 +00: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 16:44:49 +00: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 07:07:32 +00: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 09:30:36 +00: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);
Rename soft shadow quality project settings for easier searching `rendering/quality/shadows` is now `rendering/quality/positional_shadow` to explicitly denote that the settings only affect positional light shadows, not directional light shadows. Shadow atlas settings now contain the word "atlas" for easier searching. Soft shadow quality settings were renamed to contain the word "filter". This makes the settings appear when searching for "filter" in the project settings dialog, like in Godot 3.x.
2022-04-30 23:40:30 +00:00
positional_soft_shadow_filter_set_quality(RS::ShadowQuality(int(GLOBAL_GET("rendering/shadows/positional_shadow/soft_shadow_filter_quality"))));
directional_soft_shadow_filter_set_quality(RS::ShadowQuality(int(GLOBAL_GET("rendering/shadows/directional_shadow/soft_shadow_filter_quality"))));
Added volumetric fog effect.
2020-08-13 01:21:01 +00: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 16:44:49 +00: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 16:52:58 +00: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 19:41:55 +00: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 16:52:58 +00:00
cull_argument.set_page_pool(&cull_argument_pool);
Splitting tonemapper into its own class
2022-04-27 03:42:50 +00:00
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00: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 03:42:50 +00:00
tone_mapper = memnew(RendererRD::ToneMapper);
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
vrs = memnew(RendererRD::VRS);
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
if (can_use_storage) {
ss_effects = memnew(RendererRD::SSEffects);
}
Base 3D engine done, still untested, though.
2019-08-18 22:40:52 +00:00
}
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
RenderingServer reorganization
2020-12-04 18:26:24 +00:00
RendererSceneRenderRD::~RendererSceneRenderRD() {
Split out bokeh_dof and copy effects
2022-04-29 07:10:54 +00:00
if (bokeh_dof) {
memdelete(bokeh_dof);
}
if (copy_effects) {
memdelete(copy_effects);
}
Splitting tonemapper into its own class
2022-04-27 03:42:50 +00:00
if (tone_mapper) {
memdelete(tone_mapper);
}
Adding Variable Rate Shading support to Godot Improve GI renderer and add VRS support Implement render device has_feature and move subgroup settings to limit_get
2022-02-11 11:33:54 +00:00
if (vrs) {
memdelete(vrs);
}
Move screen space effects into a separate class
2022-06-28 09:10:36 +00:00
if (ss_effects) {
memdelete(ss_effects);
}
Splitting tonemapper into its own class
2022-04-27 03:42:50 +00:00
Use range iterators for `Map`
2021-08-09 20:13:42 +00: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 01:51:27 +00:00
}
GIProbes working.
2019-10-03 20:39:08 +00:00
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00: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 00:32:19 +00:00
}
Remove low_end option from renderer, being replaced by separate implementation
2021-04-07 11:06:48 +00:00
if (is_dynamic_gi_supported()) {
Moving GI code into RendererServerGIRD Moving Skyshader code into RendererServerSkyRD
2021-02-13 12:08:08 +00:00
gi.free();
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
}
Fixes recently introduced shader leaks
2020-06-27 13:08:20 +00:00
Addition of FogVolumes, FogShaders, FogMaterial, and overhaul of VolumetricFog Co-authored-by: Brian Semrau <brian.semrau@gmail.com>
2021-10-03 11:28:55 +00:00
if (is_volumetric_supported()) {
Move Sky(RD) into environment Move Fog logic from render scene render to fog
2022-07-19 04:17:58 +00:00
RendererRD::Fog::get_singleton()->free_fog_shader();
Extract global variable, shader and material storage
2022-03-21 11:25:25 +00:00
}
Add proper quality settings to soft shadows
2020-04-10 09:30:36 +00: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-22 23:39:09 +00: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 16:25:38 +00: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-22 23:39:09 +00: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 16:25:38 +00: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-22 23:39:09 +00: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 16:25:38 +00:00
memdelete_arr(cluster.reflection_sort);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00: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 16:25:38 +00:00
memdelete_arr(cluster.decal_sort);
Refactor light clustering Move from high end to shared, so all renderers use clustering.
2020-07-22 23:39:09 +00:00
}
Added volumetric fog effect.
2020-08-13 01:21:01 +00: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 16:52:58 +00:00
cull_argument.reset(); //avoid exit error
Rewrote large part of rendering, omni and spot shadows now work.
2019-09-07 01:51:27 +00:00
}