|
|
@@ -365,7 +365,7 @@ float RendererSceneRenderRD::environment_get_fog_aerial_perspective(RID p_env) c
|
|
|
return env->fog_aerial_perspective;
|
|
|
}
|
|
|
|
|
|
-void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount) {
|
|
|
+void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_albedo, const Color &p_emission, float p_emission_energy, float p_anisotropy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount, float p_ambient_inject) {
|
|
|
RendererSceneEnvironmentRD *env = environment_owner.get_or_null(p_env);
|
|
|
ERR_FAIL_COND(!env);
|
|
|
|
|
|
@@ -373,7 +373,7 @@ void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_ena
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
- env->set_volumetric_fog(p_enable, p_density, p_light, p_light_energy, p_length, p_detail_spread, p_gi_inject, p_temporal_reprojection, p_temporal_reprojection_amount);
|
|
|
+ env->set_volumetric_fog(p_enable, p_density, p_albedo, p_emission, p_emission_energy, p_anisotropy, p_length, p_detail_spread, p_gi_inject, p_temporal_reprojection, p_temporal_reprojection_amount, p_ambient_inject);
|
|
|
}
|
|
|
|
|
|
void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
|
|
|
@@ -499,6 +499,37 @@ Ref<Image> RendererSceneRenderRD::environment_bake_panorama(RID p_env, bool p_ba
|
|
|
|
|
|
////////////////////////////////////////////////////////////
|
|
|
|
|
|
+RID RendererSceneRenderRD::fog_volume_instance_create(RID p_fog_volume) {
|
|
|
+ FogVolumeInstance fvi;
|
|
|
+ fvi.volume = p_fog_volume;
|
|
|
+ return fog_volume_instance_owner.make_rid(fvi);
|
|
|
+}
|
|
|
+void RendererSceneRenderRD::fog_volume_instance_set_transform(RID p_fog_volume_instance, const Transform3D &p_transform) {
|
|
|
+ FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
|
|
|
+ ERR_FAIL_COND(!fvi);
|
|
|
+ fvi->transform = p_transform;
|
|
|
+}
|
|
|
+void RendererSceneRenderRD::fog_volume_instance_set_active(RID p_fog_volume_instance, bool p_active) {
|
|
|
+ FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
|
|
|
+ ERR_FAIL_COND(!fvi);
|
|
|
+ fvi->active = p_active;
|
|
|
+}
|
|
|
+
|
|
|
+RID RendererSceneRenderRD::fog_volume_instance_get_volume(RID p_fog_volume_instance) const {
|
|
|
+ FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
|
|
|
+ ERR_FAIL_COND_V(!fvi, RID());
|
|
|
+ return fvi->volume;
|
|
|
+}
|
|
|
+
|
|
|
+Vector3 RendererSceneRenderRD::fog_volume_instance_get_position(RID p_fog_volume_instance) const {
|
|
|
+ FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance);
|
|
|
+ ERR_FAIL_COND_V(!fvi, Vector3());
|
|
|
+
|
|
|
+ return fvi->transform.get_origin();
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
RID RendererSceneRenderRD::reflection_atlas_create() {
|
|
|
ReflectionAtlas ra;
|
|
|
ra.count = GLOBAL_GET("rendering/reflections/reflection_atlas/reflection_count");
|
|
|
@@ -3472,6 +3503,180 @@ void RendererSceneRenderRD::_setup_decals(const PagedArray<RID> &p_decals, const
|
|
|
}
|
|
|
}
|
|
|
|
|
|
+////////////////////////////////////////////////////////////////////////////////
|
|
|
+// FOG SHADER
|
|
|
+
|
|
|
+void RendererSceneRenderRD::FogShaderData::set_code(const String &p_code) {
|
|
|
+ //compile
|
|
|
+
|
|
|
+ code = p_code;
|
|
|
+ valid = false;
|
|
|
+ ubo_size = 0;
|
|
|
+ uniforms.clear();
|
|
|
+
|
|
|
+ if (code == String()) {
|
|
|
+ return; //just invalid, but no error
|
|
|
+ }
|
|
|
+
|
|
|
+ ShaderCompilerRD::GeneratedCode gen_code;
|
|
|
+ ShaderCompilerRD::IdentifierActions actions;
|
|
|
+ actions.entry_point_stages["fog"] = ShaderCompilerRD::STAGE_COMPUTE;
|
|
|
+
|
|
|
+ uses_time = false;
|
|
|
+
|
|
|
+ actions.usage_flag_pointers["TIME"] = &uses_time;
|
|
|
+
|
|
|
+ actions.uniforms = &uniforms;
|
|
|
+
|
|
|
+ RendererSceneRenderRD *scene_singleton = (RendererSceneRenderRD *)RendererSceneRenderRD::singleton;
|
|
|
+
|
|
|
+ Error err = scene_singleton->volumetric_fog.compiler.compile(RS::SHADER_FOG, code, &actions, path, gen_code);
|
|
|
+ ERR_FAIL_COND_MSG(err != OK, "Fog shader compilation failed.");
|
|
|
+
|
|
|
+ if (version.is_null()) {
|
|
|
+ version = scene_singleton->volumetric_fog.shader.version_create();
|
|
|
+ }
|
|
|
+
|
|
|
+ scene_singleton->volumetric_fog.shader.version_set_compute_code(version, gen_code.code, gen_code.uniforms, gen_code.stage_globals[ShaderCompilerRD::STAGE_COMPUTE], gen_code.defines);
|
|
|
+ ERR_FAIL_COND(!scene_singleton->volumetric_fog.shader.version_is_valid(version));
|
|
|
+
|
|
|
+ ubo_size = gen_code.uniform_total_size;
|
|
|
+ ubo_offsets = gen_code.uniform_offsets;
|
|
|
+ texture_uniforms = gen_code.texture_uniforms;
|
|
|
+
|
|
|
+ pipeline = RD::get_singleton()->compute_pipeline_create(scene_singleton->volumetric_fog.shader.version_get_shader(version, 0));
|
|
|
+
|
|
|
+ valid = true;
|
|
|
+}
|
|
|
+
|
|
|
+void RendererSceneRenderRD::FogShaderData::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 RendererSceneRenderRD::FogShaderData::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_GLOBAL || E->get().scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
|
|
|
+ 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 RendererSceneRenderRD::FogShaderData::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 RendererSceneRenderRD::FogShaderData::is_param_texture(const StringName &p_param) const {
|
|
|
+ if (!uniforms.has(p_param)) {
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ return uniforms[p_param].texture_order >= 0;
|
|
|
+}
|
|
|
+
|
|
|
+bool RendererSceneRenderRD::FogShaderData::is_animated() const {
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+bool RendererSceneRenderRD::FogShaderData::casts_shadows() const {
|
|
|
+ return false;
|
|
|
+}
|
|
|
+
|
|
|
+Variant RendererSceneRenderRD::FogShaderData::get_default_parameter(const StringName &p_parameter) const {
|
|
|
+ if (uniforms.has(p_parameter)) {
|
|
|
+ ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
|
|
|
+ Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
|
|
|
+ return ShaderLanguage::constant_value_to_variant(default_value, uniform.type, uniform.hint);
|
|
|
+ }
|
|
|
+ return Variant();
|
|
|
+}
|
|
|
+
|
|
|
+RS::ShaderNativeSourceCode RendererSceneRenderRD::FogShaderData::get_native_source_code() const {
|
|
|
+ RendererSceneRenderRD *scene_singleton = (RendererSceneRenderRD *)RendererSceneRenderRD::singleton;
|
|
|
+
|
|
|
+ return scene_singleton->volumetric_fog.shader.version_get_native_source_code(version);
|
|
|
+}
|
|
|
+
|
|
|
+RendererSceneRenderRD::FogShaderData::FogShaderData() {
|
|
|
+ valid = false;
|
|
|
+}
|
|
|
+
|
|
|
+RendererSceneRenderRD::FogShaderData::~FogShaderData() {
|
|
|
+ RendererSceneRenderRD *scene_singleton = (RendererSceneRenderRD *)RendererSceneRenderRD::singleton;
|
|
|
+ ERR_FAIL_COND(!scene_singleton);
|
|
|
+ //pipeline variants will clear themselves if shader is gone
|
|
|
+ if (version.is_valid()) {
|
|
|
+ scene_singleton->volumetric_fog.shader.version_free(version);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Fog material
|
|
|
+
|
|
|
+bool RendererSceneRenderRD::FogMaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
|
|
|
+ RendererSceneRenderRD *scene_singleton = (RendererSceneRenderRD *)RendererSceneRenderRD::singleton;
|
|
|
+
|
|
|
+ uniform_set_updated = true;
|
|
|
+
|
|
|
+ return update_parameters_uniform_set(p_parameters, p_uniform_dirty, p_textures_dirty, shader_data->uniforms, shader_data->ubo_offsets.ptr(), shader_data->texture_uniforms, shader_data->default_texture_params, shader_data->ubo_size, uniform_set, scene_singleton->volumetric_fog.shader.version_get_shader(shader_data->version, 0), VolumetricFogShader::FogSet::FOG_SET_MATERIAL);
|
|
|
+}
|
|
|
+
|
|
|
+RendererSceneRenderRD::FogMaterialData::~FogMaterialData() {
|
|
|
+ free_parameters_uniform_set(uniform_set);
|
|
|
+}
|
|
|
+
|
|
|
+RendererStorageRD::ShaderData *RendererSceneRenderRD::_create_fog_shader_func() {
|
|
|
+ FogShaderData *shader_data = memnew(FogShaderData);
|
|
|
+ return shader_data;
|
|
|
+}
|
|
|
+
|
|
|
+RendererStorageRD::ShaderData *RendererSceneRenderRD::_create_fog_shader_funcs() {
|
|
|
+ return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->_create_fog_shader_func();
|
|
|
+};
|
|
|
+
|
|
|
+RendererStorageRD::MaterialData *RendererSceneRenderRD::_create_fog_material_func(FogShaderData *p_shader) {
|
|
|
+ FogMaterialData *material_data = memnew(FogMaterialData);
|
|
|
+ material_data->shader_data = p_shader;
|
|
|
+ material_data->last_frame = false;
|
|
|
+ //update will happen later anyway so do nothing.
|
|
|
+ return material_data;
|
|
|
+}
|
|
|
+
|
|
|
+RendererStorageRD::MaterialData *RendererSceneRenderRD::_create_fog_material_funcs(RendererStorageRD::ShaderData *p_shader) {
|
|
|
+ return static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton)->_create_fog_material_func(static_cast<FogShaderData *>(p_shader));
|
|
|
+};
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Volumetric Fog
|
|
|
+
|
|
|
void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
|
|
|
ERR_FAIL_COND(!rb->volumetric_fog);
|
|
|
|
|
|
@@ -3479,11 +3684,14 @@ void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
|
|
|
RD::get_singleton()->free(rb->volumetric_fog->light_density_map);
|
|
|
RD::get_singleton()->free(rb->volumetric_fog->fog_map);
|
|
|
|
|
|
- if (rb->volumetric_fog->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->uniform_set)) {
|
|
|
- RD::get_singleton()->free(rb->volumetric_fog->uniform_set);
|
|
|
+ if (rb->volumetric_fog->fog_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->fog_uniform_set)) {
|
|
|
+ RD::get_singleton()->free(rb->volumetric_fog->fog_uniform_set);
|
|
|
}
|
|
|
- if (rb->volumetric_fog->uniform_set2.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->uniform_set2)) {
|
|
|
- RD::get_singleton()->free(rb->volumetric_fog->uniform_set2);
|
|
|
+ if (rb->volumetric_fog->process_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->process_uniform_set)) {
|
|
|
+ RD::get_singleton()->free(rb->volumetric_fog->process_uniform_set);
|
|
|
+ }
|
|
|
+ if (rb->volumetric_fog->process_uniform_set2.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->process_uniform_set2)) {
|
|
|
+ RD::get_singleton()->free(rb->volumetric_fog->process_uniform_set2);
|
|
|
}
|
|
|
if (rb->volumetric_fog->sdfgi_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->sdfgi_uniform_set)) {
|
|
|
RD::get_singleton()->free(rb->volumetric_fog->sdfgi_uniform_set);
|
|
|
@@ -3497,7 +3705,26 @@ void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
|
|
|
rb->volumetric_fog = nullptr;
|
|
|
}
|
|
|
|
|
|
-void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const CameraMatrix &p_cam_projection, const Transform3D &p_cam_transform, RID p_shadow_atlas, int p_directional_light_count, bool p_use_directional_shadows, int p_positional_light_count, int p_voxel_gi_count) {
|
|
|
+Vector3i RendererSceneRenderRD::_point_get_position_in_froxel_volume(const Vector3 &p_point, float fog_end, const Vector2 &fog_near_size, const Vector2 &fog_far_size, float volumetric_fog_detail_spread, const Vector3 &fog_size, const Transform3D &p_cam_transform) {
|
|
|
+ Vector3 view_position = p_cam_transform.affine_inverse().xform(p_point);
|
|
|
+ view_position.z = MIN(view_position.z, -0.01); // Clamp to the front of camera
|
|
|
+ Vector3 fog_position = Vector3(0, 0, 0);
|
|
|
+
|
|
|
+ view_position.y = -view_position.y;
|
|
|
+ fog_position.z = -view_position.z / fog_end;
|
|
|
+ fog_position.x = (view_position.x / (2 * (fog_near_size.x * (1.0 - fog_position.z) + fog_far_size.x * fog_position.z))) + 0.5;
|
|
|
+ fog_position.y = (view_position.y / (2 * (fog_near_size.y * (1.0 - fog_position.z) + fog_far_size.y * fog_position.z))) + 0.5;
|
|
|
+ fog_position.z = Math::pow(float(fog_position.z), float(1.0 / volumetric_fog_detail_spread));
|
|
|
+ fog_position = fog_position * fog_size - Vector3(0.5, 0.5, 0.5);
|
|
|
+
|
|
|
+ fog_position.x = CLAMP(fog_position.x, 0.0, fog_size.x);
|
|
|
+ fog_position.y = CLAMP(fog_position.y, 0.0, fog_size.y);
|
|
|
+ fog_position.z = CLAMP(fog_position.z, 0.0, fog_size.z);
|
|
|
+
|
|
|
+ return Vector3i(fog_position);
|
|
|
+}
|
|
|
+
|
|
|
+void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const CameraMatrix &p_cam_projection, const Transform3D &p_cam_transform, RID p_shadow_atlas, int p_directional_light_count, bool p_use_directional_shadows, int p_positional_light_count, int p_voxel_gi_count, const PagedArray<RID> &p_fog_volumes) {
|
|
|
ERR_FAIL_COND(!is_clustered_enabled()); // can't use volumetric fog without clustered
|
|
|
RenderBuffers *rb = render_buffers_owner.get_or_null(p_render_buffers);
|
|
|
ERR_FAIL_COND(!rb);
|
|
|
@@ -3520,6 +3747,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
}
|
|
|
|
|
|
RENDER_TIMESTAMP(">Volumetric Fog");
|
|
|
+ RD::get_singleton()->draw_command_begin_label("Volumetric Fog");
|
|
|
|
|
|
if (env && env->volumetric_fog_enabled && !rb->volumetric_fog) {
|
|
|
//required volumetric fog but not existing, create
|
|
|
@@ -3537,15 +3765,30 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
|
|
|
|
|
|
rb->volumetric_fog->light_density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
+ RD::get_singleton()->set_resource_name(rb->volumetric_fog->light_density_map, "Fog light-density map");
|
|
|
|
|
|
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
|
|
|
|
|
|
rb->volumetric_fog->prev_light_density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
+ RD::get_singleton()->set_resource_name(rb->volumetric_fog->prev_light_density_map, "Fog previous light-density map");
|
|
|
RD::get_singleton()->texture_clear(rb->volumetric_fog->prev_light_density_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
|
|
|
|
|
|
tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
|
|
|
|
|
|
rb->volumetric_fog->fog_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
+ RD::get_singleton()->set_resource_name(rb->volumetric_fog->fog_map, "Fog map");
|
|
|
+
|
|
|
+ tf.format = RD::DATA_FORMAT_R32_UINT;
|
|
|
+ tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
|
|
|
+ rb->volumetric_fog->density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
+ RD::get_singleton()->set_resource_name(rb->volumetric_fog->density_map, "Fog density map");
|
|
|
+ RD::get_singleton()->texture_clear(rb->volumetric_fog->density_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
|
|
|
+ rb->volumetric_fog->light_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
+ RD::get_singleton()->set_resource_name(rb->volumetric_fog->light_map, "Fog light map");
|
|
|
+ RD::get_singleton()->texture_clear(rb->volumetric_fog->light_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
|
|
|
+ rb->volumetric_fog->emissive_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
|
|
|
+ RD::get_singleton()->set_resource_name(rb->volumetric_fog->emissive_map, "Fog emissive map");
|
|
|
+ RD::get_singleton()->texture_clear(rb->volumetric_fog->emissive_map, Color(0, 0, 0, 0), 0, 1, 0, 1);
|
|
|
|
|
|
Vector<RD::Uniform> uniforms;
|
|
|
{
|
|
|
@@ -3559,12 +3802,194 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
rb->volumetric_fog->sky_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, sky.sky_shader.default_shader_rd, RendererSceneSkyRD::SKY_SET_FOG);
|
|
|
}
|
|
|
|
|
|
- //update volumetric fog
|
|
|
+ if (p_fog_volumes.size() > 0) {
|
|
|
+ RD::get_singleton()->draw_command_begin_label("Render Volumetric Fog Volumes");
|
|
|
|
|
|
- if (rb->volumetric_fog->uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->uniform_set)) {
|
|
|
- //re create uniform set if needed
|
|
|
+ RENDER_TIMESTAMP("Render Fog Volumes");
|
|
|
+
|
|
|
+ VolumetricFogShader::VolumeUBO params;
|
|
|
+
|
|
|
+ Vector2 frustum_near_size = p_cam_projection.get_viewport_half_extents();
|
|
|
+ Vector2 frustum_far_size = p_cam_projection.get_far_plane_half_extents();
|
|
|
+ float z_near = p_cam_projection.get_z_near();
|
|
|
+ float z_far = p_cam_projection.get_z_far();
|
|
|
+ float fog_end = env->volumetric_fog_length;
|
|
|
+
|
|
|
+ Vector2 fog_far_size = frustum_near_size.lerp(frustum_far_size, (fog_end - z_near) / (z_far - z_near));
|
|
|
+ Vector2 fog_near_size;
|
|
|
+ if (p_cam_projection.is_orthogonal()) {
|
|
|
+ fog_near_size = fog_far_size;
|
|
|
+ } else {
|
|
|
+ fog_near_size = Vector2();
|
|
|
+ }
|
|
|
+
|
|
|
+ params.fog_frustum_size_begin[0] = fog_near_size.x;
|
|
|
+ params.fog_frustum_size_begin[1] = fog_near_size.y;
|
|
|
+
|
|
|
+ params.fog_frustum_size_end[0] = fog_far_size.x;
|
|
|
+ params.fog_frustum_size_end[1] = fog_far_size.y;
|
|
|
+
|
|
|
+ params.fog_frustum_end = fog_end;
|
|
|
+ params.z_near = z_near;
|
|
|
+ params.z_far = z_far;
|
|
|
+ params.time = time;
|
|
|
+
|
|
|
+ params.fog_volume_size[0] = rb->volumetric_fog->width;
|
|
|
+ params.fog_volume_size[1] = rb->volumetric_fog->height;
|
|
|
+ params.fog_volume_size[2] = rb->volumetric_fog->depth;
|
|
|
+
|
|
|
+ params.use_temporal_reprojection = env->volumetric_fog_temporal_reprojection;
|
|
|
+ params.temporal_frame = RSG::rasterizer->get_frame_number() % VolumetricFog::MAX_TEMPORAL_FRAMES;
|
|
|
+ params.detail_spread = env->volumetric_fog_detail_spread;
|
|
|
+ params.temporal_blend = env->volumetric_fog_temporal_reprojection_amount;
|
|
|
+
|
|
|
+ Transform3D to_prev_cam_view = rb->volumetric_fog->prev_cam_transform.affine_inverse() * p_cam_transform;
|
|
|
+ storage->store_transform(to_prev_cam_view, params.to_prev_view);
|
|
|
+ storage->store_transform(p_cam_transform, params.transform);
|
|
|
+
|
|
|
+ RD::get_singleton()->buffer_update(volumetric_fog.volume_ubo, 0, sizeof(VolumetricFogShader::VolumeUBO), ¶ms, RD::BARRIER_MASK_COMPUTE);
|
|
|
+
|
|
|
+ if (rb->volumetric_fog->fog_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->fog_uniform_set)) {
|
|
|
+ Vector<RD::Uniform> uniforms;
|
|
|
+
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
|
+ u.binding = 1;
|
|
|
+ u.ids.push_back(rb->volumetric_fog->emissive_map);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
|
|
|
+ u.binding = 2;
|
|
|
+ u.ids.push_back(volumetric_fog.volume_ubo);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
|
+ u.binding = 3;
|
|
|
+ u.ids.push_back(rb->volumetric_fog->density_map);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
|
+ u.binding = 4;
|
|
|
+ u.ids.push_back(rb->volumetric_fog->light_map);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
+
|
|
|
+ rb->volumetric_fog->fog_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.default_shader_rd, VolumetricFogShader::FogSet::FOG_SET_UNIFORMS);
|
|
|
+ }
|
|
|
+
|
|
|
+ RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
|
|
+ bool any_uses_time = false;
|
|
|
+
|
|
|
+ for (int i = 0; i < (int)p_fog_volumes.size(); i++) {
|
|
|
+ FogVolumeInstance *fog_volume_instance = fog_volume_instance_owner.get_or_null(p_fog_volumes[i]);
|
|
|
+ ERR_FAIL_COND(!fog_volume_instance);
|
|
|
+ RID fog_volume = fog_volume_instance->volume;
|
|
|
+
|
|
|
+ RID fog_material = storage->fog_volume_get_material(fog_volume);
|
|
|
+
|
|
|
+ FogMaterialData *material = nullptr;
|
|
|
+
|
|
|
+ if (fog_material.is_valid()) {
|
|
|
+ material = (FogMaterialData *)storage->material_get_data(fog_material, RendererStorageRD::SHADER_TYPE_FOG);
|
|
|
+ if (!material || !material->shader_data->valid) {
|
|
|
+ material = nullptr;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if (!material) {
|
|
|
+ fog_material = volumetric_fog.default_material;
|
|
|
+ material = (FogMaterialData *)storage->material_get_data(fog_material, RendererStorageRD::SHADER_TYPE_FOG);
|
|
|
+ }
|
|
|
+
|
|
|
+ ERR_FAIL_COND(!material);
|
|
|
+
|
|
|
+ FogShaderData *shader_data = material->shader_data;
|
|
|
+
|
|
|
+ ERR_FAIL_COND(!shader_data);
|
|
|
+
|
|
|
+ any_uses_time |= shader_data->uses_time;
|
|
|
+
|
|
|
+ Vector3i min = Vector3i();
|
|
|
+ Vector3i max = Vector3i();
|
|
|
+ Vector3i kernel_size = Vector3i();
|
|
|
+
|
|
|
+ Vector3 position = fog_volume_instance->transform.get_origin();
|
|
|
+ RS::FogVolumeShape volume_type = storage->fog_volume_get_shape(fog_volume);
|
|
|
+ Vector3 extents = storage->fog_volume_get_extents(fog_volume);
|
|
|
+
|
|
|
+ if (volume_type == RS::FOG_VOLUME_SHAPE_BOX || volume_type == RS::FOG_VOLUME_SHAPE_ELLIPSOID) {
|
|
|
+ Vector3i points[8];
|
|
|
+ points[0] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+ points[1] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+ points[2] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+ points[3] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+ points[4] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+ points[5] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+ points[6] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(extents.x, -extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+ points[7] = _point_get_position_in_froxel_volume(fog_volume_instance->transform.xform(Vector3(-extents.x, -extents.y, -extents.z)), fog_end, fog_near_size, fog_far_size, env->volumetric_fog_detail_spread, Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), p_cam_transform);
|
|
|
+
|
|
|
+ min = Vector3i(int32_t(rb->volumetric_fog->width) - 1, int32_t(rb->volumetric_fog->height) - 1, int32_t(rb->volumetric_fog->depth) - 1);
|
|
|
+ max = Vector3i(1, 1, 1);
|
|
|
+
|
|
|
+ for (int j = 0; j < 8; j++) {
|
|
|
+ min = Vector3i(MIN(min.x, points[j].x), MIN(min.y, points[j].y), MIN(min.z, points[j].z));
|
|
|
+ max = Vector3i(MAX(max.x, points[j].x), MAX(max.y, points[j].y), MAX(max.z, points[j].z));
|
|
|
+ }
|
|
|
+
|
|
|
+ kernel_size = max - min;
|
|
|
+ } else {
|
|
|
+ // Volume type global runs on all cells
|
|
|
+ extents = Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
|
|
|
+ min = Vector3i(0, 0, 0);
|
|
|
+ kernel_size = Vector3i(int32_t(rb->volumetric_fog->width), int32_t(rb->volumetric_fog->height), int32_t(rb->volumetric_fog->depth));
|
|
|
+ }
|
|
|
+
|
|
|
+ volumetric_fog.push_constant.position[0] = position.x;
|
|
|
+ volumetric_fog.push_constant.position[1] = position.y;
|
|
|
+ volumetric_fog.push_constant.position[2] = position.z;
|
|
|
+ volumetric_fog.push_constant.extents[0] = extents.x;
|
|
|
+ volumetric_fog.push_constant.extents[1] = extents.y;
|
|
|
+ volumetric_fog.push_constant.extents[2] = extents.z;
|
|
|
+ volumetric_fog.push_constant.corner[0] = min.x;
|
|
|
+ volumetric_fog.push_constant.corner[1] = min.y;
|
|
|
+ volumetric_fog.push_constant.corner[2] = min.z;
|
|
|
+ volumetric_fog.push_constant.shape = uint32_t(storage->fog_volume_get_shape(fog_volume));
|
|
|
+ storage->store_transform(fog_volume_instance->transform.affine_inverse(), volumetric_fog.push_constant.transform);
|
|
|
+
|
|
|
+ RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, shader_data->pipeline);
|
|
|
+
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->fog_uniform_set, VolumetricFogShader::FogSet::FOG_SET_UNIFORMS);
|
|
|
+ RD::get_singleton()->compute_list_set_push_constant(compute_list, &volumetric_fog.push_constant, sizeof(VolumetricFogShader::FogPushConstant));
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, volumetric_fog.base_uniform_set, VolumetricFogShader::FogSet::FOG_SET_BASE);
|
|
|
+ if (material->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(material->uniform_set)) { // Material may not have a uniform set.
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, material->uniform_set, VolumetricFogShader::FogSet::FOG_SET_MATERIAL);
|
|
|
+ }
|
|
|
+
|
|
|
+ RD::get_singleton()->compute_list_dispatch_threads(compute_list, kernel_size.x, kernel_size.y, kernel_size.z);
|
|
|
+ }
|
|
|
+ if (any_uses_time || env->volumetric_fog_temporal_reprojection) {
|
|
|
+ RenderingServerDefault::redraw_request();
|
|
|
+ }
|
|
|
+
|
|
|
+ RD::get_singleton()->draw_command_end_label();
|
|
|
+
|
|
|
+ RD::get_singleton()->compute_list_end();
|
|
|
+ }
|
|
|
+
|
|
|
+ if (rb->volumetric_fog->process_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->process_uniform_set)) {
|
|
|
+ //re create uniform set if needed
|
|
|
Vector<RD::Uniform> uniforms;
|
|
|
+ Vector<RD::Uniform> copy_uniforms;
|
|
|
|
|
|
{
|
|
|
RD::Uniform u;
|
|
|
@@ -3578,6 +4003,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
}
|
|
|
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3590,6 +4016,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK));
|
|
|
}
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3598,6 +4025,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 3;
|
|
|
u.ids.push_back(get_omni_light_buffer());
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
{
|
|
|
RD::Uniform u;
|
|
|
@@ -3605,6 +4033,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 4;
|
|
|
u.ids.push_back(get_spot_light_buffer());
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3613,6 +4042,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 5;
|
|
|
u.ids.push_back(get_directional_light_buffer());
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3621,6 +4051,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 6;
|
|
|
u.ids.push_back(rb->cluster_builder->get_cluster_buffer());
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3629,6 +4060,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 7;
|
|
|
u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3637,6 +4069,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 8;
|
|
|
u.ids.push_back(rb->volumetric_fog->light_density_map);
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3647,12 +4080,21 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
|
+ u.binding = 9;
|
|
|
+ u.ids.push_back(rb->volumetric_fog->prev_light_density_map);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
+ }
|
|
|
+
|
|
|
{
|
|
|
RD::Uniform u;
|
|
|
u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
|
|
|
u.binding = 10;
|
|
|
u.ids.push_back(shadow_sampler);
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3661,6 +4103,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 11;
|
|
|
u.ids.push_back(render_buffers_get_voxel_gi_buffer(p_render_buffers));
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -3671,6 +4114,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.ids.push_back(rb->gi.voxel_gi_textures[i]);
|
|
|
}
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
{
|
|
|
RD::Uniform u;
|
|
|
@@ -3678,6 +4122,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 13;
|
|
|
u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
{
|
|
|
RD::Uniform u;
|
|
|
@@ -3685,6 +4130,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.binding = 14;
|
|
|
u.ids.push_back(volumetric_fog.params_ubo);
|
|
|
uniforms.push_back(u);
|
|
|
+ copy_uniforms.push_back(u);
|
|
|
}
|
|
|
{
|
|
|
RD::Uniform u;
|
|
|
@@ -3693,12 +4139,46 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
u.ids.push_back(rb->volumetric_fog->prev_light_density_map);
|
|
|
uniforms.push_back(u);
|
|
|
}
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
|
+ u.binding = 16;
|
|
|
+ u.ids.push_back(rb->volumetric_fog->density_map);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
|
+ u.binding = 17;
|
|
|
+ u.ids.push_back(rb->volumetric_fog->light_map);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
|
|
|
- rb->volumetric_fog->uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.shader.version_get_shader(volumetric_fog.shader_version, 0), 0);
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
|
|
|
+ u.binding = 18;
|
|
|
+ u.ids.push_back(rb->volumetric_fog->emissive_map);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ RD::Uniform u;
|
|
|
+ u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
|
|
|
+ u.binding = 19;
|
|
|
+ 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);
|
|
|
+ RID sky_texture = sky.sky_get_radiance_texture_rd(env->sky);
|
|
|
+ u.ids.push_back(sky_texture.is_valid() ? sky_texture : radiance_texture);
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
+
|
|
|
+ rb->volumetric_fog->copy_uniform_set = RD::get_singleton()->uniform_set_create(copy_uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_COPY), 0);
|
|
|
+
|
|
|
+ rb->volumetric_fog->process_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY), 0);
|
|
|
|
|
|
SWAP(uniforms.write[7].ids.write[0], uniforms.write[8].ids.write[0]);
|
|
|
|
|
|
- rb->volumetric_fog->uniform_set2 = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.shader.version_get_shader(volumetric_fog.shader_version, 0), 0);
|
|
|
+ rb->volumetric_fog->process_uniform_set2 = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, 0), 0);
|
|
|
}
|
|
|
|
|
|
bool using_sdfgi = env->volumetric_fog_gi_inject > 0.0001 && env->sdfgi_enabled && (rb->sdfgi != nullptr);
|
|
|
@@ -3731,7 +4211,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
uniforms.push_back(u);
|
|
|
}
|
|
|
|
|
|
- rb->volumetric_fog->sdfgi_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.shader.version_get_shader(volumetric_fog.shader_version, VOLUMETRIC_FOG_SHADER_DENSITY_WITH_SDFGI), 1);
|
|
|
+ rb->volumetric_fog->sdfgi_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY_WITH_SDFGI), 1);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -3760,23 +4240,35 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
params.fog_frustum_size_end[0] = fog_far_size.x;
|
|
|
params.fog_frustum_size_end[1] = fog_far_size.y;
|
|
|
|
|
|
- params.z_near = z_near;
|
|
|
+ params.ambient_inject = env->volumetric_fog_ambient_inject * env->ambient_light_energy;
|
|
|
params.z_far = z_far;
|
|
|
|
|
|
params.fog_frustum_end = fog_end;
|
|
|
|
|
|
+ Color ambient_color = env->ambient_light.to_linear();
|
|
|
+ params.ambient_color[0] = ambient_color.r;
|
|
|
+ params.ambient_color[1] = ambient_color.g;
|
|
|
+ params.ambient_color[2] = ambient_color.b;
|
|
|
+ params.sky_contribution = env->ambient_sky_contribution;
|
|
|
+
|
|
|
params.fog_volume_size[0] = rb->volumetric_fog->width;
|
|
|
params.fog_volume_size[1] = rb->volumetric_fog->height;
|
|
|
params.fog_volume_size[2] = rb->volumetric_fog->depth;
|
|
|
|
|
|
params.directional_light_count = p_directional_light_count;
|
|
|
|
|
|
- Color light = env->volumetric_fog_light.to_linear();
|
|
|
- params.light_energy[0] = light.r * env->volumetric_fog_light_energy;
|
|
|
- params.light_energy[1] = light.g * env->volumetric_fog_light_energy;
|
|
|
- params.light_energy[2] = light.b * env->volumetric_fog_light_energy;
|
|
|
+ Color emission = env->volumetric_fog_emission.to_linear();
|
|
|
+ params.base_emission[0] = emission.r * env->volumetric_fog_emission_energy;
|
|
|
+ params.base_emission[1] = emission.g * env->volumetric_fog_emission_energy;
|
|
|
+ params.base_emission[2] = emission.b * env->volumetric_fog_emission_energy;
|
|
|
params.base_density = env->volumetric_fog_density;
|
|
|
|
|
|
+ Color base_scattering = env->volumetric_fog_scattering.to_linear();
|
|
|
+ params.base_scattering[0] = base_scattering.r;
|
|
|
+ params.base_scattering[1] = base_scattering.g;
|
|
|
+ params.base_scattering[2] = base_scattering.b;
|
|
|
+ params.phase_g = env->volumetric_fog_anisotropy;
|
|
|
+
|
|
|
params.detail_spread = env->volumetric_fog_detail_spread;
|
|
|
params.gi_inject = env->volumetric_fog_gi_inject;
|
|
|
|
|
|
@@ -3816,10 +4308,9 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
params.screen_size[1] = rb->height;
|
|
|
}
|
|
|
|
|
|
- /* Vector2 dssize = directional_shadow_get_size();
|
|
|
- push_constant.directional_shadow_pixel_size[0] = 1.0 / dssize.x;
|
|
|
- push_constant.directional_shadow_pixel_size[1] = 1.0 / dssize.y;
|
|
|
-*/
|
|
|
+ Basis sky_transform = env->sky_orientation;
|
|
|
+ sky_transform = sky_transform.inverse() * p_cam_transform.basis;
|
|
|
+ RendererStorageRD::store_transform_3x3(sky_transform, params.radiance_inverse_xform);
|
|
|
|
|
|
RD::get_singleton()->draw_command_begin_label("Render Volumetric Fog");
|
|
|
|
|
|
@@ -3828,33 +4319,32 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
|
|
|
RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
|
|
|
|
|
|
- bool use_filter = volumetric_fog_filter_active;
|
|
|
-
|
|
|
- RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.pipelines[using_sdfgi ? VOLUMETRIC_FOG_SHADER_DENSITY_WITH_SDFGI : VOLUMETRIC_FOG_SHADER_DENSITY]);
|
|
|
+ RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[using_sdfgi ? VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY_WITH_SDFGI : VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_DENSITY]);
|
|
|
|
|
|
- RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->uniform_set, 0);
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set, 0);
|
|
|
|
|
|
if (using_sdfgi) {
|
|
|
RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->sdfgi_uniform_set, 1);
|
|
|
}
|
|
|
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
|
|
|
+ RD::get_singleton()->compute_list_add_barrier(compute_list);
|
|
|
|
|
|
+ // Copy fog to history buffer
|
|
|
+ if (env->volumetric_fog_temporal_reprojection) {
|
|
|
+ RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_COPY]);
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->copy_uniform_set, 0);
|
|
|
+ RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
|
|
|
+ RD::get_singleton()->compute_list_add_barrier(compute_list);
|
|
|
+ }
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
|
|
|
|
- RD::get_singleton()->compute_list_end();
|
|
|
-
|
|
|
- RD::get_singleton()->texture_copy(rb->volumetric_fog->light_density_map, rb->volumetric_fog->prev_light_density_map, Vector3(0, 0, 0), Vector3(0, 0, 0), Vector3(rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth), 0, 0, 0, 0);
|
|
|
-
|
|
|
- compute_list = RD::get_singleton()->compute_list_begin();
|
|
|
-
|
|
|
- if (use_filter) {
|
|
|
+ if (volumetric_fog_filter_active) {
|
|
|
RD::get_singleton()->draw_command_begin_label("Filter Fog");
|
|
|
|
|
|
RENDER_TIMESTAMP("Filter Fog");
|
|
|
|
|
|
- RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.pipelines[VOLUMETRIC_FOG_SHADER_FILTER]);
|
|
|
- RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->uniform_set, 0);
|
|
|
-
|
|
|
+ RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FILTER]);
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set, 0);
|
|
|
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
|
|
|
|
|
|
RD::get_singleton()->compute_list_end();
|
|
|
@@ -3864,11 +4354,8 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
RD::get_singleton()->buffer_update(volumetric_fog.params_ubo, 0, sizeof(VolumetricFogShader::ParamsUBO), ¶ms);
|
|
|
|
|
|
compute_list = RD::get_singleton()->compute_list_begin();
|
|
|
- RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.pipelines[VOLUMETRIC_FOG_SHADER_FILTER]);
|
|
|
- RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->uniform_set2, 0);
|
|
|
- if (using_sdfgi) {
|
|
|
- RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->sdfgi_uniform_set, 1);
|
|
|
- }
|
|
|
+ RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FILTER]);
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set2, 0);
|
|
|
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, rb->volumetric_fog->depth);
|
|
|
|
|
|
RD::get_singleton()->compute_list_add_barrier(compute_list);
|
|
|
@@ -3878,14 +4365,15 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
|
|
|
RENDER_TIMESTAMP("Integrate Fog");
|
|
|
RD::get_singleton()->draw_command_begin_label("Integrate Fog");
|
|
|
|
|
|
- RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.pipelines[VOLUMETRIC_FOG_SHADER_FOG]);
|
|
|
- RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->uniform_set, 0);
|
|
|
+ RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, volumetric_fog.process_pipelines[VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_FOG]);
|
|
|
+ RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rb->volumetric_fog->process_uniform_set, 0);
|
|
|
RD::get_singleton()->compute_list_dispatch_threads(compute_list, rb->volumetric_fog->width, rb->volumetric_fog->height, 1);
|
|
|
|
|
|
RD::get_singleton()->compute_list_end(RD::BARRIER_MASK_RASTER);
|
|
|
|
|
|
RENDER_TIMESTAMP("<Volumetric Fog");
|
|
|
RD::get_singleton()->draw_command_end_label();
|
|
|
+ RD::get_singleton()->draw_command_end_label();
|
|
|
|
|
|
rb->volumetric_fog->prev_cam_transform = p_cam_transform;
|
|
|
}
|
|
|
@@ -4053,12 +4541,12 @@ void RendererSceneRenderRD::_pre_opaque_render(RenderDataRD *p_render_data, bool
|
|
|
}
|
|
|
}
|
|
|
if (is_volumetric_supported()) {
|
|
|
- _update_volumetric_fog(p_render_data->render_buffers, p_render_data->environment, p_render_data->cam_projection, p_render_data->cam_transform, p_render_data->shadow_atlas, directional_light_count, directional_shadows, positional_light_count, render_state.voxel_gi_count);
|
|
|
+ _update_volumetric_fog(p_render_data->render_buffers, p_render_data->environment, p_render_data->cam_projection, p_render_data->cam_transform, p_render_data->shadow_atlas, directional_light_count, directional_shadows, positional_light_count, render_state.voxel_gi_count, *p_render_data->fog_volumes);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
-void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData *p_camera_data, const PagedArray<GeometryInstance *> &p_instances, const PagedArray<RID> &p_lights, const PagedArray<RID> &p_reflection_probes, const PagedArray<RID> &p_voxel_gi_instances, const PagedArray<RID> &p_decals, const PagedArray<RID> &p_lightmaps, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_occluder_debug_tex, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold, const RenderShadowData *p_render_shadows, int p_render_shadow_count, const RenderSDFGIData *p_render_sdfgi_regions, int p_render_sdfgi_region_count, const RenderSDFGIUpdateData *p_sdfgi_update_data, RendererScene::RenderInfo *r_render_info) {
|
|
|
+void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData *p_camera_data, const PagedArray<GeometryInstance *> &p_instances, const PagedArray<RID> &p_lights, const PagedArray<RID> &p_reflection_probes, const PagedArray<RID> &p_voxel_gi_instances, const PagedArray<RID> &p_decals, const PagedArray<RID> &p_lightmaps, const PagedArray<RID> &p_fog_volumes, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_occluder_debug_tex, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold, const RenderShadowData *p_render_shadows, int p_render_shadow_count, const RenderSDFGIData *p_render_sdfgi_regions, int p_render_sdfgi_region_count, const RenderSDFGIUpdateData *p_sdfgi_update_data, RendererScene::RenderInfo *r_render_info) {
|
|
|
// getting this here now so we can direct call a bunch of things more easily
|
|
|
RenderBuffers *rb = nullptr;
|
|
|
if (p_render_buffers.is_valid()) {
|
|
|
@@ -4091,6 +4579,7 @@ void RendererSceneRenderRD::render_scene(RID p_render_buffers, const CameraData
|
|
|
render_data.voxel_gi_instances = &p_voxel_gi_instances;
|
|
|
render_data.decals = &p_decals;
|
|
|
render_data.lightmaps = &p_lightmaps;
|
|
|
+ render_data.fog_volumes = &p_fog_volumes;
|
|
|
render_data.environment = p_environment;
|
|
|
render_data.camera_effects = p_camera_effects;
|
|
|
render_data.shadow_atlas = p_shadow_atlas;
|
|
|
@@ -4512,7 +5001,8 @@ bool RendererSceneRenderRD::free(RID p_rid) {
|
|
|
} else if (shadow_atlas_owner.owns(p_rid)) {
|
|
|
shadow_atlas_set_size(p_rid, 0);
|
|
|
shadow_atlas_owner.free(p_rid);
|
|
|
-
|
|
|
+ } else if (fog_volume_instance_owner.owns(p_rid)) {
|
|
|
+ fog_volume_instance_owner.free(p_rid);
|
|
|
} else {
|
|
|
return false;
|
|
|
}
|
|
|
@@ -4753,18 +5243,124 @@ void RendererSceneRenderRD::init() {
|
|
|
}
|
|
|
|
|
|
if (is_volumetric_supported()) {
|
|
|
- String defines = "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(cluster.max_directional_lights) + "\n";
|
|
|
- Vector<String> volumetric_fog_modes;
|
|
|
- volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n");
|
|
|
- volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n#define ENABLE_SDFGI\n");
|
|
|
- volumetric_fog_modes.push_back("\n#define MODE_FILTER\n");
|
|
|
- volumetric_fog_modes.push_back("\n#define MODE_FOG\n");
|
|
|
- volumetric_fog.shader.initialize(volumetric_fog_modes, defines);
|
|
|
- volumetric_fog.shader_version = volumetric_fog.shader.version_create();
|
|
|
- for (int i = 0; i < VOLUMETRIC_FOG_SHADER_MAX; i++) {
|
|
|
- volumetric_fog.pipelines[i] = RD::get_singleton()->compute_pipeline_create(volumetric_fog.shader.version_get_shader(volumetric_fog.shader_version, i));
|
|
|
+ {
|
|
|
+ // Initialize local fog shader
|
|
|
+ Vector<String> volumetric_fog_modes;
|
|
|
+ volumetric_fog_modes.push_back("");
|
|
|
+ volumetric_fog.shader.initialize(volumetric_fog_modes);
|
|
|
+
|
|
|
+ storage->shader_set_data_request_function(RendererStorageRD::SHADER_TYPE_FOG, _create_fog_shader_funcs);
|
|
|
+ storage->material_set_data_request_function(RendererStorageRD::SHADER_TYPE_FOG, _create_fog_material_funcs);
|
|
|
+ volumetric_fog.volume_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::VolumeUBO));
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ ShaderCompilerRD::DefaultIdentifierActions actions;
|
|
|
+
|
|
|
+ actions.renames["TIME"] = "scene_params.time";
|
|
|
+ actions.renames["PI"] = _MKSTR(Math_PI);
|
|
|
+ actions.renames["TAU"] = _MKSTR(Math_TAU);
|
|
|
+ actions.renames["E"] = _MKSTR(Math_E);
|
|
|
+ actions.renames["WORLD_POSITION"] = "world.xyz";
|
|
|
+ actions.renames["OBJECT_POSITION"] = "params.position";
|
|
|
+ actions.renames["UVW"] = "uvw";
|
|
|
+ actions.renames["EXTENTS"] = "params.extents";
|
|
|
+ actions.renames["ALBEDO"] = "albedo";
|
|
|
+ actions.renames["DENSITY"] = "density";
|
|
|
+ actions.renames["EMISSION"] = "emission";
|
|
|
+ actions.renames["SDF"] = "sdf";
|
|
|
+
|
|
|
+ actions.usage_defines["SDF"] = "#define SDF_USED\n";
|
|
|
+ actions.usage_defines["DENSITY"] = "#define DENSITY_USED\n";
|
|
|
+ actions.usage_defines["ALBEDO"] = "#define ALBEDO_USED\n";
|
|
|
+ actions.usage_defines["EMISSION"] = "#define EMISSION_USED\n";
|
|
|
+
|
|
|
+ actions.sampler_array_name = "material_samplers";
|
|
|
+ actions.base_texture_binding_index = 1;
|
|
|
+ actions.texture_layout_set = VolumetricFogShader::FogSet::FOG_SET_MATERIAL;
|
|
|
+ actions.base_uniform_string = "material.";
|
|
|
+
|
|
|
+ actions.default_filter = ShaderLanguage::FILTER_LINEAR_MIPMAP;
|
|
|
+ actions.default_repeat = ShaderLanguage::REPEAT_DISABLE;
|
|
|
+ actions.global_buffer_array_variable = "global_variables.data";
|
|
|
+
|
|
|
+ volumetric_fog.compiler.initialize(actions);
|
|
|
+ }
|
|
|
+
|
|
|
+ {
|
|
|
+ // default material and shader for fog shader
|
|
|
+ volumetric_fog.default_shader = storage->shader_allocate();
|
|
|
+ storage->shader_initialize(volumetric_fog.default_shader);
|
|
|
+ storage->shader_set_code(volumetric_fog.default_shader, R"(
|
|
|
+// Default fog shader.
|
|
|
+
|
|
|
+shader_type fog;
|
|
|
+
|
|
|
+void fog() {
|
|
|
+ DENSITY = 1.0;
|
|
|
+ ALBEDO = vec3(1.0);
|
|
|
+}
|
|
|
+)");
|
|
|
+ volumetric_fog.default_material = storage->material_allocate();
|
|
|
+ storage->material_initialize(volumetric_fog.default_material);
|
|
|
+ storage->material_set_shader(volumetric_fog.default_material, volumetric_fog.default_shader);
|
|
|
+
|
|
|
+ FogMaterialData *md = (FogMaterialData *)storage->material_get_data(volumetric_fog.default_material, RendererStorageRD::SHADER_TYPE_FOG);
|
|
|
+ volumetric_fog.default_shader_rd = volumetric_fog.shader.version_get_shader(md->shader_data->version, 0);
|
|
|
+
|
|
|
+ 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.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
|
|
|
+ u.binding = 2;
|
|
|
+ u.ids.push_back(storage->global_variables_get_storage_buffer());
|
|
|
+ uniforms.push_back(u);
|
|
|
+ }
|
|
|
+
|
|
|
+ volumetric_fog.base_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, volumetric_fog.default_shader_rd, VolumetricFogShader::FogSet::FOG_SET_BASE);
|
|
|
+ }
|
|
|
+ {
|
|
|
+ String defines = "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(cluster.max_directional_lights) + "\n";
|
|
|
+ defines += "\n#define MAX_SKY_LOD " + itos(get_roughness_layers() - 1) + ".0\n";
|
|
|
+ if (is_using_radiance_cubemap_array()) {
|
|
|
+ defines += "\n#define USE_RADIANCE_CUBEMAP_ARRAY \n";
|
|
|
+ }
|
|
|
+ Vector<String> volumetric_fog_modes;
|
|
|
+ volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n");
|
|
|
+ volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n#define ENABLE_SDFGI\n");
|
|
|
+ volumetric_fog_modes.push_back("\n#define MODE_FILTER\n");
|
|
|
+ volumetric_fog_modes.push_back("\n#define MODE_FOG\n");
|
|
|
+ volumetric_fog_modes.push_back("\n#define MODE_COPY\n");
|
|
|
+
|
|
|
+ volumetric_fog.process_shader.initialize(volumetric_fog_modes, defines);
|
|
|
+ volumetric_fog.process_shader_version = volumetric_fog.process_shader.version_create();
|
|
|
+ for (int i = 0; i < VolumetricFogShader::VOLUMETRIC_FOG_PROCESS_SHADER_MAX; i++) {
|
|
|
+ volumetric_fog.process_pipelines[i] = RD::get_singleton()->compute_pipeline_create(volumetric_fog.process_shader.version_get_shader(volumetric_fog.process_shader_version, i));
|
|
|
+ }
|
|
|
+ volumetric_fog.params_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::ParamsUBO));
|
|
|
}
|
|
|
- volumetric_fog.params_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(VolumetricFogShader::ParamsUBO));
|
|
|
}
|
|
|
|
|
|
{
|
|
|
@@ -4815,9 +5411,14 @@ RendererSceneRenderRD::~RendererSceneRenderRD() {
|
|
|
|
|
|
if (is_dynamic_gi_supported()) {
|
|
|
gi.free();
|
|
|
+ }
|
|
|
|
|
|
- volumetric_fog.shader.version_free(volumetric_fog.shader_version);
|
|
|
+ if (is_volumetric_supported()) {
|
|
|
+ volumetric_fog.process_shader.version_free(volumetric_fog.process_shader_version);
|
|
|
+ RD::get_singleton()->free(volumetric_fog.volume_ubo);
|
|
|
RD::get_singleton()->free(volumetric_fog.params_ubo);
|
|
|
+ storage->free(volumetric_fog.default_shader);
|
|
|
+ storage->free(volumetric_fog.default_material);
|
|
|
}
|
|
|
|
|
|
RendererSceneSkyRD::SkyMaterialData *md = (RendererSceneSkyRD::SkyMaterialData *)storage->material_get_data(sky.sky_shader.default_material, RendererStorageRD::SHADER_TYPE_SKY);
|
Rémi Verschelde
