From 3765b334563bf7560c61c2c40bb766453f84143b Mon Sep 17 00:00:00 2001 From: Eidolon Date: Sun, 18 Sep 2022 00:31:43 -0500 Subject: [PATCH 1/2] Add optional depth fog to Environment --- drivers/gles3/rasterizer_scene_gles3.cpp | 9 +++ drivers/gles3/rasterizer_scene_gles3.h | 11 +++ drivers/gles3/shaders/scene.glsl | 31 ++++++++ scene/resources/environment.cpp | 74 +++++++++++++++++++ scene/resources/environment.h | 21 ++++++ .../render_forward_clustered.h | 1 + .../forward_mobile/render_forward_mobile.cpp | 4 + .../forward_mobile/render_forward_mobile.h | 1 + .../scene_forward_clustered.glsl | 9 +++ .../forward_mobile/scene_forward_mobile.glsl | 9 +++ .../renderer_rd/shaders/scene_data_inc.glsl | 15 +++- .../storage_rd/render_scene_data_rd.cpp | 6 ++ .../storage_rd/render_scene_data_rd.h | 15 +++- servers/rendering/renderer_scene.h | 9 +++ servers/rendering/renderer_scene_cull.h | 8 ++ servers/rendering/renderer_scene_render.cpp | 26 +++++++ servers/rendering/renderer_scene_render.h | 8 ++ servers/rendering/rendering_server_default.h | 1 + .../rendering/storage/environment_storage.cpp | 42 +++++++++++ .../rendering/storage/environment_storage.h | 15 ++++ servers/rendering_server.h | 1 + 21 files changed, 308 insertions(+), 8 deletions(-) diff --git a/drivers/gles3/rasterizer_scene_gles3.cpp b/drivers/gles3/rasterizer_scene_gles3.cpp index 1952efff0e1d..77d28b9dd73a 100644 --- a/drivers/gles3/rasterizer_scene_gles3.cpp +++ b/drivers/gles3/rasterizer_scene_gles3.cpp @@ -1444,6 +1444,11 @@ void RasterizerSceneGLES3::_setup_environment(const RenderDataGLES3 *p_render_da scene_state.ubo.fog_enabled = environment_get_fog_enabled(p_render_data->environment); scene_state.ubo.fog_density = environment_get_fog_density(p_render_data->environment); scene_state.ubo.fog_height = environment_get_fog_height(p_render_data->environment); + scene_state.ubo.fog_depth_enabled = environment_get_fog_depth_enabled(p_render_data->environment); + scene_state.ubo.fog_depth_curve = environment_get_fog_depth_curve(p_render_data->environment); + scene_state.ubo.fog_depth_density = environment_get_fog_depth_density(p_render_data->environment); + scene_state.ubo.fog_depth_begin = environment_get_fog_depth_begin(p_render_data->environment); + scene_state.ubo.fog_depth_end = environment_get_fog_depth_end(p_render_data->environment); scene_state.ubo.fog_height_density = environment_get_fog_height_density(p_render_data->environment); scene_state.ubo.fog_aerial_perspective = environment_get_fog_aerial_perspective(p_render_data->environment); @@ -1974,6 +1979,10 @@ void RasterizerSceneGLES3::render_scene(const Ref &p_render_ if (render_data.environment.is_null() || (render_data.environment.is_valid() && !environment_get_fog_enabled(render_data.environment))) { spec_constant_base_flags |= 1 << SPEC_CONSTANT_DISABLE_FOG; } + + if (render_data.environment.is_null() || (render_data.environment.is_valid() && environment_get_fog_enabled(render_data.environment) && !environment_get_fog_depth_enabled(render_data.environment))) { + spec_constant_base_flags |= 1 << SPEC_CONSTANT_DISABLE_FOG_DEPTH; + } } // Render Opaque Objects. RenderListParameters render_list_params(render_list[RENDER_LIST_OPAQUE].elements.ptr(), render_list[RENDER_LIST_OPAQUE].elements.size(), reverse_cull, spec_constant_base_flags, use_wireframe); diff --git a/drivers/gles3/rasterizer_scene_gles3.h b/drivers/gles3/rasterizer_scene_gles3.h index d264284ef799..f6e280e49836 100644 --- a/drivers/gles3/rasterizer_scene_gles3.h +++ b/drivers/gles3/rasterizer_scene_gles3.h @@ -89,6 +89,7 @@ enum { SPEC_CONSTANT_DISABLE_OMNI_LIGHTS = 2, SPEC_CONSTANT_DISABLE_SPOT_LIGHTS = 3, SPEC_CONSTANT_DISABLE_FOG = 4, + SPEC_CONSTANT_DISABLE_FOG_DEPTH = 5, }; struct RenderDataGLES3 { @@ -366,8 +367,18 @@ class RasterizerSceneGLES3 : public RendererSceneRender { float fog_height; float fog_height_density; + uint32_t fog_depth_enabled; + float fog_depth_curve; + float fog_depth_density; + float fog_depth_begin; + float fog_light_color[3]; + float fog_depth_end; + float fog_sun_scatter; + float pad1; + float pad3; + float pad4; }; static_assert(sizeof(UBO) % 16 == 0, "Scene UBO size must be a multiple of 16 bytes"); diff --git a/drivers/gles3/shaders/scene.glsl b/drivers/gles3/shaders/scene.glsl index efd6036ba9ea..552721bbe9df 100644 --- a/drivers/gles3/shaders/scene.glsl +++ b/drivers/gles3/shaders/scene.glsl @@ -15,6 +15,7 @@ DISABLE_LIGHT_DIRECTIONAL = false DISABLE_LIGHT_OMNI = false DISABLE_LIGHT_SPOT = false DISABLE_FOG = false +DISABLE_FOG_DEPTH = false USE_RADIANCE_MAP = true @@ -148,8 +149,18 @@ layout(std140) uniform SceneData { // ubo:2 float fog_height; float fog_height_density; + bool fog_depth_enabled; + float fog_depth_curve; + float fog_depth_density; + float fog_depth_begin; + vec3 fog_light_color; + float fog_depth_end; + float fog_sun_scatter; + float pad1; + float pad3; + float pad4; } scene_data; @@ -458,8 +469,18 @@ layout(std140) uniform SceneData { // ubo:2 float fog_height; float fog_height_density; + bool fog_depth_enabled; + float fog_depth_curve; + float fog_depth_density; + float fog_depth_begin; + vec3 fog_light_color; + float fog_depth_end; + float fog_sun_scatter; + float pad1; + float pad3; + float pad4; } scene_data; @@ -866,6 +887,16 @@ vec4 fog_process(vec3 vertex) { float fog_amount = 1.0 - exp(min(0.0, -length(vertex) * scene_data.fog_density)); +#ifndef DISABLE_FOG_DEPTH + if (scene_data.fog_depth_enabled) { + float fog_far = scene_data.fog_depth_end > 0.0 ? scene_data.fog_depth_end : scene_data.z_far; + float fog_z = smoothstep(scene_data.fog_depth_begin, fog_far, length(vertex)); + + float fog_quad_amount = pow(fog_z, scene_data.fog_depth_curve) * scene_data.fog_depth_density; + fog_amount = max(fog_quad_amount, fog_amount); + } +#endif + if (abs(scene_data.fog_height_density) >= 0.0001) { float y = (scene_data.inv_view_matrix * vec4(vertex, 1.0)).y; diff --git a/scene/resources/environment.cpp b/scene/resources/environment.cpp index ebdaaaa95faf..0286adaec0c1 100644 --- a/scene/resources/environment.cpp +++ b/scene/resources/environment.cpp @@ -841,6 +841,63 @@ void Environment::_update_fog() { fog_sky_affect); } +// Depth Fog + +void Environment::set_fog_depth_enabled(bool p_enabled) { + fog_depth_enabled = p_enabled; + _update_fog_depth(); +} + +bool Environment::is_fog_depth_enabled() const { + return fog_depth_enabled; +} + +void Environment::set_fog_depth_curve(float p_curve) { + fog_depth_curve = p_curve; + _update_fog_depth(); +} + +float Environment::get_fog_depth_curve() const { + return fog_depth_curve; +} + +void Environment::set_fog_depth_density(float p_density) { + fog_depth_density = p_density; + _update_fog_depth(); +} + +float Environment::get_fog_depth_density() const { + return fog_depth_density; +} + +void Environment::set_fog_depth_begin(float p_begin) { + fog_depth_begin = p_begin; + _update_fog_depth(); +} + +float Environment::get_fog_depth_begin() const { + return fog_depth_begin; +} + +void Environment::set_fog_depth_end(float p_end) { + fog_depth_end = p_end; + _update_fog_depth(); +} + +float Environment::get_fog_depth_end() const { + return fog_depth_end; +} + +void Environment::_update_fog_depth() { + RS::get_singleton()->environment_set_fog_depth( + environment, + fog_depth_enabled, + fog_depth_curve, + fog_depth_density, + fog_depth_begin, + fog_depth_end); +} + // Volumetric Fog void Environment::_update_volumetric_fog() { @@ -1411,6 +1468,17 @@ void Environment::_bind_methods() { ClassDB::bind_method(D_METHOD("set_fog_sky_affect", "sky_affect"), &Environment::set_fog_sky_affect); ClassDB::bind_method(D_METHOD("get_fog_sky_affect"), &Environment::get_fog_sky_affect); + ClassDB::bind_method(D_METHOD("set_fog_depth_enabled", "enabled"), &Environment::set_fog_depth_enabled); + ClassDB::bind_method(D_METHOD("is_fog_depth_enabled"), &Environment::is_fog_depth_enabled); + ClassDB::bind_method(D_METHOD("set_fog_depth_curve", "curve"), &Environment::set_fog_depth_curve); + ClassDB::bind_method(D_METHOD("get_fog_depth_curve"), &Environment::get_fog_depth_curve); + ClassDB::bind_method(D_METHOD("set_fog_depth_density", "density"), &Environment::set_fog_depth_density); + ClassDB::bind_method(D_METHOD("get_fog_depth_density"), &Environment::get_fog_depth_density); + ClassDB::bind_method(D_METHOD("set_fog_depth_begin", "begin"), &Environment::set_fog_depth_begin); + ClassDB::bind_method(D_METHOD("get_fog_depth_begin"), &Environment::get_fog_depth_begin); + ClassDB::bind_method(D_METHOD("set_fog_depth_end", "end"), &Environment::set_fog_depth_end); + ClassDB::bind_method(D_METHOD("get_fog_depth_end"), &Environment::get_fog_depth_end); + ADD_GROUP("Fog", "fog_"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_enabled"), "set_fog_enabled", "is_fog_enabled"); ADD_PROPERTY(PropertyInfo(Variant::COLOR, "fog_light_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_fog_light_color", "get_fog_light_color"); @@ -1423,6 +1491,12 @@ void Environment::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height", PROPERTY_HINT_RANGE, "-1024,1024,0.01,or_less,or_greater,suffix:m"), "set_fog_height", "get_fog_height"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height_density", PROPERTY_HINT_RANGE, "-16,16,0.0001,or_less,or_greater"), "set_fog_height_density", "get_fog_height_density"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_depth_enabled"), "set_fog_depth_enabled", "is_fog_depth_enabled"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_depth_curve", PROPERTY_HINT_EXP_EASING), "set_fog_depth_curve", "get_fog_depth_curve"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_depth_density", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_fog_depth_density", "get_fog_depth_density"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_depth_begin", PROPERTY_HINT_RANGE, "0,4000,0.1"), "set_fog_depth_begin", "get_fog_depth_begin"); + ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_depth_end", PROPERTY_HINT_RANGE, "0,4000,0.1,or_greater"), "set_fog_depth_end", "get_fog_depth_end"); + ClassDB::bind_method(D_METHOD("set_volumetric_fog_enabled", "enabled"), &Environment::set_volumetric_fog_enabled); ClassDB::bind_method(D_METHOD("is_volumetric_fog_enabled"), &Environment::is_volumetric_fog_enabled); ClassDB::bind_method(D_METHOD("set_volumetric_fog_emission", "color"), &Environment::set_volumetric_fog_emission); diff --git a/scene/resources/environment.h b/scene/resources/environment.h index 507a0cee3910..29dc7c3420a7 100644 --- a/scene/resources/environment.h +++ b/scene/resources/environment.h @@ -183,6 +183,15 @@ class Environment : public Resource { void _update_fog(); + // Depth Fog + bool fog_depth_enabled = false; + float fog_depth_curve = 1.0; + float fog_depth_density = 1.0; + float fog_depth_begin = 10.0; + float fog_depth_end = 100.0; + + void _update_fog_depth(); + // Volumetric Fog bool volumetric_fog_enabled = false; float volumetric_fog_density = 0.05; @@ -379,6 +388,18 @@ class Environment : public Resource { void set_fog_sky_affect(float p_sky_affect); float get_fog_sky_affect() const; + // Depth Fog + void set_fog_depth_enabled(bool p_enabled); + bool is_fog_depth_enabled() const; + void set_fog_depth_curve(float p_curve); + float get_fog_depth_curve() const; + void set_fog_depth_density(float p_density); + float get_fog_depth_density() const; + void set_fog_depth_begin(float p_begin); + float get_fog_depth_begin() const; + void set_fog_depth_end(float p_end); + float get_fog_depth_end() const; + // Volumetric Fog void set_volumetric_fog_enabled(bool p_enable); bool is_volumetric_fog_enabled() const; diff --git a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.h b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.h index 16f6da34f8ad..2942d90c2c7d 100644 --- a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.h +++ b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.h @@ -68,6 +68,7 @@ class RenderForwardClustered : public RendererSceneRenderRD { SPEC_CONSTANT_DIRECTIONAL_PENUMBRA_SHADOW_SAMPLES = 9, SPEC_CONSTANT_DECAL_FILTER = 10, SPEC_CONSTANT_PROJECTOR_FILTER = 11, + SPEC_CONSTANT_DISABLE_FOG_DEPTH = 12, }; enum { diff --git a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp index a6512497a39a..489d36258033 100644 --- a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp +++ b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp @@ -732,6 +732,10 @@ void RenderForwardMobile::_render_scene(RenderDataRD *p_render_data, const Color if (!is_environment(p_render_data->environment) || environment_get_fog_enabled(p_render_data->environment)) { spec_constant_base_flags |= 1 << SPEC_CONSTANT_DISABLE_FOG; } + + if (!is_environment(p_render_data->environment) || !environment_get_fog_enabled(p_render_data->environment) || !environment_get_fog_depth_enabled(p_render_data->environment)) { + spec_constant_base_flags |= 1 << SPEC_CONSTANT_DISABLE_FOG_DEPTH; + } } { if (rb_data.is_valid()) { diff --git a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.h b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.h index 04b2b3ce18b7..743f141d2cde 100644 --- a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.h +++ b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.h @@ -87,6 +87,7 @@ class RenderForwardMobile : public RendererSceneRenderRD { SPEC_CONSTANT_DISABLE_DECALS = 13, SPEC_CONSTANT_DISABLE_FOG = 14, + SPEC_CONSTANT_DISABLE_FOG_DEPTH = 16, }; diff --git a/servers/rendering/renderer_rd/shaders/forward_clustered/scene_forward_clustered.glsl b/servers/rendering/renderer_rd/shaders/forward_clustered/scene_forward_clustered.glsl index d41474118d46..f7be5452dd71 100644 --- a/servers/rendering/renderer_rd/shaders/forward_clustered/scene_forward_clustered.glsl +++ b/servers/rendering/renderer_rd/shaders/forward_clustered/scene_forward_clustered.glsl @@ -432,6 +432,7 @@ layout(constant_id = 9) const uint sc_directional_penumbra_shadow_samples = 4; layout(constant_id = 10) const bool sc_decal_use_mipmaps = true; layout(constant_id = 11) const bool sc_projector_use_mipmaps = true; +layout(constant_id = 12) const bool sc_disable_fog_depth = false; // not used in clustered renderer but we share some code with the mobile renderer that requires this. const float sc_luminance_multiplier = 1.0; @@ -614,6 +615,14 @@ vec4 fog_process(vec3 vertex) { float fog_amount = 1.0 - exp(min(0.0, -length(vertex) * scene_data_block.data.fog_density)); + if (!sc_disable_fog_depth && scene_data_block.data.fog_depth_enabled) { + float fog_far = scene_data_block.data.fog_depth_end > 0.0 ? scene_data_block.data.fog_depth_end : scene_data_block.data.z_far; + float fog_z = smoothstep(scene_data_block.data.fog_depth_begin, fog_far, length(vertex)); + + float fog_quad_amount = pow(fog_z, scene_data_block.data.fog_depth_curve) * scene_data_block.data.fog_depth_density; + fog_amount = max(fog_quad_amount, fog_amount); + } + if (abs(scene_data_block.data.fog_height_density) >= 0.0001) { float y = (scene_data_block.data.inv_view_matrix * vec4(vertex, 1.0)).y; diff --git a/servers/rendering/renderer_rd/shaders/forward_mobile/scene_forward_mobile.glsl b/servers/rendering/renderer_rd/shaders/forward_mobile/scene_forward_mobile.glsl index a109fd4d75df..40b7d4fcb3d2 100644 --- a/servers/rendering/renderer_rd/shaders/forward_mobile/scene_forward_mobile.glsl +++ b/servers/rendering/renderer_rd/shaders/forward_mobile/scene_forward_mobile.glsl @@ -415,6 +415,7 @@ layout(constant_id = 12) const bool sc_disable_directional_lights = false; layout(constant_id = 7) const bool sc_decal_use_mipmaps = true; layout(constant_id = 13) const bool sc_disable_decals = false; layout(constant_id = 14) const bool sc_disable_fog = false; +layout(constant_id = 16) const bool sc_disable_fog_depth = false; #endif //!MODE_RENDER_DEPTH @@ -571,6 +572,14 @@ vec4 fog_process(vec3 vertex) { float fog_amount = 1.0 - exp(min(0.0, -length(vertex) * scene_data_block.data.fog_density)); + if (!sc_disable_fog_depth && scene_data_block.data.fog_depth_enabled) { + float fog_far = scene_data_block.data.fog_depth_end > 0.0 ? scene_data_block.data.fog_depth_end : scene_data_block.data.z_far; + float fog_z = smoothstep(scene_data_block.data.fog_depth_begin, fog_far, length(vertex)); + + float fog_quad_amount = pow(fog_z, scene_data_block.data.fog_depth_curve) * scene_data_block.data.fog_depth_density; + fog_amount = max(fog_quad_amount, fog_amount); + } + if (abs(scene_data_block.data.fog_height_density) >= 0.0001) { float y = (scene_data_block.data.inv_view_matrix * vec4(vertex, 1.0)).y; diff --git a/servers/rendering/renderer_rd/shaders/scene_data_inc.glsl b/servers/rendering/renderer_rd/shaders/scene_data_inc.glsl index 048257e9ef93..8f15dfc62aa7 100644 --- a/servers/rendering/renderer_rd/shaders/scene_data_inc.glsl +++ b/servers/rendering/renderer_rd/shaders/scene_data_inc.glsl @@ -50,20 +50,27 @@ struct SceneData { highp float fog_height; highp float fog_height_density; + bool fog_depth_enabled; + highp float fog_depth_curve; + highp float fog_depth_density; + highp float fog_depth_begin; + mediump vec3 fog_light_color; - mediump float fog_sun_scatter; + highp float fog_depth_end; + mediump float fog_sun_scatter; mediump float fog_aerial_perspective; highp float time; mediump float reflection_multiplier; // one normally, zero when rendering reflections - bool material_uv2_mode; vec2 taa_jitter; + bool material_uv2_mode; float emissive_exposure_normalization; - float IBL_exposure_normalization; + float IBL_exposure_normalization; bool pancake_shadows; uint pad1; uint pad2; - uint pad3; + + vec4 pad3; }; diff --git a/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.cpp b/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.cpp index f925f87cbe7d..75866436f20c 100644 --- a/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.cpp +++ b/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.cpp @@ -163,6 +163,12 @@ void RenderSceneDataRD::update_ubo(RID p_uniform_buffer, RS::ViewportDebugDraw p ubo.fog_height_density = render_scene_render->environment_get_fog_height_density(p_env); ubo.fog_aerial_perspective = render_scene_render->environment_get_fog_aerial_perspective(p_env); + ubo.fog_depth_enabled = render_scene_render->environment_get_fog_depth_enabled(p_env); + ubo.fog_depth_curve = render_scene_render->environment_get_fog_depth_curve(p_env); + ubo.fog_depth_density = render_scene_render->environment_get_fog_depth_density(p_env); + ubo.fog_depth_begin = render_scene_render->environment_get_fog_depth_begin(p_env); + ubo.fog_depth_end = render_scene_render->environment_get_fog_depth_end(p_env); + Color fog_color = render_scene_render->environment_get_fog_light_color(p_env).srgb_to_linear(); float fog_energy = render_scene_render->environment_get_fog_light_energy(p_env); diff --git a/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.h b/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.h index c2dc7d5f4cca..27a0149fbead 100644 --- a/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.h +++ b/servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.h @@ -130,22 +130,29 @@ class RenderSceneDataRD { float fog_height; float fog_height_density; + uint32_t fog_depth_enabled; + float fog_depth_curve; + float fog_depth_density; + float fog_depth_begin; + float fog_light_color[3]; - float fog_sun_scatter; + float fog_depth_end; + float fog_sun_scatter; float fog_aerial_perspective; float time; float reflection_multiplier; - uint32_t material_uv2_mode; float taa_jitter[2]; + uint32_t material_uv2_mode; float emissive_exposure_normalization; // Needed to normalize emissive when using physical units. - float IBL_exposure_normalization; // Adjusts for baked exposure. + float IBL_exposure_normalization; // Adjusts for baked exposure. uint32_t pancake_shadows; uint32_t pad1; uint32_t pad2; - uint32_t pad3; + + float pad3[4]; }; struct UBODATA { diff --git a/servers/rendering/renderer_scene.h b/servers/rendering/renderer_scene.h index 29c65fcffba7..133b1f733111 100644 --- a/servers/rendering/renderer_scene.h +++ b/servers/rendering/renderer_scene.h @@ -167,6 +167,15 @@ class RendererScene { virtual float environment_get_fog_aerial_perspective(RID p_env) const = 0; virtual float environment_get_fog_sky_affect(RID p_env) const = 0; + // Depth Fog + virtual void environment_set_fog_depth(RID p_env, bool p_enable, float p_curve, float p_density, float p_begin, float p_end) = 0; + + virtual bool environment_get_fog_depth_enabled(RID p_env) const = 0; + virtual float environment_get_fog_depth_curve(RID p_env) const = 0; + virtual float environment_get_fog_depth_density(RID p_env) const = 0; + virtual float environment_get_fog_depth_begin(RID p_env) const = 0; + virtual float environment_get_fog_depth_end(RID p_env) const = 0; + // Volumetric Fog virtual void 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, float p_sky_affect) = 0; diff --git a/servers/rendering/renderer_scene_cull.h b/servers/rendering/renderer_scene_cull.h index c799553f8743..85e2f051807a 100644 --- a/servers/rendering/renderer_scene_cull.h +++ b/servers/rendering/renderer_scene_cull.h @@ -1140,6 +1140,14 @@ class RendererSceneCull : public RendererScene { PASS2(environment_set_volumetric_fog_volume_size, int, int) PASS1(environment_set_volumetric_fog_filter_active, bool) + // Depth Fog + PASS6(environment_set_fog_depth, RID, bool, float, float, float, float) + PASS1RC(bool, environment_get_fog_depth_enabled, RID) + PASS1RC(float, environment_get_fog_depth_curve, RID) + PASS1RC(float, environment_get_fog_depth_density, RID) + PASS1RC(float, environment_get_fog_depth_begin, RID) + PASS1RC(float, environment_get_fog_depth_end, RID) + // Volumentric Fog PASS14(environment_set_volumetric_fog, RID, bool, float, const Color &, const Color &, float, float, float, float, float, bool, float, float, float) diff --git a/servers/rendering/renderer_scene_render.cpp b/servers/rendering/renderer_scene_render.cpp index f085168df325..f1b2f3e81404 100644 --- a/servers/rendering/renderer_scene_render.cpp +++ b/servers/rendering/renderer_scene_render.cpp @@ -348,6 +348,32 @@ float RendererSceneRender::environment_get_fog_aerial_perspective(RID p_env) con return environment_storage.environment_get_fog_aerial_perspective(p_env); } +// Depth Fog + +void RendererSceneRender::environment_set_fog_depth(RID p_env, bool p_enable, float p_curve, float p_density, float p_begin, float p_end) { + environment_storage.environment_set_fog_depth(p_env, p_enable, p_curve, p_density, p_begin, p_end); +} + +bool RendererSceneRender::environment_get_fog_depth_enabled(RID p_env) const { + return environment_storage.environment_get_fog_depth_enabled(p_env); +} + +float RendererSceneRender::environment_get_fog_depth_curve(RID p_env) const { + return environment_storage.environment_get_fog_depth_curve(p_env); +} + +float RendererSceneRender::environment_get_fog_depth_density(RID p_env) const { + return environment_storage.environment_get_fog_depth_density(p_env); +} + +float RendererSceneRender::environment_get_fog_depth_begin(RID p_env) const { + return environment_storage.environment_get_fog_depth_begin(p_env); +} + +float RendererSceneRender::environment_get_fog_depth_end(RID p_env) const { + return environment_storage.environment_get_fog_depth_end(p_env); +} + // Volumetric Fog void RendererSceneRender::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, float p_sky_affect) { diff --git a/servers/rendering/renderer_scene_render.h b/servers/rendering/renderer_scene_render.h index 9aa41084125b..419949aa0d6f 100644 --- a/servers/rendering/renderer_scene_render.h +++ b/servers/rendering/renderer_scene_render.h @@ -138,6 +138,14 @@ class RendererSceneRender { float environment_get_fog_height_density(RID p_env) const; float environment_get_fog_aerial_perspective(RID p_env) const; + // Depth Fog + void environment_set_fog_depth(RID p_env, bool p_enable, float p_curve, float p_density, float p_begin, float p_end); + bool environment_get_fog_depth_enabled(RID p_env) const; + float environment_get_fog_depth_curve(RID p_env) const; + float environment_get_fog_depth_density(RID p_env) const; + float environment_get_fog_depth_begin(RID p_env) const; + float environment_get_fog_depth_end(RID p_env) const; + // Volumetric Fog void 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, float p_sky_affect); bool environment_get_volumetric_fog_enabled(RID p_env) const; diff --git a/servers/rendering/rendering_server_default.h b/servers/rendering/rendering_server_default.h index dfe16431bdd0..6be931854136 100644 --- a/servers/rendering/rendering_server_default.h +++ b/servers/rendering/rendering_server_default.h @@ -696,6 +696,7 @@ class RenderingServerDefault : public RenderingServer { FUNC7(environment_set_adjustment, RID, bool, float, float, float, bool, RID) FUNC10(environment_set_fog, RID, bool, const Color &, float, float, float, float, float, float, float) + FUNC6(environment_set_fog_depth, RID, bool, float, float, float, float) FUNC14(environment_set_volumetric_fog, RID, bool, float, const Color &, const Color &, float, float, float, float, float, bool, float, float, float) FUNC2(environment_set_volumetric_fog_volume_size, int, int) diff --git a/servers/rendering/storage/environment_storage.cpp b/servers/rendering/storage/environment_storage.cpp index 9b1842f1d9aa..44c2119eaf14 100644 --- a/servers/rendering/storage/environment_storage.cpp +++ b/servers/rendering/storage/environment_storage.cpp @@ -273,6 +273,48 @@ float RendererEnvironmentStorage::environment_get_fog_sky_affect(RID p_env) cons return env->fog_sky_affect; } +// Depth Fog + +void RendererEnvironmentStorage::environment_set_fog_depth(RID p_env, bool p_enable, float p_curve, float p_density, float p_begin, float p_end) { + Environment *env = environment_owner.get_or_null(p_env); + ERR_FAIL_COND(!env); + env->fog_depth_enabled = p_enable; + env->fog_depth_curve = p_curve; + env->fog_depth_density = p_density; + env->fog_depth_begin = p_begin; + env->fog_depth_end = p_end; +} + +bool RendererEnvironmentStorage::environment_get_fog_depth_enabled(RID p_env) const { + Environment *env = environment_owner.get_or_null(p_env); + ERR_FAIL_COND_V(!env, 0.0); + return env->fog_depth_enabled; +} + +float RendererEnvironmentStorage::environment_get_fog_depth_curve(RID p_env) const { + Environment *env = environment_owner.get_or_null(p_env); + ERR_FAIL_COND_V(!env, 0.0); + return env->fog_depth_curve; +} + +float RendererEnvironmentStorage::environment_get_fog_depth_density(RID p_env) const { + Environment *env = environment_owner.get_or_null(p_env); + ERR_FAIL_COND_V(!env, 0.0); + return env->fog_depth_density; +} + +float RendererEnvironmentStorage::environment_get_fog_depth_begin(RID p_env) const { + Environment *env = environment_owner.get_or_null(p_env); + ERR_FAIL_COND_V(!env, 0.0); + return env->fog_depth_begin; +} + +float RendererEnvironmentStorage::environment_get_fog_depth_end(RID p_env) const { + Environment *env = environment_owner.get_or_null(p_env); + ERR_FAIL_COND_V(!env, 0.0); + return env->fog_depth_end; +} + // Volumetric Fog void RendererEnvironmentStorage::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, float p_sky_affect) { diff --git a/servers/rendering/storage/environment_storage.h b/servers/rendering/storage/environment_storage.h index 17bde9490293..57c8835ceb10 100644 --- a/servers/rendering/storage/environment_storage.h +++ b/servers/rendering/storage/environment_storage.h @@ -71,6 +71,13 @@ class RendererEnvironmentStorage { float fog_height_density = 0.0; //can be negative to invert effect float fog_aerial_perspective = 0.0; + // Depth Fog + bool fog_depth_enabled = false; + float fog_depth_curve = 1.0; + float fog_depth_density = 1.0; + float fog_depth_begin = 10.0; + float fog_depth_end = 100.0; + // Volumetric Fog bool volumetric_fog_enabled = false; float volumetric_fog_density = 0.01; @@ -203,6 +210,14 @@ class RendererEnvironmentStorage { float environment_get_fog_height_density(RID p_env) const; float environment_get_fog_aerial_perspective(RID p_env) const; + // Depth Fog + void environment_set_fog_depth(RID p_env, bool p_enable, float p_curve, float p_density, float p_begin, float p_end); + bool environment_get_fog_depth_enabled(RID p_env) const; + float environment_get_fog_depth_curve(RID p_env) const; + float environment_get_fog_depth_density(RID p_env) const; + float environment_get_fog_depth_begin(RID p_env) const; + float environment_get_fog_depth_end(RID p_env) const; + // Volumetric Fog void 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, float p_sky_affect); bool environment_get_volumetric_fog_enabled(RID p_env) const; diff --git a/servers/rendering_server.h b/servers/rendering_server.h index 67ba407775ae..61c0fe6448fb 100644 --- a/servers/rendering_server.h +++ b/servers/rendering_server.h @@ -1121,6 +1121,7 @@ class RenderingServer : public Object { virtual void environment_set_sdfgi_frames_to_update_light(EnvironmentSDFGIFramesToUpdateLight p_update) = 0; virtual void environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_aerial_perspective, float p_sky_affect) = 0; + virtual void environment_set_fog_depth(RID p_env, bool p_enable, float p_curve, float p_density, float p_begin, float p_end) = 0; virtual void 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, float p_sky_affect) = 0; virtual void environment_set_volumetric_fog_volume_size(int p_size, int p_depth) = 0; From 8d2fe22cdcd1c89734cfaab8548f97bf0db9234c Mon Sep 17 00:00:00 2001 From: Eidolon Date: Mon, 19 Sep 2022 07:13:34 -0500 Subject: [PATCH 2/2] Add depth fog properties to Environment docs --- doc/classes/Environment.xml | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/doc/classes/Environment.xml b/doc/classes/Environment.xml index 34a639d2de0c..9cde581518bb 100644 --- a/doc/classes/Environment.xml +++ b/doc/classes/Environment.xml @@ -88,6 +88,21 @@ The [i]exponential[/i] fog density to use. Higher values result in a more dense fog. Fog rendering is exponential as in real life. + + The fog's depth starting distance from the camera. + + + The fog depth's intensity curve. A number of presets are available in the Inspector by right-clicking the curve. + + + The maximum intensity of the depth fog effect. + + + If [code]true[/code], the depth fog effect is enabled. When enabled, fog will appear in the distance (relative to the camera). + + + The fog's depth end distance from the camera. If this value is set to 0, it will be equal to the current camera's Camera.far value. + If [code]true[/code], fog effects are enabled.