From 6995b6a03eb433be7f76ef3355c562a7833b6f3d Mon Sep 17 00:00:00 2001 From: Wagner Date: Sat, 30 Nov 2024 00:50:45 -0300 Subject: [PATCH] Allow changing the anisotropic filter level at run-time per Viewport --- doc/classes/ProjectSettings.xml | 5 ++-- .../RenderSceneBuffersConfiguration.xml | 3 ++ doc/classes/RenderSceneBuffersExtension.xml | 7 +++++ doc/classes/RenderingServer.xml | 29 +++++++++++++++++++ doc/classes/Viewport.xml | 24 +++++++++++++++ .../storage/render_scene_buffers_gles3.cpp | 1 + .../storage/render_scene_buffers_gles3.h | 1 + editor/plugins/node_3d_editor_plugin.cpp | 3 ++ scene/main/viewport.cpp | 27 +++++++++++++++++ scene/main/viewport.h | 14 +++++++++ .../storage_rd/material_storage.cpp | 4 +-- .../renderer_rd/storage_rd/material_storage.h | 2 +- .../storage_rd/render_scene_buffers_rd.cpp | 9 +++++- .../storage_rd/render_scene_buffers_rd.h | 2 ++ servers/rendering/renderer_viewport.cpp | 9 ++++++ servers/rendering/renderer_viewport.h | 2 ++ servers/rendering/rendering_server_default.h | 1 + .../storage/render_scene_buffers.cpp | 9 ++++++ .../rendering/storage/render_scene_buffers.h | 7 +++++ servers/rendering_server.cpp | 10 ++++++- servers/rendering_server.h | 11 +++++++ 21 files changed, 173 insertions(+), 7 deletions(-) diff --git a/doc/classes/ProjectSettings.xml b/doc/classes/ProjectSettings.xml index 91961fcf02b..95fee207e89 100644 --- a/doc/classes/ProjectSettings.xml +++ b/doc/classes/ProjectSettings.xml @@ -2905,8 +2905,9 @@ Sets the maximum number of samples to take when using anisotropic filtering on textures (as a power of two). A higher sample count will result in sharper textures at oblique angles, but is more expensive to compute. A value of [code]0[/code] forcibly disables anisotropic filtering, even on materials where it is enabled. The anisotropic filtering level also affects decals and light projectors if they are configured to use anisotropic filtering. See [member rendering/textures/decals/filter] and [member rendering/textures/light_projectors/filter]. - [b]Note:[/b] For performance reasons, anisotropic filtering [i]is not enabled by default[/i] on 2D and 3D materials. For this setting to have an effect in 3D, set [member BaseMaterial3D.texture_filter] to [constant BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on materials. For this setting to have an effect in 2D, set [member CanvasItem.texture_filter] to [constant CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on the [CanvasItem] node displaying the texture (or in [CanvasTexture]). However, anisotropic filtering is rarely useful in 2D, so only enable it for textures in 2D if it makes a meaningful visual difference. - [b]Note:[/b] This property is only read when the project starts. There is currently no way to change this setting at run-time. + [b]Note:[/b] In 3D, for this setting to have an effect, set [member BaseMaterial3D.texture_filter] to [constant BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on materials. + [b]Note:[/b] In 2D, for this setting to have an effect, set [member CanvasItem.texture_filter] to [constant CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on the [CanvasItem] node displaying the texture (or in [CanvasTexture]). However, anisotropic filtering is rarely useful in 2D, so only enable it for textures in 2D if it makes a meaningful visual difference. + [b]Note:[/b] This property is only read when the project starts. To change the anisotropic filtering level at runtime, set [member Viewport.anisotropic_filtering_level] on the root [Viewport] instead. Affects the final texture sharpness by reading from a lower or higher mipmap (also called "texture LOD bias"). Negative values make mipmapped textures sharper but grainier when viewed at a distance, while positive values make mipmapped textures blurrier (even when up close). diff --git a/doc/classes/RenderSceneBuffersConfiguration.xml b/doc/classes/RenderSceneBuffersConfiguration.xml index cb369552060..b5c37f3288f 100644 --- a/doc/classes/RenderSceneBuffersConfiguration.xml +++ b/doc/classes/RenderSceneBuffersConfiguration.xml @@ -9,6 +9,9 @@ + + Level of the anisotropic filter. + FSR Sharpness applicable if FSR upscaling is used. diff --git a/doc/classes/RenderSceneBuffersExtension.xml b/doc/classes/RenderSceneBuffersExtension.xml index f9960f0fbe4..fa3efbcaa0e 100644 --- a/doc/classes/RenderSceneBuffersExtension.xml +++ b/doc/classes/RenderSceneBuffersExtension.xml @@ -16,6 +16,13 @@ Implement this in GDExtension to handle the (re)sizing of a viewport. + + + + + Implement this in GDExtension to change the anisotropic filtering level. + + diff --git a/doc/classes/RenderingServer.xml b/doc/classes/RenderingServer.xml index 6be53b336b4..ac11c51806a 100644 --- a/doc/classes/RenderingServer.xml +++ b/doc/classes/RenderingServer.xml @@ -3842,6 +3842,17 @@ If [code]true[/code], sets the viewport active, else sets it inactive. + + + + + + Sets the maximum number of samples to take when using anisotropic filtering on textures (as a power of two). A higher sample count will result in sharper textures at oblique angles, but is more expensive to compute. A value of [code]0[/code] forcibly disables anisotropic filtering, even on materials where it is enabled. + The anisotropic filtering level also affects decals and light projectors if they are configured to use anisotropic filtering. See [member ProjectSettings.rendering/textures/decals/filter] and [member ProjectSettings.rendering/textures/light_projectors/filter]. + [b]Note:[/b] In 3D, for this setting to have an effect, set [member BaseMaterial3D.texture_filter] to [constant BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on materials. + [b]Note:[/b] In 2D, for this setting to have an effect, set [member CanvasItem.texture_filter] to [constant CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on the [CanvasItem] node displaying the texture (or in [CanvasTexture]). However, anisotropic filtering is rarely useful in 2D, so only enable it for textures in 2D if it makes a meaningful visual difference. + + @@ -4998,6 +5009,24 @@ Represents the size of the [enum ViewportMSAA] enum. + + Anisotropic filtering is disabled. + + + Use 2× anisotropic filtering. + + + Use 4× anisotropic filtering. This is the default value. + + + Use 8× anisotropic filtering. + + + Use 16× anisotropic filtering. + + + Represents the size of the [enum ViewportAnisotropicFiltering] enum. + Do not perform any antialiasing in the full screen post-process. diff --git a/doc/classes/Viewport.xml b/doc/classes/Viewport.xml index 3e772c4e884..a019295a7af 100644 --- a/doc/classes/Viewport.xml +++ b/doc/classes/Viewport.xml @@ -268,6 +268,12 @@ + + Sets the maximum number of samples to take when using anisotropic filtering on textures (as a power of two). A higher sample count will result in sharper textures at oblique angles, but is more expensive to compute. A value of [code]0[/code] forcibly disables anisotropic filtering, even on materials where it is enabled. + The anisotropic filtering level also affects decals and light projectors if they are configured to use anisotropic filtering. See [member ProjectSettings.rendering/textures/decals/filter] and [member ProjectSettings.rendering/textures/light_projectors/filter]. + [b]Note:[/b] In 3D, for this setting to have an effect, set [member BaseMaterial3D.texture_filter] to [constant BaseMaterial3D.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant BaseMaterial3D.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on materials. + [b]Note:[/b] In 2D, for this setting to have an effect, set [member CanvasItem.texture_filter] to [constant CanvasItem.TEXTURE_FILTER_LINEAR_WITH_MIPMAPS_ANISOTROPIC] or [constant CanvasItem.TEXTURE_FILTER_NEAREST_WITH_MIPMAPS_ANISOTROPIC] on the [CanvasItem] node displaying the texture (or in [CanvasTexture]). However, anisotropic filtering is rarely useful in 2D, so only enable it for textures in 2D if it makes a meaningful visual difference. + If [code]true[/code], the viewport will process 2D audio streams. @@ -515,6 +521,24 @@ Represents the size of the [enum MSAA] enum. + + Anisotropic filtering is disabled. + + + Use 2× anisotropic filtering. + + + Use 4× anisotropic filtering. This is the default value. + + + Use 8× anisotropic filtering. + + + Use 16× anisotropic filtering. + + + Represents the size of the [enum AnisotropicFiltering] enum. + Do not perform any antialiasing in the full screen post-process. diff --git a/drivers/gles3/storage/render_scene_buffers_gles3.cpp b/drivers/gles3/storage/render_scene_buffers_gles3.cpp index c91547d2b16..7d899fad778 100644 --- a/drivers/gles3/storage/render_scene_buffers_gles3.cpp +++ b/drivers/gles3/storage/render_scene_buffers_gles3.cpp @@ -138,6 +138,7 @@ void RenderSceneBuffersGLES3::configure(const RenderSceneBuffersConfiguration *p scaling_3d_mode = p_config->get_scaling_3d_mode(); //fsr_sharpness = p_config->get_fsr_sharpness(); //texture_mipmap_bias = p_config->get_texture_mipmap_bias(); + //anisotropic_filtering_level = p_config->get_anisotropic_filtering_level(); render_target = p_config->get_render_target(); msaa3d.mode = p_config->get_msaa_3d(); //screen_space_aa = p_config->get_screen_space_aa(); diff --git a/drivers/gles3/storage/render_scene_buffers_gles3.h b/drivers/gles3/storage/render_scene_buffers_gles3.h index 9a2912f9780..f69c7fb5565 100644 --- a/drivers/gles3/storage/render_scene_buffers_gles3.h +++ b/drivers/gles3/storage/render_scene_buffers_gles3.h @@ -103,6 +103,7 @@ public: virtual void configure(const RenderSceneBuffersConfiguration *p_config) override; void configure_for_probe(Size2i p_size); + virtual void set_anisotropic_filtering_level(RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) override {} virtual void set_fsr_sharpness(float p_fsr_sharpness) override {} virtual void set_texture_mipmap_bias(float p_texture_mipmap_bias) override {} virtual void set_use_debanding(bool p_use_debanding) override {} diff --git a/editor/plugins/node_3d_editor_plugin.cpp b/editor/plugins/node_3d_editor_plugin.cpp index e0da52687db..ef4c63741be 100644 --- a/editor/plugins/node_3d_editor_plugin.cpp +++ b/editor/plugins/node_3d_editor_plugin.cpp @@ -2852,6 +2852,9 @@ void Node3DEditorViewport::_project_settings_changed() { const float texture_mipmap_bias = GLOBAL_GET("rendering/textures/default_filters/texture_mipmap_bias"); viewport->set_texture_mipmap_bias(texture_mipmap_bias); + + const Viewport::AnisotropicFiltering anisotropic_filtering_level = Viewport::AnisotropicFiltering(int(GLOBAL_GET("rendering/textures/default_filters/anisotropic_filtering_level"))); + viewport->set_anisotropic_filtering_level(anisotropic_filtering_level); } void Node3DEditorViewport::_notification(int p_what) { diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp index 6c83c7843fb..5fbb976e4b6 100644 --- a/scene/main/viewport.cpp +++ b/scene/main/viewport.cpp @@ -4600,6 +4600,21 @@ float Viewport::get_texture_mipmap_bias() const { return texture_mipmap_bias; } +void Viewport::set_anisotropic_filtering_level(AnisotropicFiltering p_anisotropic_filtering_level) { + ERR_MAIN_THREAD_GUARD; + if (anisotropic_filtering_level == p_anisotropic_filtering_level) { + return; + } + + anisotropic_filtering_level = p_anisotropic_filtering_level; + RS::get_singleton()->viewport_set_anisotropic_filtering_level(viewport, (RS::ViewportAnisotropicFiltering)(int)p_anisotropic_filtering_level); +} + +Viewport::AnisotropicFiltering Viewport::get_anisotropic_filtering_level() const { + ERR_READ_THREAD_GUARD_V(ANISOTROPY_DISABLED); + return anisotropic_filtering_level; +} + #endif // _3D_DISABLED void Viewport::_propagate_world_2d_changed(Node *p_node) { @@ -4785,6 +4800,9 @@ void Viewport::_bind_methods() { ClassDB::bind_method(D_METHOD("set_texture_mipmap_bias", "texture_mipmap_bias"), &Viewport::set_texture_mipmap_bias); ClassDB::bind_method(D_METHOD("get_texture_mipmap_bias"), &Viewport::get_texture_mipmap_bias); + ClassDB::bind_method(D_METHOD("set_anisotropic_filtering_level", "anisotropic_filtering_level"), &Viewport::set_anisotropic_filtering_level); + ClassDB::bind_method(D_METHOD("get_anisotropic_filtering_level"), &Viewport::get_anisotropic_filtering_level); + ClassDB::bind_method(D_METHOD("set_vrs_mode", "mode"), &Viewport::set_vrs_mode); ClassDB::bind_method(D_METHOD("get_vrs_mode"), &Viewport::get_vrs_mode); @@ -4820,6 +4838,7 @@ void Viewport::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::INT, "scaling_3d_mode", PROPERTY_HINT_ENUM, "Bilinear (Fastest),FSR 1.0 (Fast),FSR 2.2 (Slow)"), "set_scaling_3d_mode", "get_scaling_3d_mode"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "scaling_3d_scale", PROPERTY_HINT_RANGE, "0.25,2.0,0.01"), "set_scaling_3d_scale", "get_scaling_3d_scale"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "texture_mipmap_bias", PROPERTY_HINT_RANGE, "-2,2,0.001"), "set_texture_mipmap_bias", "get_texture_mipmap_bias"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "anisotropic_filtering_level", PROPERTY_HINT_ENUM, String::utf8("Disabled (Fastest),2× (Faster),4× (Fast),8× (Average),16x (Slow)")), "set_anisotropic_filtering_level", "get_anisotropic_filtering_level"); ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fsr_sharpness", PROPERTY_HINT_RANGE, "0,2,0.1"), "set_fsr_sharpness", "get_fsr_sharpness"); ADD_GROUP("Variable Rate Shading", "vrs_"); ADD_PROPERTY(PropertyInfo(Variant::INT, "vrs_mode", PROPERTY_HINT_ENUM, "Disabled,Texture,Depth buffer,XR"), "set_vrs_mode", "get_vrs_mode"); @@ -4879,6 +4898,13 @@ void Viewport::_bind_methods() { BIND_ENUM_CONSTANT(MSAA_8X); BIND_ENUM_CONSTANT(MSAA_MAX); + BIND_ENUM_CONSTANT(ANISOTROPY_DISABLED); + BIND_ENUM_CONSTANT(ANISOTROPY_2X); + BIND_ENUM_CONSTANT(ANISOTROPY_4X); + BIND_ENUM_CONSTANT(ANISOTROPY_8X); + BIND_ENUM_CONSTANT(ANISOTROPY_16X); + BIND_ENUM_CONSTANT(ANISOTROPY_MAX); + BIND_ENUM_CONSTANT(SCREEN_SPACE_AA_DISABLED); BIND_ENUM_CONSTANT(SCREEN_SPACE_AA_FXAA); BIND_ENUM_CONSTANT(SCREEN_SPACE_AA_MAX); @@ -5004,6 +5030,7 @@ Viewport::Viewport() { set_scaling_3d_scale(GLOBAL_GET("rendering/scaling_3d/scale")); set_fsr_sharpness((float)GLOBAL_GET("rendering/scaling_3d/fsr_sharpness")); set_texture_mipmap_bias((float)GLOBAL_GET("rendering/textures/default_filters/texture_mipmap_bias")); + set_anisotropic_filtering_level((Viewport::AnisotropicFiltering)(int)GLOBAL_GET("rendering/textures/default_filters/anisotropic_filtering_level")); #endif // _3D_DISABLED set_sdf_oversize(sdf_oversize); // Set to server. diff --git a/scene/main/viewport.h b/scene/main/viewport.h index 3a5ad2d83cb..f345c103167 100644 --- a/scene/main/viewport.h +++ b/scene/main/viewport.h @@ -123,6 +123,15 @@ public: MSAA_MAX }; + enum AnisotropicFiltering { + ANISOTROPY_DISABLED, + ANISOTROPY_2X, + ANISOTROPY_4X, + ANISOTROPY_8X, + ANISOTROPY_16X, + ANISOTROPY_MAX + }; + enum ScreenSpaceAA { SCREEN_SPACE_AA_DISABLED, SCREEN_SPACE_AA_FXAA, @@ -303,6 +312,7 @@ private: float scaling_3d_scale = 1.0; float fsr_sharpness = 0.2f; float texture_mipmap_bias = 0.0f; + AnisotropicFiltering anisotropic_filtering_level = ANISOTROPY_4X; bool use_debanding = false; float mesh_lod_threshold = 1.0; bool use_occlusion_culling = false; @@ -561,6 +571,9 @@ public: void set_texture_mipmap_bias(float p_texture_mipmap_bias); float get_texture_mipmap_bias() const; + void set_anisotropic_filtering_level(AnisotropicFiltering p_anisotropic_filtering_level); + AnisotropicFiltering get_anisotropic_filtering_level() const; + void set_use_debanding(bool p_use_debanding); bool is_using_debanding() const; @@ -858,6 +871,7 @@ VARIANT_ENUM_CAST(Viewport::Scaling3DMode); VARIANT_ENUM_CAST(SubViewport::UpdateMode); VARIANT_ENUM_CAST(Viewport::PositionalShadowAtlasQuadrantSubdiv); VARIANT_ENUM_CAST(Viewport::MSAA); +VARIANT_ENUM_CAST(Viewport::AnisotropicFiltering); VARIANT_ENUM_CAST(Viewport::ScreenSpaceAA); VARIANT_ENUM_CAST(Viewport::DebugDraw); VARIANT_ENUM_CAST(Viewport::SDFScale); diff --git a/servers/rendering/renderer_rd/storage_rd/material_storage.cpp b/servers/rendering/renderer_rd/storage_rd/material_storage.cpp index 17a18b27666..337f89e72f0 100644 --- a/servers/rendering/renderer_rd/storage_rd/material_storage.cpp +++ b/servers/rendering/renderer_rd/storage_rd/material_storage.cpp @@ -2322,11 +2322,11 @@ void MaterialStorage::material_update_dependency(RID p_material, DependencyTrack } } -MaterialStorage::Samplers MaterialStorage::samplers_rd_allocate(float p_mipmap_bias) const { +MaterialStorage::Samplers MaterialStorage::samplers_rd_allocate(float p_mipmap_bias, RS::ViewportAnisotropicFiltering anisotropic_filtering_level) const { Samplers samplers; samplers.mipmap_bias = p_mipmap_bias; + samplers.anisotropic_filtering_level = (int)anisotropic_filtering_level; samplers.use_nearest_mipmap_filter = GLOBAL_GET("rendering/textures/default_filters/use_nearest_mipmap_filter"); - samplers.anisotropic_filtering_level = int(GLOBAL_GET("rendering/textures/default_filters/anisotropic_filtering_level")); RD::SamplerFilter mip_filter = samplers.use_nearest_mipmap_filter ? RD::SAMPLER_FILTER_NEAREST : RD::SAMPLER_FILTER_LINEAR; float anisotropy_max = float(1 << samplers.anisotropic_filtering_level); diff --git a/servers/rendering/renderer_rd/storage_rd/material_storage.h b/servers/rendering/renderer_rd/storage_rd/material_storage.h index 89a8b36853c..e3fa1ace913 100644 --- a/servers/rendering/renderer_rd/storage_rd/material_storage.h +++ b/servers/rendering/renderer_rd/storage_rd/material_storage.h @@ -363,7 +363,7 @@ public: /* Samplers */ - Samplers samplers_rd_allocate(float p_mipmap_bias = 0.0f) const; + Samplers samplers_rd_allocate(float p_mipmap_bias = 0.0f, RS::ViewportAnisotropicFiltering anisotropic_filtering_level = RS::ViewportAnisotropicFiltering::VIEWPORT_ANISOTROPY_4X) const; void samplers_rd_free(Samplers &p_samplers) const; _FORCE_INLINE_ RID sampler_rd_get_default(RS::CanvasItemTextureFilter p_filter, RS::CanvasItemTextureRepeat p_repeat) { diff --git a/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.cpp b/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.cpp index 6e1259eac17..4a8b8386dd6 100644 --- a/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.cpp +++ b/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.cpp @@ -119,7 +119,7 @@ void RenderSceneBuffersRD::update_samplers() { RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton(); material_storage->samplers_rd_free(samplers); - samplers = material_storage->samplers_rd_allocate(computed_mipmap_bias); + samplers = material_storage->samplers_rd_allocate(computed_mipmap_bias, anisotropic_filtering_level); } void RenderSceneBuffersRD::cleanup() { @@ -157,6 +157,7 @@ void RenderSceneBuffersRD::configure(const RenderSceneBuffersConfiguration *p_co fsr_sharpness = p_config->get_fsr_sharpness(); texture_mipmap_bias = p_config->get_texture_mipmap_bias(); + anisotropic_filtering_level = p_config->get_anisotropic_filtering_level(); use_taa = p_config->get_use_taa(); use_debanding = p_config->get_use_debanding(); @@ -230,6 +231,12 @@ void RenderSceneBuffersRD::set_texture_mipmap_bias(float p_texture_mipmap_bias) update_samplers(); } +void RenderSceneBuffersRD::set_anisotropic_filtering_level(RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) { + anisotropic_filtering_level = p_anisotropic_filtering_level; + + update_samplers(); +} + void RenderSceneBuffersRD::set_use_debanding(bool p_use_debanding) { use_debanding = p_use_debanding; } diff --git a/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.h b/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.h index 0af3a752706..4378dfbb2de 100644 --- a/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.h +++ b/servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.h @@ -81,6 +81,7 @@ private: RS::ViewportScaling3DMode scaling_3d_mode = RS::VIEWPORT_SCALING_3D_MODE_OFF; float fsr_sharpness = 0.2f; float texture_mipmap_bias = 0.0f; + RS::ViewportAnisotropicFiltering anisotropic_filtering_level = RS::VIEWPORT_ANISOTROPY_4X; // Aliassing settings RS::ViewportMSAA msaa_3d = RS::VIEWPORT_MSAA_DISABLED; @@ -190,6 +191,7 @@ public: void configure_for_reflections(const Size2i p_reflection_size); virtual void set_fsr_sharpness(float p_fsr_sharpness) override; virtual void set_texture_mipmap_bias(float p_texture_mipmap_bias) override; + virtual void set_anisotropic_filtering_level(RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) override; virtual void set_use_debanding(bool p_use_debanding) override; // Named Textures diff --git a/servers/rendering/renderer_viewport.cpp b/servers/rendering/renderer_viewport.cpp index 4d6435f48a5..3f2cab7981a 100644 --- a/servers/rendering/renderer_viewport.cpp +++ b/servers/rendering/renderer_viewport.cpp @@ -229,6 +229,7 @@ void RendererViewport::_configure_3d_render_buffers(Viewport *p_viewport) { rb_config.set_screen_space_aa(p_viewport->screen_space_aa); rb_config.set_fsr_sharpness(p_viewport->fsr_sharpness); rb_config.set_texture_mipmap_bias(texture_mipmap_bias); + rb_config.set_anisotropic_filtering_level(p_viewport->anisotropic_filtering_level); rb_config.set_use_taa(use_taa); rb_config.set_use_debanding(p_viewport->use_debanding); @@ -951,6 +952,14 @@ void RendererViewport::viewport_set_texture_mipmap_bias(RID p_viewport, float p_ _configure_3d_render_buffers(viewport); } +void RendererViewport::viewport_set_anisotropic_filtering_level(RID p_viewport, RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) { + Viewport *viewport = viewport_owner.get_or_null(p_viewport); + ERR_FAIL_NULL(viewport); + + viewport->anisotropic_filtering_level = p_anisotropic_filtering_level; + _configure_3d_render_buffers(viewport); +} + void RendererViewport::viewport_set_scaling_3d_scale(RID p_viewport, float p_scaling_3d_scale) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); ERR_FAIL_NULL(viewport); diff --git a/servers/rendering/renderer_viewport.h b/servers/rendering/renderer_viewport.h index bf97905f869..0da5dbf6f21 100644 --- a/servers/rendering/renderer_viewport.h +++ b/servers/rendering/renderer_viewport.h @@ -65,6 +65,7 @@ public: float scaling_3d_scale = 1.0; float fsr_sharpness = 0.2f; float texture_mipmap_bias = 0.0f; + RS::ViewportAnisotropicFiltering anisotropic_filtering_level = RenderingServer::VIEWPORT_ANISOTROPY_4X; bool fsr_enabled = false; uint32_t jitter_phase_count = 0; RS::ViewportUpdateMode update_mode = RenderingServer::VIEWPORT_UPDATE_WHEN_VISIBLE; @@ -234,6 +235,7 @@ public: void viewport_set_scaling_3d_scale(RID p_viewport, float p_scaling_3d_scale); void viewport_set_fsr_sharpness(RID p_viewport, float p_sharpness); void viewport_set_texture_mipmap_bias(RID p_viewport, float p_mipmap_bias); + void viewport_set_anisotropic_filtering_level(RID p_viewport, RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level); void viewport_set_update_mode(RID p_viewport, RS::ViewportUpdateMode p_mode); RS::ViewportUpdateMode viewport_get_update_mode(RID p_viewport) const; diff --git a/servers/rendering/rendering_server_default.h b/servers/rendering/rendering_server_default.h index 29b1e163c78..2b2fb00e216 100644 --- a/servers/rendering/rendering_server_default.h +++ b/servers/rendering/rendering_server_default.h @@ -686,6 +686,7 @@ public: FUNC2(viewport_set_scaling_3d_scale, RID, float) FUNC2(viewport_set_fsr_sharpness, RID, float) FUNC2(viewport_set_texture_mipmap_bias, RID, float) + FUNC2(viewport_set_anisotropic_filtering_level, RID, ViewportAnisotropicFiltering) FUNC2(viewport_set_update_mode, RID, ViewportUpdateMode) FUNC1RC(ViewportUpdateMode, viewport_get_update_mode, RID) diff --git a/servers/rendering/storage/render_scene_buffers.cpp b/servers/rendering/storage/render_scene_buffers.cpp index 6d18ae2f778..acd18795ed1 100644 --- a/servers/rendering/storage/render_scene_buffers.cpp +++ b/servers/rendering/storage/render_scene_buffers.cpp @@ -66,6 +66,10 @@ void RenderSceneBuffersConfiguration::_bind_methods() { ClassDB::bind_method(D_METHOD("get_texture_mipmap_bias"), &RenderSceneBuffersConfiguration::get_texture_mipmap_bias); ClassDB::bind_method(D_METHOD("set_texture_mipmap_bias", "texture_mipmap_bias"), &RenderSceneBuffersConfiguration::set_texture_mipmap_bias); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "texture_mipmap_bias"), "set_texture_mipmap_bias", "get_texture_mipmap_bias"); + + ClassDB::bind_method(D_METHOD("get_anisotropic_filtering_level"), &RenderSceneBuffersConfiguration::get_anisotropic_filtering_level); + ClassDB::bind_method(D_METHOD("set_anisotropic_filtering_level", "anisotropic_filtering_level"), &RenderSceneBuffersConfiguration::set_anisotropic_filtering_level); + ADD_PROPERTY(PropertyInfo(Variant::INT, "anisotropic_filtering_level"), "set_anisotropic_filtering_level", "get_anisotropic_filtering_level"); } void RenderSceneBuffers::_bind_methods() { @@ -76,6 +80,7 @@ void RenderSceneBuffersExtension::_bind_methods() { GDVIRTUAL_BIND(_configure, "config"); GDVIRTUAL_BIND(_set_fsr_sharpness, "fsr_sharpness"); GDVIRTUAL_BIND(_set_texture_mipmap_bias, "texture_mipmap_bias"); + GDVIRTUAL_BIND(_set_anisotropic_filtering_level, "anisotropic_filtering_level"); GDVIRTUAL_BIND(_set_use_debanding, "use_debanding"); } @@ -91,6 +96,10 @@ void RenderSceneBuffersExtension::set_texture_mipmap_bias(float p_texture_mipmap GDVIRTUAL_CALL(_set_texture_mipmap_bias, p_texture_mipmap_bias); } +void RenderSceneBuffersExtension::set_anisotropic_filtering_level(RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) { + GDVIRTUAL_CALL(_set_anisotropic_filtering_level, p_anisotropic_filtering_level); +} + void RenderSceneBuffersExtension::set_use_debanding(bool p_use_debanding) { GDVIRTUAL_CALL(_set_use_debanding, p_use_debanding); } diff --git a/servers/rendering/storage/render_scene_buffers.h b/servers/rendering/storage/render_scene_buffers.h index b860af76400..a3cfbea6eb8 100644 --- a/servers/rendering/storage/render_scene_buffers.h +++ b/servers/rendering/storage/render_scene_buffers.h @@ -47,6 +47,7 @@ private: RS::ViewportScaling3DMode scaling_3d_mode = RS::VIEWPORT_SCALING_3D_MODE_OFF; RS::ViewportMSAA msaa_3d = RS::VIEWPORT_MSAA_DISABLED; RS::ViewportScreenSpaceAA screen_space_aa = RS::VIEWPORT_SCREEN_SPACE_AA_DISABLED; + RS::ViewportAnisotropicFiltering anisotropic_filtering_level = RS::VIEWPORT_ANISOTROPY_4X; float fsr_sharpness = 0.0; float texture_mipmap_bias = 0.0; @@ -84,6 +85,9 @@ public: float get_texture_mipmap_bias() const { return texture_mipmap_bias; } void set_texture_mipmap_bias(float p_texture_mipmap_bias) { texture_mipmap_bias = p_texture_mipmap_bias; } + RS::ViewportAnisotropicFiltering get_anisotropic_filtering_level() const { return anisotropic_filtering_level; } + void set_anisotropic_filtering_level(RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) { anisotropic_filtering_level = p_anisotropic_filtering_level; } + bool get_use_taa() const { return use_taa; } void set_use_taa(bool p_use_taa) { use_taa = p_use_taa; } @@ -109,6 +113,7 @@ public: // for those settings that are unlikely to require buffers to be recreated, we'll add setters virtual void set_fsr_sharpness(float p_fsr_sharpness) = 0; virtual void set_texture_mipmap_bias(float p_texture_mipmap_bias) = 0; + virtual void set_anisotropic_filtering_level(RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) = 0; virtual void set_use_debanding(bool p_use_debanding) = 0; }; @@ -121,6 +126,7 @@ protected: GDVIRTUAL1(_configure, const RenderSceneBuffersConfiguration *) GDVIRTUAL1(_set_fsr_sharpness, float) GDVIRTUAL1(_set_texture_mipmap_bias, float) + GDVIRTUAL1(_set_anisotropic_filtering_level, int) GDVIRTUAL1(_set_use_debanding, bool) public: @@ -130,6 +136,7 @@ public: virtual void set_fsr_sharpness(float p_fsr_sharpness) override; virtual void set_texture_mipmap_bias(float p_texture_mipmap_bias) override; + virtual void set_anisotropic_filtering_level(RS::ViewportAnisotropicFiltering p_anisotropic_filtering_level) override; virtual void set_use_debanding(bool p_use_debanding) override; }; diff --git a/servers/rendering_server.cpp b/servers/rendering_server.cpp index 2051d0caac0..5af56cdff65 100644 --- a/servers/rendering_server.cpp +++ b/servers/rendering_server.cpp @@ -2805,6 +2805,7 @@ void RenderingServer::_bind_methods() { ClassDB::bind_method(D_METHOD("viewport_set_scaling_3d_scale", "viewport", "scale"), &RenderingServer::viewport_set_scaling_3d_scale); ClassDB::bind_method(D_METHOD("viewport_set_fsr_sharpness", "viewport", "sharpness"), &RenderingServer::viewport_set_fsr_sharpness); ClassDB::bind_method(D_METHOD("viewport_set_texture_mipmap_bias", "viewport", "mipmap_bias"), &RenderingServer::viewport_set_texture_mipmap_bias); + ClassDB::bind_method(D_METHOD("viewport_set_anisotropic_filtering_level", "viewport", "anisotropic_filtering_level"), &RenderingServer::viewport_set_anisotropic_filtering_level); ClassDB::bind_method(D_METHOD("viewport_set_update_mode", "viewport", "update_mode"), &RenderingServer::viewport_set_update_mode); ClassDB::bind_method(D_METHOD("viewport_get_update_mode", "viewport"), &RenderingServer::viewport_get_update_mode); ClassDB::bind_method(D_METHOD("viewport_set_clear_mode", "viewport", "clear_mode"), &RenderingServer::viewport_set_clear_mode); @@ -2892,6 +2893,13 @@ void RenderingServer::_bind_methods() { BIND_ENUM_CONSTANT(VIEWPORT_MSAA_8X); BIND_ENUM_CONSTANT(VIEWPORT_MSAA_MAX); + BIND_ENUM_CONSTANT(VIEWPORT_ANISOTROPY_DISABLED); + BIND_ENUM_CONSTANT(VIEWPORT_ANISOTROPY_2X); + BIND_ENUM_CONSTANT(VIEWPORT_ANISOTROPY_4X); + BIND_ENUM_CONSTANT(VIEWPORT_ANISOTROPY_8X); + BIND_ENUM_CONSTANT(VIEWPORT_ANISOTROPY_16X); + BIND_ENUM_CONSTANT(VIEWPORT_ANISOTROPY_MAX); + BIND_ENUM_CONSTANT(VIEWPORT_SCREEN_SPACE_AA_DISABLED); BIND_ENUM_CONSTANT(VIEWPORT_SCREEN_SPACE_AA_FXAA); BIND_ENUM_CONSTANT(VIEWPORT_SCREEN_SPACE_AA_MAX); @@ -3617,7 +3625,7 @@ void RenderingServer::init() { GLOBAL_DEF_RST("rendering/driver/depth_prepass/disable_for_vendors", "PowerVR,Mali,Adreno,Apple"); GLOBAL_DEF_RST("rendering/textures/default_filters/use_nearest_mipmap_filter", false); - GLOBAL_DEF_RST(PropertyInfo(Variant::INT, "rendering/textures/default_filters/anisotropic_filtering_level", PROPERTY_HINT_ENUM, String::utf8("Disabled (Fastest),2× (Faster),4× (Fast),8× (Average),16× (Slow)")), 2); + GLOBAL_DEF(PropertyInfo(Variant::INT, "rendering/textures/default_filters/anisotropic_filtering_level", PROPERTY_HINT_ENUM, String::utf8("Disabled (Fastest),2× (Faster),4× (Fast),8× (Average),16× (Slow)")), 2); GLOBAL_DEF(PropertyInfo(Variant::INT, "rendering/camera/depth_of_field/depth_of_field_bokeh_shape", PROPERTY_HINT_ENUM, "Box (Fast),Hexagon (Average),Circle (Slowest)"), 1); GLOBAL_DEF(PropertyInfo(Variant::INT, "rendering/camera/depth_of_field/depth_of_field_bokeh_quality", PROPERTY_HINT_ENUM, "Very Low (Fastest),Low (Fast),Medium (Average),High (Slow)"), 1); diff --git a/servers/rendering_server.h b/servers/rendering_server.h index 0917af73c6a..5dcd588bb36 100644 --- a/servers/rendering_server.h +++ b/servers/rendering_server.h @@ -908,6 +908,15 @@ public: VIEWPORT_SCALING_3D_MODE_OFF = 255, // for internal use only }; + enum ViewportAnisotropicFiltering { + VIEWPORT_ANISOTROPY_DISABLED, + VIEWPORT_ANISOTROPY_2X, + VIEWPORT_ANISOTROPY_4X, + VIEWPORT_ANISOTROPY_8X, + VIEWPORT_ANISOTROPY_16X, + VIEWPORT_ANISOTROPY_MAX + }; + virtual void viewport_set_use_xr(RID p_viewport, bool p_use_xr) = 0; virtual void viewport_set_size(RID p_viewport, int p_width, int p_height) = 0; virtual void viewport_set_active(RID p_viewport, bool p_active) = 0; @@ -921,6 +930,7 @@ public: virtual void viewport_set_scaling_3d_scale(RID p_viewport, float p_scaling_3d_scale) = 0; virtual void viewport_set_fsr_sharpness(RID p_viewport, float p_fsr_sharpness) = 0; virtual void viewport_set_texture_mipmap_bias(RID p_viewport, float p_texture_mipmap_bias) = 0; + virtual void viewport_set_anisotropic_filtering_level(RID p_viewport, ViewportAnisotropicFiltering p_anisotropic_filtering_level) = 0; enum ViewportUpdateMode { VIEWPORT_UPDATE_DISABLED, @@ -1864,6 +1874,7 @@ VARIANT_ENUM_CAST(RenderingServer::ViewportUpdateMode); VARIANT_ENUM_CAST(RenderingServer::ViewportClearMode); VARIANT_ENUM_CAST(RenderingServer::ViewportEnvironmentMode); VARIANT_ENUM_CAST(RenderingServer::ViewportMSAA); +VARIANT_ENUM_CAST(RenderingServer::ViewportAnisotropicFiltering); VARIANT_ENUM_CAST(RenderingServer::ViewportScreenSpaceAA); VARIANT_ENUM_CAST(RenderingServer::ViewportRenderInfo); VARIANT_ENUM_CAST(RenderingServer::ViewportRenderInfoType);