8b19ffd810
-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).
3673 lines
154 KiB
C++
3673 lines
154 KiB
C++
/*************************************************************************/
|
|
/* renderer_scene_render_forward.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "renderer_scene_render_forward.h"
|
|
#include "core/config/project_settings.h"
|
|
#include "servers/rendering/rendering_device.h"
|
|
#include "servers/rendering/rendering_server_default.h"
|
|
|
|
/* SCENE SHADER */
|
|
void RendererSceneRenderForward::ShaderData::set_code(const String &p_code) {
|
|
//compile
|
|
|
|
code = p_code;
|
|
valid = false;
|
|
ubo_size = 0;
|
|
uniforms.clear();
|
|
uses_screen_texture = false;
|
|
|
|
if (code == String()) {
|
|
return; //just invalid, but no error
|
|
}
|
|
|
|
ShaderCompilerRD::GeneratedCode gen_code;
|
|
|
|
int blend_mode = BLEND_MODE_MIX;
|
|
int depth_testi = DEPTH_TEST_ENABLED;
|
|
int alpha_antialiasing_mode = ALPHA_ANTIALIASING_OFF;
|
|
int cull = CULL_BACK;
|
|
|
|
uses_point_size = false;
|
|
uses_alpha = false;
|
|
uses_blend_alpha = false;
|
|
uses_depth_pre_pass = false;
|
|
uses_discard = false;
|
|
uses_roughness = false;
|
|
uses_normal = false;
|
|
bool wireframe = false;
|
|
|
|
unshaded = false;
|
|
uses_vertex = false;
|
|
uses_sss = false;
|
|
uses_transmittance = false;
|
|
uses_screen_texture = false;
|
|
uses_depth_texture = false;
|
|
uses_normal_texture = false;
|
|
uses_time = false;
|
|
writes_modelview_or_projection = false;
|
|
uses_world_coordinates = false;
|
|
|
|
int depth_drawi = DEPTH_DRAW_OPAQUE;
|
|
|
|
ShaderCompilerRD::IdentifierActions actions;
|
|
|
|
actions.render_mode_values["blend_add"] = Pair<int *, int>(&blend_mode, BLEND_MODE_ADD);
|
|
actions.render_mode_values["blend_mix"] = Pair<int *, int>(&blend_mode, BLEND_MODE_MIX);
|
|
actions.render_mode_values["blend_sub"] = Pair<int *, int>(&blend_mode, BLEND_MODE_SUB);
|
|
actions.render_mode_values["blend_mul"] = Pair<int *, int>(&blend_mode, BLEND_MODE_MUL);
|
|
|
|
actions.render_mode_values["alpha_to_coverage"] = Pair<int *, int>(&alpha_antialiasing_mode, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE);
|
|
actions.render_mode_values["alpha_to_coverage_and_one"] = Pair<int *, int>(&alpha_antialiasing_mode, ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE);
|
|
|
|
actions.render_mode_values["depth_draw_never"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_DISABLED);
|
|
actions.render_mode_values["depth_draw_opaque"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_OPAQUE);
|
|
actions.render_mode_values["depth_draw_always"] = Pair<int *, int>(&depth_drawi, DEPTH_DRAW_ALWAYS);
|
|
|
|
actions.render_mode_values["depth_test_disabled"] = Pair<int *, int>(&depth_testi, DEPTH_TEST_DISABLED);
|
|
|
|
actions.render_mode_values["cull_disabled"] = Pair<int *, int>(&cull, CULL_DISABLED);
|
|
actions.render_mode_values["cull_front"] = Pair<int *, int>(&cull, CULL_FRONT);
|
|
actions.render_mode_values["cull_back"] = Pair<int *, int>(&cull, CULL_BACK);
|
|
|
|
actions.render_mode_flags["unshaded"] = &unshaded;
|
|
actions.render_mode_flags["wireframe"] = &wireframe;
|
|
|
|
actions.usage_flag_pointers["ALPHA"] = &uses_alpha;
|
|
actions.render_mode_flags["depth_prepass_alpha"] = &uses_depth_pre_pass;
|
|
|
|
actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;
|
|
actions.usage_flag_pointers["SSS_TRANSMITTANCE_DEPTH"] = &uses_transmittance;
|
|
|
|
actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
|
|
actions.usage_flag_pointers["DEPTH_TEXTURE"] = &uses_depth_texture;
|
|
actions.usage_flag_pointers["NORMAL_TEXTURE"] = &uses_normal_texture;
|
|
actions.usage_flag_pointers["DISCARD"] = &uses_discard;
|
|
actions.usage_flag_pointers["TIME"] = &uses_time;
|
|
actions.usage_flag_pointers["ROUGHNESS"] = &uses_roughness;
|
|
actions.usage_flag_pointers["NORMAL"] = &uses_normal;
|
|
actions.usage_flag_pointers["NORMAL_MAP"] = &uses_normal;
|
|
|
|
actions.usage_flag_pointers["POINT_SIZE"] = &uses_point_size;
|
|
actions.usage_flag_pointers["POINT_COORD"] = &uses_point_size;
|
|
|
|
actions.write_flag_pointers["MODELVIEW_MATRIX"] = &writes_modelview_or_projection;
|
|
actions.write_flag_pointers["PROJECTION_MATRIX"] = &writes_modelview_or_projection;
|
|
actions.write_flag_pointers["VERTEX"] = &uses_vertex;
|
|
|
|
actions.uniforms = &uniforms;
|
|
|
|
RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
|
|
|
|
Error err = scene_singleton->shader.compiler.compile(RS::SHADER_SPATIAL, code, &actions, path, gen_code);
|
|
|
|
ERR_FAIL_COND(err != OK);
|
|
|
|
if (version.is_null()) {
|
|
version = scene_singleton->shader.scene_shader.version_create();
|
|
}
|
|
|
|
depth_draw = DepthDraw(depth_drawi);
|
|
depth_test = DepthTest(depth_testi);
|
|
|
|
#if 0
|
|
print_line("**compiling shader:");
|
|
print_line("**defines:\n");
|
|
for (int i = 0; i < gen_code.defines.size(); i++) {
|
|
print_line(gen_code.defines[i]);
|
|
}
|
|
print_line("\n**uniforms:\n" + gen_code.uniforms);
|
|
print_line("\n**vertex_globals:\n" + gen_code.vertex_global);
|
|
print_line("\n**vertex_code:\n" + gen_code.vertex);
|
|
print_line("\n**fragment_globals:\n" + gen_code.fragment_global);
|
|
print_line("\n**fragment_code:\n" + gen_code.fragment);
|
|
print_line("\n**light_code:\n" + gen_code.light);
|
|
#endif
|
|
scene_singleton->shader.scene_shader.version_set_code(version, gen_code.uniforms, gen_code.vertex_global, gen_code.vertex, gen_code.fragment_global, gen_code.light, gen_code.fragment, gen_code.defines);
|
|
ERR_FAIL_COND(!scene_singleton->shader.scene_shader.version_is_valid(version));
|
|
|
|
ubo_size = gen_code.uniform_total_size;
|
|
ubo_offsets = gen_code.uniform_offsets;
|
|
texture_uniforms = gen_code.texture_uniforms;
|
|
|
|
//blend modes
|
|
|
|
// if any form of Alpha Antialiasing is enabled, set the blend mode to alpha to coverage
|
|
if (alpha_antialiasing_mode != ALPHA_ANTIALIASING_OFF) {
|
|
blend_mode = BLEND_MODE_ALPHA_TO_COVERAGE;
|
|
}
|
|
|
|
RD::PipelineColorBlendState::Attachment blend_attachment;
|
|
|
|
switch (blend_mode) {
|
|
case BLEND_MODE_MIX: {
|
|
blend_attachment.enable_blend = true;
|
|
blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
|
|
blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
|
|
blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
|
|
} break;
|
|
case BLEND_MODE_ADD: {
|
|
blend_attachment.enable_blend = true;
|
|
blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
|
|
blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE;
|
|
blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
|
|
blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
|
|
uses_blend_alpha = true; //force alpha used because of blend
|
|
|
|
} break;
|
|
case BLEND_MODE_SUB: {
|
|
blend_attachment.enable_blend = true;
|
|
blend_attachment.alpha_blend_op = RD::BLEND_OP_SUBTRACT;
|
|
blend_attachment.color_blend_op = RD::BLEND_OP_SUBTRACT;
|
|
blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
|
|
blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE;
|
|
blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
|
|
blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
|
|
uses_blend_alpha = true; //force alpha used because of blend
|
|
|
|
} break;
|
|
case BLEND_MODE_MUL: {
|
|
blend_attachment.enable_blend = true;
|
|
blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_DST_COLOR;
|
|
blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ZERO;
|
|
blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_DST_ALPHA;
|
|
blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ZERO;
|
|
uses_blend_alpha = true; //force alpha used because of blend
|
|
} break;
|
|
case BLEND_MODE_ALPHA_TO_COVERAGE: {
|
|
blend_attachment.enable_blend = true;
|
|
blend_attachment.alpha_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.color_blend_op = RD::BLEND_OP_ADD;
|
|
blend_attachment.src_color_blend_factor = RD::BLEND_FACTOR_SRC_ALPHA;
|
|
blend_attachment.dst_color_blend_factor = RD::BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
|
|
blend_attachment.src_alpha_blend_factor = RD::BLEND_FACTOR_ONE;
|
|
blend_attachment.dst_alpha_blend_factor = RD::BLEND_FACTOR_ZERO;
|
|
}
|
|
}
|
|
|
|
RD::PipelineColorBlendState blend_state_blend;
|
|
blend_state_blend.attachments.push_back(blend_attachment);
|
|
RD::PipelineColorBlendState blend_state_opaque = RD::PipelineColorBlendState::create_disabled(1);
|
|
RD::PipelineColorBlendState blend_state_opaque_specular = RD::PipelineColorBlendState::create_disabled(2);
|
|
RD::PipelineColorBlendState blend_state_depth_normal_roughness = RD::PipelineColorBlendState::create_disabled(1);
|
|
RD::PipelineColorBlendState blend_state_depth_normal_roughness_giprobe = RD::PipelineColorBlendState::create_disabled(2);
|
|
|
|
//update pipelines
|
|
|
|
RD::PipelineDepthStencilState depth_stencil_state;
|
|
|
|
if (depth_test != DEPTH_TEST_DISABLED) {
|
|
depth_stencil_state.enable_depth_test = true;
|
|
depth_stencil_state.depth_compare_operator = RD::COMPARE_OP_LESS_OR_EQUAL;
|
|
depth_stencil_state.enable_depth_write = depth_draw != DEPTH_DRAW_DISABLED ? true : false;
|
|
}
|
|
|
|
for (int i = 0; i < CULL_VARIANT_MAX; i++) {
|
|
RD::PolygonCullMode cull_mode_rd_table[CULL_VARIANT_MAX][3] = {
|
|
{ RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_FRONT, RD::POLYGON_CULL_BACK },
|
|
{ RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_BACK, RD::POLYGON_CULL_FRONT },
|
|
{ RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_DISABLED, RD::POLYGON_CULL_DISABLED }
|
|
};
|
|
|
|
RD::PolygonCullMode cull_mode_rd = cull_mode_rd_table[i][cull];
|
|
|
|
for (int j = 0; j < RS::PRIMITIVE_MAX; j++) {
|
|
RD::RenderPrimitive primitive_rd_table[RS::PRIMITIVE_MAX] = {
|
|
RD::RENDER_PRIMITIVE_POINTS,
|
|
RD::RENDER_PRIMITIVE_LINES,
|
|
RD::RENDER_PRIMITIVE_LINESTRIPS,
|
|
RD::RENDER_PRIMITIVE_TRIANGLES,
|
|
RD::RENDER_PRIMITIVE_TRIANGLE_STRIPS,
|
|
};
|
|
|
|
RD::RenderPrimitive primitive_rd = uses_point_size ? RD::RENDER_PRIMITIVE_POINTS : primitive_rd_table[j];
|
|
|
|
for (int k = 0; k < SHADER_VERSION_MAX; k++) {
|
|
if (!static_cast<RendererSceneRenderForward *>(singleton)->shader.scene_shader.is_variant_enabled(k)) {
|
|
continue;
|
|
}
|
|
RD::PipelineRasterizationState raster_state;
|
|
raster_state.cull_mode = cull_mode_rd;
|
|
raster_state.wireframe = wireframe;
|
|
|
|
RD::PipelineColorBlendState blend_state;
|
|
RD::PipelineDepthStencilState depth_stencil = depth_stencil_state;
|
|
RD::PipelineMultisampleState multisample_state;
|
|
|
|
if (uses_alpha || uses_blend_alpha) {
|
|
// only allow these flags to go through if we have some form of msaa
|
|
if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE) {
|
|
multisample_state.enable_alpha_to_coverage = true;
|
|
} else if (alpha_antialiasing_mode == ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE_AND_TO_ONE) {
|
|
multisample_state.enable_alpha_to_coverage = true;
|
|
multisample_state.enable_alpha_to_one = true;
|
|
}
|
|
|
|
if (k == SHADER_VERSION_COLOR_PASS || k == SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI || k == SHADER_VERSION_LIGHTMAP_COLOR_PASS) {
|
|
blend_state = blend_state_blend;
|
|
if (depth_draw == DEPTH_DRAW_OPAQUE) {
|
|
depth_stencil.enable_depth_write = false; //alpha does not draw depth
|
|
}
|
|
} else if (uses_depth_pre_pass && (k == SHADER_VERSION_DEPTH_PASS || k == SHADER_VERSION_DEPTH_PASS_DP || k == SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS || k == SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL)) {
|
|
if (k == SHADER_VERSION_DEPTH_PASS || k == SHADER_VERSION_DEPTH_PASS_DP) {
|
|
//none, blend state contains nothing
|
|
} else if (k == SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL) {
|
|
blend_state = RD::PipelineColorBlendState::create_disabled(5); //writes to normal and roughness in opaque way
|
|
} else {
|
|
blend_state = blend_state_opaque; //writes to normal and roughness in opaque way
|
|
}
|
|
} else {
|
|
pipelines[i][j][k].clear();
|
|
continue; // do not use this version (will error if using it is attempted)
|
|
}
|
|
} else {
|
|
if (k == SHADER_VERSION_COLOR_PASS || k == SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI || k == SHADER_VERSION_LIGHTMAP_COLOR_PASS) {
|
|
blend_state = blend_state_opaque;
|
|
} else if (k == SHADER_VERSION_DEPTH_PASS || k == SHADER_VERSION_DEPTH_PASS_DP) {
|
|
//none, leave empty
|
|
} else if (k == SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS) {
|
|
blend_state = blend_state_depth_normal_roughness;
|
|
} else if (k == SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_GIPROBE) {
|
|
blend_state = blend_state_depth_normal_roughness_giprobe;
|
|
} else if (k == SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL) {
|
|
blend_state = RD::PipelineColorBlendState::create_disabled(5); //writes to normal and roughness in opaque way
|
|
} else if (k == SHADER_VERSION_DEPTH_PASS_WITH_SDF) {
|
|
blend_state = RD::PipelineColorBlendState(); //no color targets for SDF
|
|
} else {
|
|
//specular write
|
|
blend_state = blend_state_opaque_specular;
|
|
depth_stencil.enable_depth_test = false;
|
|
depth_stencil.enable_depth_write = false;
|
|
}
|
|
}
|
|
|
|
RID shader_variant = scene_singleton->shader.scene_shader.version_get_shader(version, k);
|
|
pipelines[i][j][k].setup(shader_variant, primitive_rd, raster_state, multisample_state, depth_stencil, blend_state, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
valid = true;
|
|
}
|
|
|
|
void RendererSceneRenderForward::ShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
|
|
if (!p_texture.is_valid()) {
|
|
default_texture_params.erase(p_name);
|
|
} else {
|
|
default_texture_params[p_name] = p_texture;
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::ShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
|
|
Map<int, StringName> order;
|
|
|
|
for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
|
|
if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_LOCAL) {
|
|
continue;
|
|
}
|
|
|
|
if (E->get().texture_order >= 0) {
|
|
order[E->get().texture_order + 100000] = E->key();
|
|
} else {
|
|
order[E->get().order] = E->key();
|
|
}
|
|
}
|
|
|
|
for (Map<int, StringName>::Element *E = order.front(); E; E = E->next()) {
|
|
PropertyInfo pi = ShaderLanguage::uniform_to_property_info(uniforms[E->get()]);
|
|
pi.name = E->get();
|
|
p_param_list->push_back(pi);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::ShaderData::get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const {
|
|
for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
|
|
if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
|
|
continue;
|
|
}
|
|
|
|
RendererStorage::InstanceShaderParam p;
|
|
p.info = ShaderLanguage::uniform_to_property_info(E->get());
|
|
p.info.name = E->key(); //supply name
|
|
p.index = E->get().instance_index;
|
|
p.default_value = ShaderLanguage::constant_value_to_variant(E->get().default_value, E->get().type, E->get().hint);
|
|
p_param_list->push_back(p);
|
|
}
|
|
}
|
|
|
|
bool RendererSceneRenderForward::ShaderData::is_param_texture(const StringName &p_param) const {
|
|
if (!uniforms.has(p_param)) {
|
|
return false;
|
|
}
|
|
|
|
return uniforms[p_param].texture_order >= 0;
|
|
}
|
|
|
|
bool RendererSceneRenderForward::ShaderData::is_animated() const {
|
|
return false;
|
|
}
|
|
|
|
bool RendererSceneRenderForward::ShaderData::casts_shadows() const {
|
|
return false;
|
|
}
|
|
|
|
Variant RendererSceneRenderForward::ShaderData::get_default_parameter(const StringName &p_parameter) const {
|
|
if (uniforms.has(p_parameter)) {
|
|
ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
|
|
Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
|
|
return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.hint);
|
|
}
|
|
return Variant();
|
|
}
|
|
|
|
RS::ShaderNativeSourceCode RendererSceneRenderForward::ShaderData::get_native_source_code() const {
|
|
RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
|
|
|
|
return scene_singleton->shader.scene_shader.version_get_native_source_code(version);
|
|
}
|
|
|
|
RendererSceneRenderForward::ShaderData::ShaderData() {
|
|
valid = false;
|
|
uses_screen_texture = false;
|
|
}
|
|
|
|
RendererSceneRenderForward::ShaderData::~ShaderData() {
|
|
RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
|
|
ERR_FAIL_COND(!scene_singleton);
|
|
//pipeline variants will clear themselves if shader is gone
|
|
if (version.is_valid()) {
|
|
scene_singleton->shader.scene_shader.version_free(version);
|
|
}
|
|
}
|
|
|
|
RendererStorageRD::ShaderData *RendererSceneRenderForward::_create_shader_func() {
|
|
ShaderData *shader_data = memnew(ShaderData);
|
|
return shader_data;
|
|
}
|
|
|
|
void RendererSceneRenderForward::MaterialData::set_render_priority(int p_priority) {
|
|
priority = p_priority - RS::MATERIAL_RENDER_PRIORITY_MIN; //8 bits
|
|
}
|
|
|
|
void RendererSceneRenderForward::MaterialData::set_next_pass(RID p_pass) {
|
|
next_pass = p_pass;
|
|
}
|
|
|
|
void RendererSceneRenderForward::MaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
|
|
RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
|
|
|
|
if ((uint32_t)ubo_data.size() != shader_data->ubo_size) {
|
|
p_uniform_dirty = true;
|
|
if (uniform_buffer.is_valid()) {
|
|
RD::get_singleton()->free(uniform_buffer);
|
|
uniform_buffer = RID();
|
|
}
|
|
|
|
ubo_data.resize(shader_data->ubo_size);
|
|
if (ubo_data.size()) {
|
|
uniform_buffer = RD::get_singleton()->uniform_buffer_create(ubo_data.size());
|
|
memset(ubo_data.ptrw(), 0, ubo_data.size()); //clear
|
|
}
|
|
|
|
//clear previous uniform set
|
|
if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
|
|
RD::get_singleton()->free(uniform_set);
|
|
uniform_set = RID();
|
|
}
|
|
}
|
|
|
|
//check whether buffer changed
|
|
if (p_uniform_dirty && ubo_data.size()) {
|
|
update_uniform_buffer(shader_data->uniforms, shader_data->ubo_offsets.ptr(), p_parameters, ubo_data.ptrw(), ubo_data.size(), false);
|
|
RD::get_singleton()->buffer_update(uniform_buffer, 0, ubo_data.size(), ubo_data.ptrw(), RD::BARRIER_MASK_RASTER);
|
|
}
|
|
|
|
uint32_t tex_uniform_count = shader_data->texture_uniforms.size();
|
|
|
|
if ((uint32_t)texture_cache.size() != tex_uniform_count) {
|
|
texture_cache.resize(tex_uniform_count);
|
|
p_textures_dirty = true;
|
|
|
|
//clear previous uniform set
|
|
if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
|
|
RD::get_singleton()->free(uniform_set);
|
|
uniform_set = RID();
|
|
}
|
|
}
|
|
|
|
if (p_textures_dirty && tex_uniform_count) {
|
|
update_textures(p_parameters, shader_data->default_texture_params, shader_data->texture_uniforms, texture_cache.ptrw(), true);
|
|
}
|
|
|
|
if (shader_data->ubo_size == 0 && shader_data->texture_uniforms.size() == 0) {
|
|
// This material does not require an uniform set, so don't create it.
|
|
return;
|
|
}
|
|
|
|
if (!p_textures_dirty && uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
|
|
//no reason to update uniform set, only UBO (or nothing) was needed to update
|
|
return;
|
|
}
|
|
|
|
Vector<RD::Uniform> uniforms;
|
|
|
|
{
|
|
if (shader_data->ubo_size) {
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
|
|
u.binding = 0;
|
|
u.ids.push_back(uniform_buffer);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
const RID *textures = texture_cache.ptrw();
|
|
for (uint32_t i = 0; i < tex_uniform_count; i++) {
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.binding = 1 + i;
|
|
u.ids.push_back(textures[i]);
|
|
uniforms.push_back(u);
|
|
}
|
|
}
|
|
|
|
uniform_set = RD::get_singleton()->uniform_set_create(uniforms, scene_singleton->shader.scene_shader.version_get_shader(shader_data->version, 0), MATERIAL_UNIFORM_SET);
|
|
}
|
|
|
|
RendererSceneRenderForward::MaterialData::~MaterialData() {
|
|
if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
|
|
RD::get_singleton()->free(uniform_set);
|
|
}
|
|
|
|
if (uniform_buffer.is_valid()) {
|
|
RD::get_singleton()->free(uniform_buffer);
|
|
}
|
|
}
|
|
|
|
RendererStorageRD::MaterialData *RendererSceneRenderForward::_create_material_func(ShaderData *p_shader) {
|
|
MaterialData *material_data = memnew(MaterialData);
|
|
material_data->shader_data = p_shader;
|
|
material_data->last_frame = false;
|
|
//update will happen later anyway so do nothing.
|
|
return material_data;
|
|
}
|
|
|
|
RendererSceneRenderForward::RenderBufferDataForward::~RenderBufferDataForward() {
|
|
clear();
|
|
}
|
|
|
|
void RendererSceneRenderForward::RenderBufferDataForward::ensure_specular() {
|
|
if (!specular.is_valid()) {
|
|
RD::TextureFormat tf;
|
|
tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
|
|
tf.width = width;
|
|
tf.height = height;
|
|
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
|
|
if (msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
|
|
} else {
|
|
tf.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
}
|
|
|
|
specular = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
|
if (msaa == RS::VIEWPORT_MSAA_DISABLED) {
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(color);
|
|
fb.push_back(specular);
|
|
fb.push_back(depth);
|
|
|
|
color_specular_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(specular);
|
|
|
|
specular_only_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
|
|
} else {
|
|
tf.samples = texture_samples;
|
|
tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
|
|
specular_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(color_msaa);
|
|
fb.push_back(specular_msaa);
|
|
fb.push_back(depth_msaa);
|
|
|
|
color_specular_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(specular_msaa);
|
|
|
|
specular_only_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::RenderBufferDataForward::ensure_giprobe() {
|
|
if (!giprobe_buffer.is_valid()) {
|
|
RD::TextureFormat tf;
|
|
tf.format = RD::DATA_FORMAT_R8G8_UINT;
|
|
tf.width = width;
|
|
tf.height = height;
|
|
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
|
|
|
|
if (msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
RD::TextureFormat tf_aa = tf;
|
|
tf_aa.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
tf_aa.samples = texture_samples;
|
|
giprobe_buffer_msaa = RD::get_singleton()->texture_create(tf_aa, RD::TextureView());
|
|
} else {
|
|
tf.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
}
|
|
|
|
tf.usage_bits |= RD::TEXTURE_USAGE_STORAGE_BIT;
|
|
|
|
giprobe_buffer = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
|
Vector<RID> fb;
|
|
if (msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
fb.push_back(depth_msaa);
|
|
fb.push_back(normal_roughness_buffer_msaa);
|
|
fb.push_back(giprobe_buffer_msaa);
|
|
} else {
|
|
fb.push_back(depth);
|
|
fb.push_back(normal_roughness_buffer);
|
|
fb.push_back(giprobe_buffer);
|
|
}
|
|
|
|
depth_normal_roughness_giprobe_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::RenderBufferDataForward::clear() {
|
|
if (giprobe_buffer != RID()) {
|
|
RD::get_singleton()->free(giprobe_buffer);
|
|
giprobe_buffer = RID();
|
|
|
|
if (giprobe_buffer_msaa.is_valid()) {
|
|
RD::get_singleton()->free(giprobe_buffer_msaa);
|
|
giprobe_buffer_msaa = RID();
|
|
}
|
|
|
|
depth_normal_roughness_giprobe_fb = RID();
|
|
}
|
|
|
|
if (color_msaa.is_valid()) {
|
|
RD::get_singleton()->free(color_msaa);
|
|
color_msaa = RID();
|
|
}
|
|
|
|
if (depth_msaa.is_valid()) {
|
|
RD::get_singleton()->free(depth_msaa);
|
|
depth_msaa = RID();
|
|
}
|
|
|
|
if (specular.is_valid()) {
|
|
if (specular_msaa.is_valid()) {
|
|
RD::get_singleton()->free(specular_msaa);
|
|
specular_msaa = RID();
|
|
}
|
|
RD::get_singleton()->free(specular);
|
|
specular = RID();
|
|
}
|
|
|
|
color = RID();
|
|
depth = RID();
|
|
color_specular_fb = RID();
|
|
specular_only_fb = RID();
|
|
color_fb = RID();
|
|
depth_fb = RID();
|
|
|
|
if (normal_roughness_buffer.is_valid()) {
|
|
RD::get_singleton()->free(normal_roughness_buffer);
|
|
if (normal_roughness_buffer_msaa.is_valid()) {
|
|
RD::get_singleton()->free(normal_roughness_buffer_msaa);
|
|
normal_roughness_buffer_msaa = RID();
|
|
}
|
|
normal_roughness_buffer = RID();
|
|
depth_normal_roughness_fb = RID();
|
|
}
|
|
|
|
if (!render_sdfgi_uniform_set.is_null() && RD::get_singleton()->uniform_set_is_valid(render_sdfgi_uniform_set)) {
|
|
RD::get_singleton()->free(render_sdfgi_uniform_set);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::RenderBufferDataForward::configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, RS::ViewportMSAA p_msaa) {
|
|
clear();
|
|
|
|
msaa = p_msaa;
|
|
|
|
width = p_width;
|
|
height = p_height;
|
|
|
|
color = p_color_buffer;
|
|
depth = p_depth_buffer;
|
|
|
|
if (p_msaa == RS::VIEWPORT_MSAA_DISABLED) {
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(p_color_buffer);
|
|
fb.push_back(depth);
|
|
|
|
color_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(depth);
|
|
|
|
depth_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
} else {
|
|
RD::TextureFormat tf;
|
|
tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
|
|
tf.width = p_width;
|
|
tf.height = p_height;
|
|
tf.texture_type = RD::TEXTURE_TYPE_2D;
|
|
tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
|
|
|
|
RD::TextureSamples ts[RS::VIEWPORT_MSAA_MAX] = {
|
|
RD::TEXTURE_SAMPLES_1,
|
|
RD::TEXTURE_SAMPLES_2,
|
|
RD::TEXTURE_SAMPLES_4,
|
|
RD::TEXTURE_SAMPLES_8,
|
|
RD::TEXTURE_SAMPLES_16
|
|
};
|
|
|
|
texture_samples = ts[p_msaa];
|
|
tf.samples = texture_samples;
|
|
|
|
color_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
|
tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D24_UNORM_S8_UINT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D24_UNORM_S8_UINT : RD::DATA_FORMAT_D32_SFLOAT_S8_UINT;
|
|
tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
|
|
|
|
depth_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(color_msaa);
|
|
fb.push_back(depth_msaa);
|
|
|
|
color_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
{
|
|
Vector<RID> fb;
|
|
fb.push_back(depth_msaa);
|
|
|
|
depth_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_allocate_normal_roughness_texture(RenderBufferDataForward *rb) {
|
|
if (rb->normal_roughness_buffer.is_valid()) {
|
|
return;
|
|
}
|
|
|
|
RD::TextureFormat tf;
|
|
tf.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
|
|
tf.width = rb->width;
|
|
tf.height = rb->height;
|
|
tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
|
|
|
|
if (rb->msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
tf.usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
|
|
} else {
|
|
tf.usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
|
|
}
|
|
|
|
rb->normal_roughness_buffer = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
|
if (rb->msaa == RS::VIEWPORT_MSAA_DISABLED) {
|
|
Vector<RID> fb;
|
|
fb.push_back(rb->depth);
|
|
fb.push_back(rb->normal_roughness_buffer);
|
|
rb->depth_normal_roughness_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
} else {
|
|
tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
|
|
tf.samples = rb->texture_samples;
|
|
rb->normal_roughness_buffer_msaa = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
|
Vector<RID> fb;
|
|
fb.push_back(rb->depth_msaa);
|
|
fb.push_back(rb->normal_roughness_buffer_msaa);
|
|
rb->depth_normal_roughness_fb = RD::get_singleton()->framebuffer_create(fb);
|
|
}
|
|
|
|
_render_buffers_clear_uniform_set(rb);
|
|
}
|
|
|
|
RendererSceneRenderRD::RenderBufferData *RendererSceneRenderForward::_create_render_buffer_data() {
|
|
return memnew(RenderBufferDataForward);
|
|
}
|
|
|
|
bool RendererSceneRenderForward::free(RID p_rid) {
|
|
if (RendererSceneRenderRD::free(p_rid)) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// RENDERING ///
|
|
|
|
template <RendererSceneRenderForward::PassMode p_pass_mode>
|
|
void RendererSceneRenderForward::_render_list_template(RenderingDevice::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_framebuffer_Format, RenderListParameters *p_params, uint32_t p_from_element, uint32_t p_to_element) {
|
|
RD::DrawListID draw_list = p_draw_list;
|
|
RD::FramebufferFormatID framebuffer_format = p_framebuffer_Format;
|
|
|
|
//global scope bindings
|
|
RD::get_singleton()->draw_list_bind_uniform_set(draw_list, render_base_uniform_set, SCENE_UNIFORM_SET);
|
|
RD::get_singleton()->draw_list_bind_uniform_set(draw_list, p_params->render_pass_uniform_set, RENDER_PASS_UNIFORM_SET);
|
|
RD::get_singleton()->draw_list_bind_uniform_set(draw_list, default_vec4_xform_uniform_set, TRANSFORMS_UNIFORM_SET);
|
|
|
|
RID prev_material_uniform_set;
|
|
|
|
RID prev_vertex_array_rd;
|
|
RID prev_index_array_rd;
|
|
RID prev_pipeline_rd;
|
|
RID prev_xforms_uniform_set;
|
|
|
|
bool shadow_pass = (p_params->pass_mode == PASS_MODE_SHADOW) || (p_params->pass_mode == PASS_MODE_SHADOW_DP);
|
|
|
|
SceneState::PushConstant push_constant;
|
|
|
|
if (p_params->pass_mode == PASS_MODE_DEPTH_MATERIAL) {
|
|
push_constant.uv_offset = Math::make_half_float(p_params->uv_offset.y) << 16;
|
|
push_constant.uv_offset |= Math::make_half_float(p_params->uv_offset.x);
|
|
} else {
|
|
push_constant.uv_offset = 0;
|
|
}
|
|
|
|
for (uint32_t i = p_from_element; i < p_to_element; i++) {
|
|
const GeometryInstanceSurfaceDataCache *surf = p_params->elements[i];
|
|
const RenderElementInfo &element_info = p_params->element_info[i];
|
|
|
|
push_constant.base_index = i + p_params->element_offset;
|
|
|
|
RID material_uniform_set;
|
|
ShaderData *shader;
|
|
void *mesh_surface;
|
|
|
|
if (shadow_pass || p_params->pass_mode == PASS_MODE_DEPTH) { //regular depth pass can use these too
|
|
material_uniform_set = surf->material_uniform_set_shadow;
|
|
shader = surf->shader_shadow;
|
|
mesh_surface = surf->surface_shadow;
|
|
|
|
} else {
|
|
material_uniform_set = surf->material_uniform_set;
|
|
shader = surf->shader;
|
|
mesh_surface = surf->surface;
|
|
}
|
|
|
|
if (!mesh_surface) {
|
|
continue;
|
|
}
|
|
|
|
//find cull variant
|
|
ShaderData::CullVariant cull_variant;
|
|
|
|
if (p_params->pass_mode == PASS_MODE_DEPTH_MATERIAL || p_params->pass_mode == PASS_MODE_SDF || ((p_params->pass_mode == PASS_MODE_SHADOW || p_params->pass_mode == PASS_MODE_SHADOW_DP) && surf->flags & GeometryInstanceSurfaceDataCache::FLAG_USES_DOUBLE_SIDED_SHADOWS)) {
|
|
cull_variant = ShaderData::CULL_VARIANT_DOUBLE_SIDED;
|
|
} else {
|
|
bool mirror = surf->owner->mirror;
|
|
if (p_params->reverse_cull) {
|
|
mirror = !mirror;
|
|
}
|
|
cull_variant = mirror ? ShaderData::CULL_VARIANT_REVERSED : ShaderData::CULL_VARIANT_NORMAL;
|
|
}
|
|
|
|
RS::PrimitiveType primitive = surf->primitive;
|
|
RID xforms_uniform_set = surf->owner->transforms_uniform_set;
|
|
|
|
ShaderVersion shader_version = SHADER_VERSION_MAX; // Assigned to silence wrong -Wmaybe-initialized.
|
|
|
|
switch (p_params->pass_mode) {
|
|
case PASS_MODE_COLOR:
|
|
case PASS_MODE_COLOR_TRANSPARENT: {
|
|
if (element_info.uses_lightmap) {
|
|
shader_version = SHADER_VERSION_LIGHTMAP_COLOR_PASS;
|
|
} else if (element_info.uses_forward_gi) {
|
|
shader_version = SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI;
|
|
} else {
|
|
shader_version = SHADER_VERSION_COLOR_PASS;
|
|
}
|
|
} break;
|
|
case PASS_MODE_COLOR_SPECULAR: {
|
|
if (element_info.uses_lightmap) {
|
|
shader_version = SHADER_VERSION_LIGHTMAP_COLOR_PASS_WITH_SEPARATE_SPECULAR;
|
|
} else {
|
|
shader_version = SHADER_VERSION_COLOR_PASS_WITH_SEPARATE_SPECULAR;
|
|
}
|
|
} break;
|
|
case PASS_MODE_SHADOW:
|
|
case PASS_MODE_DEPTH: {
|
|
shader_version = SHADER_VERSION_DEPTH_PASS;
|
|
} break;
|
|
case PASS_MODE_SHADOW_DP: {
|
|
shader_version = SHADER_VERSION_DEPTH_PASS_DP;
|
|
} break;
|
|
case PASS_MODE_DEPTH_NORMAL_ROUGHNESS: {
|
|
shader_version = SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS;
|
|
} break;
|
|
case PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE: {
|
|
shader_version = SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_GIPROBE;
|
|
} break;
|
|
case PASS_MODE_DEPTH_MATERIAL: {
|
|
shader_version = SHADER_VERSION_DEPTH_PASS_WITH_MATERIAL;
|
|
} break;
|
|
case PASS_MODE_SDF: {
|
|
shader_version = SHADER_VERSION_DEPTH_PASS_WITH_SDF;
|
|
} break;
|
|
}
|
|
|
|
PipelineCacheRD *pipeline = nullptr;
|
|
|
|
pipeline = &shader->pipelines[cull_variant][primitive][shader_version];
|
|
|
|
RD::VertexFormatID vertex_format = -1;
|
|
RID vertex_array_rd;
|
|
RID index_array_rd;
|
|
|
|
//skeleton and blend shape
|
|
if (surf->owner->mesh_instance.is_valid()) {
|
|
storage->mesh_instance_surface_get_vertex_arrays_and_format(surf->owner->mesh_instance, surf->surface_index, pipeline->get_vertex_input_mask(), vertex_array_rd, vertex_format);
|
|
} else {
|
|
storage->mesh_surface_get_vertex_arrays_and_format(mesh_surface, pipeline->get_vertex_input_mask(), vertex_array_rd, vertex_format);
|
|
}
|
|
|
|
index_array_rd = storage->mesh_surface_get_index_array(mesh_surface, element_info.lod_index);
|
|
|
|
if (prev_vertex_array_rd != vertex_array_rd) {
|
|
RD::get_singleton()->draw_list_bind_vertex_array(draw_list, vertex_array_rd);
|
|
prev_vertex_array_rd = vertex_array_rd;
|
|
}
|
|
|
|
if (prev_index_array_rd != index_array_rd) {
|
|
if (index_array_rd.is_valid()) {
|
|
RD::get_singleton()->draw_list_bind_index_array(draw_list, index_array_rd);
|
|
}
|
|
prev_index_array_rd = index_array_rd;
|
|
}
|
|
|
|
RID pipeline_rd = pipeline->get_render_pipeline(vertex_format, framebuffer_format, p_params->force_wireframe);
|
|
|
|
if (pipeline_rd != prev_pipeline_rd) {
|
|
// checking with prev shader does not make so much sense, as
|
|
// the pipeline may still be different.
|
|
RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, pipeline_rd);
|
|
prev_pipeline_rd = pipeline_rd;
|
|
}
|
|
|
|
if (xforms_uniform_set.is_valid() && prev_xforms_uniform_set != xforms_uniform_set) {
|
|
RD::get_singleton()->draw_list_bind_uniform_set(draw_list, xforms_uniform_set, TRANSFORMS_UNIFORM_SET);
|
|
prev_xforms_uniform_set = xforms_uniform_set;
|
|
}
|
|
|
|
if (material_uniform_set != prev_material_uniform_set) {
|
|
//update uniform set
|
|
if (material_uniform_set.is_valid()) {
|
|
RD::get_singleton()->draw_list_bind_uniform_set(draw_list, material_uniform_set, MATERIAL_UNIFORM_SET);
|
|
}
|
|
|
|
prev_material_uniform_set = material_uniform_set;
|
|
}
|
|
|
|
RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(SceneState::PushConstant));
|
|
|
|
uint32_t instance_count = surf->owner->instance_count > 1 ? surf->owner->instance_count : element_info.repeat;
|
|
RD::get_singleton()->draw_list_draw(draw_list, index_array_rd.is_valid(), instance_count);
|
|
i += element_info.repeat - 1; //skip equal elements
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_list(RenderingDevice::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_framebuffer_Format, RenderListParameters *p_params, uint32_t p_from_element, uint32_t p_to_element) {
|
|
//use template for faster performance (pass mode comparisons are inlined)
|
|
|
|
switch (p_params->pass_mode) {
|
|
case PASS_MODE_COLOR: {
|
|
_render_list_template<PASS_MODE_COLOR>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_COLOR_SPECULAR: {
|
|
_render_list_template<PASS_MODE_COLOR_SPECULAR>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_COLOR_TRANSPARENT: {
|
|
_render_list_template<PASS_MODE_COLOR_TRANSPARENT>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_SHADOW: {
|
|
_render_list_template<PASS_MODE_SHADOW>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_SHADOW_DP: {
|
|
_render_list_template<PASS_MODE_SHADOW_DP>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_DEPTH: {
|
|
_render_list_template<PASS_MODE_DEPTH>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_DEPTH_NORMAL_ROUGHNESS: {
|
|
_render_list_template<PASS_MODE_DEPTH_NORMAL_ROUGHNESS>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE: {
|
|
_render_list_template<PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_DEPTH_MATERIAL: {
|
|
_render_list_template<PASS_MODE_DEPTH_MATERIAL>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
case PASS_MODE_SDF: {
|
|
_render_list_template<PASS_MODE_SDF>(p_draw_list, p_framebuffer_Format, p_params, p_from_element, p_to_element);
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_list_thread_function(uint32_t p_thread, RenderListParameters *p_params) {
|
|
uint32_t render_total = p_params->element_count;
|
|
uint32_t total_threads = RendererThreadPool::singleton->thread_work_pool.get_thread_count();
|
|
uint32_t render_from = p_thread * render_total / total_threads;
|
|
uint32_t render_to = (p_thread + 1 == total_threads) ? render_total : ((p_thread + 1) * render_total / total_threads);
|
|
_render_list(thread_draw_lists[p_thread], p_params->framebuffer_format, p_params, render_from, render_to);
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_list_with_threads(RenderListParameters *p_params, RID p_framebuffer, RD::InitialAction p_initial_color_action, RD::FinalAction p_final_color_action, RD::InitialAction p_initial_depth_action, RD::FinalAction p_final_depth_action, const Vector<Color> &p_clear_color_values, float p_clear_depth, uint32_t p_clear_stencil, const Rect2 &p_region, const Vector<RID> &p_storage_textures) {
|
|
RD::FramebufferFormatID fb_format = RD::get_singleton()->framebuffer_get_format(p_framebuffer);
|
|
p_params->framebuffer_format = fb_format;
|
|
|
|
if ((uint32_t)p_params->element_count > render_list_thread_threshold && false) { // secondary command buffers need more testing at this time
|
|
//multi threaded
|
|
thread_draw_lists.resize(RendererThreadPool::singleton->thread_work_pool.get_thread_count());
|
|
RD::get_singleton()->draw_list_begin_split(p_framebuffer, thread_draw_lists.size(), thread_draw_lists.ptr(), p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, p_region, p_storage_textures);
|
|
RendererThreadPool::singleton->thread_work_pool.do_work(thread_draw_lists.size(), this, &RendererSceneRenderForward::_render_list_thread_function, p_params);
|
|
RD::get_singleton()->draw_list_end(p_params->barrier);
|
|
} else {
|
|
//single threaded
|
|
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, p_initial_color_action, p_final_color_action, p_initial_depth_action, p_final_depth_action, p_clear_color_values, p_clear_depth, p_clear_stencil, p_region, p_storage_textures);
|
|
_render_list(draw_list, fb_format, p_params, 0, p_params->element_count);
|
|
RD::get_singleton()->draw_list_end(p_params->barrier);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_setup_environment(RID p_environment, RID p_render_buffers, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_reflection_probe, bool p_no_fog, const Size2i &p_screen_size, uint32_t p_cluster_size, uint32_t p_max_cluster_elements, RID p_shadow_atlas, bool p_flip_y, const Color &p_default_bg_color, float p_znear, float p_zfar, bool p_opaque_render_buffers, bool p_pancake_shadows, int p_index) {
|
|
//CameraMatrix projection = p_cam_projection;
|
|
//projection.flip_y(); // Vulkan and modern APIs use Y-Down
|
|
CameraMatrix correction;
|
|
correction.set_depth_correction(p_flip_y);
|
|
CameraMatrix projection = correction * p_cam_projection;
|
|
|
|
//store camera into ubo
|
|
RendererStorageRD::store_camera(projection, scene_state.ubo.projection_matrix);
|
|
RendererStorageRD::store_camera(projection.inverse(), scene_state.ubo.inv_projection_matrix);
|
|
RendererStorageRD::store_transform(p_cam_transform, scene_state.ubo.camera_matrix);
|
|
RendererStorageRD::store_transform(p_cam_transform.affine_inverse(), scene_state.ubo.inv_camera_matrix);
|
|
|
|
scene_state.ubo.z_far = p_zfar;
|
|
scene_state.ubo.z_near = p_znear;
|
|
|
|
scene_state.ubo.pancake_shadows = p_pancake_shadows;
|
|
|
|
RendererStorageRD::store_soft_shadow_kernel(directional_penumbra_shadow_kernel_get(), scene_state.ubo.directional_penumbra_shadow_kernel);
|
|
RendererStorageRD::store_soft_shadow_kernel(directional_soft_shadow_kernel_get(), scene_state.ubo.directional_soft_shadow_kernel);
|
|
RendererStorageRD::store_soft_shadow_kernel(penumbra_shadow_kernel_get(), scene_state.ubo.penumbra_shadow_kernel);
|
|
RendererStorageRD::store_soft_shadow_kernel(soft_shadow_kernel_get(), scene_state.ubo.soft_shadow_kernel);
|
|
|
|
scene_state.ubo.directional_penumbra_shadow_samples = directional_penumbra_shadow_samples_get();
|
|
scene_state.ubo.directional_soft_shadow_samples = directional_soft_shadow_samples_get();
|
|
scene_state.ubo.penumbra_shadow_samples = penumbra_shadow_samples_get();
|
|
scene_state.ubo.soft_shadow_samples = soft_shadow_samples_get();
|
|
|
|
Size2 screen_pixel_size = Vector2(1.0, 1.0) / Size2(p_screen_size);
|
|
scene_state.ubo.screen_pixel_size[0] = screen_pixel_size.x;
|
|
scene_state.ubo.screen_pixel_size[1] = screen_pixel_size.y;
|
|
|
|
scene_state.ubo.cluster_shift = get_shift_from_power_of_2(p_cluster_size);
|
|
scene_state.ubo.max_cluster_element_count_div_32 = p_max_cluster_elements / 32;
|
|
{
|
|
uint32_t cluster_screen_width = (p_screen_size.width - 1) / p_cluster_size + 1;
|
|
uint32_t cluster_screen_height = (p_screen_size.height - 1) / p_cluster_size + 1;
|
|
scene_state.ubo.cluster_type_size = cluster_screen_width * cluster_screen_height * (scene_state.ubo.max_cluster_element_count_div_32 + 32);
|
|
scene_state.ubo.cluster_width = cluster_screen_width;
|
|
}
|
|
|
|
if (p_shadow_atlas.is_valid()) {
|
|
Vector2 sas = shadow_atlas_get_size(p_shadow_atlas);
|
|
scene_state.ubo.shadow_atlas_pixel_size[0] = 1.0 / sas.x;
|
|
scene_state.ubo.shadow_atlas_pixel_size[1] = 1.0 / sas.y;
|
|
}
|
|
{
|
|
Vector2 dss = directional_shadow_get_size();
|
|
scene_state.ubo.directional_shadow_pixel_size[0] = 1.0 / dss.x;
|
|
scene_state.ubo.directional_shadow_pixel_size[1] = 1.0 / dss.y;
|
|
}
|
|
//time global variables
|
|
scene_state.ubo.time = time;
|
|
|
|
scene_state.ubo.gi_upscale_for_msaa = false;
|
|
scene_state.ubo.volumetric_fog_enabled = false;
|
|
scene_state.ubo.fog_enabled = false;
|
|
|
|
if (p_render_buffers.is_valid()) {
|
|
RenderBufferDataForward *render_buffers = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
|
|
if (render_buffers->msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
scene_state.ubo.gi_upscale_for_msaa = true;
|
|
}
|
|
|
|
if (render_buffers_has_volumetric_fog(p_render_buffers)) {
|
|
scene_state.ubo.volumetric_fog_enabled = true;
|
|
float fog_end = render_buffers_get_volumetric_fog_end(p_render_buffers);
|
|
if (fog_end > 0.0) {
|
|
scene_state.ubo.volumetric_fog_inv_length = 1.0 / fog_end;
|
|
} else {
|
|
scene_state.ubo.volumetric_fog_inv_length = 1.0;
|
|
}
|
|
|
|
float fog_detail_spread = render_buffers_get_volumetric_fog_detail_spread(p_render_buffers); //reverse lookup
|
|
if (fog_detail_spread > 0.0) {
|
|
scene_state.ubo.volumetric_fog_detail_spread = 1.0 / fog_detail_spread;
|
|
} else {
|
|
scene_state.ubo.volumetric_fog_detail_spread = 1.0;
|
|
}
|
|
}
|
|
}
|
|
#if 0
|
|
if (p_render_buffers.is_valid() && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
|
|
scene_state.ubo.sdfgi_cascade_count = render_buffers_get_sdfgi_cascade_count(p_render_buffers);
|
|
scene_state.ubo.sdfgi_probe_axis_size = render_buffers_get_sdfgi_cascade_probe_count(p_render_buffers);
|
|
scene_state.ubo.sdfgi_cascade_probe_size[0] = scene_state.ubo.sdfgi_probe_axis_size - 1; //float version for performance
|
|
scene_state.ubo.sdfgi_cascade_probe_size[1] = scene_state.ubo.sdfgi_probe_axis_size - 1;
|
|
scene_state.ubo.sdfgi_cascade_probe_size[2] = scene_state.ubo.sdfgi_probe_axis_size - 1;
|
|
|
|
float csize = render_buffers_get_sdfgi_cascade_size(p_render_buffers);
|
|
scene_state.ubo.sdfgi_probe_to_uvw = 1.0 / float(scene_state.ubo.sdfgi_cascade_probe_size[0]);
|
|
float occ_bias = 0.0;
|
|
scene_state.ubo.sdfgi_occlusion_bias = occ_bias / csize;
|
|
scene_state.ubo.sdfgi_use_occlusion = render_buffers_is_sdfgi_using_occlusion(p_render_buffers);
|
|
scene_state.ubo.sdfgi_energy = render_buffers_get_sdfgi_energy(p_render_buffers);
|
|
|
|
float cascade_voxel_size = (csize / scene_state.ubo.sdfgi_cascade_probe_size[0]);
|
|
float occlusion_clamp = (cascade_voxel_size - 0.5) / cascade_voxel_size;
|
|
scene_state.ubo.sdfgi_occlusion_clamp[0] = occlusion_clamp;
|
|
scene_state.ubo.sdfgi_occlusion_clamp[1] = occlusion_clamp;
|
|
scene_state.ubo.sdfgi_occlusion_clamp[2] = occlusion_clamp;
|
|
scene_state.ubo.sdfgi_normal_bias = (render_buffers_get_sdfgi_normal_bias(p_render_buffers) / csize) * scene_state.ubo.sdfgi_cascade_probe_size[0];
|
|
|
|
//vec2 tex_pixel_size = 1.0 / vec2(ivec2( (OCT_SIZE+2) * params.probe_axis_size * params.probe_axis_size, (OCT_SIZE+2) * params.probe_axis_size ) );
|
|
//vec3 probe_uv_offset = (ivec3(OCT_SIZE+2,OCT_SIZE+2,(OCT_SIZE+2) * params.probe_axis_size)) * tex_pixel_size.xyx;
|
|
|
|
uint32_t oct_size = sdfgi_get_lightprobe_octahedron_size();
|
|
|
|
scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[0] = 1.0 / ((oct_size + 2) * scene_state.ubo.sdfgi_probe_axis_size * scene_state.ubo.sdfgi_probe_axis_size);
|
|
scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[1] = 1.0 / ((oct_size + 2) * scene_state.ubo.sdfgi_probe_axis_size);
|
|
scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[2] = 1.0;
|
|
|
|
scene_state.ubo.sdfgi_probe_uv_offset[0] = float(oct_size + 2) * scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[0];
|
|
scene_state.ubo.sdfgi_probe_uv_offset[1] = float(oct_size + 2) * scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[1];
|
|
scene_state.ubo.sdfgi_probe_uv_offset[2] = float((oct_size + 2) * scene_state.ubo.sdfgi_probe_axis_size) * scene_state.ubo.sdfgi_lightprobe_tex_pixel_size[0];
|
|
|
|
scene_state.ubo.sdfgi_occlusion_renormalize[0] = 0.5;
|
|
scene_state.ubo.sdfgi_occlusion_renormalize[1] = 1.0;
|
|
scene_state.ubo.sdfgi_occlusion_renormalize[2] = 1.0 / float(scene_state.ubo.sdfgi_cascade_count);
|
|
|
|
for (uint32_t i = 0; i < scene_state.ubo.sdfgi_cascade_count; i++) {
|
|
SceneState::UBO::SDFGICascade &c = scene_state.ubo.sdfgi_cascades[i];
|
|
Vector3 pos = render_buffers_get_sdfgi_cascade_offset(p_render_buffers, i);
|
|
pos -= p_cam_transform.origin; //make pos local to camera, to reduce numerical error
|
|
c.position[0] = pos.x;
|
|
c.position[1] = pos.y;
|
|
c.position[2] = pos.z;
|
|
c.to_probe = 1.0 / render_buffers_get_sdfgi_cascade_probe_size(p_render_buffers, i);
|
|
|
|
Vector3i probe_ofs = render_buffers_get_sdfgi_cascade_probe_offset(p_render_buffers, i);
|
|
c.probe_world_offset[0] = probe_ofs.x;
|
|
c.probe_world_offset[1] = probe_ofs.y;
|
|
c.probe_world_offset[2] = probe_ofs.z;
|
|
}
|
|
}
|
|
#endif
|
|
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
|
|
scene_state.ubo.use_ambient_light = true;
|
|
scene_state.ubo.ambient_light_color_energy[0] = 1;
|
|
scene_state.ubo.ambient_light_color_energy[1] = 1;
|
|
scene_state.ubo.ambient_light_color_energy[2] = 1;
|
|
scene_state.ubo.ambient_light_color_energy[3] = 1.0;
|
|
scene_state.ubo.use_ambient_cubemap = false;
|
|
scene_state.ubo.use_reflection_cubemap = false;
|
|
scene_state.ubo.ssao_enabled = false;
|
|
|
|
} else if (is_environment(p_environment)) {
|
|
RS::EnvironmentBG env_bg = environment_get_background(p_environment);
|
|
RS::EnvironmentAmbientSource ambient_src = environment_get_ambient_source(p_environment);
|
|
|
|
float bg_energy = environment_get_bg_energy(p_environment);
|
|
scene_state.ubo.ambient_light_color_energy[3] = bg_energy;
|
|
|
|
scene_state.ubo.ambient_color_sky_mix = environment_get_ambient_sky_contribution(p_environment);
|
|
|
|
//ambient
|
|
if (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && (env_bg == RS::ENV_BG_CLEAR_COLOR || env_bg == RS::ENV_BG_COLOR)) {
|
|
Color color = env_bg == RS::ENV_BG_CLEAR_COLOR ? p_default_bg_color : environment_get_bg_color(p_environment);
|
|
color = color.to_linear();
|
|
|
|
scene_state.ubo.ambient_light_color_energy[0] = color.r * bg_energy;
|
|
scene_state.ubo.ambient_light_color_energy[1] = color.g * bg_energy;
|
|
scene_state.ubo.ambient_light_color_energy[2] = color.b * bg_energy;
|
|
scene_state.ubo.use_ambient_light = true;
|
|
scene_state.ubo.use_ambient_cubemap = false;
|
|
} else {
|
|
float energy = environment_get_ambient_light_energy(p_environment);
|
|
Color color = environment_get_ambient_light_color(p_environment);
|
|
color = color.to_linear();
|
|
scene_state.ubo.ambient_light_color_energy[0] = color.r * energy;
|
|
scene_state.ubo.ambient_light_color_energy[1] = color.g * energy;
|
|
scene_state.ubo.ambient_light_color_energy[2] = color.b * energy;
|
|
|
|
Basis sky_transform = environment_get_sky_orientation(p_environment);
|
|
sky_transform = sky_transform.inverse() * p_cam_transform.basis;
|
|
RendererStorageRD::store_transform_3x3(sky_transform, scene_state.ubo.radiance_inverse_xform);
|
|
|
|
scene_state.ubo.use_ambient_cubemap = (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && env_bg == RS::ENV_BG_SKY) || ambient_src == RS::ENV_AMBIENT_SOURCE_SKY;
|
|
scene_state.ubo.use_ambient_light = scene_state.ubo.use_ambient_cubemap || ambient_src == RS::ENV_AMBIENT_SOURCE_COLOR;
|
|
}
|
|
|
|
//specular
|
|
RS::EnvironmentReflectionSource ref_src = environment_get_reflection_source(p_environment);
|
|
if ((ref_src == RS::ENV_REFLECTION_SOURCE_BG && env_bg == RS::ENV_BG_SKY) || ref_src == RS::ENV_REFLECTION_SOURCE_SKY) {
|
|
scene_state.ubo.use_reflection_cubemap = true;
|
|
} else {
|
|
scene_state.ubo.use_reflection_cubemap = false;
|
|
}
|
|
|
|
scene_state.ubo.ssao_enabled = p_opaque_render_buffers && environment_is_ssao_enabled(p_environment);
|
|
scene_state.ubo.ssao_ao_affect = environment_get_ssao_ao_affect(p_environment);
|
|
scene_state.ubo.ssao_light_affect = environment_get_ssao_light_affect(p_environment);
|
|
|
|
Color ao_color = environment_get_ao_color(p_environment).to_linear();
|
|
scene_state.ubo.ao_color[0] = ao_color.r;
|
|
scene_state.ubo.ao_color[1] = ao_color.g;
|
|
scene_state.ubo.ao_color[2] = ao_color.b;
|
|
scene_state.ubo.ao_color[3] = ao_color.a;
|
|
|
|
scene_state.ubo.fog_enabled = environment_is_fog_enabled(p_environment);
|
|
scene_state.ubo.fog_density = environment_get_fog_density(p_environment);
|
|
scene_state.ubo.fog_height = environment_get_fog_height(p_environment);
|
|
scene_state.ubo.fog_height_density = environment_get_fog_height_density(p_environment);
|
|
if (scene_state.ubo.fog_height_density >= 0.0001) {
|
|
scene_state.ubo.fog_height_density = 1.0 / scene_state.ubo.fog_height_density;
|
|
}
|
|
scene_state.ubo.fog_aerial_perspective = environment_get_fog_aerial_perspective(p_environment);
|
|
|
|
Color fog_color = environment_get_fog_light_color(p_environment).to_linear();
|
|
float fog_energy = environment_get_fog_light_energy(p_environment);
|
|
|
|
scene_state.ubo.fog_light_color[0] = fog_color.r * fog_energy;
|
|
scene_state.ubo.fog_light_color[1] = fog_color.g * fog_energy;
|
|
scene_state.ubo.fog_light_color[2] = fog_color.b * fog_energy;
|
|
|
|
scene_state.ubo.fog_sun_scatter = environment_get_fog_sun_scatter(p_environment);
|
|
|
|
} else {
|
|
if (p_reflection_probe.is_valid() && storage->reflection_probe_is_interior(reflection_probe_instance_get_probe(p_reflection_probe))) {
|
|
scene_state.ubo.use_ambient_light = false;
|
|
} else {
|
|
scene_state.ubo.use_ambient_light = true;
|
|
Color clear_color = p_default_bg_color;
|
|
clear_color = clear_color.to_linear();
|
|
scene_state.ubo.ambient_light_color_energy[0] = clear_color.r;
|
|
scene_state.ubo.ambient_light_color_energy[1] = clear_color.g;
|
|
scene_state.ubo.ambient_light_color_energy[2] = clear_color.b;
|
|
scene_state.ubo.ambient_light_color_energy[3] = 1.0;
|
|
}
|
|
|
|
scene_state.ubo.use_ambient_cubemap = false;
|
|
scene_state.ubo.use_reflection_cubemap = false;
|
|
scene_state.ubo.ssao_enabled = false;
|
|
}
|
|
|
|
scene_state.ubo.roughness_limiter_enabled = p_opaque_render_buffers && screen_space_roughness_limiter_is_active();
|
|
scene_state.ubo.roughness_limiter_amount = screen_space_roughness_limiter_get_amount();
|
|
scene_state.ubo.roughness_limiter_limit = screen_space_roughness_limiter_get_limit();
|
|
|
|
if (p_index >= (int)scene_state.uniform_buffers.size()) {
|
|
uint32_t from = scene_state.uniform_buffers.size();
|
|
scene_state.uniform_buffers.resize(p_index + 1);
|
|
render_pass_uniform_sets.resize(p_index + 1);
|
|
for (uint32_t i = from; i < scene_state.uniform_buffers.size(); i++) {
|
|
scene_state.uniform_buffers[i] = RD::get_singleton()->uniform_buffer_create(sizeof(SceneState::UBO));
|
|
}
|
|
}
|
|
RD::get_singleton()->buffer_update(scene_state.uniform_buffers[p_index], 0, sizeof(SceneState::UBO), &scene_state.ubo, RD::BARRIER_MASK_RASTER);
|
|
}
|
|
|
|
void RendererSceneRenderForward::_update_instance_data_buffer(RenderListType p_render_list) {
|
|
if (scene_state.instance_data[p_render_list].size() > 0) {
|
|
if (scene_state.instance_buffer[p_render_list] == RID() || scene_state.instance_buffer_size[p_render_list] < scene_state.instance_data[p_render_list].size()) {
|
|
if (scene_state.instance_buffer[p_render_list] != RID()) {
|
|
RD::get_singleton()->free(scene_state.instance_buffer[p_render_list]);
|
|
}
|
|
uint32_t new_size = nearest_power_of_2_templated(MAX(uint64_t(INSTANCE_DATA_BUFFER_MIN_SIZE), scene_state.instance_data[p_render_list].size()));
|
|
scene_state.instance_buffer[p_render_list] = RD::get_singleton()->storage_buffer_create(new_size * sizeof(SceneState::InstanceData));
|
|
scene_state.instance_buffer_size[p_render_list] = new_size;
|
|
}
|
|
RD::get_singleton()->buffer_update(scene_state.instance_buffer[p_render_list], 0, sizeof(SceneState::InstanceData) * scene_state.instance_data[p_render_list].size(), scene_state.instance_data[p_render_list].ptr(), RD::BARRIER_MASK_RASTER);
|
|
}
|
|
}
|
|
void RendererSceneRenderForward::_fill_instance_data(RenderListType p_render_list, uint32_t p_offset, int32_t p_max_elements, bool p_update_buffer) {
|
|
RenderList *rl = &render_list[p_render_list];
|
|
uint32_t element_total = p_max_elements >= 0 ? uint32_t(p_max_elements) : rl->elements.size();
|
|
|
|
scene_state.instance_data[p_render_list].resize(p_offset + element_total);
|
|
rl->element_info.resize(p_offset + element_total);
|
|
|
|
uint32_t repeats = 0;
|
|
GeometryInstanceSurfaceDataCache *prev_surface = nullptr;
|
|
for (uint32_t i = 0; i < element_total; i++) {
|
|
GeometryInstanceSurfaceDataCache *surface = rl->elements[i + p_offset];
|
|
GeometryInstanceForward *inst = surface->owner;
|
|
|
|
SceneState::InstanceData &instance_data = scene_state.instance_data[p_render_list][i + p_offset];
|
|
|
|
if (inst->store_transform_cache) {
|
|
RendererStorageRD::store_transform(inst->transform, instance_data.transform);
|
|
} else {
|
|
RendererStorageRD::store_transform(Transform(), instance_data.transform);
|
|
}
|
|
|
|
instance_data.flags = inst->flags_cache;
|
|
instance_data.gi_offset = inst->gi_offset_cache;
|
|
instance_data.layer_mask = inst->layer_mask;
|
|
instance_data.instance_uniforms_ofs = uint32_t(inst->shader_parameters_offset);
|
|
instance_data.lightmap_uv_scale[0] = inst->lightmap_uv_scale.position.x;
|
|
instance_data.lightmap_uv_scale[1] = inst->lightmap_uv_scale.position.y;
|
|
instance_data.lightmap_uv_scale[2] = inst->lightmap_uv_scale.size.x;
|
|
instance_data.lightmap_uv_scale[3] = inst->lightmap_uv_scale.size.y;
|
|
|
|
bool cant_repeat = instance_data.flags & INSTANCE_DATA_FLAG_MULTIMESH || inst->mesh_instance.is_valid();
|
|
|
|
if (prev_surface != nullptr && !cant_repeat && prev_surface->sort.sort_key1 == surface->sort.sort_key1 && prev_surface->sort.sort_key2 == surface->sort.sort_key2) {
|
|
//this element is the same as the previous one, count repeats to draw it using instancing
|
|
repeats++;
|
|
} else {
|
|
if (repeats > 0) {
|
|
for (uint32_t j = 1; j <= repeats; j++) {
|
|
rl->element_info[p_offset + i - j].repeat = j;
|
|
}
|
|
}
|
|
repeats = 1;
|
|
}
|
|
|
|
RenderElementInfo &element_info = rl->element_info[p_offset + i];
|
|
|
|
element_info.lod_index = surface->sort.lod_index;
|
|
element_info.uses_forward_gi = surface->sort.uses_forward_gi;
|
|
element_info.uses_lightmap = surface->sort.uses_lightmap;
|
|
|
|
if (cant_repeat) {
|
|
prev_surface = nullptr;
|
|
} else {
|
|
prev_surface = surface;
|
|
}
|
|
}
|
|
|
|
if (repeats > 0) {
|
|
for (uint32_t j = 1; j <= repeats; j++) {
|
|
rl->element_info[p_offset + element_total - j].repeat = j;
|
|
}
|
|
}
|
|
|
|
if (p_update_buffer) {
|
|
_update_instance_data_buffer(p_render_list);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_fill_render_list(RenderListType p_render_list, const PagedArray<GeometryInstance *> &p_instances, PassMode p_pass_mode, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, bool p_using_sdfgi, bool p_using_opaque_gi, const Plane &p_lod_plane, float p_lod_distance_multiplier, float p_screen_lod_threshold, bool p_append) {
|
|
if (p_render_list == RENDER_LIST_OPAQUE) {
|
|
scene_state.used_sss = false;
|
|
scene_state.used_screen_texture = false;
|
|
scene_state.used_normal_texture = false;
|
|
scene_state.used_depth_texture = false;
|
|
}
|
|
uint32_t lightmap_captures_used = 0;
|
|
|
|
Plane near_plane(p_cam_transform.origin, -p_cam_transform.basis.get_axis(Vector3::AXIS_Z));
|
|
near_plane.d += p_cam_projection.get_z_near();
|
|
float z_max = p_cam_projection.get_z_far() - p_cam_projection.get_z_near();
|
|
|
|
RenderList *rl = &render_list[p_render_list];
|
|
_update_dirty_geometry_instances();
|
|
|
|
if (!p_append) {
|
|
rl->clear();
|
|
if (p_render_list == RENDER_LIST_OPAQUE) {
|
|
render_list[RENDER_LIST_ALPHA].clear(); //opaque fills alpha too
|
|
}
|
|
}
|
|
|
|
//fill list
|
|
|
|
for (int i = 0; i < (int)p_instances.size(); i++) {
|
|
GeometryInstanceForward *inst = static_cast<GeometryInstanceForward *>(p_instances[i]);
|
|
|
|
Vector3 support_min = inst->transformed_aabb.get_support(-near_plane.normal);
|
|
inst->depth = near_plane.distance_to(support_min);
|
|
uint32_t depth_layer = CLAMP(int(inst->depth * 16 / z_max), 0, 15);
|
|
|
|
uint32_t flags = inst->base_flags; //fill flags if appropriate
|
|
|
|
bool uses_lightmap = false;
|
|
bool uses_gi = false;
|
|
|
|
if (p_render_list == RENDER_LIST_OPAQUE) {
|
|
//setup GI
|
|
|
|
if (inst->lightmap_instance.is_valid()) {
|
|
int32_t lightmap_cull_index = -1;
|
|
for (uint32_t j = 0; j < scene_state.lightmaps_used; j++) {
|
|
if (scene_state.lightmap_ids[j] == inst->lightmap_instance) {
|
|
lightmap_cull_index = j;
|
|
break;
|
|
}
|
|
}
|
|
if (lightmap_cull_index >= 0) {
|
|
inst->gi_offset_cache = inst->lightmap_slice_index << 16;
|
|
inst->gi_offset_cache |= lightmap_cull_index;
|
|
flags |= INSTANCE_DATA_FLAG_USE_LIGHTMAP;
|
|
if (scene_state.lightmap_has_sh[lightmap_cull_index]) {
|
|
flags |= INSTANCE_DATA_FLAG_USE_SH_LIGHTMAP;
|
|
}
|
|
uses_lightmap = true;
|
|
} else {
|
|
inst->gi_offset_cache = 0xFFFFFFFF;
|
|
}
|
|
|
|
} else if (inst->lightmap_sh) {
|
|
if (lightmap_captures_used < scene_state.max_lightmap_captures) {
|
|
const Color *src_capture = inst->lightmap_sh->sh;
|
|
LightmapCaptureData &lcd = scene_state.lightmap_captures[lightmap_captures_used];
|
|
for (int j = 0; j < 9; j++) {
|
|
lcd.sh[j * 4 + 0] = src_capture[j].r;
|
|
lcd.sh[j * 4 + 1] = src_capture[j].g;
|
|
lcd.sh[j * 4 + 2] = src_capture[j].b;
|
|
lcd.sh[j * 4 + 3] = src_capture[j].a;
|
|
}
|
|
flags |= INSTANCE_DATA_FLAG_USE_LIGHTMAP_CAPTURE;
|
|
inst->gi_offset_cache = lightmap_captures_used;
|
|
lightmap_captures_used++;
|
|
uses_lightmap = true;
|
|
}
|
|
|
|
} else if (!low_end) {
|
|
if (p_using_opaque_gi) {
|
|
flags |= INSTANCE_DATA_FLAG_USE_GI_BUFFERS;
|
|
}
|
|
|
|
if (inst->gi_probes[0].is_valid()) {
|
|
uint32_t probe0_index = 0xFFFF;
|
|
uint32_t probe1_index = 0xFFFF;
|
|
|
|
for (uint32_t j = 0; j < scene_state.giprobes_used; j++) {
|
|
if (scene_state.giprobe_ids[j] == inst->gi_probes[0]) {
|
|
probe0_index = j;
|
|
} else if (scene_state.giprobe_ids[j] == inst->gi_probes[1]) {
|
|
probe1_index = j;
|
|
}
|
|
}
|
|
|
|
if (probe0_index == 0xFFFF && probe1_index != 0xFFFF) {
|
|
//0 must always exist if a probe exists
|
|
SWAP(probe0_index, probe1_index);
|
|
}
|
|
|
|
inst->gi_offset_cache = probe0_index | (probe1_index << 16);
|
|
flags |= INSTANCE_DATA_FLAG_USE_GIPROBE;
|
|
uses_gi = true;
|
|
} else {
|
|
if (p_using_sdfgi && inst->can_sdfgi) {
|
|
flags |= INSTANCE_DATA_FLAG_USE_SDFGI;
|
|
uses_gi = true;
|
|
}
|
|
inst->gi_offset_cache = 0xFFFFFFFF;
|
|
}
|
|
}
|
|
}
|
|
inst->flags_cache = flags;
|
|
|
|
GeometryInstanceSurfaceDataCache *surf = inst->surface_caches;
|
|
|
|
while (surf) {
|
|
surf->sort.uses_forward_gi = 0;
|
|
surf->sort.uses_lightmap = 0;
|
|
|
|
// LOD
|
|
|
|
if (p_screen_lod_threshold > 0.0 && storage->mesh_surface_has_lod(surf->surface)) {
|
|
//lod
|
|
Vector3 lod_support_min = inst->transformed_aabb.get_support(-p_lod_plane.normal);
|
|
Vector3 lod_support_max = inst->transformed_aabb.get_support(p_lod_plane.normal);
|
|
|
|
float distance_min = p_lod_plane.distance_to(lod_support_min);
|
|
float distance_max = p_lod_plane.distance_to(lod_support_max);
|
|
|
|
float distance = 0.0;
|
|
|
|
if (distance_min * distance_max < 0.0) {
|
|
//crossing plane
|
|
distance = 0.0;
|
|
} else if (distance_min >= 0.0) {
|
|
distance = distance_min;
|
|
} else if (distance_max <= 0.0) {
|
|
distance = -distance_max;
|
|
}
|
|
|
|
surf->sort.lod_index = storage->mesh_surface_get_lod(surf->surface, inst->lod_model_scale * inst->lod_bias, distance * p_lod_distance_multiplier, p_screen_lod_threshold);
|
|
} else {
|
|
surf->sort.lod_index = 0;
|
|
}
|
|
|
|
// ADD Element
|
|
if (p_pass_mode == PASS_MODE_COLOR) {
|
|
if (surf->flags & (GeometryInstanceSurfaceDataCache::FLAG_PASS_DEPTH | GeometryInstanceSurfaceDataCache::FLAG_PASS_OPAQUE)) {
|
|
rl->add_element(surf);
|
|
}
|
|
if (surf->flags & GeometryInstanceSurfaceDataCache::FLAG_PASS_ALPHA) {
|
|
render_list[RENDER_LIST_ALPHA].add_element(surf);
|
|
if (uses_gi) {
|
|
surf->sort.uses_forward_gi = 1;
|
|
}
|
|
}
|
|
|
|
if (uses_lightmap) {
|
|
surf->sort.uses_lightmap = 1;
|
|
}
|
|
|
|
if (surf->flags & GeometryInstanceSurfaceDataCache::FLAG_USES_SUBSURFACE_SCATTERING) {
|
|
scene_state.used_sss = true;
|
|
}
|
|
if (surf->flags & GeometryInstanceSurfaceDataCache::FLAG_USES_SCREEN_TEXTURE) {
|
|
scene_state.used_screen_texture = true;
|
|
}
|
|
if (surf->flags & GeometryInstanceSurfaceDataCache::FLAG_USES_NORMAL_TEXTURE) {
|
|
scene_state.used_normal_texture = true;
|
|
}
|
|
if (surf->flags & GeometryInstanceSurfaceDataCache::FLAG_USES_DEPTH_TEXTURE) {
|
|
scene_state.used_depth_texture = true;
|
|
}
|
|
|
|
} else if (p_pass_mode == PASS_MODE_SHADOW || p_pass_mode == PASS_MODE_SHADOW_DP) {
|
|
if (surf->flags & GeometryInstanceSurfaceDataCache::FLAG_PASS_SHADOW) {
|
|
rl->add_element(surf);
|
|
}
|
|
} else {
|
|
if (surf->flags & (GeometryInstanceSurfaceDataCache::FLAG_PASS_DEPTH | GeometryInstanceSurfaceDataCache::FLAG_PASS_OPAQUE)) {
|
|
rl->add_element(surf);
|
|
}
|
|
}
|
|
|
|
surf->sort.depth_layer = depth_layer;
|
|
|
|
surf = surf->next;
|
|
}
|
|
}
|
|
|
|
if (p_render_list == RENDER_LIST_OPAQUE && lightmap_captures_used) {
|
|
RD::get_singleton()->buffer_update(scene_state.lightmap_capture_buffer, 0, sizeof(LightmapCaptureData) * lightmap_captures_used, scene_state.lightmap_captures, RD::BARRIER_MASK_RASTER);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_setup_giprobes(const PagedArray<RID> &p_giprobes) {
|
|
scene_state.giprobes_used = MIN(p_giprobes.size(), uint32_t(MAX_GI_PROBES));
|
|
for (uint32_t i = 0; i < scene_state.giprobes_used; i++) {
|
|
scene_state.giprobe_ids[i] = p_giprobes[i];
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_setup_lightmaps(const PagedArray<RID> &p_lightmaps, const Transform &p_cam_transform) {
|
|
scene_state.lightmaps_used = 0;
|
|
for (int i = 0; i < (int)p_lightmaps.size(); i++) {
|
|
if (i >= (int)scene_state.max_lightmaps) {
|
|
break;
|
|
}
|
|
|
|
RID lightmap = lightmap_instance_get_lightmap(p_lightmaps[i]);
|
|
|
|
Basis to_lm = lightmap_instance_get_transform(p_lightmaps[i]).basis.inverse() * p_cam_transform.basis;
|
|
to_lm = to_lm.inverse().transposed(); //will transform normals
|
|
RendererStorageRD::store_transform_3x3(to_lm, scene_state.lightmaps[i].normal_xform);
|
|
scene_state.lightmap_ids[i] = p_lightmaps[i];
|
|
scene_state.lightmap_has_sh[i] = storage->lightmap_uses_spherical_harmonics(lightmap);
|
|
|
|
scene_state.lightmaps_used++;
|
|
}
|
|
if (scene_state.lightmaps_used > 0) {
|
|
RD::get_singleton()->buffer_update(scene_state.lightmap_buffer, 0, sizeof(LightmapData) * scene_state.lightmaps_used, scene_state.lightmaps, RD::BARRIER_MASK_RASTER);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, const PagedArray<GeometryInstance *> &p_instances, const PagedArray<RID> &p_gi_probes, const PagedArray<RID> &p_lightmaps, RID p_environment, RID p_cluster_buffer, uint32_t p_cluster_size, uint32_t p_max_cluster_elements, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color, float p_screen_lod_threshold) {
|
|
RenderBufferDataForward *render_buffer = nullptr;
|
|
if (p_render_buffer.is_valid()) {
|
|
render_buffer = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffer);
|
|
}
|
|
|
|
//first of all, make a new render pass
|
|
//fill up ubo
|
|
|
|
RENDER_TIMESTAMP("Setup 3D Scene");
|
|
|
|
float lod_distance_multiplier = p_cam_projection.get_lod_multiplier();
|
|
Plane lod_camera_plane(p_cam_transform.get_origin(), -p_cam_transform.basis.get_axis(Vector3::AXIS_Z));
|
|
|
|
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_DISABLE_LOD) {
|
|
p_screen_lod_threshold = 0.0;
|
|
}
|
|
|
|
//scene_state.ubo.subsurface_scatter_width = subsurface_scatter_size;
|
|
|
|
Vector2 vp_he = p_cam_projection.get_viewport_half_extents();
|
|
scene_state.ubo.viewport_size[0] = vp_he.x;
|
|
scene_state.ubo.viewport_size[1] = vp_he.y;
|
|
scene_state.ubo.directional_light_count = 0;
|
|
|
|
Size2i screen_size;
|
|
RID opaque_framebuffer;
|
|
RID opaque_specular_framebuffer;
|
|
RID depth_framebuffer;
|
|
RID alpha_framebuffer;
|
|
|
|
PassMode depth_pass_mode = PASS_MODE_DEPTH;
|
|
Vector<Color> depth_pass_clear;
|
|
bool using_separate_specular = false;
|
|
bool using_ssr = false;
|
|
bool using_sdfgi = false;
|
|
bool using_giprobe = false;
|
|
|
|
if (render_buffer) {
|
|
screen_size.x = render_buffer->width;
|
|
screen_size.y = render_buffer->height;
|
|
|
|
opaque_framebuffer = render_buffer->color_fb;
|
|
|
|
if (!low_end && p_gi_probes.size() > 0) {
|
|
using_giprobe = true;
|
|
}
|
|
|
|
if (!p_environment.is_valid() && using_giprobe) {
|
|
depth_pass_mode = PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE;
|
|
|
|
} else if (p_environment.is_valid() && (environment_is_ssr_enabled(p_environment) || environment_is_sdfgi_enabled(p_environment) || using_giprobe)) {
|
|
if (environment_is_sdfgi_enabled(p_environment)) {
|
|
depth_pass_mode = using_giprobe ? PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE : PASS_MODE_DEPTH_NORMAL_ROUGHNESS; // also giprobe
|
|
using_sdfgi = true;
|
|
} else {
|
|
depth_pass_mode = using_giprobe ? PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE : PASS_MODE_DEPTH_NORMAL_ROUGHNESS;
|
|
}
|
|
|
|
if (environment_is_ssr_enabled(p_environment)) {
|
|
render_buffer->ensure_specular();
|
|
using_separate_specular = true;
|
|
using_ssr = true;
|
|
opaque_specular_framebuffer = render_buffer->color_specular_fb;
|
|
}
|
|
|
|
} else if (p_environment.is_valid() && (environment_is_ssao_enabled(p_environment) || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER)) {
|
|
depth_pass_mode = PASS_MODE_DEPTH_NORMAL_ROUGHNESS;
|
|
}
|
|
|
|
switch (depth_pass_mode) {
|
|
case PASS_MODE_DEPTH: {
|
|
depth_framebuffer = render_buffer->depth_fb;
|
|
} break;
|
|
case PASS_MODE_DEPTH_NORMAL_ROUGHNESS: {
|
|
_allocate_normal_roughness_texture(render_buffer);
|
|
depth_framebuffer = render_buffer->depth_normal_roughness_fb;
|
|
depth_pass_clear.push_back(Color(0.5, 0.5, 0.5, 0));
|
|
} break;
|
|
case PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE: {
|
|
_allocate_normal_roughness_texture(render_buffer);
|
|
render_buffer->ensure_giprobe();
|
|
depth_framebuffer = render_buffer->depth_normal_roughness_giprobe_fb;
|
|
depth_pass_clear.push_back(Color(0.5, 0.5, 0.5, 0));
|
|
depth_pass_clear.push_back(Color(0, 0, 0, 0));
|
|
} break;
|
|
default: {
|
|
};
|
|
}
|
|
|
|
alpha_framebuffer = opaque_framebuffer;
|
|
} else if (p_reflection_probe.is_valid()) {
|
|
uint32_t resolution = reflection_probe_instance_get_resolution(p_reflection_probe);
|
|
screen_size.x = resolution;
|
|
screen_size.y = resolution;
|
|
|
|
opaque_framebuffer = reflection_probe_instance_get_framebuffer(p_reflection_probe, p_reflection_probe_pass);
|
|
depth_framebuffer = reflection_probe_instance_get_depth_framebuffer(p_reflection_probe, p_reflection_probe_pass);
|
|
alpha_framebuffer = opaque_framebuffer;
|
|
|
|
if (storage->reflection_probe_is_interior(reflection_probe_instance_get_probe(p_reflection_probe))) {
|
|
p_environment = RID(); //no environment on interiors
|
|
}
|
|
} else {
|
|
ERR_FAIL(); //bug?
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render Setup");
|
|
|
|
_setup_lightmaps(p_lightmaps, p_cam_transform);
|
|
_setup_giprobes(p_gi_probes);
|
|
_setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_size, p_cluster_size, p_max_cluster_elements, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), false);
|
|
|
|
_update_render_base_uniform_set(); //may have changed due to the above (light buffer enlarged, as an example)
|
|
|
|
_fill_render_list(RENDER_LIST_OPAQUE, p_instances, PASS_MODE_COLOR, p_cam_projection, p_cam_transform, using_sdfgi, using_sdfgi || using_giprobe, lod_camera_plane, lod_distance_multiplier, p_screen_lod_threshold);
|
|
render_list[RENDER_LIST_OPAQUE].sort_by_key();
|
|
render_list[RENDER_LIST_ALPHA].sort_by_depth();
|
|
_fill_instance_data(RENDER_LIST_OPAQUE);
|
|
_fill_instance_data(RENDER_LIST_ALPHA);
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
|
|
bool using_sss = !low_end && render_buffer && scene_state.used_sss && sub_surface_scattering_get_quality() != RS::SUB_SURFACE_SCATTERING_QUALITY_DISABLED;
|
|
|
|
if (using_sss) {
|
|
using_separate_specular = true;
|
|
render_buffer->ensure_specular();
|
|
using_separate_specular = true;
|
|
opaque_specular_framebuffer = render_buffer->color_specular_fb;
|
|
}
|
|
RID radiance_texture;
|
|
bool draw_sky = false;
|
|
bool draw_sky_fog_only = false;
|
|
|
|
Color clear_color;
|
|
bool keep_color = false;
|
|
|
|
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_OVERDRAW) {
|
|
clear_color = Color(0, 0, 0, 1); //in overdraw mode, BG should always be black
|
|
} else if (is_environment(p_environment)) {
|
|
RS::EnvironmentBG bg_mode = environment_get_background(p_environment);
|
|
float bg_energy = environment_get_bg_energy(p_environment);
|
|
switch (bg_mode) {
|
|
case RS::ENV_BG_CLEAR_COLOR: {
|
|
clear_color = p_default_bg_color;
|
|
clear_color.r *= bg_energy;
|
|
clear_color.g *= bg_energy;
|
|
clear_color.b *= bg_energy;
|
|
if (render_buffers_has_volumetric_fog(p_render_buffer) || environment_is_fog_enabled(p_environment)) {
|
|
draw_sky_fog_only = true;
|
|
storage->material_set_param(sky_scene_state.fog_material, "clear_color", Variant(clear_color.to_linear()));
|
|
}
|
|
} break;
|
|
case RS::ENV_BG_COLOR: {
|
|
clear_color = environment_get_bg_color(p_environment);
|
|
clear_color.r *= bg_energy;
|
|
clear_color.g *= bg_energy;
|
|
clear_color.b *= bg_energy;
|
|
if (render_buffers_has_volumetric_fog(p_render_buffer) || environment_is_fog_enabled(p_environment)) {
|
|
draw_sky_fog_only = true;
|
|
storage->material_set_param(sky_scene_state.fog_material, "clear_color", Variant(clear_color.to_linear()));
|
|
}
|
|
} break;
|
|
case RS::ENV_BG_SKY: {
|
|
draw_sky = true;
|
|
} break;
|
|
case RS::ENV_BG_CANVAS: {
|
|
keep_color = true;
|
|
} break;
|
|
case RS::ENV_BG_KEEP: {
|
|
keep_color = true;
|
|
} break;
|
|
case RS::ENV_BG_CAMERA_FEED: {
|
|
} break;
|
|
default: {
|
|
}
|
|
}
|
|
// setup sky if used for ambient, reflections, or background
|
|
if (draw_sky || draw_sky_fog_only || environment_get_reflection_source(p_environment) == RS::ENV_REFLECTION_SOURCE_SKY || environment_get_ambient_source(p_environment) == RS::ENV_AMBIENT_SOURCE_SKY) {
|
|
RENDER_TIMESTAMP("Setup Sky");
|
|
RD::get_singleton()->draw_command_begin_label("Setup Sky");
|
|
CameraMatrix projection = p_cam_projection;
|
|
if (p_reflection_probe.is_valid()) {
|
|
CameraMatrix correction;
|
|
correction.set_depth_correction(true);
|
|
projection = correction * p_cam_projection;
|
|
}
|
|
|
|
_setup_sky(p_environment, p_render_buffer, projection, p_cam_transform, screen_size);
|
|
|
|
RID sky = environment_get_sky(p_environment);
|
|
if (sky.is_valid()) {
|
|
_update_sky(p_environment, projection, p_cam_transform);
|
|
radiance_texture = sky_get_radiance_texture_rd(sky);
|
|
} else {
|
|
// do not try to draw sky if invalid
|
|
draw_sky = false;
|
|
}
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
} else {
|
|
clear_color = p_default_bg_color;
|
|
}
|
|
|
|
bool debug_giprobes = get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_ALBEDO || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_LIGHTING || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_EMISSION;
|
|
bool debug_sdfgi_probes = get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_SDFGI_PROBES;
|
|
bool depth_pre_pass = !low_end && depth_framebuffer.is_valid();
|
|
|
|
bool using_ssao = depth_pre_pass && p_render_buffer.is_valid() && p_environment.is_valid() && environment_is_ssao_enabled(p_environment);
|
|
bool continue_depth = false;
|
|
if (depth_pre_pass) { //depth pre pass
|
|
|
|
bool needs_pre_resolve = _needs_post_prepass_render(using_sdfgi || using_giprobe);
|
|
if (needs_pre_resolve) {
|
|
RENDER_TIMESTAMP("GI + Render Depth Pre-Pass (parallel)");
|
|
} else {
|
|
RENDER_TIMESTAMP("Render Depth Pre-Pass");
|
|
}
|
|
if (needs_pre_resolve) {
|
|
//pre clear the depth framebuffer, as AMD (and maybe others?) use compute for it, and barrier other compute shaders.
|
|
RD::get_singleton()->draw_list_begin(depth_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_CONTINUE, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_CONTINUE, depth_pass_clear);
|
|
RD::get_singleton()->draw_list_end();
|
|
//start compute processes here, so they run at the same time as depth pre-pass
|
|
_post_prepass_render(using_sdfgi || using_giprobe);
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render Depth Pre-Pass");
|
|
|
|
RID rp_uniform_set = _setup_render_pass_uniform_set(RENDER_LIST_OPAQUE, RID(), RID(), RID(), RID(), RID(), PagedArray<RID>(), PagedArray<RID>());
|
|
|
|
bool finish_depth = using_ssao || using_sdfgi || using_giprobe;
|
|
RenderListParameters render_list_params(render_list[RENDER_LIST_OPAQUE].elements.ptr(), render_list[RENDER_LIST_OPAQUE].element_info.ptr(), render_list[RENDER_LIST_OPAQUE].elements.size(), false, depth_pass_mode, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, Vector2(), lod_camera_plane, lod_distance_multiplier, p_screen_lod_threshold);
|
|
_render_list_with_threads(&render_list_params, depth_framebuffer, needs_pre_resolve ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, needs_pre_resolve ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_CLEAR, finish_depth ? RD::FINAL_ACTION_READ : RD::FINAL_ACTION_CONTINUE, needs_pre_resolve ? Vector<Color>() : depth_pass_clear);
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
|
|
if (needs_pre_resolve) {
|
|
_pre_resolve_render(using_sdfgi || using_giprobe);
|
|
}
|
|
|
|
if (render_buffer && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
RENDER_TIMESTAMP("Resolve Depth Pre-Pass");
|
|
RD::get_singleton()->draw_command_begin_label("Resolve Depth Pre-Pass");
|
|
if (depth_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS || depth_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE) {
|
|
if (needs_pre_resolve) {
|
|
RD::get_singleton()->barrier(RD::BARRIER_MASK_RASTER, RD::BARRIER_MASK_COMPUTE);
|
|
}
|
|
static int texture_samples[RS::VIEWPORT_MSAA_MAX] = { 1, 2, 4, 8, 16 };
|
|
storage->get_effects()->resolve_gi(render_buffer->depth_msaa, render_buffer->normal_roughness_buffer_msaa, using_giprobe ? render_buffer->giprobe_buffer_msaa : RID(), render_buffer->depth, render_buffer->normal_roughness_buffer, using_giprobe ? render_buffer->giprobe_buffer : RID(), Vector2i(render_buffer->width, render_buffer->height), texture_samples[render_buffer->msaa]);
|
|
} else if (finish_depth) {
|
|
RD::get_singleton()->texture_resolve_multisample(render_buffer->depth_msaa, render_buffer->depth);
|
|
}
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
continue_depth = !finish_depth;
|
|
}
|
|
|
|
_pre_opaque_render(using_ssao, using_sdfgi || using_giprobe, render_buffer ? render_buffer->normal_roughness_buffer : RID(), render_buffer ? render_buffer->giprobe_buffer : RID());
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render Opaque Pass");
|
|
|
|
scene_state.ubo.directional_light_count = _get_render_state_directional_light_count();
|
|
|
|
_setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_size, p_cluster_size, p_max_cluster_elements, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), p_render_buffer.is_valid());
|
|
|
|
RENDER_TIMESTAMP("Render Opaque Pass");
|
|
|
|
RID rp_uniform_set = _setup_render_pass_uniform_set(RENDER_LIST_OPAQUE, p_render_buffer, radiance_texture, p_shadow_atlas, p_reflection_atlas, p_cluster_buffer, p_gi_probes, p_lightmaps, true);
|
|
|
|
bool can_continue_color = !scene_state.used_screen_texture && !using_ssr && !using_sss;
|
|
bool can_continue_depth = !scene_state.used_depth_texture && !using_ssr && !using_sss;
|
|
|
|
{
|
|
bool will_continue_color = (can_continue_color || draw_sky || draw_sky_fog_only || debug_giprobes || debug_sdfgi_probes);
|
|
bool will_continue_depth = (can_continue_depth || draw_sky || draw_sky_fog_only || debug_giprobes || debug_sdfgi_probes);
|
|
|
|
//regular forward for now
|
|
Vector<Color> c;
|
|
if (using_separate_specular) {
|
|
Color cc = clear_color.to_linear();
|
|
cc.a = 0; //subsurf scatter must be 0
|
|
c.push_back(cc);
|
|
c.push_back(Color(0, 0, 0, 0));
|
|
} else {
|
|
c.push_back(clear_color.to_linear());
|
|
}
|
|
|
|
RID framebuffer = using_separate_specular ? opaque_specular_framebuffer : opaque_framebuffer;
|
|
RenderListParameters render_list_params(render_list[RENDER_LIST_OPAQUE].elements.ptr(), render_list[RENDER_LIST_OPAQUE].element_info.ptr(), render_list[RENDER_LIST_OPAQUE].elements.size(), false, using_separate_specular ? PASS_MODE_COLOR_SPECULAR : PASS_MODE_COLOR, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, Vector2(), lod_camera_plane, lod_distance_multiplier, p_screen_lod_threshold);
|
|
_render_list_with_threads(&render_list_params, framebuffer, keep_color ? RD::INITIAL_ACTION_KEEP : RD::INITIAL_ACTION_CLEAR, will_continue_color ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, depth_pre_pass ? (continue_depth ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP) : RD::INITIAL_ACTION_CLEAR, will_continue_depth ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, c, 1.0, 0);
|
|
if (will_continue_color && using_separate_specular) {
|
|
// close the specular framebuffer, as it's no longer used
|
|
RD::get_singleton()->draw_list_begin(render_buffer->specular_only_fb, RD::INITIAL_ACTION_CONTINUE, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CONTINUE, RD::FINAL_ACTION_CONTINUE);
|
|
RD::get_singleton()->draw_list_end();
|
|
}
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
|
|
if (debug_giprobes) {
|
|
//debug giprobes
|
|
bool will_continue_color = (can_continue_color || draw_sky || draw_sky_fog_only);
|
|
bool will_continue_depth = (can_continue_depth || draw_sky || draw_sky_fog_only);
|
|
|
|
CameraMatrix dc;
|
|
dc.set_depth_correction(true);
|
|
CameraMatrix cm = (dc * p_cam_projection) * CameraMatrix(p_cam_transform.affine_inverse());
|
|
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(opaque_framebuffer, RD::INITIAL_ACTION_CONTINUE, will_continue_color ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CONTINUE, will_continue_depth ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ);
|
|
RD::get_singleton()->draw_command_begin_label("Debug GIProbes");
|
|
for (int i = 0; i < (int)p_gi_probes.size(); i++) {
|
|
_debug_giprobe(p_gi_probes[i], draw_list, opaque_framebuffer, cm, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_LIGHTING, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_EMISSION, 1.0);
|
|
}
|
|
RD::get_singleton()->draw_command_end_label();
|
|
RD::get_singleton()->draw_list_end();
|
|
}
|
|
|
|
if (debug_sdfgi_probes) {
|
|
//debug giprobes
|
|
bool will_continue_color = (can_continue_color || draw_sky || draw_sky_fog_only);
|
|
bool will_continue_depth = (can_continue_depth || draw_sky || draw_sky_fog_only);
|
|
|
|
CameraMatrix dc;
|
|
dc.set_depth_correction(true);
|
|
CameraMatrix cm = (dc * p_cam_projection) * CameraMatrix(p_cam_transform.affine_inverse());
|
|
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(opaque_framebuffer, RD::INITIAL_ACTION_CONTINUE, will_continue_color ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CONTINUE, will_continue_depth ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ);
|
|
RD::get_singleton()->draw_command_begin_label("Debug SDFGI");
|
|
_debug_sdfgi_probes(p_render_buffer, draw_list, opaque_framebuffer, cm);
|
|
RD::get_singleton()->draw_command_end_label();
|
|
RD::get_singleton()->draw_list_end();
|
|
}
|
|
|
|
if (draw_sky || draw_sky_fog_only) {
|
|
RENDER_TIMESTAMP("Render Sky");
|
|
|
|
CameraMatrix projection = p_cam_projection;
|
|
if (p_reflection_probe.is_valid()) {
|
|
CameraMatrix correction;
|
|
correction.set_depth_correction(true);
|
|
projection = correction * p_cam_projection;
|
|
}
|
|
RD::get_singleton()->draw_command_begin_label("Draw Sky");
|
|
_draw_sky(can_continue_color, can_continue_depth, opaque_framebuffer, p_environment, projection, p_cam_transform);
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
if (render_buffer && !can_continue_color && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
RD::get_singleton()->texture_resolve_multisample(render_buffer->color_msaa, render_buffer->color);
|
|
if (using_separate_specular) {
|
|
RD::get_singleton()->texture_resolve_multisample(render_buffer->specular_msaa, render_buffer->specular);
|
|
}
|
|
}
|
|
|
|
if (render_buffer && !can_continue_depth && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
RD::get_singleton()->texture_resolve_multisample(render_buffer->depth_msaa, render_buffer->depth);
|
|
}
|
|
|
|
if (using_separate_specular) {
|
|
if (using_sss) {
|
|
RENDER_TIMESTAMP("Sub Surface Scattering");
|
|
RD::get_singleton()->draw_command_begin_label("Process Sub Surface Scattering");
|
|
_process_sss(p_render_buffer, p_cam_projection);
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
if (using_ssr) {
|
|
RENDER_TIMESTAMP("Screen Space Reflection");
|
|
RD::get_singleton()->draw_command_begin_label("Process Screen Space Reflections");
|
|
_process_ssr(p_render_buffer, render_buffer->color_fb, render_buffer->normal_roughness_buffer, render_buffer->specular, render_buffer->specular, Color(0, 0, 0, 1), p_environment, p_cam_projection, render_buffer->msaa == RS::VIEWPORT_MSAA_DISABLED);
|
|
RD::get_singleton()->draw_command_end_label();
|
|
} else {
|
|
//just mix specular back
|
|
RENDER_TIMESTAMP("Merge Specular");
|
|
storage->get_effects()->merge_specular(render_buffer->color_fb, render_buffer->specular, render_buffer->msaa == RS::VIEWPORT_MSAA_DISABLED ? RID() : render_buffer->color, RID());
|
|
}
|
|
}
|
|
|
|
RENDER_TIMESTAMP("Render Transparent Pass");
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render Transparent Pass");
|
|
|
|
rp_uniform_set = _setup_render_pass_uniform_set(RENDER_LIST_ALPHA, p_render_buffer, radiance_texture, p_shadow_atlas, p_reflection_atlas, p_cluster_buffer, p_gi_probes, p_lightmaps, true);
|
|
|
|
_setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_size, p_cluster_size, p_max_cluster_elements, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), false);
|
|
|
|
{
|
|
RenderListParameters render_list_params(render_list[RENDER_LIST_ALPHA].elements.ptr(), render_list[RENDER_LIST_ALPHA].element_info.ptr(), render_list[RENDER_LIST_ALPHA].elements.size(), false, PASS_MODE_COLOR, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, Vector2(), lod_camera_plane, lod_distance_multiplier, p_screen_lod_threshold);
|
|
_render_list_with_threads(&render_list_params, alpha_framebuffer, can_continue_color ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, can_continue_depth ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ);
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Resolve");
|
|
|
|
if (render_buffer && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
|
|
RD::get_singleton()->texture_resolve_multisample(render_buffer->color_msaa, render_buffer->color);
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_shadow_begin() {
|
|
scene_state.shadow_passes.clear();
|
|
RD::get_singleton()->draw_command_begin_label("Shadow Setup");
|
|
_update_render_base_uniform_set();
|
|
|
|
render_list[RENDER_LIST_SECONDARY].clear();
|
|
scene_state.instance_data[RENDER_LIST_SECONDARY].clear();
|
|
}
|
|
void RendererSceneRenderForward::_render_shadow_append(RID p_framebuffer, const PagedArray<GeometryInstance *> &p_instances, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake, const Plane &p_camera_plane, float p_lod_distance_multiplier, float p_screen_lod_threshold, const Rect2i &p_rect, bool p_flip_y, bool p_clear_region, bool p_begin, bool p_end) {
|
|
uint32_t shadow_pass_index = scene_state.shadow_passes.size();
|
|
|
|
SceneState::ShadowPass shadow_pass;
|
|
|
|
scene_state.ubo.dual_paraboloid_side = p_use_dp_flip ? -1 : 1;
|
|
|
|
_setup_environment(RID(), RID(), p_projection, p_transform, RID(), true, Vector2(1, 1), 1, 32, RID(), !p_flip_y, Color(), 0, p_zfar, false, p_use_pancake, shadow_pass_index);
|
|
|
|
if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_DISABLE_LOD) {
|
|
p_screen_lod_threshold = 0.0;
|
|
}
|
|
|
|
PassMode pass_mode = p_use_dp ? PASS_MODE_SHADOW_DP : PASS_MODE_SHADOW;
|
|
|
|
uint32_t render_list_from = render_list[RENDER_LIST_SECONDARY].elements.size();
|
|
_fill_render_list(RENDER_LIST_SECONDARY, p_instances, pass_mode, p_projection, p_transform, false, false, p_camera_plane, p_lod_distance_multiplier, p_screen_lod_threshold, true);
|
|
uint32_t render_list_size = render_list[RENDER_LIST_SECONDARY].elements.size() - render_list_from;
|
|
render_list[RENDER_LIST_SECONDARY].sort_by_key_range(render_list_from, render_list_size);
|
|
_fill_instance_data(RENDER_LIST_SECONDARY, render_list_from, render_list_size, false);
|
|
|
|
{
|
|
//regular forward for now
|
|
bool flip_cull = p_use_dp_flip;
|
|
if (p_flip_y) {
|
|
flip_cull = !flip_cull;
|
|
}
|
|
|
|
shadow_pass.element_from = render_list_from;
|
|
shadow_pass.element_count = render_list_size;
|
|
shadow_pass.flip_cull = flip_cull;
|
|
shadow_pass.pass_mode = pass_mode;
|
|
|
|
shadow_pass.rp_uniform_set = RID(); //will be filled later when instance buffer is complete
|
|
shadow_pass.camera_plane = p_camera_plane;
|
|
shadow_pass.screen_lod_threshold = p_screen_lod_threshold;
|
|
shadow_pass.lod_distance_multiplier = p_lod_distance_multiplier;
|
|
|
|
shadow_pass.framebuffer = p_framebuffer;
|
|
shadow_pass.initial_depth_action = p_begin ? (p_clear_region ? RD::INITIAL_ACTION_CLEAR_REGION : RD::INITIAL_ACTION_CLEAR) : (p_clear_region ? RD::INITIAL_ACTION_CLEAR_REGION_CONTINUE : RD::INITIAL_ACTION_CONTINUE);
|
|
shadow_pass.final_depth_action = p_end ? RD::FINAL_ACTION_READ : RD::FINAL_ACTION_CONTINUE;
|
|
shadow_pass.rect = p_rect;
|
|
|
|
scene_state.shadow_passes.push_back(shadow_pass);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_shadow_process() {
|
|
_update_instance_data_buffer(RENDER_LIST_SECONDARY);
|
|
//render shadows one after the other, so this can be done un-barriered and the driver can optimize (as well as allow us to run compute at the same time)
|
|
|
|
for (uint32_t i = 0; i < scene_state.shadow_passes.size(); i++) {
|
|
//render passes need to be configured after instance buffer is done, since they need the latest version
|
|
SceneState::ShadowPass &shadow_pass = scene_state.shadow_passes[i];
|
|
shadow_pass.rp_uniform_set = _setup_render_pass_uniform_set(RENDER_LIST_SECONDARY, RID(), RID(), RID(), RID(), RID(), PagedArray<RID>(), PagedArray<RID>(), false, i);
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
void RendererSceneRenderForward::_render_shadow_end(uint32_t p_barrier) {
|
|
RD::get_singleton()->draw_command_begin_label("Shadow Render");
|
|
|
|
for (uint32_t i = 0; i < scene_state.shadow_passes.size(); i++) {
|
|
SceneState::ShadowPass &shadow_pass = scene_state.shadow_passes[i];
|
|
RenderListParameters render_list_parameters(render_list[RENDER_LIST_SECONDARY].elements.ptr() + shadow_pass.element_from, render_list[RENDER_LIST_SECONDARY].element_info.ptr() + shadow_pass.element_from, shadow_pass.element_count, shadow_pass.flip_cull, shadow_pass.pass_mode, true, shadow_pass.rp_uniform_set, false, Vector2(), shadow_pass.camera_plane, shadow_pass.lod_distance_multiplier, shadow_pass.screen_lod_threshold, shadow_pass.element_from, RD::BARRIER_MASK_NO_BARRIER);
|
|
_render_list_with_threads(&render_list_parameters, shadow_pass.framebuffer, RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, shadow_pass.initial_depth_action, shadow_pass.final_depth_action, Vector<Color>(), 1.0, 0, shadow_pass.rect);
|
|
}
|
|
|
|
if (p_barrier != RD::BARRIER_MASK_NO_BARRIER) {
|
|
RD::get_singleton()->barrier(RD::BARRIER_MASK_RASTER, p_barrier);
|
|
}
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_particle_collider_heightfield(RID p_fb, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, const PagedArray<GeometryInstance *> &p_instances) {
|
|
RENDER_TIMESTAMP("Setup Render Collider Heightfield");
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render Collider Heightfield");
|
|
|
|
_update_render_base_uniform_set();
|
|
scene_state.ubo.dual_paraboloid_side = 0;
|
|
|
|
_setup_environment(RID(), RID(), p_cam_projection, p_cam_transform, RID(), true, Vector2(1, 1), 1, 32, RID(), true, Color(), 0, p_cam_projection.get_z_far(), false, false);
|
|
|
|
PassMode pass_mode = PASS_MODE_SHADOW;
|
|
|
|
_fill_render_list(RENDER_LIST_SECONDARY, p_instances, pass_mode, p_cam_projection, p_cam_transform);
|
|
render_list[RENDER_LIST_SECONDARY].sort_by_key();
|
|
_fill_instance_data(RENDER_LIST_SECONDARY);
|
|
|
|
RID rp_uniform_set = _setup_render_pass_uniform_set(RENDER_LIST_SECONDARY, RID(), RID(), RID(), RID(), RID(), PagedArray<RID>(), PagedArray<RID>());
|
|
|
|
RENDER_TIMESTAMP("Render Collider Heightfield");
|
|
|
|
{
|
|
//regular forward for now
|
|
RenderListParameters render_list_params(render_list[RENDER_LIST_SECONDARY].elements.ptr(), render_list[RENDER_LIST_SECONDARY].element_info.ptr(), render_list[RENDER_LIST_SECONDARY].elements.size(), false, pass_mode, true, rp_uniform_set);
|
|
_render_list_with_threads(&render_list_params, p_fb, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ);
|
|
}
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, const PagedArray<GeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) {
|
|
RENDER_TIMESTAMP("Setup Rendering Material");
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render Material");
|
|
|
|
_update_render_base_uniform_set();
|
|
|
|
scene_state.ubo.dual_paraboloid_side = 0;
|
|
scene_state.ubo.material_uv2_mode = false;
|
|
|
|
_setup_environment(RID(), RID(), p_cam_projection, p_cam_transform, RID(), true, Vector2(1, 1), 1, 32, RID(), false, Color(), 0, 0);
|
|
|
|
PassMode pass_mode = PASS_MODE_DEPTH_MATERIAL;
|
|
_fill_render_list(RENDER_LIST_SECONDARY, p_instances, pass_mode, p_cam_projection, p_cam_transform);
|
|
render_list[RENDER_LIST_SECONDARY].sort_by_key();
|
|
_fill_instance_data(RENDER_LIST_SECONDARY);
|
|
|
|
RID rp_uniform_set = _setup_render_pass_uniform_set(RENDER_LIST_SECONDARY, RID(), RID(), RID(), RID(), RID(), PagedArray<RID>(), PagedArray<RID>());
|
|
|
|
RENDER_TIMESTAMP("Render Material");
|
|
|
|
{
|
|
RenderListParameters render_list_params(render_list[RENDER_LIST_SECONDARY].elements.ptr(), render_list[RENDER_LIST_SECONDARY].element_info.ptr(), render_list[RENDER_LIST_SECONDARY].elements.size(), true, pass_mode, true, rp_uniform_set);
|
|
//regular forward for now
|
|
Vector<Color> clear;
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, clear, 1.0, 0, p_region);
|
|
_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), &render_list_params, 0, render_list_params.element_count);
|
|
RD::get_singleton()->draw_list_end();
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_uv2(const PagedArray<GeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) {
|
|
RENDER_TIMESTAMP("Setup Rendering UV2");
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render UV2");
|
|
|
|
_update_render_base_uniform_set();
|
|
|
|
scene_state.ubo.dual_paraboloid_side = 0;
|
|
scene_state.ubo.material_uv2_mode = true;
|
|
|
|
_setup_environment(RID(), RID(), CameraMatrix(), Transform(), RID(), true, Vector2(1, 1), 1, 32, RID(), false, Color(), 0, 0);
|
|
|
|
PassMode pass_mode = PASS_MODE_DEPTH_MATERIAL;
|
|
_fill_render_list(RENDER_LIST_SECONDARY, p_instances, pass_mode, CameraMatrix(), Transform());
|
|
render_list[RENDER_LIST_SECONDARY].sort_by_key();
|
|
_fill_instance_data(RENDER_LIST_SECONDARY);
|
|
|
|
RID rp_uniform_set = _setup_render_pass_uniform_set(RENDER_LIST_SECONDARY, RID(), RID(), RID(), RID(), RID(), PagedArray<RID>(), PagedArray<RID>());
|
|
|
|
RENDER_TIMESTAMP("Render Material");
|
|
|
|
{
|
|
RenderListParameters render_list_params(render_list[RENDER_LIST_SECONDARY].elements.ptr(), render_list[RENDER_LIST_SECONDARY].element_info.ptr(), render_list[RENDER_LIST_SECONDARY].elements.size(), true, pass_mode, true, rp_uniform_set, true);
|
|
//regular forward for now
|
|
Vector<Color> clear;
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
clear.push_back(Color(0, 0, 0, 0));
|
|
RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, clear, 1.0, 0, p_region);
|
|
|
|
const int uv_offset_count = 9;
|
|
static const Vector2 uv_offsets[uv_offset_count] = {
|
|
Vector2(-1, 1),
|
|
Vector2(1, 1),
|
|
Vector2(1, -1),
|
|
Vector2(-1, -1),
|
|
Vector2(-1, 0),
|
|
Vector2(1, 0),
|
|
Vector2(0, -1),
|
|
Vector2(0, 1),
|
|
Vector2(0, 0),
|
|
|
|
};
|
|
|
|
for (int i = 0; i < uv_offset_count; i++) {
|
|
Vector2 ofs = uv_offsets[i];
|
|
ofs.x /= p_region.size.width;
|
|
ofs.y /= p_region.size.height;
|
|
render_list_params.uv_offset = ofs;
|
|
_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), &render_list_params, 0, render_list_params.element_count); //first wireframe, for pseudo conservative
|
|
}
|
|
render_list_params.uv_offset = Vector2();
|
|
_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), &render_list_params, 0, render_list_params.element_count); //second regular triangles
|
|
|
|
RD::get_singleton()->draw_list_end();
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_sdfgi(RID p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, const PagedArray<GeometryInstance *> &p_instances, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture) {
|
|
RENDER_TIMESTAMP("Render SDFGI");
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render SDFGI Voxel");
|
|
|
|
_update_render_base_uniform_set();
|
|
|
|
RenderBufferDataForward *render_buffer = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
|
|
ERR_FAIL_COND(!render_buffer);
|
|
|
|
PassMode pass_mode = PASS_MODE_SDF;
|
|
_fill_render_list(RENDER_LIST_SECONDARY, p_instances, pass_mode, CameraMatrix(), Transform());
|
|
render_list[RENDER_LIST_SECONDARY].sort_by_key();
|
|
_fill_instance_data(RENDER_LIST_SECONDARY);
|
|
|
|
Vector3 half_extents = p_bounds.size * 0.5;
|
|
Vector3 center = p_bounds.position + half_extents;
|
|
|
|
Vector<RID> sbs;
|
|
sbs.push_back(p_albedo_texture);
|
|
sbs.push_back(p_emission_texture);
|
|
sbs.push_back(p_emission_aniso_texture);
|
|
sbs.push_back(p_geom_facing_texture);
|
|
|
|
//print_line("re-render " + p_from + " - " + p_size + " bounds " + p_bounds);
|
|
for (int i = 0; i < 3; i++) {
|
|
scene_state.ubo.sdf_offset[i] = p_from[i];
|
|
scene_state.ubo.sdf_size[i] = p_size[i];
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++) {
|
|
Vector3 axis;
|
|
axis[i] = 1.0;
|
|
Vector3 up, right;
|
|
int right_axis = (i + 1) % 3;
|
|
int up_axis = (i + 2) % 3;
|
|
up[up_axis] = 1.0;
|
|
right[right_axis] = 1.0;
|
|
|
|
Size2i fb_size;
|
|
fb_size.x = p_size[right_axis];
|
|
fb_size.y = p_size[up_axis];
|
|
|
|
Transform cam_xform;
|
|
cam_xform.origin = center + axis * half_extents;
|
|
cam_xform.basis.set_axis(0, right);
|
|
cam_xform.basis.set_axis(1, up);
|
|
cam_xform.basis.set_axis(2, axis);
|
|
|
|
//print_line("pass: " + itos(i) + " xform " + cam_xform);
|
|
|
|
float h_size = half_extents[right_axis];
|
|
float v_size = half_extents[up_axis];
|
|
float d_size = half_extents[i] * 2.0;
|
|
CameraMatrix camera_proj;
|
|
camera_proj.set_orthogonal(-h_size, h_size, -v_size, v_size, 0, d_size);
|
|
//print_line("pass: " + itos(i) + " cam hsize: " + rtos(h_size) + " vsize: " + rtos(v_size) + " dsize " + rtos(d_size));
|
|
|
|
Transform to_bounds;
|
|
to_bounds.origin = p_bounds.position;
|
|
to_bounds.basis.scale(p_bounds.size);
|
|
|
|
RendererStorageRD::store_transform(to_bounds.affine_inverse() * cam_xform, scene_state.ubo.sdf_to_bounds);
|
|
|
|
_setup_environment(RID(), RID(), camera_proj, cam_xform, RID(), true, Vector2(1, 1), 1, 32, RID(), false, Color(), 0, 0);
|
|
|
|
RID rp_uniform_set = _setup_sdfgi_render_pass_uniform_set(p_albedo_texture, p_emission_texture, p_emission_aniso_texture, p_geom_facing_texture);
|
|
|
|
Map<Size2i, RID>::Element *E = sdfgi_framebuffer_size_cache.find(fb_size);
|
|
if (!E) {
|
|
RID fb = RD::get_singleton()->framebuffer_create_empty(fb_size);
|
|
E = sdfgi_framebuffer_size_cache.insert(fb_size, fb);
|
|
}
|
|
|
|
RenderListParameters render_list_params(render_list[RENDER_LIST_SECONDARY].elements.ptr(), render_list[RENDER_LIST_SECONDARY].element_info.ptr(), render_list[RENDER_LIST_SECONDARY].elements.size(), true, pass_mode, true, rp_uniform_set, false);
|
|
_render_list_with_threads(&render_list_params, E->get(), RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, Vector<Color>(), 1.0, 0, Rect2(), sbs);
|
|
}
|
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_base_uniforms_changed() {
|
|
if (!render_base_uniform_set.is_null() && RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set)) {
|
|
RD::get_singleton()->free(render_base_uniform_set);
|
|
}
|
|
render_base_uniform_set = RID();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_update_render_base_uniform_set() {
|
|
if (render_base_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set) || (lightmap_texture_array_version != storage->lightmap_array_get_version())) {
|
|
if (render_base_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set)) {
|
|
RD::get_singleton()->free(render_base_uniform_set);
|
|
}
|
|
|
|
lightmap_texture_array_version = storage->lightmap_array_get_version();
|
|
|
|
Vector<RD::Uniform> uniforms;
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
|
|
u.binding = 1;
|
|
u.ids.resize(12);
|
|
RID *ids_ptr = u.ids.ptrw();
|
|
ids_ptr[0] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
|
ids_ptr[1] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
|
ids_ptr[2] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
|
ids_ptr[3] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
|
ids_ptr[4] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
|
ids_ptr[5] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
|
|
ids_ptr[6] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
|
|
ids_ptr[7] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
|
|
ids_ptr[8] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
|
|
ids_ptr[9] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
|
|
ids_ptr[10] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
|
|
ids_ptr[11] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 2;
|
|
u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
|
|
u.ids.push_back(shadow_sampler);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 3;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(get_omni_light_buffer());
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 4;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(get_spot_light_buffer());
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 5;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(get_reflection_probe_buffer());
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 6;
|
|
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
|
|
u.ids.push_back(get_directional_light_buffer());
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 7;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(scene_state.lightmap_buffer);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 8;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(scene_state.lightmap_capture_buffer);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 9;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID decal_atlas = storage->decal_atlas_get_texture();
|
|
u.ids.push_back(decal_atlas);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 10;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID decal_atlas = storage->decal_atlas_get_texture_srgb();
|
|
u.ids.push_back(decal_atlas);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 11;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(get_decal_buffer());
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.binding = 12;
|
|
u.ids.push_back(storage->global_variables_get_storage_buffer());
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
if (!low_end) {
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
|
|
u.binding = 13;
|
|
u.ids.push_back(sdfgi_get_ubo());
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
render_base_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, SCENE_UNIFORM_SET);
|
|
}
|
|
}
|
|
|
|
RID RendererSceneRenderForward::_setup_render_pass_uniform_set(RenderListType p_render_list, RID p_render_buffers, RID p_radiance_texture, RID p_shadow_atlas, RID p_reflection_atlas, RID p_cluster_buffer, const PagedArray<RID> &p_gi_probes, const PagedArray<RID> &p_lightmaps, bool p_use_directional_shadow_atlas, int p_index) {
|
|
//there should always be enough uniform buffers for render passes, otherwise bugs
|
|
ERR_FAIL_INDEX_V(p_index, (int)scene_state.uniform_buffers.size(), RID());
|
|
|
|
RenderBufferDataForward *rb = nullptr;
|
|
if (p_render_buffers.is_valid()) {
|
|
rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
|
|
}
|
|
|
|
//default render buffer and scene state uniform set
|
|
|
|
Vector<RD::Uniform> uniforms;
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 0;
|
|
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
|
|
u.ids.push_back(scene_state.uniform_buffers[p_index]);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 1;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
RID instance_buffer = scene_state.instance_buffer[p_render_list];
|
|
if (instance_buffer == RID()) {
|
|
instance_buffer = default_vec4_xform_buffer; // any buffer will do since its not used
|
|
}
|
|
u.ids.push_back(instance_buffer);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RID radiance_texture;
|
|
if (p_radiance_texture.is_valid()) {
|
|
radiance_texture = p_radiance_texture;
|
|
} else {
|
|
radiance_texture = storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
|
|
}
|
|
RD::Uniform u;
|
|
u.binding = 2;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.ids.push_back(radiance_texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RID ref_texture = p_reflection_atlas.is_valid() ? reflection_atlas_get_texture(p_reflection_atlas) : RID();
|
|
RD::Uniform u;
|
|
u.binding = 3;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
if (ref_texture.is_valid()) {
|
|
u.ids.push_back(ref_texture);
|
|
} else {
|
|
u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK));
|
|
}
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 4;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID texture;
|
|
if (p_shadow_atlas.is_valid()) {
|
|
texture = shadow_atlas_get_texture(p_shadow_atlas);
|
|
}
|
|
if (!texture.is_valid()) {
|
|
texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
|
|
}
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 5;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
if (p_use_directional_shadow_atlas && directional_shadow_get_texture().is_valid()) {
|
|
u.ids.push_back(directional_shadow_get_texture());
|
|
} else {
|
|
u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE));
|
|
}
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 6;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.ids.resize(scene_state.max_lightmaps);
|
|
RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE);
|
|
for (uint32_t i = 0; i < scene_state.max_lightmaps; i++) {
|
|
if (i < p_lightmaps.size()) {
|
|
RID base = lightmap_instance_get_lightmap(p_lightmaps[i]);
|
|
RID texture = storage->lightmap_get_texture(base);
|
|
RID rd_texture = storage->texture_get_rd_texture(texture);
|
|
u.ids.write[i] = rd_texture;
|
|
} else {
|
|
u.ids.write[i] = default_tex;
|
|
}
|
|
}
|
|
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 7;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.ids.resize(MAX_GI_PROBES);
|
|
RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
|
|
for (int i = 0; i < MAX_GI_PROBES; i++) {
|
|
if (i < (int)p_gi_probes.size()) {
|
|
RID tex = gi_probe_instance_get_texture(p_gi_probes[i]);
|
|
if (!tex.is_valid()) {
|
|
tex = default_tex;
|
|
}
|
|
u.ids.write[i] = tex;
|
|
} else {
|
|
u.ids.write[i] = default_tex;
|
|
}
|
|
}
|
|
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 8;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
RID cb = p_cluster_buffer.is_valid() ? p_cluster_buffer : default_vec4_xform_buffer;
|
|
u.ids.push_back(cb);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 9;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID texture = (false && rb && rb->depth.is_valid()) ? rb->depth : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 10;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID bbt = rb ? render_buffers_get_back_buffer_texture(p_render_buffers) : RID();
|
|
RID texture = bbt.is_valid() ? bbt : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
if (!low_end) {
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 11;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID texture = rb && rb->normal_roughness_buffer.is_valid() ? rb->normal_roughness_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_NORMAL);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 12;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID aot = rb ? render_buffers_get_ao_texture(p_render_buffers) : RID();
|
|
RID texture = aot.is_valid() ? aot : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 13;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID ambient_buffer = p_render_buffers.is_valid() ? render_buffers_get_gi_ambient_texture(p_render_buffers) : RID();
|
|
RID texture = ambient_buffer.is_valid() ? ambient_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 14;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID reflection_buffer = p_render_buffers.is_valid() ? render_buffers_get_gi_reflection_texture(p_render_buffers) : RID();
|
|
RID texture = reflection_buffer.is_valid() ? reflection_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 15;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID t;
|
|
if (rb && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
|
|
t = render_buffers_get_sdfgi_irradiance_probes(p_render_buffers);
|
|
} else {
|
|
t = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE);
|
|
}
|
|
u.ids.push_back(t);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 16;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
if (rb && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
|
|
u.ids.push_back(render_buffers_get_sdfgi_occlusion_texture(p_render_buffers));
|
|
} else {
|
|
u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
|
|
}
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 17;
|
|
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
|
|
u.ids.push_back(rb ? render_buffers_get_gi_probe_buffer(p_render_buffers) : render_buffers_get_default_gi_probe_buffer());
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 18;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID vfog = RID();
|
|
if (rb && render_buffers_has_volumetric_fog(p_render_buffers)) {
|
|
vfog = render_buffers_get_volumetric_fog_texture(p_render_buffers);
|
|
if (vfog.is_null()) {
|
|
vfog = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
|
|
}
|
|
} else {
|
|
vfog = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
|
|
}
|
|
u.ids.push_back(vfog);
|
|
uniforms.push_back(u);
|
|
}
|
|
}
|
|
|
|
if (p_index >= (int)render_pass_uniform_sets.size()) {
|
|
render_pass_uniform_sets.resize(p_index + 1);
|
|
}
|
|
|
|
if (render_pass_uniform_sets[p_index].is_valid() && RD::get_singleton()->uniform_set_is_valid(render_pass_uniform_sets[p_index])) {
|
|
RD::get_singleton()->free(render_pass_uniform_sets[p_index]);
|
|
}
|
|
|
|
render_pass_uniform_sets[p_index] = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RENDER_PASS_UNIFORM_SET);
|
|
return render_pass_uniform_sets[p_index];
|
|
}
|
|
|
|
RID RendererSceneRenderForward::_setup_sdfgi_render_pass_uniform_set(RID p_albedo_texture, RID p_emission_texture, RID p_emission_aniso_texture, RID p_geom_facing_texture) {
|
|
if (sdfgi_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sdfgi_pass_uniform_set)) {
|
|
RD::get_singleton()->free(sdfgi_pass_uniform_set);
|
|
}
|
|
|
|
Vector<RD::Uniform> uniforms;
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 0;
|
|
u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
|
|
u.ids.push_back(scene_state.uniform_buffers[0]);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 1;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(scene_state.instance_buffer[RENDER_LIST_SECONDARY]);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
// No radiance texture.
|
|
RID radiance_texture = storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
|
|
RD::Uniform u;
|
|
u.binding = 2;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.ids.push_back(radiance_texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
// No reflection atlas.
|
|
RID ref_texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK);
|
|
RD::Uniform u;
|
|
u.binding = 3;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.ids.push_back(ref_texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
// No shadow atlas.
|
|
RD::Uniform u;
|
|
u.binding = 4;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
// No directional shadow atlas.
|
|
RD::Uniform u;
|
|
u.binding = 5;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
RID texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
|
|
u.ids.push_back(texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
// No Lightmaps
|
|
RD::Uniform u;
|
|
u.binding = 6;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.ids.resize(scene_state.max_lightmaps);
|
|
RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE);
|
|
for (uint32_t i = 0; i < scene_state.max_lightmaps; i++) {
|
|
u.ids.write[i] = default_tex;
|
|
}
|
|
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
// No GIProbes
|
|
RD::Uniform u;
|
|
u.binding = 7;
|
|
u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
u.ids.resize(MAX_GI_PROBES);
|
|
RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
|
|
for (int i = 0; i < MAX_GI_PROBES; i++) {
|
|
u.ids.write[i] = default_tex;
|
|
}
|
|
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.binding = 8;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
RID cb = default_vec4_xform_buffer;
|
|
u.ids.push_back(cb);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
// actual sdfgi stuff
|
|
|
|
{
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
u.binding = 9;
|
|
u.ids.push_back(p_albedo_texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
u.binding = 10;
|
|
u.ids.push_back(p_emission_texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
u.binding = 11;
|
|
u.ids.push_back(p_emission_aniso_texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
{
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
u.binding = 12;
|
|
u.ids.push_back(p_geom_facing_texture);
|
|
uniforms.push_back(u);
|
|
}
|
|
|
|
sdfgi_pass_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_sdfgi_rd, RENDER_PASS_UNIFORM_SET);
|
|
return sdfgi_pass_uniform_set;
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_buffers_clear_uniform_set(RenderBufferDataForward *rb) {
|
|
}
|
|
|
|
void RendererSceneRenderForward::_render_buffers_uniform_set_changed(RID p_render_buffers) {
|
|
RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
|
|
|
|
_render_buffers_clear_uniform_set(rb);
|
|
}
|
|
|
|
RID RendererSceneRenderForward::_render_buffers_get_normal_texture(RID p_render_buffers) {
|
|
RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
|
|
|
|
return rb->normal_roughness_buffer;
|
|
}
|
|
|
|
RendererSceneRenderForward *RendererSceneRenderForward::singleton = nullptr;
|
|
|
|
void RendererSceneRenderForward::set_time(double p_time, double p_step) {
|
|
time = p_time;
|
|
RendererSceneRenderRD::set_time(p_time, p_step);
|
|
}
|
|
|
|
void RendererSceneRenderForward::_geometry_instance_mark_dirty(GeometryInstance *p_geometry_instance) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
if (ginstance->dirty_list_element.in_list()) {
|
|
return;
|
|
}
|
|
|
|
//clear surface caches
|
|
GeometryInstanceSurfaceDataCache *surf = ginstance->surface_caches;
|
|
|
|
while (surf) {
|
|
GeometryInstanceSurfaceDataCache *next = surf->next;
|
|
geometry_instance_surface_alloc.free(surf);
|
|
surf = next;
|
|
}
|
|
|
|
ginstance->surface_caches = nullptr;
|
|
|
|
geometry_instance_dirty_list.add(&ginstance->dirty_list_element);
|
|
}
|
|
|
|
void RendererSceneRenderForward::_geometry_instance_add_surface_with_material(GeometryInstanceForward *ginstance, uint32_t p_surface, MaterialData *p_material, uint32_t p_material_id, uint32_t p_shader_id, RID p_mesh) {
|
|
bool has_read_screen_alpha = p_material->shader_data->uses_screen_texture || p_material->shader_data->uses_depth_texture || p_material->shader_data->uses_normal_texture;
|
|
bool has_base_alpha = (p_material->shader_data->uses_alpha || has_read_screen_alpha);
|
|
bool has_blend_alpha = p_material->shader_data->uses_blend_alpha;
|
|
bool has_alpha = has_base_alpha || has_blend_alpha;
|
|
|
|
uint32_t flags = 0;
|
|
|
|
if (p_material->shader_data->uses_sss) {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_SUBSURFACE_SCATTERING;
|
|
}
|
|
|
|
if (p_material->shader_data->uses_screen_texture) {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_SCREEN_TEXTURE;
|
|
}
|
|
|
|
if (p_material->shader_data->uses_depth_texture) {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_DEPTH_TEXTURE;
|
|
}
|
|
|
|
if (p_material->shader_data->uses_normal_texture) {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_NORMAL_TEXTURE;
|
|
}
|
|
|
|
if (ginstance->data->cast_double_sided_shaodows) {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_DOUBLE_SIDED_SHADOWS;
|
|
}
|
|
|
|
if (has_alpha || has_read_screen_alpha || p_material->shader_data->depth_draw == ShaderData::DEPTH_DRAW_DISABLED || p_material->shader_data->depth_test == ShaderData::DEPTH_TEST_DISABLED) {
|
|
//material is only meant for alpha pass
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_PASS_ALPHA;
|
|
if (p_material->shader_data->uses_depth_pre_pass && !(p_material->shader_data->depth_draw == ShaderData::DEPTH_DRAW_DISABLED || p_material->shader_data->depth_test == ShaderData::DEPTH_TEST_DISABLED)) {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_PASS_DEPTH;
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_PASS_SHADOW;
|
|
}
|
|
} else {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_PASS_OPAQUE;
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_PASS_DEPTH;
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_PASS_SHADOW;
|
|
}
|
|
|
|
MaterialData *material_shadow = nullptr;
|
|
void *surface_shadow = nullptr;
|
|
if (!p_material->shader_data->writes_modelview_or_projection && !p_material->shader_data->uses_vertex && !p_material->shader_data->uses_discard && !p_material->shader_data->uses_depth_pre_pass) {
|
|
flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_SHARED_SHADOW_MATERIAL;
|
|
material_shadow = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
|
|
|
|
RID shadow_mesh = storage->mesh_get_shadow_mesh(p_mesh);
|
|
|
|
if (shadow_mesh.is_valid()) {
|
|
surface_shadow = storage->mesh_get_surface(shadow_mesh, p_surface);
|
|
}
|
|
|
|
} else {
|
|
material_shadow = p_material;
|
|
}
|
|
|
|
GeometryInstanceSurfaceDataCache *sdcache = geometry_instance_surface_alloc.alloc();
|
|
|
|
sdcache->flags = flags;
|
|
|
|
sdcache->shader = p_material->shader_data;
|
|
sdcache->material_uniform_set = p_material->uniform_set;
|
|
sdcache->surface = storage->mesh_get_surface(p_mesh, p_surface);
|
|
sdcache->primitive = storage->mesh_surface_get_primitive(sdcache->surface);
|
|
sdcache->surface_index = p_surface;
|
|
|
|
if (ginstance->data->dirty_dependencies) {
|
|
storage->base_update_dependency(p_mesh, &ginstance->data->dependency_tracker);
|
|
}
|
|
|
|
//shadow
|
|
sdcache->shader_shadow = material_shadow->shader_data;
|
|
sdcache->material_uniform_set_shadow = material_shadow->uniform_set;
|
|
|
|
sdcache->surface_shadow = surface_shadow ? surface_shadow : sdcache->surface;
|
|
|
|
sdcache->owner = ginstance;
|
|
|
|
sdcache->next = ginstance->surface_caches;
|
|
ginstance->surface_caches = sdcache;
|
|
|
|
//sortkey
|
|
|
|
sdcache->sort.sort_key1 = 0;
|
|
sdcache->sort.sort_key2 = 0;
|
|
|
|
sdcache->sort.surface_index = p_surface;
|
|
sdcache->sort.material_id_low = p_material_id & 0x3FFF;
|
|
sdcache->sort.material_id_hi = p_material_id >> 14;
|
|
sdcache->sort.shader_id = p_shader_id;
|
|
sdcache->sort.geometry_id = p_mesh.get_local_index(); //only meshes can repeat anyway
|
|
sdcache->sort.uses_forward_gi = ginstance->can_sdfgi;
|
|
sdcache->sort.priority = p_material->priority;
|
|
}
|
|
|
|
void RendererSceneRenderForward::_geometry_instance_add_surface(GeometryInstanceForward *ginstance, uint32_t p_surface, RID p_material, RID p_mesh) {
|
|
RID m_src;
|
|
|
|
m_src = ginstance->data->material_override.is_valid() ? ginstance->data->material_override : p_material;
|
|
|
|
MaterialData *material = nullptr;
|
|
|
|
if (m_src.is_valid()) {
|
|
material = (MaterialData *)storage->material_get_data(m_src, RendererStorageRD::SHADER_TYPE_3D);
|
|
if (!material || !material->shader_data->valid) {
|
|
material = nullptr;
|
|
}
|
|
}
|
|
|
|
if (material) {
|
|
if (ginstance->data->dirty_dependencies) {
|
|
storage->material_update_dependency(m_src, &ginstance->data->dependency_tracker);
|
|
}
|
|
} else {
|
|
material = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
|
|
m_src = default_material;
|
|
}
|
|
|
|
ERR_FAIL_COND(!material);
|
|
|
|
_geometry_instance_add_surface_with_material(ginstance, p_surface, material, m_src.get_local_index(), storage->material_get_shader_id(m_src), p_mesh);
|
|
|
|
while (material->next_pass.is_valid()) {
|
|
RID next_pass = material->next_pass;
|
|
material = (MaterialData *)storage->material_get_data(next_pass, RendererStorageRD::SHADER_TYPE_3D);
|
|
if (!material || !material->shader_data->valid) {
|
|
break;
|
|
}
|
|
if (ginstance->data->dirty_dependencies) {
|
|
storage->material_update_dependency(next_pass, &ginstance->data->dependency_tracker);
|
|
}
|
|
_geometry_instance_add_surface_with_material(ginstance, p_surface, material, next_pass.get_local_index(), storage->material_get_shader_id(next_pass), p_mesh);
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_geometry_instance_update(GeometryInstance *p_geometry_instance) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
|
|
if (ginstance->data->dirty_dependencies) {
|
|
ginstance->data->dependency_tracker.update_begin();
|
|
}
|
|
|
|
//add geometry for drawing
|
|
switch (ginstance->data->base_type) {
|
|
case RS::INSTANCE_MESH: {
|
|
const RID *materials = nullptr;
|
|
uint32_t surface_count;
|
|
RID mesh = ginstance->data->base;
|
|
|
|
materials = storage->mesh_get_surface_count_and_materials(mesh, surface_count);
|
|
if (materials) {
|
|
//if no materials, no surfaces.
|
|
const RID *inst_materials = ginstance->data->surface_materials.ptr();
|
|
uint32_t surf_mat_count = ginstance->data->surface_materials.size();
|
|
|
|
for (uint32_t j = 0; j < surface_count; j++) {
|
|
RID material = (j < surf_mat_count && inst_materials[j].is_valid()) ? inst_materials[j] : materials[j];
|
|
_geometry_instance_add_surface(ginstance, j, material, mesh);
|
|
}
|
|
}
|
|
|
|
ginstance->instance_count = 1;
|
|
|
|
} break;
|
|
|
|
case RS::INSTANCE_MULTIMESH: {
|
|
RID mesh = storage->multimesh_get_mesh(ginstance->data->base);
|
|
if (mesh.is_valid()) {
|
|
const RID *materials = nullptr;
|
|
uint32_t surface_count;
|
|
|
|
materials = storage->mesh_get_surface_count_and_materials(mesh, surface_count);
|
|
if (materials) {
|
|
for (uint32_t j = 0; j < surface_count; j++) {
|
|
_geometry_instance_add_surface(ginstance, j, materials[j], mesh);
|
|
}
|
|
}
|
|
|
|
ginstance->instance_count = storage->multimesh_get_instances_to_draw(ginstance->data->base);
|
|
}
|
|
|
|
} break;
|
|
#if 0
|
|
case RS::INSTANCE_IMMEDIATE: {
|
|
RasterizerStorageGLES3::Immediate *immediate = storage->immediate_owner.getornull(inst->base);
|
|
ERR_CONTINUE(!immediate);
|
|
|
|
_add_geometry(immediate, inst, nullptr, -1, p_depth_pass, p_shadow_pass);
|
|
|
|
} break;
|
|
#endif
|
|
case RS::INSTANCE_PARTICLES: {
|
|
int draw_passes = storage->particles_get_draw_passes(ginstance->data->base);
|
|
|
|
for (int j = 0; j < draw_passes; j++) {
|
|
RID mesh = storage->particles_get_draw_pass_mesh(ginstance->data->base, j);
|
|
if (!mesh.is_valid())
|
|
continue;
|
|
|
|
const RID *materials = nullptr;
|
|
uint32_t surface_count;
|
|
|
|
materials = storage->mesh_get_surface_count_and_materials(mesh, surface_count);
|
|
if (materials) {
|
|
for (uint32_t k = 0; k < surface_count; k++) {
|
|
_geometry_instance_add_surface(ginstance, k, materials[k], mesh);
|
|
}
|
|
}
|
|
}
|
|
|
|
ginstance->instance_count = storage->particles_get_amount(ginstance->data->base);
|
|
|
|
} break;
|
|
|
|
default: {
|
|
}
|
|
}
|
|
|
|
//Fill push constant
|
|
|
|
bool store_transform = true;
|
|
|
|
if (ginstance->data->base_type == RS::INSTANCE_MULTIMESH) {
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH;
|
|
uint32_t stride;
|
|
if (storage->multimesh_get_transform_format(ginstance->data->base) == RS::MULTIMESH_TRANSFORM_2D) {
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_FORMAT_2D;
|
|
stride = 2;
|
|
} else {
|
|
stride = 3;
|
|
}
|
|
if (storage->multimesh_uses_colors(ginstance->data->base)) {
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_COLOR;
|
|
stride += 1;
|
|
}
|
|
if (storage->multimesh_uses_custom_data(ginstance->data->base)) {
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_CUSTOM_DATA;
|
|
stride += 1;
|
|
}
|
|
|
|
ginstance->base_flags |= (stride << INSTANCE_DATA_FLAGS_MULTIMESH_STRIDE_SHIFT);
|
|
ginstance->transforms_uniform_set = storage->multimesh_get_3d_uniform_set(ginstance->data->base, default_shader_rd, TRANSFORMS_UNIFORM_SET);
|
|
|
|
} else if (ginstance->data->base_type == RS::INSTANCE_PARTICLES) {
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH;
|
|
uint32_t stride;
|
|
if (false) { // 2D particles
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_FORMAT_2D;
|
|
stride = 2;
|
|
} else {
|
|
stride = 3;
|
|
}
|
|
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_COLOR;
|
|
stride += 1;
|
|
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_CUSTOM_DATA;
|
|
stride += 1;
|
|
|
|
ginstance->base_flags |= (stride << INSTANCE_DATA_FLAGS_MULTIMESH_STRIDE_SHIFT);
|
|
|
|
if (!storage->particles_is_using_local_coords(ginstance->data->base)) {
|
|
store_transform = false;
|
|
}
|
|
ginstance->transforms_uniform_set = storage->particles_get_instance_buffer_uniform_set(ginstance->data->base, default_shader_rd, TRANSFORMS_UNIFORM_SET);
|
|
|
|
} else if (ginstance->data->base_type == RS::INSTANCE_MESH) {
|
|
if (storage->skeleton_is_valid(ginstance->data->skeleton)) {
|
|
ginstance->base_flags |= INSTANCE_DATA_FLAG_SKELETON;
|
|
ginstance->transforms_uniform_set = storage->skeleton_get_3d_uniform_set(ginstance->data->skeleton, default_shader_rd, TRANSFORMS_UNIFORM_SET);
|
|
if (ginstance->data->dirty_dependencies) {
|
|
storage->skeleton_update_dependency(ginstance->data->skeleton, &ginstance->data->dependency_tracker);
|
|
}
|
|
}
|
|
}
|
|
|
|
ginstance->store_transform_cache = store_transform;
|
|
ginstance->can_sdfgi = false;
|
|
|
|
if (!lightmap_instance_is_valid(ginstance->lightmap_instance) && !low_end) {
|
|
if (ginstance->gi_probes[0].is_null() && (ginstance->data->use_baked_light || ginstance->data->use_dynamic_gi)) {
|
|
ginstance->can_sdfgi = true;
|
|
}
|
|
}
|
|
|
|
if (ginstance->data->dirty_dependencies) {
|
|
ginstance->data->dependency_tracker.update_end();
|
|
ginstance->data->dirty_dependencies = false;
|
|
}
|
|
|
|
ginstance->dirty_list_element.remove_from_list();
|
|
}
|
|
|
|
void RendererSceneRenderForward::_update_dirty_geometry_instances() {
|
|
while (geometry_instance_dirty_list.first()) {
|
|
_geometry_instance_update(geometry_instance_dirty_list.first()->self());
|
|
}
|
|
}
|
|
|
|
void RendererSceneRenderForward::_geometry_instance_dependency_changed(RendererStorage::DependencyChangedNotification p_notification, RendererStorage::DependencyTracker *p_tracker) {
|
|
switch (p_notification) {
|
|
case RendererStorage::DEPENDENCY_CHANGED_MATERIAL:
|
|
case RendererStorage::DEPENDENCY_CHANGED_MESH:
|
|
case RendererStorage::DEPENDENCY_CHANGED_MULTIMESH:
|
|
case RendererStorage::DEPENDENCY_CHANGED_SKELETON_DATA: {
|
|
static_cast<RendererSceneRenderForward *>(singleton)->_geometry_instance_mark_dirty(static_cast<GeometryInstance *>(p_tracker->userdata));
|
|
} break;
|
|
case RendererStorage::DEPENDENCY_CHANGED_MULTIMESH_VISIBLE_INSTANCES: {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_tracker->userdata);
|
|
if (ginstance->data->base_type == RS::INSTANCE_MULTIMESH) {
|
|
ginstance->instance_count = static_cast<RendererSceneRenderForward *>(singleton)->storage->multimesh_get_instances_to_draw(ginstance->data->base);
|
|
}
|
|
} break;
|
|
default: {
|
|
//rest of notifications of no interest
|
|
} break;
|
|
}
|
|
}
|
|
void RendererSceneRenderForward::_geometry_instance_dependency_deleted(const RID &p_dependency, RendererStorage::DependencyTracker *p_tracker) {
|
|
static_cast<RendererSceneRenderForward *>(singleton)->_geometry_instance_mark_dirty(static_cast<GeometryInstance *>(p_tracker->userdata));
|
|
}
|
|
|
|
RendererSceneRender::GeometryInstance *RendererSceneRenderForward::geometry_instance_create(RID p_base) {
|
|
RS::InstanceType type = storage->get_base_type(p_base);
|
|
ERR_FAIL_COND_V(!((1 << type) & RS::INSTANCE_GEOMETRY_MASK), nullptr);
|
|
|
|
GeometryInstanceForward *ginstance = geometry_instance_alloc.alloc();
|
|
ginstance->data = memnew(GeometryInstanceForward::Data);
|
|
|
|
ginstance->data->base = p_base;
|
|
ginstance->data->base_type = type;
|
|
ginstance->data->dependency_tracker.userdata = ginstance;
|
|
ginstance->data->dependency_tracker.changed_callback = _geometry_instance_dependency_changed;
|
|
ginstance->data->dependency_tracker.deleted_callback = _geometry_instance_dependency_deleted;
|
|
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
|
|
return ginstance;
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_skeleton(GeometryInstance *p_geometry_instance, RID p_skeleton) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->data->skeleton = p_skeleton;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
ginstance->data->dirty_dependencies = true;
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_material_override(GeometryInstance *p_geometry_instance, RID p_override) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->data->material_override = p_override;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
ginstance->data->dirty_dependencies = true;
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_surface_materials(GeometryInstance *p_geometry_instance, const Vector<RID> &p_materials) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->data->surface_materials = p_materials;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
ginstance->data->dirty_dependencies = true;
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_mesh_instance(GeometryInstance *p_geometry_instance, RID p_mesh_instance) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->mesh_instance = p_mesh_instance;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_transform(GeometryInstance *p_geometry_instance, const Transform &p_transform, const AABB &p_aabb, const AABB &p_transformed_aabb) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->transform = p_transform;
|
|
ginstance->mirror = p_transform.basis.determinant() < 0;
|
|
ginstance->data->aabb = p_aabb;
|
|
ginstance->transformed_aabb = p_transformed_aabb;
|
|
|
|
Vector3 model_scale_vec = p_transform.basis.get_scale_abs();
|
|
// handle non uniform scale here
|
|
|
|
float max_scale = MAX(model_scale_vec.x, MAX(model_scale_vec.y, model_scale_vec.z));
|
|
float min_scale = MIN(model_scale_vec.x, MIN(model_scale_vec.y, model_scale_vec.z));
|
|
ginstance->non_uniform_scale = max_scale >= 0.0 && (min_scale / max_scale) < 0.9;
|
|
|
|
ginstance->lod_model_scale = max_scale;
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_lod_bias(GeometryInstance *p_geometry_instance, float p_lod_bias) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->lod_bias = p_lod_bias;
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_use_baked_light(GeometryInstance *p_geometry_instance, bool p_enable) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->data->use_baked_light = p_enable;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_use_dynamic_gi(GeometryInstance *p_geometry_instance, bool p_enable) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->data->use_dynamic_gi = p_enable;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_use_lightmap(GeometryInstance *p_geometry_instance, RID p_lightmap_instance, const Rect2 &p_lightmap_uv_scale, int p_lightmap_slice_index) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->lightmap_instance = p_lightmap_instance;
|
|
ginstance->lightmap_uv_scale = p_lightmap_uv_scale;
|
|
ginstance->lightmap_slice_index = p_lightmap_slice_index;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_lightmap_capture(GeometryInstance *p_geometry_instance, const Color *p_sh9) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
if (p_sh9) {
|
|
if (ginstance->lightmap_sh == nullptr) {
|
|
ginstance->lightmap_sh = geometry_instance_lightmap_sh.alloc();
|
|
}
|
|
|
|
copymem(ginstance->lightmap_sh->sh, p_sh9, sizeof(Color) * 9);
|
|
} else {
|
|
if (ginstance->lightmap_sh != nullptr) {
|
|
geometry_instance_lightmap_sh.free(ginstance->lightmap_sh);
|
|
ginstance->lightmap_sh = nullptr;
|
|
}
|
|
}
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_instance_shader_parameters_offset(GeometryInstance *p_geometry_instance, int32_t p_offset) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->shader_parameters_offset = p_offset;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_set_cast_double_sided_shadows(GeometryInstance *p_geometry_instance, bool p_enable) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
|
|
ginstance->data->cast_double_sided_shaodows = p_enable;
|
|
_geometry_instance_mark_dirty(ginstance);
|
|
}
|
|
|
|
void RendererSceneRenderForward::geometry_instance_set_layer_mask(GeometryInstance *p_geometry_instance, uint32_t p_layer_mask) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
ginstance->layer_mask = p_layer_mask;
|
|
}
|
|
|
|
void RendererSceneRenderForward::geometry_instance_free(GeometryInstance *p_geometry_instance) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
if (ginstance->lightmap_sh != nullptr) {
|
|
geometry_instance_lightmap_sh.free(ginstance->lightmap_sh);
|
|
}
|
|
GeometryInstanceSurfaceDataCache *surf = ginstance->surface_caches;
|
|
while (surf) {
|
|
GeometryInstanceSurfaceDataCache *next = surf->next;
|
|
geometry_instance_surface_alloc.free(surf);
|
|
surf = next;
|
|
}
|
|
memdelete(ginstance->data);
|
|
geometry_instance_alloc.free(ginstance);
|
|
}
|
|
|
|
uint32_t RendererSceneRenderForward::geometry_instance_get_pair_mask() {
|
|
return (1 << RS::INSTANCE_GI_PROBE);
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_pair_light_instances(GeometryInstance *p_geometry_instance, const RID *p_light_instances, uint32_t p_light_instance_count) {
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_pair_reflection_probe_instances(GeometryInstance *p_geometry_instance, const RID *p_reflection_probe_instances, uint32_t p_reflection_probe_instance_count) {
|
|
}
|
|
void RendererSceneRenderForward::geometry_instance_pair_decal_instances(GeometryInstance *p_geometry_instance, const RID *p_decal_instances, uint32_t p_decal_instance_count) {
|
|
}
|
|
|
|
Transform RendererSceneRenderForward::geometry_instance_get_transform(GeometryInstance *p_instance) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_instance);
|
|
ERR_FAIL_COND_V(!ginstance, Transform());
|
|
return ginstance->transform;
|
|
}
|
|
AABB RendererSceneRenderForward::geometry_instance_get_aabb(GeometryInstance *p_instance) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_instance);
|
|
ERR_FAIL_COND_V(!ginstance, AABB());
|
|
return ginstance->data->aabb;
|
|
}
|
|
|
|
void RendererSceneRenderForward::geometry_instance_pair_gi_probe_instances(GeometryInstance *p_geometry_instance, const RID *p_gi_probe_instances, uint32_t p_gi_probe_instance_count) {
|
|
GeometryInstanceForward *ginstance = static_cast<GeometryInstanceForward *>(p_geometry_instance);
|
|
ERR_FAIL_COND(!ginstance);
|
|
if (p_gi_probe_instance_count > 0) {
|
|
ginstance->gi_probes[0] = p_gi_probe_instances[0];
|
|
} else {
|
|
ginstance->gi_probes[0] = RID();
|
|
}
|
|
|
|
if (p_gi_probe_instance_count > 1) {
|
|
ginstance->gi_probes[1] = p_gi_probe_instances[1];
|
|
} else {
|
|
ginstance->gi_probes[1] = RID();
|
|
}
|
|
}
|
|
|
|
RendererSceneRenderForward::RendererSceneRenderForward(RendererStorageRD *p_storage) :
|
|
RendererSceneRenderRD(p_storage) {
|
|
singleton = this;
|
|
low_end = is_low_end();
|
|
storage = p_storage;
|
|
|
|
/* SCENE SHADER */
|
|
|
|
{
|
|
String defines;
|
|
if (low_end) {
|
|
defines += "\n#define LOW_END_MODE \n";
|
|
}
|
|
|
|
defines += "\n#define MAX_ROUGHNESS_LOD " + itos(get_roughness_layers() - 1) + ".0\n";
|
|
if (is_using_radiance_cubemap_array()) {
|
|
defines += "\n#define USE_RADIANCE_CUBEMAP_ARRAY \n";
|
|
}
|
|
defines += "\n#define SDFGI_OCT_SIZE " + itos(sdfgi_get_lightprobe_octahedron_size()) + "\n";
|
|
defines += "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(get_max_directional_lights()) + "\n";
|
|
|
|
{
|
|
//lightmaps
|
|
scene_state.max_lightmaps = low_end ? 2 : MAX_LIGHTMAPS;
|
|
defines += "\n#define MAX_LIGHTMAP_TEXTURES " + itos(scene_state.max_lightmaps) + "\n";
|
|
defines += "\n#define MAX_LIGHTMAPS " + itos(scene_state.max_lightmaps) + "\n";
|
|
|
|
scene_state.lightmap_buffer = RD::get_singleton()->storage_buffer_create(sizeof(LightmapData) * scene_state.max_lightmaps);
|
|
}
|
|
{
|
|
//captures
|
|
scene_state.max_lightmap_captures = 2048;
|
|
scene_state.lightmap_captures = memnew_arr(LightmapCaptureData, scene_state.max_lightmap_captures);
|
|
scene_state.lightmap_capture_buffer = RD::get_singleton()->storage_buffer_create(sizeof(LightmapCaptureData) * scene_state.max_lightmap_captures);
|
|
}
|
|
{
|
|
defines += "\n#define MATERIAL_UNIFORM_SET " + itos(MATERIAL_UNIFORM_SET) + "\n";
|
|
}
|
|
|
|
Vector<String> shader_versions;
|
|
shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n");
|
|
shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_DUAL_PARABOLOID\n");
|
|
shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_NORMAL_ROUGHNESS\n");
|
|
shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_NORMAL_ROUGHNESS\n#define MODE_RENDER_GIPROBE\n");
|
|
shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_MATERIAL\n");
|
|
shader_versions.push_back("\n#define MODE_RENDER_DEPTH\n#define MODE_RENDER_SDF\n");
|
|
shader_versions.push_back("");
|
|
shader_versions.push_back("\n#define USE_FORWARD_GI\n");
|
|
shader_versions.push_back("\n#define MODE_MULTIPLE_RENDER_TARGETS\n");
|
|
shader_versions.push_back("\n#define USE_LIGHTMAP\n");
|
|
shader_versions.push_back("\n#define MODE_MULTIPLE_RENDER_TARGETS\n#define USE_LIGHTMAP\n");
|
|
shader.scene_shader.initialize(shader_versions, defines);
|
|
|
|
if (is_low_end()) {
|
|
//disable the high end versions
|
|
shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS, false);
|
|
shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_GIPROBE, false);
|
|
shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_SDF, false);
|
|
shader.scene_shader.set_variant_enabled(SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI, false);
|
|
shader.scene_shader.set_variant_enabled(SHADER_VERSION_COLOR_PASS_WITH_SEPARATE_SPECULAR, false);
|
|
shader.scene_shader.set_variant_enabled(SHADER_VERSION_LIGHTMAP_COLOR_PASS_WITH_SEPARATE_SPECULAR, false);
|
|
}
|
|
}
|
|
|
|
storage->shader_set_data_request_function(RendererStorageRD::SHADER_TYPE_3D, _create_shader_funcs);
|
|
storage->material_set_data_request_function(RendererStorageRD::SHADER_TYPE_3D, _create_material_funcs);
|
|
|
|
{
|
|
//shader compiler
|
|
ShaderCompilerRD::DefaultIdentifierActions actions;
|
|
|
|
actions.renames["WORLD_MATRIX"] = "world_matrix";
|
|
actions.renames["WORLD_NORMAL_MATRIX"] = "world_normal_matrix";
|
|
actions.renames["INV_CAMERA_MATRIX"] = "scene_data.inv_camera_matrix";
|
|
actions.renames["CAMERA_MATRIX"] = "scene_data.camera_matrix";
|
|
actions.renames["PROJECTION_MATRIX"] = "projection_matrix";
|
|
actions.renames["INV_PROJECTION_MATRIX"] = "scene_data.inv_projection_matrix";
|
|
actions.renames["MODELVIEW_MATRIX"] = "modelview";
|
|
actions.renames["MODELVIEW_NORMAL_MATRIX"] = "modelview_normal";
|
|
|
|
actions.renames["VERTEX"] = "vertex";
|
|
actions.renames["NORMAL"] = "normal";
|
|
actions.renames["TANGENT"] = "tangent";
|
|
actions.renames["BINORMAL"] = "binormal";
|
|
actions.renames["POSITION"] = "position";
|
|
actions.renames["UV"] = "uv_interp";
|
|
actions.renames["UV2"] = "uv2_interp";
|
|
actions.renames["COLOR"] = "color_interp";
|
|
actions.renames["POINT_SIZE"] = "gl_PointSize";
|
|
actions.renames["INSTANCE_ID"] = "gl_InstanceIndex";
|
|
|
|
actions.renames["ALPHA_SCISSOR_THRESHOLD"] = "alpha_scissor_threshold";
|
|
actions.renames["ALPHA_HASH_SCALE"] = "alpha_hash_scale";
|
|
actions.renames["ALPHA_ANTIALIASING_EDGE"] = "alpha_antialiasing_edge";
|
|
actions.renames["ALPHA_TEXTURE_COORDINATE"] = "alpha_texture_coordinate";
|
|
|
|
//builtins
|
|
|
|
actions.renames["TIME"] = "scene_data.time";
|
|
actions.renames["VIEWPORT_SIZE"] = "scene_data.viewport_size";
|
|
|
|
actions.renames["FRAGCOORD"] = "gl_FragCoord";
|
|
actions.renames["FRONT_FACING"] = "gl_FrontFacing";
|
|
actions.renames["NORMAL_MAP"] = "normal_map";
|
|
actions.renames["NORMAL_MAP_DEPTH"] = "normal_map_depth";
|
|
actions.renames["ALBEDO"] = "albedo";
|
|
actions.renames["ALPHA"] = "alpha";
|
|
actions.renames["METALLIC"] = "metallic";
|
|
actions.renames["SPECULAR"] = "specular";
|
|
actions.renames["ROUGHNESS"] = "roughness";
|
|
actions.renames["RIM"] = "rim";
|
|
actions.renames["RIM_TINT"] = "rim_tint";
|
|
actions.renames["CLEARCOAT"] = "clearcoat";
|
|
actions.renames["CLEARCOAT_GLOSS"] = "clearcoat_gloss";
|
|
actions.renames["ANISOTROPY"] = "anisotropy";
|
|
actions.renames["ANISOTROPY_FLOW"] = "anisotropy_flow";
|
|
actions.renames["SSS_STRENGTH"] = "sss_strength";
|
|
actions.renames["SSS_TRANSMITTANCE_COLOR"] = "transmittance_color";
|
|
actions.renames["SSS_TRANSMITTANCE_DEPTH"] = "transmittance_depth";
|
|
actions.renames["SSS_TRANSMITTANCE_CURVE"] = "transmittance_curve";
|
|
actions.renames["SSS_TRANSMITTANCE_BOOST"] = "transmittance_boost";
|
|
actions.renames["BACKLIGHT"] = "backlight";
|
|
actions.renames["AO"] = "ao";
|
|
actions.renames["AO_LIGHT_AFFECT"] = "ao_light_affect";
|
|
actions.renames["EMISSION"] = "emission";
|
|
actions.renames["POINT_COORD"] = "gl_PointCoord";
|
|
actions.renames["INSTANCE_CUSTOM"] = "instance_custom";
|
|
actions.renames["SCREEN_UV"] = "screen_uv";
|
|
actions.renames["SCREEN_TEXTURE"] = "color_buffer";
|
|
actions.renames["DEPTH_TEXTURE"] = "depth_buffer";
|
|
actions.renames["NORMAL_ROUGHNESS_TEXTURE"] = "normal_roughness_buffer";
|
|
actions.renames["DEPTH"] = "gl_FragDepth";
|
|
actions.renames["OUTPUT_IS_SRGB"] = "true";
|
|
actions.renames["FOG"] = "custom_fog";
|
|
actions.renames["RADIANCE"] = "custom_radiance";
|
|
actions.renames["IRRADIANCE"] = "custom_irradiance";
|
|
actions.renames["BONE_INDICES"] = "bone_attrib";
|
|
actions.renames["BONE_WEIGHTS"] = "weight_attrib";
|
|
actions.renames["CUSTOM0"] = "custom0_attrib";
|
|
actions.renames["CUSTOM1"] = "custom1_attrib";
|
|
actions.renames["CUSTOM2"] = "custom2_attrib";
|
|
actions.renames["CUSTOM3"] = "custom3_attrib";
|
|
|
|
//for light
|
|
actions.renames["VIEW"] = "view";
|
|
actions.renames["LIGHT_COLOR"] = "light_color";
|
|
actions.renames["LIGHT"] = "light";
|
|
actions.renames["ATTENUATION"] = "attenuation";
|
|
actions.renames["SHADOW_ATTENUATION"] = "shadow_attenuation";
|
|
actions.renames["DIFFUSE_LIGHT"] = "diffuse_light";
|
|
actions.renames["SPECULAR_LIGHT"] = "specular_light";
|
|
|
|
actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
|
|
actions.usage_defines["TANGENT"] = "#define TANGENT_USED\n";
|
|
actions.usage_defines["BINORMAL"] = "@TANGENT";
|
|
actions.usage_defines["RIM"] = "#define LIGHT_RIM_USED\n";
|
|
actions.usage_defines["RIM_TINT"] = "@RIM";
|
|
actions.usage_defines["CLEARCOAT"] = "#define LIGHT_CLEARCOAT_USED\n";
|
|
actions.usage_defines["CLEARCOAT_GLOSS"] = "@CLEARCOAT";
|
|
actions.usage_defines["ANISOTROPY"] = "#define LIGHT_ANISOTROPY_USED\n";
|
|
actions.usage_defines["ANISOTROPY_FLOW"] = "@ANISOTROPY";
|
|
actions.usage_defines["AO"] = "#define AO_USED\n";
|
|
actions.usage_defines["AO_LIGHT_AFFECT"] = "#define AO_USED\n";
|
|
actions.usage_defines["UV"] = "#define UV_USED\n";
|
|
actions.usage_defines["UV2"] = "#define UV2_USED\n";
|
|
actions.usage_defines["BONE_INDICES"] = "#define BONES_USED\n";
|
|
actions.usage_defines["BONE_WEIGHTS"] = "#define WEIGHTS_USED\n";
|
|
actions.usage_defines["CUSTOM0"] = "#define CUSTOM0\n";
|
|
actions.usage_defines["CUSTOM1"] = "#define CUSTOM1\n";
|
|
actions.usage_defines["CUSTOM2"] = "#define CUSTOM2\n";
|
|
actions.usage_defines["CUSTOM3"] = "#define CUSTOM3\n";
|
|
actions.usage_defines["NORMAL_MAP"] = "#define NORMAL_MAP_USED\n";
|
|
actions.usage_defines["NORMAL_MAP_DEPTH"] = "@NORMAL_MAP";
|
|
actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
|
|
actions.usage_defines["INSTANCE_CUSTOM"] = "#define ENABLE_INSTANCE_CUSTOM\n";
|
|
actions.usage_defines["POSITION"] = "#define OVERRIDE_POSITION\n";
|
|
|
|
actions.usage_defines["ALPHA_SCISSOR_THRESHOLD"] = "#define ALPHA_SCISSOR_USED\n";
|
|
actions.usage_defines["ALPHA_HASH_SCALE"] = "#define ALPHA_HASH_USED\n";
|
|
actions.usage_defines["ALPHA_ANTIALIASING_EDGE"] = "#define ALPHA_ANTIALIASING_EDGE_USED\n";
|
|
actions.usage_defines["ALPHA_TEXTURE_COORDINATE"] = "@ALPHA_ANTIALIASING_EDGE";
|
|
|
|
actions.usage_defines["SSS_STRENGTH"] = "#define ENABLE_SSS\n";
|
|
actions.usage_defines["SSS_TRANSMITTANCE_DEPTH"] = "#define ENABLE_TRANSMITTANCE\n";
|
|
actions.usage_defines["BACKLIGHT"] = "#define LIGHT_BACKLIGHT_USED\n";
|
|
actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
|
|
actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
|
|
|
|
actions.usage_defines["DIFFUSE_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
|
|
actions.usage_defines["SPECULAR_LIGHT"] = "#define USE_LIGHT_SHADER_CODE\n";
|
|
|
|
actions.usage_defines["FOG"] = "#define CUSTOM_FOG_USED\n";
|
|
actions.usage_defines["RADIANCE"] = "#define CUSTOM_RADIANCE_USED\n";
|
|
actions.usage_defines["IRRADIANCE"] = "#define CUSTOM_IRRADIANCE_USED\n";
|
|
|
|
actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
|
|
actions.render_mode_defines["world_vertex_coords"] = "#define VERTEX_WORLD_COORDS_USED\n";
|
|
actions.render_mode_defines["ensure_correct_normals"] = "#define ENSURE_CORRECT_NORMALS\n";
|
|
actions.render_mode_defines["cull_front"] = "#define DO_SIDE_CHECK\n";
|
|
actions.render_mode_defines["cull_disabled"] = "#define DO_SIDE_CHECK\n";
|
|
|
|
bool force_lambert = GLOBAL_GET("rendering/quality/shading/force_lambert_over_burley");
|
|
|
|
if (!force_lambert) {
|
|
actions.render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
|
|
}
|
|
|
|
actions.render_mode_defines["diffuse_oren_nayar"] = "#define DIFFUSE_OREN_NAYAR\n";
|
|
actions.render_mode_defines["diffuse_lambert_wrap"] = "#define DIFFUSE_LAMBERT_WRAP\n";
|
|
actions.render_mode_defines["diffuse_toon"] = "#define DIFFUSE_TOON\n";
|
|
|
|
actions.render_mode_defines["sss_mode_skin"] = "#define SSS_MODE_SKIN\n";
|
|
|
|
bool force_blinn = GLOBAL_GET("rendering/quality/shading/force_blinn_over_ggx");
|
|
|
|
if (!force_blinn) {
|
|
actions.render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
|
|
} else {
|
|
actions.render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_BLINN\n";
|
|
}
|
|
|
|
actions.render_mode_defines["specular_blinn"] = "#define SPECULAR_BLINN\n";
|
|
actions.render_mode_defines["specular_phong"] = "#define SPECULAR_PHONG\n";
|
|
actions.render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
|
|
actions.render_mode_defines["specular_disabled"] = "#define SPECULAR_DISABLED\n";
|
|
actions.render_mode_defines["shadows_disabled"] = "#define SHADOWS_DISABLED\n";
|
|
actions.render_mode_defines["ambient_light_disabled"] = "#define AMBIENT_LIGHT_DISABLED\n";
|
|
actions.render_mode_defines["shadow_to_opacity"] = "#define USE_SHADOW_TO_OPACITY\n";
|
|
actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
|
|
|
|
actions.sampler_array_name = "material_samplers";
|
|
actions.base_texture_binding_index = 1;
|
|
actions.texture_layout_set = MATERIAL_UNIFORM_SET;
|
|
actions.base_uniform_string = "material.";
|
|
actions.base_varying_index = 10;
|
|
|
|
actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
|
|
actions.default_repeat = ShaderLanguage::REPEAT_ENABLE;
|
|
actions.global_buffer_array_variable = "global_variables.data";
|
|
actions.instance_uniform_index_variable = "draw_call.instance_uniforms_ofs";
|
|
|
|
shader.compiler.initialize(actions);
|
|
}
|
|
|
|
{
|
|
//default material and shader
|
|
default_shader = storage->shader_allocate();
|
|
storage->shader_initialize(default_shader);
|
|
storage->shader_set_code(default_shader, "shader_type spatial; void vertex() { ROUGHNESS = 0.8; } void fragment() { ALBEDO=vec3(0.6); ROUGHNESS=0.8; METALLIC=0.2; } \n");
|
|
default_material = storage->material_allocate();
|
|
storage->material_initialize(default_material);
|
|
storage->material_set_shader(default_material, default_shader);
|
|
|
|
MaterialData *md = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
|
|
default_shader_rd = shader.scene_shader.version_get_shader(md->shader_data->version, SHADER_VERSION_COLOR_PASS);
|
|
if (!low_end) {
|
|
default_shader_sdfgi_rd = shader.scene_shader.version_get_shader(md->shader_data->version, SHADER_VERSION_DEPTH_PASS_WITH_SDF);
|
|
}
|
|
}
|
|
|
|
{
|
|
overdraw_material_shader = storage->shader_allocate();
|
|
storage->shader_initialize(overdraw_material_shader);
|
|
storage->shader_set_code(overdraw_material_shader, "shader_type spatial;\nrender_mode blend_add,unshaded;\n void fragment() { ALBEDO=vec3(0.4,0.8,0.8); ALPHA=0.2; }");
|
|
overdraw_material = storage->material_allocate();
|
|
storage->material_initialize(overdraw_material);
|
|
storage->material_set_shader(overdraw_material, overdraw_material_shader);
|
|
|
|
wireframe_material_shader = storage->shader_allocate();
|
|
storage->shader_initialize(wireframe_material_shader);
|
|
storage->shader_set_code(wireframe_material_shader, "shader_type spatial;\nrender_mode wireframe,unshaded;\n void fragment() { ALBEDO=vec3(0.0,0.0,0.0); }");
|
|
wireframe_material = storage->material_allocate();
|
|
storage->material_initialize(wireframe_material);
|
|
storage->material_set_shader(wireframe_material, wireframe_material_shader);
|
|
}
|
|
|
|
{
|
|
default_vec4_xform_buffer = RD::get_singleton()->storage_buffer_create(256);
|
|
Vector<RD::Uniform> uniforms;
|
|
RD::Uniform u;
|
|
u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
u.ids.push_back(default_vec4_xform_buffer);
|
|
u.binding = 0;
|
|
uniforms.push_back(u);
|
|
|
|
default_vec4_xform_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, TRANSFORMS_UNIFORM_SET);
|
|
}
|
|
{
|
|
RD::SamplerState sampler;
|
|
sampler.mag_filter = RD::SAMPLER_FILTER_LINEAR;
|
|
sampler.min_filter = RD::SAMPLER_FILTER_LINEAR;
|
|
sampler.enable_compare = true;
|
|
sampler.compare_op = RD::COMPARE_OP_LESS;
|
|
shadow_sampler = RD::get_singleton()->sampler_create(sampler);
|
|
}
|
|
|
|
render_list_thread_threshold = GLOBAL_GET("rendering/forward_renderer/threaded_render_minimum_instances");
|
|
}
|
|
|
|
RendererSceneRenderForward::~RendererSceneRenderForward() {
|
|
directional_shadow_atlas_set_size(0);
|
|
|
|
//clear base uniform set if still valid
|
|
for (uint32_t i = 0; i < render_pass_uniform_sets.size(); i++) {
|
|
if (render_pass_uniform_sets[i].is_valid() && RD::get_singleton()->uniform_set_is_valid(render_pass_uniform_sets[i])) {
|
|
RD::get_singleton()->free(render_pass_uniform_sets[i]);
|
|
}
|
|
}
|
|
|
|
if (sdfgi_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sdfgi_pass_uniform_set)) {
|
|
RD::get_singleton()->free(sdfgi_pass_uniform_set);
|
|
}
|
|
|
|
RD::get_singleton()->free(default_vec4_xform_buffer);
|
|
RD::get_singleton()->free(shadow_sampler);
|
|
|
|
storage->free(wireframe_material_shader);
|
|
storage->free(overdraw_material_shader);
|
|
storage->free(default_shader);
|
|
|
|
storage->free(wireframe_material);
|
|
storage->free(overdraw_material);
|
|
storage->free(default_material);
|
|
|
|
{
|
|
for (uint32_t i = 0; i < scene_state.uniform_buffers.size(); i++) {
|
|
RD::get_singleton()->free(scene_state.uniform_buffers[i]);
|
|
}
|
|
RD::get_singleton()->free(scene_state.lightmap_buffer);
|
|
RD::get_singleton()->free(scene_state.lightmap_capture_buffer);
|
|
for (uint32_t i = 0; i < RENDER_LIST_MAX; i++) {
|
|
if (scene_state.instance_buffer[i] != RID()) {
|
|
RD::get_singleton()->free(scene_state.instance_buffer[i]);
|
|
}
|
|
}
|
|
memdelete_arr(scene_state.lightmap_captures);
|
|
}
|
|
|
|
while (sdfgi_framebuffer_size_cache.front()) {
|
|
RD::get_singleton()->free(sdfgi_framebuffer_size_cache.front()->get());
|
|
sdfgi_framebuffer_size_cache.erase(sdfgi_framebuffer_size_cache.front());
|
|
}
|
|
}
|