Environment: Refactor code for readability + more

- Makes all boolean setters/getters consistent.
- Fixes bug where `glow_hdr_bleed_scale` was not used.
- Split CameraEffects to their own source file.
- Reorder all Environment method and properties declarations,
  definitions and bindings to be consistent with each other
  and with the order of property bindings.
- Bind missing enum values added with SDFGI.
- Remove unused SDFGI enhance_ssr boolean.
- Sync doc changes after SDFGI merge and other misc changes.

5 files changed, 1113 insertions, 1032 deletions

diff --git a/scene/resources/camera_effects.cpp b/scene/resources/camera_effects.cpp
new file mode 100644
index 0000000000..6b6ed51ed0
--- /dev/null
+++ b/scene/resources/camera_effects.cpp
@@ -0,0 +1,197 @@
+/*************************************************************************/
+/*  camera_effects.cpp                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#include "camera_effects.h"
+
+#include "servers/rendering_server.h"
+
+RID CameraEffects::get_rid() const {
+	return camera_effects;
+}
+
+// DOF blur
+
+void CameraEffects::set_dof_blur_far_enabled(bool p_enabled) {
+	dof_blur_far_enabled = p_enabled;
+	_update_dof_blur();
+	_change_notify();
+}
+
+bool CameraEffects::is_dof_blur_far_enabled() const {
+	return dof_blur_far_enabled;
+}
+
+void CameraEffects::set_dof_blur_far_distance(float p_distance) {
+	dof_blur_far_distance = p_distance;
+	_update_dof_blur();
+}
+
+float CameraEffects::get_dof_blur_far_distance() const {
+	return dof_blur_far_distance;
+}
+
+void CameraEffects::set_dof_blur_far_transition(float p_distance) {
+	dof_blur_far_transition = p_distance;
+	_update_dof_blur();
+}
+
+float CameraEffects::get_dof_blur_far_transition() const {
+	return dof_blur_far_transition;
+}
+
+void CameraEffects::set_dof_blur_near_enabled(bool p_enabled) {
+	dof_blur_near_enabled = p_enabled;
+	_update_dof_blur();
+	_change_notify();
+}
+
+bool CameraEffects::is_dof_blur_near_enabled() const {
+	return dof_blur_near_enabled;
+}
+
+void CameraEffects::set_dof_blur_near_distance(float p_distance) {
+	dof_blur_near_distance = p_distance;
+	_update_dof_blur();
+}
+
+float CameraEffects::get_dof_blur_near_distance() const {
+	return dof_blur_near_distance;
+}
+
+void CameraEffects::set_dof_blur_near_transition(float p_distance) {
+	dof_blur_near_transition = p_distance;
+	_update_dof_blur();
+}
+
+float CameraEffects::get_dof_blur_near_transition() const {
+	return dof_blur_near_transition;
+}
+
+void CameraEffects::set_dof_blur_amount(float p_amount) {
+	dof_blur_amount = p_amount;
+	_update_dof_blur();
+}
+
+float CameraEffects::get_dof_blur_amount() const {
+	return dof_blur_amount;
+}
+
+void CameraEffects::_update_dof_blur() {
+	RS::get_singleton()->camera_effects_set_dof_blur(
+			camera_effects,
+			dof_blur_far_enabled,
+			dof_blur_far_distance,
+			dof_blur_far_transition,
+			dof_blur_near_enabled,
+			dof_blur_near_distance,
+			dof_blur_near_transition,
+			dof_blur_amount);
+}
+
+// Custom exposure
+
+void CameraEffects::set_override_exposure_enabled(bool p_enabled) {
+	override_exposure_enabled = p_enabled;
+	_update_override_exposure();
+}
+
+bool CameraEffects::is_override_exposure_enabled() const {
+	return override_exposure_enabled;
+}
+
+void CameraEffects::set_override_exposure(float p_exposure) {
+	override_exposure = p_exposure;
+	_update_override_exposure();
+}
+
+float CameraEffects::get_override_exposure() const {
+	return override_exposure;
+}
+
+void CameraEffects::_update_override_exposure() {
+	RS::get_singleton()->camera_effects_set_custom_exposure(
+			camera_effects,
+			override_exposure_enabled,
+			override_exposure);
+}
+
+// Private methods, constructor and destructor
+
+void CameraEffects::_bind_methods() {
+	// DOF blur
+
+	ClassDB::bind_method(D_METHOD("set_dof_blur_far_enabled", "enabled"), &CameraEffects::set_dof_blur_far_enabled);
+	ClassDB::bind_method(D_METHOD("is_dof_blur_far_enabled"), &CameraEffects::is_dof_blur_far_enabled);
+	ClassDB::bind_method(D_METHOD("set_dof_blur_far_distance", "distance"), &CameraEffects::set_dof_blur_far_distance);
+	ClassDB::bind_method(D_METHOD("get_dof_blur_far_distance"), &CameraEffects::get_dof_blur_far_distance);
+	ClassDB::bind_method(D_METHOD("set_dof_blur_far_transition", "distance"), &CameraEffects::set_dof_blur_far_transition);
+	ClassDB::bind_method(D_METHOD("get_dof_blur_far_transition"), &CameraEffects::get_dof_blur_far_transition);
+
+	ClassDB::bind_method(D_METHOD("set_dof_blur_near_enabled", "enabled"), &CameraEffects::set_dof_blur_near_enabled);
+	ClassDB::bind_method(D_METHOD("is_dof_blur_near_enabled"), &CameraEffects::is_dof_blur_near_enabled);
+	ClassDB::bind_method(D_METHOD("set_dof_blur_near_distance", "distance"), &CameraEffects::set_dof_blur_near_distance);
+	ClassDB::bind_method(D_METHOD("get_dof_blur_near_distance"), &CameraEffects::get_dof_blur_near_distance);
+	ClassDB::bind_method(D_METHOD("set_dof_blur_near_transition", "distance"), &CameraEffects::set_dof_blur_near_transition);
+	ClassDB::bind_method(D_METHOD("get_dof_blur_near_transition"), &CameraEffects::get_dof_blur_near_transition);
+
+	ClassDB::bind_method(D_METHOD("set_dof_blur_amount", "amount"), &CameraEffects::set_dof_blur_amount);
+	ClassDB::bind_method(D_METHOD("get_dof_blur_amount"), &CameraEffects::get_dof_blur_amount);
+
+	ADD_GROUP("DOF Blur", "dof_blur_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dof_blur_far_enabled"), "set_dof_blur_far_enabled", "is_dof_blur_far_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_far_distance", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_far_distance", "get_dof_blur_far_distance");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_far_transition", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_far_transition", "get_dof_blur_far_transition");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dof_blur_near_enabled"), "set_dof_blur_near_enabled", "is_dof_blur_near_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_near_distance", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_near_distance", "get_dof_blur_near_distance");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_near_transition", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_near_transition", "get_dof_blur_near_transition");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_dof_blur_amount", "get_dof_blur_amount");
+
+	// Override exposure
+
+	ClassDB::bind_method(D_METHOD("set_override_exposure_enabled", "enabled"), &CameraEffects::set_override_exposure_enabled);
+	ClassDB::bind_method(D_METHOD("is_override_exposure_enabled"), &CameraEffects::is_override_exposure_enabled);
+	ClassDB::bind_method(D_METHOD("set_override_exposure", "exposure"), &CameraEffects::set_override_exposure);
+	ClassDB::bind_method(D_METHOD("get_override_exposure"), &CameraEffects::get_override_exposure);
+
+	ADD_GROUP("Override Exposure", "override_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "override_exposure_enabled"), "set_override_exposure_enabled", "is_override_exposure_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "override_exposure", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_override_exposure", "get_override_exposure");
+}
+
+CameraEffects::CameraEffects() {
+	camera_effects = RS::get_singleton()->camera_effects_create();
+
+	_update_dof_blur();
+	_update_override_exposure();
+}
+
+CameraEffects::~CameraEffects() {
+	RS::get_singleton()->free(camera_effects);
+}
diff --git a/scene/resources/camera_effects.h b/scene/resources/camera_effects.h
new file mode 100644
index 0000000000..6b216e3296
--- /dev/null
+++ b/scene/resources/camera_effects.h
@@ -0,0 +1,94 @@
+/*************************************************************************/
+/*  camera_effects.h                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef CAMERA_EFFECTS_H
+#define CAMERA_EFFECTS_H
+
+#include "core/resource.h"
+#include "core/rid.h"
+
+class CameraEffects : public Resource {
+	GDCLASS(CameraEffects, Resource);
+
+private:
+	RID camera_effects;
+
+	// DOF blur
+	bool dof_blur_far_enabled = false;
+	float dof_blur_far_distance = 10;
+	float dof_blur_far_transition = 5;
+
+	bool dof_blur_near_enabled = false;
+	float dof_blur_near_distance = 2;
+	float dof_blur_near_transition = 1;
+
+	float dof_blur_amount = 0.1;
+	void _update_dof_blur();
+
+	// Override exposure
+	bool override_exposure_enabled = false;
+	float override_exposure = 1.0;
+	void _update_override_exposure();
+
+protected:
+	static void _bind_methods();
+
+public:
+	virtual RID get_rid() const;
+
+	// DOF blur
+	void set_dof_blur_far_enabled(bool p_enabled);
+	bool is_dof_blur_far_enabled() const;
+	void set_dof_blur_far_distance(float p_distance);
+	float get_dof_blur_far_distance() const;
+	void set_dof_blur_far_transition(float p_distance);
+	float get_dof_blur_far_transition() const;
+
+	void set_dof_blur_near_enabled(bool p_enabled);
+	bool is_dof_blur_near_enabled() const;
+	void set_dof_blur_near_distance(float p_distance);
+	float get_dof_blur_near_distance() const;
+	void set_dof_blur_near_transition(float p_distance);
+	float get_dof_blur_near_transition() const;
+
+	void set_dof_blur_amount(float p_amount);
+	float get_dof_blur_amount() const;
+
+	// Override exposure
+	void set_override_exposure_enabled(bool p_enabled);
+	bool is_override_exposure_enabled() const;
+	void set_override_exposure(float p_exposure);
+	float get_override_exposure() const;
+
+	CameraEffects();
+	~CameraEffects();
+};
+
+#endif // CAMERA_EFFECTS_H
diff --git a/scene/resources/environment.cpp b/scene/resources/environment.cpp
index c003a99a2b..94629a77b9 100644
--- a/scene/resources/environment.cpp
+++ b/scene/resources/environment.cpp
@@ -29,6 +29,7 @@
 /*************************************************************************/
 
 #include "environment.h"
+
 #include "core/project_settings.h"
 #include "servers/rendering_server.h"
 #include "texture.h"
@@ -37,136 +38,159 @@ RID Environment::get_rid() const {
 	return environment;
 }
 
+// Background
+
 void Environment::set_background(BGMode p_bg) {
 	bg_mode = p_bg;
 	RS::get_singleton()->environment_set_background(environment, RS::EnvironmentBG(p_bg));
 	_change_notify();
 }
 
+Environment::BGMode Environment::get_background() const {
+	return bg_mode;
+}
+
 void Environment::set_sky(const Ref<Sky> &p_sky) {
 	bg_sky = p_sky;
-
 	RID sb_rid;
 	if (bg_sky.is_valid()) {
 		sb_rid = bg_sky->get_rid();
 	}
-
 	RS::get_singleton()->environment_set_sky(environment, sb_rid);
 }
 
+Ref<Sky> Environment::get_sky() const {
+	return bg_sky;
+}
+
 void Environment::set_sky_custom_fov(float p_scale) {
 	bg_sky_custom_fov = p_scale;
 	RS::get_singleton()->environment_set_sky_custom_fov(environment, p_scale);
 }
 
+float Environment::get_sky_custom_fov() const {
+	return bg_sky_custom_fov;
+}
+
+void Environment::set_sky_rotation(const Vector3 &p_rotation) {
+	bg_sky_rotation = p_rotation;
+	RS::get_singleton()->environment_set_sky_orientation(environment, Basis(p_rotation));
+}
+
+Vector3 Environment::get_sky_rotation() const {
+	return bg_sky_rotation;
+}
+
 void Environment::set_bg_color(const Color &p_color) {
 	bg_color = p_color;
 	RS::get_singleton()->environment_set_bg_color(environment, p_color);
 }
 
+Color Environment::get_bg_color() const {
+	return bg_color;
+}
+
 void Environment::set_bg_energy(float p_energy) {
 	bg_energy = p_energy;
 	RS::get_singleton()->environment_set_bg_energy(environment, p_energy);
 }
 
+float Environment::get_bg_energy() const {
+	return bg_energy;
+}
+
 void Environment::set_canvas_max_layer(int p_max_layer) {
 	bg_canvas_max_layer = p_max_layer;
 	RS::get_singleton()->environment_set_canvas_max_layer(environment, p_max_layer);
 }
 
-void Environment::set_ambient_light_color(const Color &p_color) {
-	ambient_color = p_color;
-	RS::get_singleton()->environment_set_ambient_light(environment, ambient_color, RS::EnvironmentAmbientSource(ambient_source), ambient_energy, ambient_sky_contribution, RS::EnvironmentReflectionSource(reflection_source), ao_color);
-}
-
-void Environment::set_ambient_light_energy(float p_energy) {
-	ambient_energy = p_energy;
-	RS::get_singleton()->environment_set_ambient_light(environment, ambient_color, RS::EnvironmentAmbientSource(ambient_source), ambient_energy, ambient_sky_contribution, RS::EnvironmentReflectionSource(reflection_source), ao_color);
-}
-
-void Environment::set_ambient_light_sky_contribution(float p_energy) {
-	ambient_sky_contribution = p_energy;
-	RS::get_singleton()->environment_set_ambient_light(environment, ambient_color, RS::EnvironmentAmbientSource(ambient_source), ambient_energy, ambient_sky_contribution, RS::EnvironmentReflectionSource(reflection_source), ao_color);
+int Environment::get_canvas_max_layer() const {
+	return bg_canvas_max_layer;
 }
 
-void Environment::set_camera_feed_id(int p_camera_feed_id) {
-	camera_feed_id = p_camera_feed_id;
+void Environment::set_camera_feed_id(int p_id) {
+	bg_camera_feed_id = p_id;
 // FIXME: Disabled during Vulkan refactoring, should be ported.
 #if 0
 	RS::get_singleton()->environment_set_camera_feed_id(environment, camera_feed_id);
 #endif
-};
-
-void Environment::set_ambient_source(AmbientSource p_source) {
-	ambient_source = p_source;
-	RS::get_singleton()->environment_set_ambient_light(environment, ambient_color, RS::EnvironmentAmbientSource(ambient_source), ambient_energy, ambient_sky_contribution, RS::EnvironmentReflectionSource(reflection_source), ao_color);
 }
 
-Environment::AmbientSource Environment::get_ambient_source() const {
-	return ambient_source;
+int Environment::get_camera_feed_id() const {
+	return bg_camera_feed_id;
 }
 
-void Environment::set_reflection_source(ReflectionSource p_source) {
-	reflection_source = p_source;
-	RS::get_singleton()->environment_set_ambient_light(environment, ambient_color, RS::EnvironmentAmbientSource(ambient_source), ambient_energy, ambient_sky_contribution, RS::EnvironmentReflectionSource(reflection_source), ao_color);
-}
+// Ambient light
 
-Environment::ReflectionSource Environment::get_reflection_source() const {
-	return reflection_source;
+void Environment::set_ambient_light_color(const Color &p_color) {
+	ambient_color = p_color;
+	_update_ambient_light();
 }
 
-Environment::BGMode Environment::get_background() const {
-	return bg_mode;
+Color Environment::get_ambient_light_color() const {
+	return ambient_color;
 }
 
-Ref<Sky> Environment::get_sky() const {
-	return bg_sky;
+void Environment::set_ambient_source(AmbientSource p_source) {
+	ambient_source = p_source;
+	_update_ambient_light();
 }
 
-float Environment::get_sky_custom_fov() const {
-	return bg_sky_custom_fov;
+Environment::AmbientSource Environment::get_ambient_source() const {
+	return ambient_source;
 }
 
-void Environment::set_sky_rotation(const Vector3 &p_rotation) {
-	sky_rotation = p_rotation;
-	RS::get_singleton()->environment_set_sky_orientation(environment, Basis(p_rotation));
+void Environment::set_ambient_light_energy(float p_energy) {
+	ambient_energy = p_energy;
+	_update_ambient_light();
 }
 
-Vector3 Environment::get_sky_rotation() const {
-	return sky_rotation;
+float Environment::get_ambient_light_energy() const {
+	return ambient_energy;
 }
 
-Color Environment::get_bg_color() const {
-	return bg_color;
+void Environment::set_ambient_light_sky_contribution(float p_ratio) {
+	ambient_sky_contribution = p_ratio;
+	_update_ambient_light();
 }
 
-float Environment::get_bg_energy() const {
-	return bg_energy;
+float Environment::get_ambient_light_sky_contribution() const {
+	return ambient_sky_contribution;
 }
 
-int Environment::get_canvas_max_layer() const {
-	return bg_canvas_max_layer;
+void Environment::set_reflection_source(ReflectionSource p_source) {
+	reflection_source = p_source;
+	_update_ambient_light();
 }
 
-Color Environment::get_ambient_light_color() const {
-	return ambient_color;
+Environment::ReflectionSource Environment::get_reflection_source() const {
+	return reflection_source;
 }
 
-float Environment::get_ambient_light_energy() const {
-	return ambient_energy;
+void Environment::set_ao_color(const Color &p_color) {
+	ao_color = p_color;
+	_update_ambient_light();
 }
 
-float Environment::get_ambient_light_sky_contribution() const {
-	return ambient_sky_contribution;
+Color Environment::get_ao_color() const {
+	return ao_color;
 }
 
-int Environment::get_camera_feed_id() const {
-	return camera_feed_id;
+void Environment::_update_ambient_light() {
+	RS::get_singleton()->environment_set_ambient_light(
+			environment,
+			ambient_color,
+			RS::EnvironmentAmbientSource(ambient_source),
+			ambient_energy,
+			ambient_sky_contribution, RS::EnvironmentReflectionSource(reflection_source),
+			ao_color);
 }
 
+// Tonemap
+
 void Environment::set_tonemapper(ToneMapper p_tone_mapper) {
 	tone_mapper = p_tone_mapper;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
+	_update_tonemap();
 }
 
 Environment::ToneMapper Environment::get_tonemapper() const {
@@ -175,7 +199,7 @@ Environment::ToneMapper Environment::get_tonemapper() const {
 
 void Environment::set_tonemap_exposure(float p_exposure) {
 	tonemap_exposure = p_exposure;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
+	_update_tonemap();
 }
 
 float Environment::get_tonemap_exposure() const {
@@ -184,44 +208,44 @@ float Environment::get_tonemap_exposure() const {
 
 void Environment::set_tonemap_white(float p_white) {
 	tonemap_white = p_white;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
+	_update_tonemap();
 }
 
 float Environment::get_tonemap_white() const {
 	return tonemap_white;
 }
 
-void Environment::set_tonemap_auto_exposure(bool p_enabled) {
-	tonemap_auto_exposure = p_enabled;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
+void Environment::set_tonemap_auto_exposure_enabled(bool p_enabled) {
+	tonemap_auto_exposure_enabled = p_enabled;
+	_update_tonemap();
 	_change_notify();
 }
 
-bool Environment::get_tonemap_auto_exposure() const {
-	return tonemap_auto_exposure;
-}
-
-void Environment::set_tonemap_auto_exposure_max(float p_auto_exposure_max) {
-	tonemap_auto_exposure_max = p_auto_exposure_max;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
-}
-
-float Environment::get_tonemap_auto_exposure_max() const {
-	return tonemap_auto_exposure_max;
+bool Environment::is_tonemap_auto_exposure_enabled() const {
+	return tonemap_auto_exposure_enabled;
 }
 
 void Environment::set_tonemap_auto_exposure_min(float p_auto_exposure_min) {
 	tonemap_auto_exposure_min = p_auto_exposure_min;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
+	_update_tonemap();
 }
 
 float Environment::get_tonemap_auto_exposure_min() const {
 	return tonemap_auto_exposure_min;
 }
 
+void Environment::set_tonemap_auto_exposure_max(float p_auto_exposure_max) {
+	tonemap_auto_exposure_max = p_auto_exposure_max;
+	_update_tonemap();
+}
+
+float Environment::get_tonemap_auto_exposure_max() const {
+	return tonemap_auto_exposure_max;
+}
+
 void Environment::set_tonemap_auto_exposure_speed(float p_auto_exposure_speed) {
 	tonemap_auto_exposure_speed = p_auto_exposure_speed;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
+	_update_tonemap();
 }
 
 float Environment::get_tonemap_auto_exposure_speed() const {
@@ -230,143 +254,31 @@ float Environment::get_tonemap_auto_exposure_speed() const {
 
 void Environment::set_tonemap_auto_exposure_grey(float p_auto_exposure_grey) {
 	tonemap_auto_exposure_grey = p_auto_exposure_grey;
-	RS::get_singleton()->environment_set_tonemap(environment, RS::EnvironmentToneMapper(tone_mapper), tonemap_exposure, tonemap_white, tonemap_auto_exposure, tonemap_auto_exposure_min, tonemap_auto_exposure_max, tonemap_auto_exposure_speed, tonemap_auto_exposure_grey);
+	_update_tonemap();
 }
 
 float Environment::get_tonemap_auto_exposure_grey() const {
 	return tonemap_auto_exposure_grey;
 }
 
-void Environment::set_adjustment_enable(bool p_enable) {
-	adjustment_enabled = p_enable;
-	RS::get_singleton()->environment_set_adjustment(environment, adjustment_enabled, adjustment_brightness, adjustment_contrast, adjustment_saturation, adjustment_color_correction.is_valid() ? adjustment_color_correction->get_rid() : RID());
-	_change_notify();
-}
-
-bool Environment::is_adjustment_enabled() const {
-	return adjustment_enabled;
-}
-
-void Environment::set_adjustment_brightness(float p_brightness) {
-	adjustment_brightness = p_brightness;
-	RS::get_singleton()->environment_set_adjustment(environment, adjustment_enabled, adjustment_brightness, adjustment_contrast, adjustment_saturation, adjustment_color_correction.is_valid() ? adjustment_color_correction->get_rid() : RID());
-}
-
-float Environment::get_adjustment_brightness() const {
-	return adjustment_brightness;
-}
-
-void Environment::set_adjustment_contrast(float p_contrast) {
-	adjustment_contrast = p_contrast;
-	RS::get_singleton()->environment_set_adjustment(environment, adjustment_enabled, adjustment_brightness, adjustment_contrast, adjustment_saturation, adjustment_color_correction.is_valid() ? adjustment_color_correction->get_rid() : RID());
-}
-
-float Environment::get_adjustment_contrast() const {
-	return adjustment_contrast;
-}
-
-void Environment::set_adjustment_saturation(float p_saturation) {
-	adjustment_saturation = p_saturation;
-	RS::get_singleton()->environment_set_adjustment(environment, adjustment_enabled, adjustment_brightness, adjustment_contrast, adjustment_saturation, adjustment_color_correction.is_valid() ? adjustment_color_correction->get_rid() : RID());
-}
-
-float Environment::get_adjustment_saturation() const {
-	return adjustment_saturation;
-}
-
-void Environment::set_adjustment_color_correction(const Ref<Texture2D> &p_ramp) {
-	adjustment_color_correction = p_ramp;
-	RS::get_singleton()->environment_set_adjustment(environment, adjustment_enabled, adjustment_brightness, adjustment_contrast, adjustment_saturation, adjustment_color_correction.is_valid() ? adjustment_color_correction->get_rid() : RID());
-}
-
-Ref<Texture2D> Environment::get_adjustment_color_correction() const {
-	return adjustment_color_correction;
+void Environment::_update_tonemap() {
+	RS::get_singleton()->environment_set_tonemap(
+			environment,
+			RS::EnvironmentToneMapper(tone_mapper),
+			tonemap_exposure,
+			tonemap_white,
+			tonemap_auto_exposure_enabled,
+			tonemap_auto_exposure_min,
+			tonemap_auto_exposure_max,
+			tonemap_auto_exposure_speed,
+			tonemap_auto_exposure_grey);
 }
 
-void Environment::_validate_property(PropertyInfo &property) const {
-	if (property.name == "sky" || property.name == "sky_custom_fov" || property.name == "sky_rotation" || property.name == "ambient_light/sky_contribution") {
-		if (bg_mode != BG_SKY && ambient_source != AMBIENT_SOURCE_SKY && reflection_source != REFLECTION_SOURCE_SKY) {
-			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
-		}
-	}
-
-	if (property.name == "glow_intensity" && glow_blend_mode == GLOW_BLEND_MODE_MIX) {
-		property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
-	}
-
-	if (property.name == "glow_mix" && glow_blend_mode != GLOW_BLEND_MODE_MIX) {
-		property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
-	}
+// SSR
 
-	if (property.name == "background_color") {
-		if (bg_mode != BG_COLOR && ambient_source != AMBIENT_SOURCE_COLOR) {
-			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
-		}
-	}
-
-	if (property.name == "background_canvas_max_layer") {
-		if (bg_mode != BG_CANVAS) {
-			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
-		}
-	}
-
-	if (property.name == "background_camera_feed_id") {
-		if (bg_mode != BG_CAMERA_FEED) {
-			property.usage = PROPERTY_USAGE_NOEDITOR;
-		}
-	}
-
-	static const char *hide_prefixes[] = {
-		"fog_",
-		"auto_exposure_",
-		"ss_reflections_",
-		"ssao_",
-		"glow_",
-		"adjustment_",
-		nullptr
-
-	};
-
-	static const char *high_end_prefixes[] = {
-		"auto_exposure_",
-		"tonemap_",
-		"ss_reflections_",
-		"ssao_",
-		nullptr
-
-	};
-
-	const char **prefixes = hide_prefixes;
-	while (*prefixes) {
-		String prefix = String(*prefixes);
-
-		String enabled = prefix + "enabled";
-		if (property.name.begins_with(prefix) && property.name != enabled && !bool(get(enabled))) {
-			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
-			return;
-		}
-
-		prefixes++;
-	}
-
-	if (RenderingServer::get_singleton()->is_low_end()) {
-		prefixes = high_end_prefixes;
-		while (*prefixes) {
-			String prefix = String(*prefixes);
-
-			if (property.name.begins_with(prefix)) {
-				property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
-				return;
-			}
-
-			prefixes++;
-		}
-	}
-}
-
-void Environment::set_ssr_enabled(bool p_enable) {
-	ssr_enabled = p_enable;
-	RS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance);
+void Environment::set_ssr_enabled(bool p_enabled) {
+	ssr_enabled = p_enabled;
+	_update_ssr();
 	_change_notify();
 }
 
@@ -376,7 +288,7 @@ bool Environment::is_ssr_enabled() const {
 
 void Environment::set_ssr_max_steps(int p_steps) {
 	ssr_max_steps = p_steps;
-	RS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance);
+	_update_ssr();
 }
 
 int Environment::get_ssr_max_steps() const {
@@ -385,7 +297,7 @@ int Environment::get_ssr_max_steps() const {
 
 void Environment::set_ssr_fade_in(float p_fade_in) {
 	ssr_fade_in = p_fade_in;
-	RS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance);
+	_update_ssr();
 }
 
 float Environment::get_ssr_fade_in() const {
@@ -394,7 +306,7 @@ float Environment::get_ssr_fade_in() const {
 
 void Environment::set_ssr_fade_out(float p_fade_out) {
 	ssr_fade_out = p_fade_out;
-	RS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance);
+	_update_ssr();
 }
 
 float Environment::get_ssr_fade_out() const {
@@ -403,16 +315,28 @@ float Environment::get_ssr_fade_out() const {
 
 void Environment::set_ssr_depth_tolerance(float p_depth_tolerance) {
 	ssr_depth_tolerance = p_depth_tolerance;
-	RS::get_singleton()->environment_set_ssr(environment, ssr_enabled, ssr_max_steps, ssr_fade_in, ssr_fade_out, ssr_depth_tolerance);
+	_update_ssr();
 }
 
 float Environment::get_ssr_depth_tolerance() const {
 	return ssr_depth_tolerance;
 }
 
-void Environment::set_ssao_enabled(bool p_enable) {
-	ssao_enabled = p_enable;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+void Environment::_update_ssr() {
+	RS::get_singleton()->environment_set_ssr(
+			environment,
+			ssr_enabled,
+			ssr_max_steps,
+			ssr_fade_in,
+			ssr_fade_out,
+			ssr_depth_tolerance);
+}
+
+// SSAO
+
+void Environment::set_ssao_enabled(bool p_enabled) {
+	ssao_enabled = p_enabled;
+	_update_ssao();
 	_change_notify();
 }
 
@@ -422,7 +346,7 @@ bool Environment::is_ssao_enabled() const {
 
 void Environment::set_ssao_radius(float p_radius) {
 	ssao_radius = p_radius;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+	_update_ssao();
 }
 
 float Environment::get_ssao_radius() const {
@@ -431,7 +355,7 @@ float Environment::get_ssao_radius() const {
 
 void Environment::set_ssao_intensity(float p_intensity) {
 	ssao_intensity = p_intensity;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+	_update_ssao();
 }
 
 float Environment::get_ssao_intensity() const {
@@ -440,7 +364,7 @@ float Environment::get_ssao_intensity() const {
 
 void Environment::set_ssao_bias(float p_bias) {
 	ssao_bias = p_bias;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+	_update_ssao();
 }
 
 float Environment::get_ssao_bias() const {
@@ -449,7 +373,7 @@ float Environment::get_ssao_bias() const {
 
 void Environment::set_ssao_direct_light_affect(float p_direct_light_affect) {
 	ssao_direct_light_affect = p_direct_light_affect;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+	_update_ssao();
 }
 
 float Environment::get_ssao_direct_light_affect() const {
@@ -458,25 +382,16 @@ float Environment::get_ssao_direct_light_affect() const {
 
 void Environment::set_ssao_ao_channel_affect(float p_ao_channel_affect) {
 	ssao_ao_channel_affect = p_ao_channel_affect;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+	_update_ssao();
 }
 
 float Environment::get_ssao_ao_channel_affect() const {
 	return ssao_ao_channel_affect;
 }
 
-void Environment::set_ao_color(const Color &p_color) {
-	ao_color = p_color;
-	RS::get_singleton()->environment_set_ambient_light(environment, ambient_color, RS::EnvironmentAmbientSource(ambient_source), ambient_energy, ambient_sky_contribution, RS::EnvironmentReflectionSource(reflection_source), ao_color);
-}
-
-Color Environment::get_ao_color() const {
-	return ao_color;
-}
-
 void Environment::set_ssao_blur(SSAOBlur p_blur) {
 	ssao_blur = p_blur;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+	_update_ssao();
 }
 
 Environment::SSAOBlur Environment::get_ssao_blur() const {
@@ -485,16 +400,175 @@ Environment::SSAOBlur Environment::get_ssao_blur() const {
 
 void Environment::set_ssao_edge_sharpness(float p_edge_sharpness) {
 	ssao_edge_sharpness = p_edge_sharpness;
-	RS::get_singleton()->environment_set_ssao(environment, ssao_enabled, ssao_radius, ssao_intensity, ssao_bias, ssao_direct_light_affect, ssao_ao_channel_affect, RS::EnvironmentSSAOBlur(ssao_blur), ssao_edge_sharpness);
+	_update_ssao();
 }
 
 float Environment::get_ssao_edge_sharpness() const {
 	return ssao_edge_sharpness;
 }
 
+void Environment::_update_ssao() {
+	RS::get_singleton()->environment_set_ssao(
+			environment,
+			ssao_enabled,
+			ssao_radius,
+			ssao_intensity,
+			ssao_bias,
+			ssao_direct_light_affect,
+			ssao_ao_channel_affect,
+			RS::EnvironmentSSAOBlur(ssao_blur),
+			ssao_edge_sharpness);
+}
+
+// SDFGI
+
+void Environment::set_sdfgi_enabled(bool p_enabled) {
+	sdfgi_enabled = p_enabled;
+	_update_sdfgi();
+}
+
+bool Environment::is_sdfgi_enabled() const {
+	return sdfgi_enabled;
+}
+
+void Environment::set_sdfgi_cascades(SDFGICascades p_cascades) {
+	sdfgi_cascades = p_cascades;
+	_update_sdfgi();
+}
+
+Environment::SDFGICascades Environment::get_sdfgi_cascades() const {
+	return sdfgi_cascades;
+}
+
+void Environment::set_sdfgi_min_cell_size(float p_size) {
+	sdfgi_min_cell_size = p_size;
+	_change_notify("sdfgi_max_distance");
+	_change_notify("sdfgi_cascade0_distance");
+	_update_sdfgi();
+}
+
+float Environment::get_sdfgi_min_cell_size() const {
+	return sdfgi_min_cell_size;
+}
+
+void Environment::set_sdfgi_max_distance(float p_distance) {
+	p_distance /= 64.0;
+	int cc[3] = { 4, 6, 8 };
+	int cascades = cc[sdfgi_cascades];
+	for (int i = 0; i < cascades; i++) {
+		p_distance *= 0.5; //halve for each cascade
+	}
+	sdfgi_min_cell_size = p_distance;
+	_change_notify("sdfgi_min_cell_size");
+	_change_notify("sdfgi_cascade0_distance");
+	_update_sdfgi();
+}
+
+float Environment::get_sdfgi_max_distance() const {
+	float md = sdfgi_min_cell_size;
+	md *= 64.0;
+	int cc[3] = { 4, 6, 8 };
+	int cascades = cc[sdfgi_cascades];
+	for (int i = 0; i < cascades; i++) {
+		md *= 2.0;
+	}
+	return md;
+}
+
+void Environment::set_sdfgi_cascade0_distance(float p_distance) {
+	sdfgi_min_cell_size = p_distance / 64.0;
+	_change_notify("sdfgi_min_cell_size");
+	_change_notify("sdfgi_max_distance");
+	_update_sdfgi();
+}
+
+float Environment::get_sdfgi_cascade0_distance() const {
+	return sdfgi_min_cell_size * 64.0;
+}
+
+void Environment::set_sdfgi_y_scale(SDFGIYScale p_y_scale) {
+	sdfgi_y_scale = p_y_scale;
+	_update_sdfgi();
+}
+
+Environment::SDFGIYScale Environment::get_sdfgi_y_scale() const {
+	return sdfgi_y_scale;
+}
+
+void Environment::set_sdfgi_use_occlusion(bool p_enabled) {
+	sdfgi_use_occlusion = p_enabled;
+	_update_sdfgi();
+}
+
+bool Environment::is_sdfgi_using_occlusion() const {
+	return sdfgi_use_occlusion;
+}
+
+void Environment::set_sdfgi_use_multi_bounce(bool p_enabled) {
+	sdfgi_use_multibounce = p_enabled;
+	_update_sdfgi();
+}
+
+bool Environment::is_sdfgi_using_multi_bounce() const {
+	return sdfgi_use_multibounce;
+}
+
+void Environment::set_sdfgi_read_sky_light(bool p_enabled) {
+	sdfgi_read_sky_light = p_enabled;
+	_update_sdfgi();
+}
+
+bool Environment::is_sdfgi_reading_sky_light() const {
+	return sdfgi_read_sky_light;
+}
+
+void Environment::set_sdfgi_energy(float p_energy) {
+	sdfgi_energy = p_energy;
+	_update_sdfgi();
+}
+
+float Environment::get_sdfgi_energy() const {
+	return sdfgi_energy;
+}
+
+void Environment::set_sdfgi_normal_bias(float p_bias) {
+	sdfgi_normal_bias = p_bias;
+	_update_sdfgi();
+}
+
+float Environment::get_sdfgi_normal_bias() const {
+	return sdfgi_normal_bias;
+}
+
+void Environment::set_sdfgi_probe_bias(float p_bias) {
+	sdfgi_probe_bias = p_bias;
+	_update_sdfgi();
+}
+
+float Environment::get_sdfgi_probe_bias() const {
+	return sdfgi_probe_bias;
+}
+
+void Environment::_update_sdfgi() {
+	RS::get_singleton()->environment_set_sdfgi(
+			environment,
+			sdfgi_enabled,
+			RS::EnvironmentSDFGICascades(sdfgi_cascades),
+			sdfgi_min_cell_size,
+			RS::EnvironmentSDFGIYScale(sdfgi_y_scale),
+			sdfgi_use_occlusion,
+			sdfgi_use_multibounce,
+			sdfgi_read_sky_light,
+			sdfgi_energy,
+			sdfgi_normal_bias,
+			sdfgi_probe_bias);
+}
+
+// Glow
+
 void Environment::set_glow_enabled(bool p_enabled) {
 	glow_enabled = p_enabled;
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 	_change_notify();
 }
 
@@ -502,7 +576,7 @@ bool Environment::is_glow_enabled() const {
 	return glow_enabled;
 }
 
-void Environment::set_glow_level(int p_level, bool p_enabled) {
+void Environment::set_glow_level_enabled(int p_level, bool p_enabled) {
 	ERR_FAIL_INDEX(p_level, RS::MAX_GLOW_LEVELS);
 
 	if (p_enabled) {
@@ -511,7 +585,7 @@ void Environment::set_glow_level(int p_level, bool p_enabled) {
 		glow_levels &= ~(1 << p_level);
 	}
 
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 }
 
 bool Environment::is_glow_level_enabled(int p_level) const {
@@ -522,8 +596,7 @@ bool Environment::is_glow_level_enabled(int p_level) const {
 
 void Environment::set_glow_intensity(float p_intensity) {
 	glow_intensity = p_intensity;
-
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 }
 
 float Environment::get_glow_intensity() const {
@@ -532,7 +605,7 @@ float Environment::get_glow_intensity() const {
 
 void Environment::set_glow_strength(float p_strength) {
 	glow_strength = p_strength;
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 }
 
 float Environment::get_glow_strength() const {
@@ -541,7 +614,7 @@ float Environment::get_glow_strength() const {
 
 void Environment::set_glow_mix(float p_mix) {
 	glow_mix = p_mix;
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 }
 
 float Environment::get_glow_mix() const {
@@ -550,8 +623,7 @@ float Environment::get_glow_mix() const {
 
 void Environment::set_glow_bloom(float p_threshold) {
 	glow_bloom = p_threshold;
-
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 }
 
 float Environment::get_glow_bloom() const {
@@ -560,8 +632,7 @@ float Environment::get_glow_bloom() const {
 
 void Environment::set_glow_blend_mode(GlowBlendMode p_mode) {
 	glow_blend_mode = p_mode;
-
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 	_change_notify();
 }
 
@@ -571,37 +642,51 @@ Environment::GlowBlendMode Environment::get_glow_blend_mode() const {
 
 void Environment::set_glow_hdr_bleed_threshold(float p_threshold) {
 	glow_hdr_bleed_threshold = p_threshold;
-
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 }
 
 float Environment::get_glow_hdr_bleed_threshold() const {
 	return glow_hdr_bleed_threshold;
 }
 
+void Environment::set_glow_hdr_bleed_scale(float p_scale) {
+	glow_hdr_bleed_scale = p_scale;
+	_update_glow();
+}
+
+float Environment::get_glow_hdr_bleed_scale() const {
+	return glow_hdr_bleed_scale;
+}
+
 void Environment::set_glow_hdr_luminance_cap(float p_amount) {
 	glow_hdr_luminance_cap = p_amount;
-
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+	_update_glow();
 }
 
 float Environment::get_glow_hdr_luminance_cap() const {
 	return glow_hdr_luminance_cap;
 }
 
-void Environment::set_glow_hdr_bleed_scale(float p_scale) {
-	glow_hdr_bleed_scale = p_scale;
-
-	RS::get_singleton()->environment_set_glow(environment, glow_enabled, glow_levels, glow_intensity, glow_strength, glow_mix, glow_bloom, RS::EnvironmentGlowBlendMode(glow_blend_mode), glow_hdr_bleed_threshold, glow_hdr_bleed_threshold, glow_hdr_luminance_cap);
+void Environment::_update_glow() {
+	RS::get_singleton()->environment_set_glow(
+			environment,
+			glow_enabled,
+			glow_levels,
+			glow_intensity,
+			glow_strength,
+			glow_mix,
+			glow_bloom,
+			RS::EnvironmentGlowBlendMode(glow_blend_mode),
+			glow_hdr_bleed_threshold,
+			glow_hdr_bleed_scale,
+			glow_hdr_luminance_cap);
 }
 
-float Environment::get_glow_hdr_bleed_scale() const {
-	return glow_hdr_bleed_scale;
-}
+// Fog
 
 void Environment::set_fog_enabled(bool p_enabled) {
 	fog_enabled = p_enabled;
-	RS::get_singleton()->environment_set_fog(environment, fog_enabled, fog_color, fog_sun_color, fog_sun_amount);
+	_update_fog();
 	_change_notify();
 }
 
@@ -611,7 +696,7 @@ bool Environment::is_fog_enabled() const {
 
 void Environment::set_fog_color(const Color &p_color) {
 	fog_color = p_color;
-	RS::get_singleton()->environment_set_fog(environment, fog_enabled, fog_color, fog_sun_color, fog_sun_amount);
+	_update_fog();
 }
 
 Color Environment::get_fog_color() const {
@@ -620,7 +705,7 @@ Color Environment::get_fog_color() const {
 
 void Environment::set_fog_sun_color(const Color &p_color) {
 	fog_sun_color = p_color;
-	RS::get_singleton()->environment_set_fog(environment, fog_enabled, fog_color, fog_sun_color, fog_sun_amount);
+	_update_fog();
 }
 
 Color Environment::get_fog_sun_color() const {
@@ -629,16 +714,25 @@ Color Environment::get_fog_sun_color() const {
 
 void Environment::set_fog_sun_amount(float p_amount) {
 	fog_sun_amount = p_amount;
-	RS::get_singleton()->environment_set_fog(environment, fog_enabled, fog_color, fog_sun_color, fog_sun_amount);
+	_update_fog();
 }
 
 float Environment::get_fog_sun_amount() const {
 	return fog_sun_amount;
 }
 
+void Environment::_update_fog() {
+	RS::get_singleton()->environment_set_fog(
+			environment,
+			fog_enabled,
+			fog_color,
+			fog_sun_color,
+			fog_sun_amount);
+}
+
 void Environment::set_fog_depth_enabled(bool p_enabled) {
 	fog_depth_enabled = p_enabled;
-	RS::get_singleton()->environment_set_fog_depth(environment, fog_depth_enabled, fog_depth_begin, fog_depth_end, fog_depth_curve, fog_transmit_enabled, fog_transmit_curve);
+	_update_fog_depth();
 }
 
 bool Environment::is_fog_depth_enabled() const {
@@ -647,7 +741,7 @@ bool Environment::is_fog_depth_enabled() const {
 
 void Environment::set_fog_depth_begin(float p_distance) {
 	fog_depth_begin = p_distance;
-	RS::get_singleton()->environment_set_fog_depth(environment, fog_depth_enabled, fog_depth_begin, fog_depth_end, fog_depth_curve, fog_transmit_enabled, fog_transmit_curve);
+	_update_fog_depth();
 }
 
 float Environment::get_fog_depth_begin() const {
@@ -656,7 +750,7 @@ float Environment::get_fog_depth_begin() const {
 
 void Environment::set_fog_depth_end(float p_distance) {
 	fog_depth_end = p_distance;
-	RS::get_singleton()->environment_set_fog_depth(environment, fog_depth_enabled, fog_depth_begin, fog_depth_end, fog_depth_curve, fog_transmit_enabled, fog_transmit_curve);
+	_update_fog_depth();
 }
 
 float Environment::get_fog_depth_end() const {
@@ -665,7 +759,7 @@ float Environment::get_fog_depth_end() const {
 
 void Environment::set_fog_depth_curve(float p_curve) {
 	fog_depth_curve = p_curve;
-	RS::get_singleton()->environment_set_fog_depth(environment, fog_depth_enabled, fog_depth_begin, fog_depth_end, fog_depth_curve, fog_transmit_enabled, fog_transmit_curve);
+	_update_fog_depth();
 }
 
 float Environment::get_fog_depth_curve() const {
@@ -674,7 +768,7 @@ float Environment::get_fog_depth_curve() const {
 
 void Environment::set_fog_transmit_enabled(bool p_enabled) {
 	fog_transmit_enabled = p_enabled;
-	RS::get_singleton()->environment_set_fog_depth(environment, fog_depth_enabled, fog_depth_begin, fog_depth_end, fog_depth_curve, fog_transmit_enabled, fog_transmit_curve);
+	_update_fog_depth();
 }
 
 bool Environment::is_fog_transmit_enabled() const {
@@ -683,16 +777,27 @@ bool Environment::is_fog_transmit_enabled() const {
 
 void Environment::set_fog_transmit_curve(float p_curve) {
 	fog_transmit_curve = p_curve;
-	RS::get_singleton()->environment_set_fog_depth(environment, fog_depth_enabled, fog_depth_begin, fog_depth_end, fog_depth_curve, fog_transmit_enabled, fog_transmit_curve);
+	_update_fog_depth();
 }
 
 float Environment::get_fog_transmit_curve() const {
 	return fog_transmit_curve;
 }
 
+void Environment::_update_fog_depth() {
+	RS::get_singleton()->environment_set_fog_depth(
+			environment,
+			fog_depth_enabled,
+			fog_depth_begin,
+			fog_depth_end,
+			fog_depth_curve,
+			fog_transmit_enabled,
+			fog_transmit_curve);
+}
+
 void Environment::set_fog_height_enabled(bool p_enabled) {
 	fog_height_enabled = p_enabled;
-	RS::get_singleton()->environment_set_fog_height(environment, fog_height_enabled, fog_height_min, fog_height_max, fog_height_curve);
+	_update_fog_height();
 }
 
 bool Environment::is_fog_height_enabled() const {
@@ -701,7 +806,7 @@ bool Environment::is_fog_height_enabled() const {
 
 void Environment::set_fog_height_min(float p_distance) {
 	fog_height_min = p_distance;
-	RS::get_singleton()->environment_set_fog_height(environment, fog_height_enabled, fog_height_min, fog_height_max, fog_height_curve);
+	_update_fog_height();
 }
 
 float Environment::get_fog_height_min() const {
@@ -710,7 +815,7 @@ float Environment::get_fog_height_min() const {
 
 void Environment::set_fog_height_max(float p_distance) {
 	fog_height_max = p_distance;
-	RS::get_singleton()->environment_set_fog_height(environment, fog_height_enabled, fog_height_min, fog_height_max, fog_height_curve);
+	_update_fog_height();
 }
 
 float Environment::get_fog_height_max() const {
@@ -719,290 +824,255 @@ float Environment::get_fog_height_max() const {
 
 void Environment::set_fog_height_curve(float p_distance) {
 	fog_height_curve = p_distance;
-	RS::get_singleton()->environment_set_fog_height(environment, fog_height_enabled, fog_height_min, fog_height_max, fog_height_curve);
+	_update_fog_height();
 }
 
 float Environment::get_fog_height_curve() const {
 	return fog_height_curve;
 }
 
-#ifndef DISABLE_DEPRECATED
-// Kept for compatibility from 3.x to 4.0.
-bool Environment::_set(const StringName &p_name, const Variant &p_value) {
-	if (p_name == "background_sky") {
-		set_sky(p_value);
-		return true;
-	} else if (p_name == "background_sky_custom_fov") {
-		set_sky_custom_fov(p_value);
-		return true;
-	} else if (p_name == "background_sky_orientation") {
-		Vector3 euler = p_value.operator Basis().get_euler();
-		set_sky_rotation(euler);
-		return true;
-	} else {
-		return false;
-	}
+void Environment::_update_fog_height() {
+	RS::get_singleton()->environment_set_fog_height(
+			environment,
+			fog_height_enabled,
+			fog_height_min,
+			fog_height_max,
+			fog_height_curve);
 }
-#endif
 
-void Environment::set_sdfgi_enabled(bool p_enabled) {
-	sdfgi_enabled = p_enabled;
-	_update_sdfgi();
-}
+// Adjustment
 
-bool Environment::is_sdfgi_enabled() const {
-	return sdfgi_enabled;
+void Environment::set_adjustment_enabled(bool p_enabled) {
+	adjustment_enabled = p_enabled;
+	_update_adjustment();
+	_change_notify();
 }
 
-void Environment::set_sdfgi_cascades(SDFGICascades p_cascades) {
-	sdfgi_cascades = p_cascades;
-	_update_sdfgi();
-}
-Environment::SDFGICascades Environment::get_sdfgi_cascades() const {
-	return sdfgi_cascades;
+bool Environment::is_adjustment_enabled() const {
+	return adjustment_enabled;
 }
 
-void Environment::set_sdfgi_min_cell_size(float p_size) {
-	sdfgi_min_cell_size = p_size;
-	_change_notify("sdfgi_max_distance");
-	_change_notify("sdfgi_cascade0_distance");
-	_update_sdfgi();
-}
-float Environment::get_sdfgi_min_cell_size() const {
-	return sdfgi_min_cell_size;
+void Environment::set_adjustment_brightness(float p_brightness) {
+	adjustment_brightness = p_brightness;
+	_update_adjustment();
 }
 
-void Environment::set_sdfgi_max_distance(float p_size) {
-	p_size /= 64.0;
-	int cc[3] = { 4, 6, 8 };
-	int cascades = cc[sdfgi_cascades];
-	for (int i = 0; i < cascades; i++) {
-		p_size *= 0.5; //halve for each cascade
-	}
-	sdfgi_min_cell_size = p_size;
-	_change_notify("sdfgi_min_cell_size");
-	_change_notify("sdfgi_cascade0_distance");
-	_update_sdfgi();
-}
-float Environment::get_sdfgi_max_distance() const {
-	float md = sdfgi_min_cell_size;
-	md *= 64.0;
-	int cc[3] = { 4, 6, 8 };
-	int cascades = cc[sdfgi_cascades];
-	for (int i = 0; i < cascades; i++) {
-		md *= 2.0;
-	}
-	return md;
+float Environment::get_adjustment_brightness() const {
+	return adjustment_brightness;
 }
 
-void Environment::set_sdfgi_cascade0_distance(float p_size) {
-	sdfgi_min_cell_size = p_size / 64.0;
-	_change_notify("sdfgi_min_cell_size");
-	_change_notify("sdfgi_max_distance");
-	_update_sdfgi();
-}
-float Environment::get_sdfgi_cascade0_distance() const {
-	return sdfgi_min_cell_size * 64.0;
+void Environment::set_adjustment_contrast(float p_contrast) {
+	adjustment_contrast = p_contrast;
+	_update_adjustment();
 }
 
-void Environment::set_sdfgi_use_occlusion(bool p_enable) {
-	sdfgi_use_occlusion = p_enable;
-	_update_sdfgi();
+float Environment::get_adjustment_contrast() const {
+	return adjustment_contrast;
 }
 
-bool Environment::is_sdfgi_using_occlusion() const {
-	return sdfgi_use_occlusion;
+void Environment::set_adjustment_saturation(float p_saturation) {
+	adjustment_saturation = p_saturation;
+	_update_adjustment();
 }
 
-void Environment::set_sdfgi_use_multi_bounce(bool p_enable) {
-	sdfgi_use_multibounce = p_enable;
-	_update_sdfgi();
-}
-bool Environment::is_sdfgi_using_multi_bounce() const {
-	return sdfgi_use_multibounce;
+float Environment::get_adjustment_saturation() const {
+	return adjustment_saturation;
 }
 
-void Environment::set_sdfgi_use_enhance_ssr(bool p_enable) {
-	sdfgi_enhance_ssr = p_enable;
-	_update_sdfgi();
-}
-bool Environment::is_sdfgi_using_enhance_ssr() const {
-	return sdfgi_enhance_ssr;
+void Environment::set_adjustment_color_correction(const Ref<Texture2D> &p_ramp) {
+	adjustment_color_correction = p_ramp;
+	_update_adjustment();
 }
 
-void Environment::set_sdfgi_read_sky_light(bool p_enable) {
-	sdfgi_read_sky_light = p_enable;
-	_update_sdfgi();
+Ref<Texture2D> Environment::get_adjustment_color_correction() const {
+	return adjustment_color_correction;
 }
 
-bool Environment::is_sdfgi_reading_sky_light() const {
-	return sdfgi_read_sky_light;
+void Environment::_update_adjustment() {
+	RS::get_singleton()->environment_set_adjustment(
+			environment,
+			adjustment_enabled,
+			adjustment_brightness,
+			adjustment_contrast,
+			adjustment_saturation,
+			adjustment_color_correction.is_valid() ? adjustment_color_correction->get_rid() : RID());
 }
 
-void Environment::set_sdfgi_energy(float p_energy) {
-	sdfgi_energy = p_energy;
-	_update_sdfgi();
-}
-float Environment::get_sdfgi_energy() const {
-	return sdfgi_energy;
-}
+// Private methods, constructor and destructor
 
-void Environment::set_sdfgi_normal_bias(float p_bias) {
-	sdfgi_normal_bias = p_bias;
-	_update_sdfgi();
-}
-float Environment::get_sdfgi_normal_bias() const {
-	return sdfgi_normal_bias;
-}
+void Environment::_validate_property(PropertyInfo &property) const {
+	if (property.name == "sky" || property.name == "sky_custom_fov" || property.name == "sky_rotation" || property.name == "ambient_light/sky_contribution") {
+		if (bg_mode != BG_SKY && ambient_source != AMBIENT_SOURCE_SKY && reflection_source != REFLECTION_SOURCE_SKY) {
+			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
+		}
+	}
 
-void Environment::set_sdfgi_probe_bias(float p_bias) {
-	sdfgi_probe_bias = p_bias;
-	_update_sdfgi();
-}
-float Environment::get_sdfgi_probe_bias() const {
-	return sdfgi_probe_bias;
-}
+	if (property.name == "glow_intensity" && glow_blend_mode == GLOW_BLEND_MODE_MIX) {
+		property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
+	}
 
-void Environment::set_sdfgi_y_scale(SDFGIYScale p_y_scale) {
-	sdfgi_y_scale = p_y_scale;
-	_update_sdfgi();
-}
-Environment::SDFGIYScale Environment::get_sdfgi_y_scale() const {
-	return sdfgi_y_scale;
+	if (property.name == "glow_mix" && glow_blend_mode != GLOW_BLEND_MODE_MIX) {
+		property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
+	}
+
+	if (property.name == "background_color") {
+		if (bg_mode != BG_COLOR && ambient_source != AMBIENT_SOURCE_COLOR) {
+			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
+		}
+	}
+
+	if (property.name == "background_canvas_max_layer") {
+		if (bg_mode != BG_CANVAS) {
+			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
+		}
+	}
+
+	if (property.name == "background_camera_feed_id") {
+		if (bg_mode != BG_CAMERA_FEED) {
+			property.usage = PROPERTY_USAGE_NOEDITOR;
+		}
+	}
+
+	static const char *hide_prefixes[] = {
+		"fog_",
+		"auto_exposure_",
+		"ss_reflections_",
+		"ssao_",
+		"glow_",
+		"adjustment_",
+		nullptr
+
+	};
+
+	static const char *high_end_prefixes[] = {
+		"auto_exposure_",
+		"tonemap_",
+		"ss_reflections_",
+		"ssao_",
+		nullptr
+
+	};
+
+	const char **prefixes = hide_prefixes;
+	while (*prefixes) {
+		String prefix = String(*prefixes);
+
+		String enabled = prefix + "enabled";
+		if (property.name.begins_with(prefix) && property.name != enabled && !bool(get(enabled))) {
+			property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
+			return;
+		}
+
+		prefixes++;
+	}
+
+	if (RenderingServer::get_singleton()->is_low_end()) {
+		prefixes = high_end_prefixes;
+		while (*prefixes) {
+			String prefix = String(*prefixes);
+
+			if (property.name.begins_with(prefix)) {
+				property.usage = PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL;
+				return;
+			}
+
+			prefixes++;
+		}
+	}
 }
-void Environment::_update_sdfgi() {
-	RS::get_singleton()->environment_set_sdfgi(environment, sdfgi_enabled, RS::EnvironmentSDFGICascades(sdfgi_cascades), sdfgi_min_cell_size, RS::EnvironmentSDFGIYScale(sdfgi_y_scale), sdfgi_use_occlusion, sdfgi_use_multibounce, sdfgi_read_sky_light, sdfgi_enhance_ssr, sdfgi_energy, sdfgi_normal_bias, sdfgi_probe_bias);
+
+#ifndef DISABLE_DEPRECATED
+// Kept for compatibility from 3.x to 4.0.
+bool Environment::_set(const StringName &p_name, const Variant &p_value) {
+	if (p_name == "background_sky") {
+		set_sky(p_value);
+		return true;
+	} else if (p_name == "background_sky_custom_fov") {
+		set_sky_custom_fov(p_value);
+		return true;
+	} else if (p_name == "background_sky_orientation") {
+		Vector3 euler = p_value.operator Basis().get_euler();
+		set_sky_rotation(euler);
+		return true;
+	} else {
+		return false;
+	}
 }
+#endif
 
 void Environment::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_background", "mode"), &Environment::set_background);
-	ClassDB::bind_method(D_METHOD("set_sky", "sky"), &Environment::set_sky);
-	ClassDB::bind_method(D_METHOD("set_sky_custom_fov", "scale"), &Environment::set_sky_custom_fov);
-	ClassDB::bind_method(D_METHOD("set_sky_rotation", "euler_radians"), &Environment::set_sky_rotation);
-	ClassDB::bind_method(D_METHOD("set_bg_color", "color"), &Environment::set_bg_color);
-	ClassDB::bind_method(D_METHOD("set_bg_energy", "energy"), &Environment::set_bg_energy);
-	ClassDB::bind_method(D_METHOD("set_canvas_max_layer", "layer"), &Environment::set_canvas_max_layer);
-	ClassDB::bind_method(D_METHOD("set_ambient_light_color", "color"), &Environment::set_ambient_light_color);
-	ClassDB::bind_method(D_METHOD("set_ambient_light_energy", "energy"), &Environment::set_ambient_light_energy);
-	ClassDB::bind_method(D_METHOD("set_ambient_light_sky_contribution", "energy"), &Environment::set_ambient_light_sky_contribution);
-	ClassDB::bind_method(D_METHOD("set_camera_feed_id", "camera_feed_id"), &Environment::set_camera_feed_id);
-	ClassDB::bind_method(D_METHOD("set_ambient_source", "source"), &Environment::set_ambient_source);
-	ClassDB::bind_method(D_METHOD("set_reflection_source", "source"), &Environment::set_reflection_source);
+	// Background
 
+	ClassDB::bind_method(D_METHOD("set_background", "mode"), &Environment::set_background);
 	ClassDB::bind_method(D_METHOD("get_background"), &Environment::get_background);
+	ClassDB::bind_method(D_METHOD("set_sky", "sky"), &Environment::set_sky);
 	ClassDB::bind_method(D_METHOD("get_sky"), &Environment::get_sky);
+	ClassDB::bind_method(D_METHOD("set_sky_custom_fov", "scale"), &Environment::set_sky_custom_fov);
 	ClassDB::bind_method(D_METHOD("get_sky_custom_fov"), &Environment::get_sky_custom_fov);
+	ClassDB::bind_method(D_METHOD("set_sky_rotation", "euler_radians"), &Environment::set_sky_rotation);
 	ClassDB::bind_method(D_METHOD("get_sky_rotation"), &Environment::get_sky_rotation);
+	ClassDB::bind_method(D_METHOD("set_bg_color", "color"), &Environment::set_bg_color);
 	ClassDB::bind_method(D_METHOD("get_bg_color"), &Environment::get_bg_color);
+	ClassDB::bind_method(D_METHOD("set_bg_energy", "energy"), &Environment::set_bg_energy);
 	ClassDB::bind_method(D_METHOD("get_bg_energy"), &Environment::get_bg_energy);
+	ClassDB::bind_method(D_METHOD("set_canvas_max_layer", "layer"), &Environment::set_canvas_max_layer);
 	ClassDB::bind_method(D_METHOD("get_canvas_max_layer"), &Environment::get_canvas_max_layer);
-	ClassDB::bind_method(D_METHOD("get_ambient_light_color"), &Environment::get_ambient_light_color);
-	ClassDB::bind_method(D_METHOD("get_ambient_light_energy"), &Environment::get_ambient_light_energy);
-	ClassDB::bind_method(D_METHOD("get_ambient_light_sky_contribution"), &Environment::get_ambient_light_sky_contribution);
+	ClassDB::bind_method(D_METHOD("set_camera_feed_id", "id"), &Environment::set_camera_feed_id);
 	ClassDB::bind_method(D_METHOD("get_camera_feed_id"), &Environment::get_camera_feed_id);
-	ClassDB::bind_method(D_METHOD("get_ambient_source"), &Environment::get_ambient_source);
-	ClassDB::bind_method(D_METHOD("get_reflection_source"), &Environment::get_reflection_source);
-	ClassDB::bind_method(D_METHOD("set_ao_color", "color"), &Environment::set_ao_color);
-	ClassDB::bind_method(D_METHOD("get_ao_color"), &Environment::get_ao_color);
 
 	ADD_GROUP("Background", "background_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "background_mode", PROPERTY_HINT_ENUM, "Clear Color,Custom Color,Sky,Canvas,Keep,Camera Feed"), "set_background", "get_background");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "background_canvas_max_layer", PROPERTY_HINT_RANGE, "-1000,1000,1"), "set_canvas_max_layer", "get_canvas_max_layer");
-	ADD_PROPERTY(PropertyInfo(Variant::INT, "background_camera_feed_id", PROPERTY_HINT_RANGE, "1,10,1"), "set_camera_feed_id", "get_camera_feed_id");
 	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "background_color"), "set_bg_color", "get_bg_color");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "background_energy", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_bg_energy", "get_bg_energy");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "background_canvas_max_layer", PROPERTY_HINT_RANGE, "-1000,1000,1"), "set_canvas_max_layer", "get_canvas_max_layer");
+	ADD_PROPERTY(PropertyInfo(Variant::INT, "background_camera_feed_id", PROPERTY_HINT_RANGE, "1,10,1"), "set_camera_feed_id", "get_camera_feed_id");
+
 	ADD_GROUP("Sky", "sky_");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "sky", PROPERTY_HINT_RESOURCE_TYPE, "Sky"), "set_sky", "get_sky");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sky_custom_fov", PROPERTY_HINT_RANGE, "0,180,0.1"), "set_sky_custom_fov", "get_sky_custom_fov");
 	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "sky_rotation"), "set_sky_rotation", "get_sky_rotation");
+
+	// Ambient light
+
+	ClassDB::bind_method(D_METHOD("set_ambient_light_color", "color"), &Environment::set_ambient_light_color);
+	ClassDB::bind_method(D_METHOD("get_ambient_light_color"), &Environment::get_ambient_light_color);
+	ClassDB::bind_method(D_METHOD("set_ambient_source", "source"), &Environment::set_ambient_source);
+	ClassDB::bind_method(D_METHOD("get_ambient_source"), &Environment::get_ambient_source);
+	ClassDB::bind_method(D_METHOD("set_ambient_light_energy", "energy"), &Environment::set_ambient_light_energy);
+	ClassDB::bind_method(D_METHOD("get_ambient_light_energy"), &Environment::get_ambient_light_energy);
+	ClassDB::bind_method(D_METHOD("set_ambient_light_sky_contribution", "ratio"), &Environment::set_ambient_light_sky_contribution);
+	ClassDB::bind_method(D_METHOD("get_ambient_light_sky_contribution"), &Environment::get_ambient_light_sky_contribution);
+	ClassDB::bind_method(D_METHOD("set_reflection_source", "source"), &Environment::set_reflection_source);
+	ClassDB::bind_method(D_METHOD("get_reflection_source"), &Environment::get_reflection_source);
+	ClassDB::bind_method(D_METHOD("set_ao_color", "color"), &Environment::set_ao_color);
+	ClassDB::bind_method(D_METHOD("get_ao_color"), &Environment::get_ao_color);
+
 	ADD_GROUP("Ambient Light", "ambient_light_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "ambient_light_source", PROPERTY_HINT_ENUM, "Background,Disabled,Color,Sky"), "set_ambient_source", "get_ambient_source");
 	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "ambient_light_color"), "set_ambient_light_color", "get_ambient_light_color");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ambient_light_sky_contribution", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_ambient_light_sky_contribution", "get_ambient_light_sky_contribution");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ambient_light_energy", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_ambient_light_energy", "get_ambient_light_energy");
 	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "ambient_light_occlusion_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_ao_color", "get_ao_color");
+
 	ADD_GROUP("Reflected Light", "reflected_light_");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "reflected_light_source", PROPERTY_HINT_ENUM, "Background,Disabled,Sky"), "set_reflection_source", "get_reflection_source");
 
-	ClassDB::bind_method(D_METHOD("set_fog_enabled", "enabled"), &Environment::set_fog_enabled);
-	ClassDB::bind_method(D_METHOD("is_fog_enabled"), &Environment::is_fog_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_fog_color", "color"), &Environment::set_fog_color);
-	ClassDB::bind_method(D_METHOD("get_fog_color"), &Environment::get_fog_color);
-
-	ClassDB::bind_method(D_METHOD("set_fog_sun_color", "color"), &Environment::set_fog_sun_color);
-	ClassDB::bind_method(D_METHOD("get_fog_sun_color"), &Environment::get_fog_sun_color);
-
-	ClassDB::bind_method(D_METHOD("set_fog_sun_amount", "amount"), &Environment::set_fog_sun_amount);
-	ClassDB::bind_method(D_METHOD("get_fog_sun_amount"), &Environment::get_fog_sun_amount);
-
-	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_begin", "distance"), &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", "distance"), &Environment::set_fog_depth_end);
-	ClassDB::bind_method(D_METHOD("get_fog_depth_end"), &Environment::get_fog_depth_end);
-
-	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_transmit_enabled", "enabled"), &Environment::set_fog_transmit_enabled);
-	ClassDB::bind_method(D_METHOD("is_fog_transmit_enabled"), &Environment::is_fog_transmit_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_fog_transmit_curve", "curve"), &Environment::set_fog_transmit_curve);
-	ClassDB::bind_method(D_METHOD("get_fog_transmit_curve"), &Environment::get_fog_transmit_curve);
-
-	ClassDB::bind_method(D_METHOD("set_fog_height_enabled", "enabled"), &Environment::set_fog_height_enabled);
-	ClassDB::bind_method(D_METHOD("is_fog_height_enabled"), &Environment::is_fog_height_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_fog_height_min", "height"), &Environment::set_fog_height_min);
-	ClassDB::bind_method(D_METHOD("get_fog_height_min"), &Environment::get_fog_height_min);
-
-	ClassDB::bind_method(D_METHOD("set_fog_height_max", "height"), &Environment::set_fog_height_max);
-	ClassDB::bind_method(D_METHOD("get_fog_height_max"), &Environment::get_fog_height_max);
-
-	ClassDB::bind_method(D_METHOD("set_fog_height_curve", "curve"), &Environment::set_fog_height_curve);
-	ClassDB::bind_method(D_METHOD("get_fog_height_curve"), &Environment::get_fog_height_curve);
-
-	ADD_GROUP("Fog", "fog_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_enabled"), "set_fog_enabled", "is_fog_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "fog_color"), "set_fog_color", "get_fog_color");
-	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "fog_sun_color"), "set_fog_sun_color", "get_fog_sun_color");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_sun_amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_fog_sun_amount", "get_fog_sun_amount");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_depth_enabled"), "set_fog_depth_enabled", "is_fog_depth_enabled");
-	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");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_depth_curve", PROPERTY_HINT_EXP_EASING), "set_fog_depth_curve", "get_fog_depth_curve");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_transmit_enabled"), "set_fog_transmit_enabled", "is_fog_transmit_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_transmit_curve", PROPERTY_HINT_EXP_EASING), "set_fog_transmit_curve", "get_fog_transmit_curve");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_height_enabled"), "set_fog_height_enabled", "is_fog_height_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height_min", PROPERTY_HINT_RANGE, "-4000,4000,0.1,or_lesser,or_greater"), "set_fog_height_min", "get_fog_height_min");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height_max", PROPERTY_HINT_RANGE, "-4000,4000,0.1,or_lesser,or_greater"), "set_fog_height_max", "get_fog_height_max");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height_curve", PROPERTY_HINT_EXP_EASING), "set_fog_height_curve", "get_fog_height_curve");
+	// Tonemap
 
 	ClassDB::bind_method(D_METHOD("set_tonemapper", "mode"), &Environment::set_tonemapper);
 	ClassDB::bind_method(D_METHOD("get_tonemapper"), &Environment::get_tonemapper);
-
 	ClassDB::bind_method(D_METHOD("set_tonemap_exposure", "exposure"), &Environment::set_tonemap_exposure);
 	ClassDB::bind_method(D_METHOD("get_tonemap_exposure"), &Environment::get_tonemap_exposure);
-
 	ClassDB::bind_method(D_METHOD("set_tonemap_white", "white"), &Environment::set_tonemap_white);
 	ClassDB::bind_method(D_METHOD("get_tonemap_white"), &Environment::get_tonemap_white);
-
-	ClassDB::bind_method(D_METHOD("set_tonemap_auto_exposure", "auto_exposure"), &Environment::set_tonemap_auto_exposure);
-	ClassDB::bind_method(D_METHOD("get_tonemap_auto_exposure"), &Environment::get_tonemap_auto_exposure);
-
+	ClassDB::bind_method(D_METHOD("set_tonemap_auto_exposure_enabled", "enabled"), &Environment::set_tonemap_auto_exposure_enabled);
+	ClassDB::bind_method(D_METHOD("is_tonemap_auto_exposure_enabled"), &Environment::is_tonemap_auto_exposure_enabled);
 	ClassDB::bind_method(D_METHOD("set_tonemap_auto_exposure_max", "exposure_max"), &Environment::set_tonemap_auto_exposure_max);
 	ClassDB::bind_method(D_METHOD("get_tonemap_auto_exposure_max"), &Environment::get_tonemap_auto_exposure_max);
-
 	ClassDB::bind_method(D_METHOD("set_tonemap_auto_exposure_min", "exposure_min"), &Environment::set_tonemap_auto_exposure_min);
 	ClassDB::bind_method(D_METHOD("get_tonemap_auto_exposure_min"), &Environment::get_tonemap_auto_exposure_min);
-
 	ClassDB::bind_method(D_METHOD("set_tonemap_auto_exposure_speed", "exposure_speed"), &Environment::set_tonemap_auto_exposure_speed);
 	ClassDB::bind_method(D_METHOD("get_tonemap_auto_exposure_speed"), &Environment::get_tonemap_auto_exposure_speed);
-
 	ClassDB::bind_method(D_METHOD("set_tonemap_auto_exposure_grey", "exposure_grey"), &Environment::set_tonemap_auto_exposure_grey);
 	ClassDB::bind_method(D_METHOD("get_tonemap_auto_exposure_grey"), &Environment::get_tonemap_auto_exposure_grey);
 
@@ -1011,24 +1081,22 @@ void Environment::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "tonemap_exposure", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_tonemap_exposure", "get_tonemap_exposure");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "tonemap_white", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_tonemap_white", "get_tonemap_white");
 	ADD_GROUP("Auto Exposure", "auto_exposure_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_exposure_enabled"), "set_tonemap_auto_exposure", "get_tonemap_auto_exposure");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_exposure_enabled"), "set_tonemap_auto_exposure_enabled", "is_tonemap_auto_exposure_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "auto_exposure_scale", PROPERTY_HINT_RANGE, "0.01,64,0.01"), "set_tonemap_auto_exposure_grey", "get_tonemap_auto_exposure_grey");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "auto_exposure_min_luma", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_tonemap_auto_exposure_min", "get_tonemap_auto_exposure_min");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "auto_exposure_max_luma", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_tonemap_auto_exposure_max", "get_tonemap_auto_exposure_max");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "auto_exposure_speed", PROPERTY_HINT_RANGE, "0.01,64,0.01"), "set_tonemap_auto_exposure_speed", "get_tonemap_auto_exposure_speed");
 
+	// SSR
+
 	ClassDB::bind_method(D_METHOD("set_ssr_enabled", "enabled"), &Environment::set_ssr_enabled);
 	ClassDB::bind_method(D_METHOD("is_ssr_enabled"), &Environment::is_ssr_enabled);
-
 	ClassDB::bind_method(D_METHOD("set_ssr_max_steps", "max_steps"), &Environment::set_ssr_max_steps);
 	ClassDB::bind_method(D_METHOD("get_ssr_max_steps"), &Environment::get_ssr_max_steps);
-
 	ClassDB::bind_method(D_METHOD("set_ssr_fade_in", "fade_in"), &Environment::set_ssr_fade_in);
 	ClassDB::bind_method(D_METHOD("get_ssr_fade_in"), &Environment::get_ssr_fade_in);
-
 	ClassDB::bind_method(D_METHOD("set_ssr_fade_out", "fade_out"), &Environment::set_ssr_fade_out);
 	ClassDB::bind_method(D_METHOD("get_ssr_fade_out"), &Environment::get_ssr_fade_out);
-
 	ClassDB::bind_method(D_METHOD("set_ssr_depth_tolerance", "depth_tolerance"), &Environment::set_ssr_depth_tolerance);
 	ClassDB::bind_method(D_METHOD("get_ssr_depth_tolerance"), &Environment::get_ssr_depth_tolerance);
 
@@ -1039,27 +1107,22 @@ void Environment::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ss_reflections_fade_out", PROPERTY_HINT_EXP_EASING), "set_ssr_fade_out", "get_ssr_fade_out");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ss_reflections_depth_tolerance", PROPERTY_HINT_RANGE, "0.01,128,0.1"), "set_ssr_depth_tolerance", "get_ssr_depth_tolerance");
 
+	// SSAO
+
 	ClassDB::bind_method(D_METHOD("set_ssao_enabled", "enabled"), &Environment::set_ssao_enabled);
 	ClassDB::bind_method(D_METHOD("is_ssao_enabled"), &Environment::is_ssao_enabled);
-
 	ClassDB::bind_method(D_METHOD("set_ssao_radius", "radius"), &Environment::set_ssao_radius);
 	ClassDB::bind_method(D_METHOD("get_ssao_radius"), &Environment::get_ssao_radius);
-
 	ClassDB::bind_method(D_METHOD("set_ssao_intensity", "intensity"), &Environment::set_ssao_intensity);
 	ClassDB::bind_method(D_METHOD("get_ssao_intensity"), &Environment::get_ssao_intensity);
-
 	ClassDB::bind_method(D_METHOD("set_ssao_bias", "bias"), &Environment::set_ssao_bias);
 	ClassDB::bind_method(D_METHOD("get_ssao_bias"), &Environment::get_ssao_bias);
-
 	ClassDB::bind_method(D_METHOD("set_ssao_direct_light_affect", "amount"), &Environment::set_ssao_direct_light_affect);
 	ClassDB::bind_method(D_METHOD("get_ssao_direct_light_affect"), &Environment::get_ssao_direct_light_affect);
-
 	ClassDB::bind_method(D_METHOD("set_ssao_ao_channel_affect", "amount"), &Environment::set_ssao_ao_channel_affect);
 	ClassDB::bind_method(D_METHOD("get_ssao_ao_channel_affect"), &Environment::get_ssao_ao_channel_affect);
-
 	ClassDB::bind_method(D_METHOD("set_ssao_blur", "mode"), &Environment::set_ssao_blur);
 	ClassDB::bind_method(D_METHOD("get_ssao_blur"), &Environment::get_ssao_blur);
-
 	ClassDB::bind_method(D_METHOD("set_ssao_edge_sharpness", "edge_sharpness"), &Environment::set_ssao_edge_sharpness);
 	ClassDB::bind_method(D_METHOD("get_ssao_edge_sharpness"), &Environment::get_ssao_edge_sharpness);
 
@@ -1073,42 +1136,33 @@ void Environment::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "ssao_blur", PROPERTY_HINT_ENUM, "Disabled,1x1,2x2,3x3"), "set_ssao_blur", "get_ssao_blur");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ssao_edge_sharpness", PROPERTY_HINT_RANGE, "0,32,0.01"), "set_ssao_edge_sharpness", "get_ssao_edge_sharpness");
 
+	// SDFGI
+
 	ClassDB::bind_method(D_METHOD("set_sdfgi_enabled", "enabled"), &Environment::set_sdfgi_enabled);
 	ClassDB::bind_method(D_METHOD("is_sdfgi_enabled"), &Environment::is_sdfgi_enabled);
-
 	ClassDB::bind_method(D_METHOD("set_sdfgi_cascades", "amount"), &Environment::set_sdfgi_cascades);
 	ClassDB::bind_method(D_METHOD("get_sdfgi_cascades"), &Environment::get_sdfgi_cascades);
-
-	ClassDB::bind_method(D_METHOD("set_sdfgi_min_cell_size", "strength"), &Environment::set_sdfgi_min_cell_size);
+	ClassDB::bind_method(D_METHOD("set_sdfgi_min_cell_size", "size"), &Environment::set_sdfgi_min_cell_size);
 	ClassDB::bind_method(D_METHOD("get_sdfgi_min_cell_size"), &Environment::get_sdfgi_min_cell_size);
-
-	ClassDB::bind_method(D_METHOD("set_sdfgi_max_distance", "strength"), &Environment::set_sdfgi_max_distance);
+	ClassDB::bind_method(D_METHOD("set_sdfgi_max_distance", "distance"), &Environment::set_sdfgi_max_distance);
 	ClassDB::bind_method(D_METHOD("get_sdfgi_max_distance"), &Environment::get_sdfgi_max_distance);
-
-	ClassDB::bind_method(D_METHOD("set_sdfgi_cascade0_distance", "strength"), &Environment::set_sdfgi_cascade0_distance);
+	ClassDB::bind_method(D_METHOD("set_sdfgi_cascade0_distance", "distance"), &Environment::set_sdfgi_cascade0_distance);
 	ClassDB::bind_method(D_METHOD("get_sdfgi_cascade0_distance"), &Environment::get_sdfgi_cascade0_distance);
-
+	ClassDB::bind_method(D_METHOD("set_sdfgi_y_scale", "scale"), &Environment::set_sdfgi_y_scale);
+	ClassDB::bind_method(D_METHOD("get_sdfgi_y_scale"), &Environment::get_sdfgi_y_scale);
 	ClassDB::bind_method(D_METHOD("set_sdfgi_use_occlusion", "enable"), &Environment::set_sdfgi_use_occlusion);
 	ClassDB::bind_method(D_METHOD("is_sdfgi_using_occlusion"), &Environment::is_sdfgi_using_occlusion);
-
 	ClassDB::bind_method(D_METHOD("set_sdfgi_use_multi_bounce", "enable"), &Environment::set_sdfgi_use_multi_bounce);
 	ClassDB::bind_method(D_METHOD("is_sdfgi_using_multi_bounce"), &Environment::is_sdfgi_using_multi_bounce);
-
 	ClassDB::bind_method(D_METHOD("set_sdfgi_read_sky_light", "enable"), &Environment::set_sdfgi_read_sky_light);
 	ClassDB::bind_method(D_METHOD("is_sdfgi_reading_sky_light"), &Environment::is_sdfgi_reading_sky_light);
-
 	ClassDB::bind_method(D_METHOD("set_sdfgi_energy", "amount"), &Environment::set_sdfgi_energy);
 	ClassDB::bind_method(D_METHOD("get_sdfgi_energy"), &Environment::get_sdfgi_energy);
-
 	ClassDB::bind_method(D_METHOD("set_sdfgi_normal_bias", "bias"), &Environment::set_sdfgi_normal_bias);
 	ClassDB::bind_method(D_METHOD("get_sdfgi_normal_bias"), &Environment::get_sdfgi_normal_bias);
-
 	ClassDB::bind_method(D_METHOD("set_sdfgi_probe_bias", "bias"), &Environment::set_sdfgi_probe_bias);
 	ClassDB::bind_method(D_METHOD("get_sdfgi_probe_bias"), &Environment::get_sdfgi_probe_bias);
 
-	ClassDB::bind_method(D_METHOD("set_sdfgi_y_scale", "scale"), &Environment::set_sdfgi_y_scale);
-	ClassDB::bind_method(D_METHOD("get_sdfgi_y_scale"), &Environment::get_sdfgi_y_scale);
-
 	ADD_GROUP("SDFGI", "sdfgi_");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sdfgi_enabled"), "set_sdfgi_enabled", "is_sdfgi_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "sdfgi_use_multi_bounce"), "set_sdfgi_use_multi_bounce", "is_sdfgi_using_multi_bounce");
@@ -1123,77 +1177,120 @@ void Environment::_bind_methods() {
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sdfgi_normal_bias"), "set_sdfgi_normal_bias", "get_sdfgi_normal_bias");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sdfgi_probe_bias"), "set_sdfgi_probe_bias", "get_sdfgi_probe_bias");
 
+	// Glow
+
 	ClassDB::bind_method(D_METHOD("set_glow_enabled", "enabled"), &Environment::set_glow_enabled);
 	ClassDB::bind_method(D_METHOD("is_glow_enabled"), &Environment::is_glow_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_glow_level", "idx", "enabled"), &Environment::set_glow_level);
+	ClassDB::bind_method(D_METHOD("set_glow_level_enabled", "idx", "enabled"), &Environment::set_glow_level_enabled);
 	ClassDB::bind_method(D_METHOD("is_glow_level_enabled", "idx"), &Environment::is_glow_level_enabled);
-
 	ClassDB::bind_method(D_METHOD("set_glow_intensity", "intensity"), &Environment::set_glow_intensity);
 	ClassDB::bind_method(D_METHOD("get_glow_intensity"), &Environment::get_glow_intensity);
-
 	ClassDB::bind_method(D_METHOD("set_glow_strength", "strength"), &Environment::set_glow_strength);
 	ClassDB::bind_method(D_METHOD("get_glow_strength"), &Environment::get_glow_strength);
-
 	ClassDB::bind_method(D_METHOD("set_glow_mix", "mix"), &Environment::set_glow_mix);
 	ClassDB::bind_method(D_METHOD("get_glow_mix"), &Environment::get_glow_mix);
-
 	ClassDB::bind_method(D_METHOD("set_glow_bloom", "amount"), &Environment::set_glow_bloom);
 	ClassDB::bind_method(D_METHOD("get_glow_bloom"), &Environment::get_glow_bloom);
-
 	ClassDB::bind_method(D_METHOD("set_glow_blend_mode", "mode"), &Environment::set_glow_blend_mode);
 	ClassDB::bind_method(D_METHOD("get_glow_blend_mode"), &Environment::get_glow_blend_mode);
-
 	ClassDB::bind_method(D_METHOD("set_glow_hdr_bleed_threshold", "threshold"), &Environment::set_glow_hdr_bleed_threshold);
 	ClassDB::bind_method(D_METHOD("get_glow_hdr_bleed_threshold"), &Environment::get_glow_hdr_bleed_threshold);
-
-	ClassDB::bind_method(D_METHOD("set_glow_hdr_luminance_cap", "amount"), &Environment::set_glow_hdr_luminance_cap);
-	ClassDB::bind_method(D_METHOD("get_glow_hdr_luminance_cap"), &Environment::get_glow_hdr_luminance_cap);
-
 	ClassDB::bind_method(D_METHOD("set_glow_hdr_bleed_scale", "scale"), &Environment::set_glow_hdr_bleed_scale);
 	ClassDB::bind_method(D_METHOD("get_glow_hdr_bleed_scale"), &Environment::get_glow_hdr_bleed_scale);
+	ClassDB::bind_method(D_METHOD("set_glow_hdr_luminance_cap", "amount"), &Environment::set_glow_hdr_luminance_cap);
+	ClassDB::bind_method(D_METHOD("get_glow_hdr_luminance_cap"), &Environment::get_glow_hdr_luminance_cap);
 
 	ADD_GROUP("Glow", "glow_");
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "glow_enabled"), "set_glow_enabled", "is_glow_enabled");
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/1"), "set_glow_level", "is_glow_level_enabled", 0);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/2"), "set_glow_level", "is_glow_level_enabled", 1);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/3"), "set_glow_level", "is_glow_level_enabled", 2);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/4"), "set_glow_level", "is_glow_level_enabled", 3);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/5"), "set_glow_level", "is_glow_level_enabled", 4);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/6"), "set_glow_level", "is_glow_level_enabled", 5);
-	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/7"), "set_glow_level", "is_glow_level_enabled", 6);
-
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/1"), "set_glow_level_enabled", "is_glow_level_enabled", 0);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/2"), "set_glow_level_enabled", "is_glow_level_enabled", 1);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/3"), "set_glow_level_enabled", "is_glow_level_enabled", 2);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/4"), "set_glow_level_enabled", "is_glow_level_enabled", 3);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/5"), "set_glow_level_enabled", "is_glow_level_enabled", 4);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/6"), "set_glow_level_enabled", "is_glow_level_enabled", 5);
+	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, "glow_levels/7"), "set_glow_level_enabled", "is_glow_level_enabled", 6);
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_intensity", PROPERTY_HINT_RANGE, "0.0,8.0,0.01"), "set_glow_intensity", "get_glow_intensity");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_mix", PROPERTY_HINT_RANGE, "0.0,1.0,0.001"), "set_glow_mix", "get_glow_mix");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_strength", PROPERTY_HINT_RANGE, "0.0,2.0,0.01"), "set_glow_strength", "get_glow_strength");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_mix", PROPERTY_HINT_RANGE, "0.0,1.0,0.001"), "set_glow_mix", "get_glow_mix");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_bloom", PROPERTY_HINT_RANGE, "0.0,1.0,0.01"), "set_glow_bloom", "get_glow_bloom");
 	ADD_PROPERTY(PropertyInfo(Variant::INT, "glow_blend_mode", PROPERTY_HINT_ENUM, "Additive,Screen,Softlight,Replace,Mix"), "set_glow_blend_mode", "get_glow_blend_mode");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_hdr_threshold", PROPERTY_HINT_RANGE, "0.0,4.0,0.01"), "set_glow_hdr_bleed_threshold", "get_glow_hdr_bleed_threshold");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_hdr_luminance_cap", PROPERTY_HINT_RANGE, "0.0,256.0,0.01"), "set_glow_hdr_luminance_cap", "get_glow_hdr_luminance_cap");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_hdr_scale", PROPERTY_HINT_RANGE, "0.0,4.0,0.01"), "set_glow_hdr_bleed_scale", "get_glow_hdr_bleed_scale");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "glow_hdr_luminance_cap", PROPERTY_HINT_RANGE, "0.0,256.0,0.01"), "set_glow_hdr_luminance_cap", "get_glow_hdr_luminance_cap");
 
-	ClassDB::bind_method(D_METHOD("set_adjustment_enable", "enabled"), &Environment::set_adjustment_enable);
-	ClassDB::bind_method(D_METHOD("is_adjustment_enabled"), &Environment::is_adjustment_enabled);
+	// Fog
 
+	ClassDB::bind_method(D_METHOD("set_fog_enabled", "enabled"), &Environment::set_fog_enabled);
+	ClassDB::bind_method(D_METHOD("is_fog_enabled"), &Environment::is_fog_enabled);
+	ClassDB::bind_method(D_METHOD("set_fog_color", "color"), &Environment::set_fog_color);
+	ClassDB::bind_method(D_METHOD("get_fog_color"), &Environment::get_fog_color);
+	ClassDB::bind_method(D_METHOD("set_fog_sun_color", "color"), &Environment::set_fog_sun_color);
+	ClassDB::bind_method(D_METHOD("get_fog_sun_color"), &Environment::get_fog_sun_color);
+	ClassDB::bind_method(D_METHOD("set_fog_sun_amount", "amount"), &Environment::set_fog_sun_amount);
+	ClassDB::bind_method(D_METHOD("get_fog_sun_amount"), &Environment::get_fog_sun_amount);
+
+	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_begin", "distance"), &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", "distance"), &Environment::set_fog_depth_end);
+	ClassDB::bind_method(D_METHOD("get_fog_depth_end"), &Environment::get_fog_depth_end);
+	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_transmit_enabled", "enabled"), &Environment::set_fog_transmit_enabled);
+	ClassDB::bind_method(D_METHOD("is_fog_transmit_enabled"), &Environment::is_fog_transmit_enabled);
+	ClassDB::bind_method(D_METHOD("set_fog_transmit_curve", "curve"), &Environment::set_fog_transmit_curve);
+	ClassDB::bind_method(D_METHOD("get_fog_transmit_curve"), &Environment::get_fog_transmit_curve);
+
+	ClassDB::bind_method(D_METHOD("set_fog_height_enabled", "enabled"), &Environment::set_fog_height_enabled);
+	ClassDB::bind_method(D_METHOD("is_fog_height_enabled"), &Environment::is_fog_height_enabled);
+	ClassDB::bind_method(D_METHOD("set_fog_height_min", "height"), &Environment::set_fog_height_min);
+	ClassDB::bind_method(D_METHOD("get_fog_height_min"), &Environment::get_fog_height_min);
+	ClassDB::bind_method(D_METHOD("set_fog_height_max", "height"), &Environment::set_fog_height_max);
+	ClassDB::bind_method(D_METHOD("get_fog_height_max"), &Environment::get_fog_height_max);
+	ClassDB::bind_method(D_METHOD("set_fog_height_curve", "curve"), &Environment::set_fog_height_curve);
+	ClassDB::bind_method(D_METHOD("get_fog_height_curve"), &Environment::get_fog_height_curve);
+
+	ADD_GROUP("Fog", "fog_");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_enabled"), "set_fog_enabled", "is_fog_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "fog_color"), "set_fog_color", "get_fog_color");
+	ADD_PROPERTY(PropertyInfo(Variant::COLOR, "fog_sun_color"), "set_fog_sun_color", "get_fog_sun_color");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_sun_amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_fog_sun_amount", "get_fog_sun_amount");
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_depth_enabled"), "set_fog_depth_enabled", "is_fog_depth_enabled");
+	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");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_depth_curve", PROPERTY_HINT_EXP_EASING), "set_fog_depth_curve", "get_fog_depth_curve");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_transmit_enabled"), "set_fog_transmit_enabled", "is_fog_transmit_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_transmit_curve", PROPERTY_HINT_EXP_EASING), "set_fog_transmit_curve", "get_fog_transmit_curve");
+
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "fog_height_enabled"), "set_fog_height_enabled", "is_fog_height_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height_min", PROPERTY_HINT_RANGE, "-4000,4000,0.1,or_lesser,or_greater"), "set_fog_height_min", "get_fog_height_min");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height_max", PROPERTY_HINT_RANGE, "-4000,4000,0.1,or_lesser,or_greater"), "set_fog_height_max", "get_fog_height_max");
+	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fog_height_curve", PROPERTY_HINT_EXP_EASING), "set_fog_height_curve", "get_fog_height_curve");
+
+	// Adjustment
+
+	ClassDB::bind_method(D_METHOD("set_adjustment_enabled", "enabled"), &Environment::set_adjustment_enabled);
+	ClassDB::bind_method(D_METHOD("is_adjustment_enabled"), &Environment::is_adjustment_enabled);
 	ClassDB::bind_method(D_METHOD("set_adjustment_brightness", "brightness"), &Environment::set_adjustment_brightness);
 	ClassDB::bind_method(D_METHOD("get_adjustment_brightness"), &Environment::get_adjustment_brightness);
-
 	ClassDB::bind_method(D_METHOD("set_adjustment_contrast", "contrast"), &Environment::set_adjustment_contrast);
 	ClassDB::bind_method(D_METHOD("get_adjustment_contrast"), &Environment::get_adjustment_contrast);
-
 	ClassDB::bind_method(D_METHOD("set_adjustment_saturation", "saturation"), &Environment::set_adjustment_saturation);
 	ClassDB::bind_method(D_METHOD("get_adjustment_saturation"), &Environment::get_adjustment_saturation);
-
 	ClassDB::bind_method(D_METHOD("set_adjustment_color_correction", "color_correction"), &Environment::set_adjustment_color_correction);
 	ClassDB::bind_method(D_METHOD("get_adjustment_color_correction"), &Environment::get_adjustment_color_correction);
 
 	ADD_GROUP("Adjustments", "adjustment_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "adjustment_enabled"), "set_adjustment_enable", "is_adjustment_enabled");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "adjustment_enabled"), "set_adjustment_enabled", "is_adjustment_enabled");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "adjustment_brightness", PROPERTY_HINT_RANGE, "0.01,8,0.01"), "set_adjustment_brightness", "get_adjustment_brightness");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "adjustment_contrast", PROPERTY_HINT_RANGE, "0.01,8,0.01"), "set_adjustment_contrast", "get_adjustment_contrast");
 	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "adjustment_saturation", PROPERTY_HINT_RANGE, "0.01,8,0.01"), "set_adjustment_saturation", "get_adjustment_saturation");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "adjustment_color_correction", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_adjustment_color_correction", "get_adjustment_color_correction");
 
+	// Constants
+
 	BIND_ENUM_CONSTANT(BG_CLEAR_COLOR);
 	BIND_ENUM_CONSTANT(BG_COLOR);
 	BIND_ENUM_CONSTANT(BG_SKY);
@@ -1211,267 +1308,49 @@ void Environment::_bind_methods() {
 	BIND_ENUM_CONSTANT(REFLECTION_SOURCE_DISABLED);
 	BIND_ENUM_CONSTANT(REFLECTION_SOURCE_SKY);
 
+	BIND_ENUM_CONSTANT(TONE_MAPPER_LINEAR);
+	BIND_ENUM_CONSTANT(TONE_MAPPER_REINHARDT);
+	BIND_ENUM_CONSTANT(TONE_MAPPER_FILMIC);
+	BIND_ENUM_CONSTANT(TONE_MAPPER_ACES);
+
 	BIND_ENUM_CONSTANT(GLOW_BLEND_MODE_ADDITIVE);
 	BIND_ENUM_CONSTANT(GLOW_BLEND_MODE_SCREEN);
 	BIND_ENUM_CONSTANT(GLOW_BLEND_MODE_SOFTLIGHT);
 	BIND_ENUM_CONSTANT(GLOW_BLEND_MODE_REPLACE);
 	BIND_ENUM_CONSTANT(GLOW_BLEND_MODE_MIX);
 
-	BIND_ENUM_CONSTANT(TONE_MAPPER_LINEAR);
-	BIND_ENUM_CONSTANT(TONE_MAPPER_REINHARDT);
-	BIND_ENUM_CONSTANT(TONE_MAPPER_FILMIC);
-	BIND_ENUM_CONSTANT(TONE_MAPPER_ACES);
-
 	BIND_ENUM_CONSTANT(SSAO_BLUR_DISABLED);
 	BIND_ENUM_CONSTANT(SSAO_BLUR_1x1);
 	BIND_ENUM_CONSTANT(SSAO_BLUR_2x2);
 	BIND_ENUM_CONSTANT(SSAO_BLUR_3x3);
+
+	BIND_ENUM_CONSTANT(SDFGI_CASCADES_4);
+	BIND_ENUM_CONSTANT(SDFGI_CASCADES_6);
+	BIND_ENUM_CONSTANT(SDFGI_CASCADES_8);
+
+	BIND_ENUM_CONSTANT(SDFGI_Y_SCALE_DISABLED);
+	BIND_ENUM_CONSTANT(SDFGI_Y_SCALE_75_PERCENT);
+	BIND_ENUM_CONSTANT(SDFGI_Y_SCALE_50_PERCENT);
 }
 
 Environment::Environment() {
 	environment = RS::get_singleton()->environment_create();
 
-	bg_mode = BG_CLEAR_COLOR;
-	bg_sky_custom_fov = 0;
-	bg_energy = 1.0;
-	bg_canvas_max_layer = 0;
-	ambient_energy = 1.0;
-	//ambient_sky_contribution = 1.0;
-	ambient_source = AMBIENT_SOURCE_BG;
-	reflection_source = REFLECTION_SOURCE_BG;
-	set_ambient_light_sky_contribution(1.0);
-	set_camera_feed_id(1);
-
-	tone_mapper = TONE_MAPPER_LINEAR;
-	tonemap_exposure = 1.0;
-	tonemap_white = 1.0;
-	tonemap_auto_exposure = false;
-	tonemap_auto_exposure_max = 8;
-	tonemap_auto_exposure_min = 0.05;
-	tonemap_auto_exposure_speed = 0.5;
-	tonemap_auto_exposure_grey = 0.4;
-
-	set_tonemapper(tone_mapper); //update
-
-	adjustment_enabled = false;
-	adjustment_contrast = 1.0;
-	adjustment_saturation = 1.0;
-	adjustment_brightness = 1.0;
-
-	set_adjustment_enable(adjustment_enabled); //update
-
-	ssr_enabled = false;
-	ssr_max_steps = 64;
-	ssr_fade_in = 0.15;
-	ssr_fade_out = 2.0;
-	ssr_depth_tolerance = 0.2;
-
-	ssao_enabled = false;
-	ssao_radius = 1;
-	ssao_intensity = 1;
-	ssao_bias = 0.01;
-	ssao_direct_light_affect = 0.0;
-	ssao_ao_channel_affect = 0.0;
-	ssao_blur = SSAO_BLUR_3x3;
-	set_ssao_edge_sharpness(4);
-
-	glow_enabled = false;
-	glow_levels = (1 << 2) | (1 << 4);
-	glow_intensity = 0.8;
-	glow_strength = 1.0;
-	glow_mix = 0.05;
-	glow_bloom = 0.0;
-	glow_blend_mode = GLOW_BLEND_MODE_SOFTLIGHT;
-	glow_hdr_bleed_threshold = 1.0;
-	glow_hdr_luminance_cap = 12.0;
-	glow_hdr_bleed_scale = 2.0;
-
-	fog_enabled = false;
-	fog_color = Color(0.5, 0.5, 0.5);
-	fog_sun_color = Color(0.8, 0.8, 0.0);
-	fog_sun_amount = 0;
-
-	fog_depth_enabled = true;
-
-	fog_depth_begin = 10;
-	fog_depth_end = 100;
-	fog_depth_curve = 1;
-
-	fog_transmit_enabled = false;
-	fog_transmit_curve = 1;
-
-	fog_height_enabled = false;
-	fog_height_min = 10;
-	fog_height_max = 0;
-	fog_height_curve = 1;
-
-	set_fog_color(Color(0.5, 0.6, 0.7));
-	set_fog_sun_color(Color(1.0, 0.9, 0.7));
-
-	sdfgi_enabled = false;
-	sdfgi_cascades = SDFGI_CASCADES_6;
-	sdfgi_min_cell_size = 0.2;
-	sdfgi_use_occlusion = false;
-	sdfgi_use_multibounce = false;
-	sdfgi_read_sky_light = false;
-	sdfgi_enhance_ssr = false;
-	sdfgi_energy = 1.0;
-	sdfgi_normal_bias = 1.1;
-	sdfgi_probe_bias = 1.1;
-	sdfgi_y_scale = SDFGI_Y_SCALE_DISABLED;
+	set_camera_feed_id(bg_camera_feed_id);
+	_update_ambient_light();
+	_update_tonemap();
+	_update_ssr();
+	_update_ssao();
 	_update_sdfgi();
-}
-
-Environment::~Environment() {
-	RS::get_singleton()->free(environment);
-}
-
-//////////////////////
+	_update_glow();
+	_update_fog();
+	_update_fog_depth();
+	_update_fog_height();
+	_update_adjustment();
 
-void CameraEffects::set_dof_blur_far_enabled(bool p_enable) {
-	dof_blur_far_enabled = p_enable;
-	RS::get_singleton()->camera_effects_set_dof_blur(camera_effects, dof_blur_far_enabled, dof_blur_far_distance, dof_blur_far_transition, dof_blur_near_enabled, dof_blur_near_distance, dof_blur_near_transition, dof_blur_amount);
-}
-
-bool CameraEffects::is_dof_blur_far_enabled() const {
-	return dof_blur_far_enabled;
-}
-
-void CameraEffects::set_dof_blur_far_distance(float p_distance) {
-	dof_blur_far_distance = p_distance;
-	RS::get_singleton()->camera_effects_set_dof_blur(camera_effects, dof_blur_far_enabled, dof_blur_far_distance, dof_blur_far_transition, dof_blur_near_enabled, dof_blur_near_distance, dof_blur_near_transition, dof_blur_amount);
-}
-
-float CameraEffects::get_dof_blur_far_distance() const {
-	return dof_blur_far_distance;
-}
-
-void CameraEffects::set_dof_blur_far_transition(float p_distance) {
-	dof_blur_far_transition = p_distance;
-	RS::get_singleton()->camera_effects_set_dof_blur(camera_effects, dof_blur_far_enabled, dof_blur_far_distance, dof_blur_far_transition, dof_blur_near_enabled, dof_blur_near_distance, dof_blur_near_transition, dof_blur_amount);
-}
-
-float CameraEffects::get_dof_blur_far_transition() const {
-	return dof_blur_far_transition;
-}
-
-void CameraEffects::set_dof_blur_near_enabled(bool p_enable) {
-	dof_blur_near_enabled = p_enable;
-	RS::get_singleton()->camera_effects_set_dof_blur(camera_effects, dof_blur_far_enabled, dof_blur_far_distance, dof_blur_far_transition, dof_blur_near_enabled, dof_blur_near_distance, dof_blur_near_transition, dof_blur_amount);
 	_change_notify();
 }
 
-bool CameraEffects::is_dof_blur_near_enabled() const {
-	return dof_blur_near_enabled;
-}
-
-void CameraEffects::set_dof_blur_near_distance(float p_distance) {
-	dof_blur_near_distance = p_distance;
-	RS::get_singleton()->camera_effects_set_dof_blur(camera_effects, dof_blur_far_enabled, dof_blur_far_distance, dof_blur_far_transition, dof_blur_near_enabled, dof_blur_near_distance, dof_blur_near_transition, dof_blur_amount);
-}
-
-float CameraEffects::get_dof_blur_near_distance() const {
-	return dof_blur_near_distance;
-}
-
-void CameraEffects::set_dof_blur_near_transition(float p_distance) {
-	dof_blur_near_transition = p_distance;
-	RS::get_singleton()->camera_effects_set_dof_blur(camera_effects, dof_blur_far_enabled, dof_blur_far_distance, dof_blur_far_transition, dof_blur_near_enabled, dof_blur_near_distance, dof_blur_near_transition, dof_blur_amount);
-}
-
-float CameraEffects::get_dof_blur_near_transition() const {
-	return dof_blur_near_transition;
-}
-
-void CameraEffects::set_dof_blur_amount(float p_amount) {
-	dof_blur_amount = p_amount;
-	RS::get_singleton()->camera_effects_set_dof_blur(camera_effects, dof_blur_far_enabled, dof_blur_far_distance, dof_blur_far_transition, dof_blur_near_enabled, dof_blur_near_distance, dof_blur_near_transition, dof_blur_amount);
-}
-
-float CameraEffects::get_dof_blur_amount() const {
-	return dof_blur_amount;
-}
-
-void CameraEffects::set_override_exposure_enabled(bool p_enabled) {
-	override_exposure_enabled = p_enabled;
-	RS::get_singleton()->camera_effects_set_custom_exposure(camera_effects, override_exposure_enabled, override_exposure);
-}
-
-bool CameraEffects::is_override_exposure_enabled() const {
-	return override_exposure_enabled;
-}
-
-void CameraEffects::set_override_exposure(float p_exposure) {
-	override_exposure = p_exposure;
-	RS::get_singleton()->camera_effects_set_custom_exposure(camera_effects, override_exposure_enabled, override_exposure);
-}
-
-float CameraEffects::get_override_exposure() const {
-	return override_exposure;
-}
-
-RID CameraEffects::get_rid() const {
-	return camera_effects;
-}
-
-void CameraEffects::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("set_dof_blur_far_enabled", "enabled"), &CameraEffects::set_dof_blur_far_enabled);
-	ClassDB::bind_method(D_METHOD("is_dof_blur_far_enabled"), &CameraEffects::is_dof_blur_far_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_dof_blur_far_distance", "intensity"), &CameraEffects::set_dof_blur_far_distance);
-	ClassDB::bind_method(D_METHOD("get_dof_blur_far_distance"), &CameraEffects::get_dof_blur_far_distance);
-
-	ClassDB::bind_method(D_METHOD("set_dof_blur_far_transition", "intensity"), &CameraEffects::set_dof_blur_far_transition);
-	ClassDB::bind_method(D_METHOD("get_dof_blur_far_transition"), &CameraEffects::get_dof_blur_far_transition);
-
-	ClassDB::bind_method(D_METHOD("set_dof_blur_near_enabled", "enabled"), &CameraEffects::set_dof_blur_near_enabled);
-	ClassDB::bind_method(D_METHOD("is_dof_blur_near_enabled"), &CameraEffects::is_dof_blur_near_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_dof_blur_near_distance", "intensity"), &CameraEffects::set_dof_blur_near_distance);
-	ClassDB::bind_method(D_METHOD("get_dof_blur_near_distance"), &CameraEffects::get_dof_blur_near_distance);
-
-	ClassDB::bind_method(D_METHOD("set_dof_blur_near_transition", "intensity"), &CameraEffects::set_dof_blur_near_transition);
-	ClassDB::bind_method(D_METHOD("get_dof_blur_near_transition"), &CameraEffects::get_dof_blur_near_transition);
-
-	ClassDB::bind_method(D_METHOD("set_dof_blur_amount", "intensity"), &CameraEffects::set_dof_blur_amount);
-	ClassDB::bind_method(D_METHOD("get_dof_blur_amount"), &CameraEffects::get_dof_blur_amount);
-
-	ClassDB::bind_method(D_METHOD("set_override_exposure_enabled", "enable"), &CameraEffects::set_override_exposure_enabled);
-	ClassDB::bind_method(D_METHOD("is_override_exposure_enabled"), &CameraEffects::is_override_exposure_enabled);
-
-	ClassDB::bind_method(D_METHOD("set_override_exposure", "exposure"), &CameraEffects::set_override_exposure);
-	ClassDB::bind_method(D_METHOD("get_override_exposure"), &CameraEffects::get_override_exposure);
-
-	ADD_GROUP("DOF Blur", "dof_blur_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dof_blur_far_enabled"), "set_dof_blur_far_enabled", "is_dof_blur_far_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_far_distance", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_far_distance", "get_dof_blur_far_distance");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_far_transition", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_far_transition", "get_dof_blur_far_transition");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "dof_blur_near_enabled"), "set_dof_blur_near_enabled", "is_dof_blur_near_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_near_distance", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_near_distance", "get_dof_blur_near_distance");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_near_transition", PROPERTY_HINT_EXP_RANGE, "0.01,8192,0.01"), "set_dof_blur_near_transition", "get_dof_blur_near_transition");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "dof_blur_amount", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_dof_blur_amount", "get_dof_blur_amount");
-	ADD_GROUP("Override Exposure", "override_");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "override_exposure_enable"), "set_override_exposure_enabled", "is_override_exposure_enabled");
-	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "override_exposure", PROPERTY_HINT_RANGE, "0,16,0.01"), "set_override_exposure", "get_override_exposure");
-}
-
-CameraEffects::CameraEffects() {
-	camera_effects = RS::get_singleton()->camera_effects_create();
-
-	dof_blur_far_enabled = false;
-	dof_blur_far_distance = 10;
-	dof_blur_far_transition = 5;
-
-	dof_blur_near_enabled = false;
-	dof_blur_near_distance = 2;
-	dof_blur_near_transition = 1;
-
-	set_dof_blur_amount(0.1);
-
-	override_exposure_enabled = false;
-	set_override_exposure(1.0);
-}
-
-CameraEffects::~CameraEffects() {
-	RS::get_singleton()->free(camera_effects);
+Environment::~Environment() {
+	RS::get_singleton()->free(environment);
 }
diff --git a/scene/resources/environment.h b/scene/resources/environment.h
index 83a5fe939c..5dbeeb2fc8 100644
--- a/scene/resources/environment.h
+++ b/scene/resources/environment.h
@@ -41,7 +41,6 @@ class Environment : public Resource {
 
 public:
 	enum BGMode {
-
 		BG_CLEAR_COLOR,
 		BG_COLOR,
 		BG_SKY,
@@ -68,22 +67,14 @@ public:
 		TONE_MAPPER_LINEAR,
 		TONE_MAPPER_REINHARDT,
 		TONE_MAPPER_FILMIC,
-		TONE_MAPPER_ACES
-	};
-
-	enum GlowBlendMode {
-		GLOW_BLEND_MODE_ADDITIVE,
-		GLOW_BLEND_MODE_SCREEN,
-		GLOW_BLEND_MODE_SOFTLIGHT,
-		GLOW_BLEND_MODE_REPLACE,
-		GLOW_BLEND_MODE_MIX,
+		TONE_MAPPER_ACES,
 	};
 
 	enum SSAOBlur {
 		SSAO_BLUR_DISABLED,
 		SSAO_BLUR_1x1,
 		SSAO_BLUR_2x2,
-		SSAO_BLUR_3x3
+		SSAO_BLUR_3x3,
 	};
 
 	enum SDFGICascades {
@@ -98,97 +89,121 @@ public:
 		SDFGI_Y_SCALE_50_PERCENT,
 	};
 
+	enum GlowBlendMode {
+		GLOW_BLEND_MODE_ADDITIVE,
+		GLOW_BLEND_MODE_SCREEN,
+		GLOW_BLEND_MODE_SOFTLIGHT,
+		GLOW_BLEND_MODE_REPLACE,
+		GLOW_BLEND_MODE_MIX,
+	};
+
 private:
 	RID environment;
 
+	// Background
 	BGMode bg_mode = BG_CLEAR_COLOR;
 	Ref<Sky> bg_sky;
-	float bg_sky_custom_fov;
-	Vector3 sky_rotation;
+	float bg_sky_custom_fov = 0;
+	Vector3 bg_sky_rotation;
 	Color bg_color;
-	float bg_energy;
-	int bg_canvas_max_layer;
+	float bg_energy = 1.0;
+	int bg_canvas_max_layer = 0;
+	int bg_camera_feed_id = 1;
+
+	// Ambient light
 	Color ambient_color;
-	float ambient_energy;
+	AmbientSource ambient_source = AMBIENT_SOURCE_BG;
+	float ambient_energy = 1.0;
+	float ambient_sky_contribution = 1.0;
+	ReflectionSource reflection_source = REFLECTION_SOURCE_BG;
 	Color ao_color;
-	float ambient_sky_contribution;
-	int camera_feed_id;
-	AmbientSource ambient_source;
-	ReflectionSource reflection_source;
+	void _update_ambient_light();
 
+	// Tonemap
 	ToneMapper tone_mapper = TONE_MAPPER_LINEAR;
-	float tonemap_exposure;
-	float tonemap_white;
-	bool tonemap_auto_exposure;
-	float tonemap_auto_exposure_max;
-	float tonemap_auto_exposure_min;
-	float tonemap_auto_exposure_speed;
-	float tonemap_auto_exposure_grey;
-
-	bool adjustment_enabled;
-	float adjustment_contrast;
-	float adjustment_saturation;
-	float adjustment_brightness;
-	Ref<Texture2D> adjustment_color_correction;
-
-	bool ssr_enabled;
-	int ssr_max_steps;
-	float ssr_fade_in;
-	float ssr_fade_out;
-	float ssr_depth_tolerance;
-
-	bool ssao_enabled;
-	float ssao_radius;
-	float ssao_intensity;
-	float ssao_bias;
-	float ssao_direct_light_affect;
-	float ssao_ao_channel_affect;
+	float tonemap_exposure = 1.0;
+	float tonemap_white = 1.0;
+	bool tonemap_auto_exposure_enabled = false;
+	float tonemap_auto_exposure_min = 0.05;
+	float tonemap_auto_exposure_max = 8;
+	float tonemap_auto_exposure_speed = 0.5;
+	float tonemap_auto_exposure_grey = 0.4;
+	void _update_tonemap();
+
+	// SSR
+	bool ssr_enabled = false;
+	int ssr_max_steps = 64;
+	float ssr_fade_in = 0.15;
+	float ssr_fade_out = 2.0;
+	float ssr_depth_tolerance = 0.2;
+	void _update_ssr();
+
+	// SSAO
+	bool ssao_enabled = false;
+	float ssao_radius = 1.0;
+	float ssao_intensity = 1.0;
+	float ssao_bias = 0.01;
+	float ssao_direct_light_affect = 0.0;
+	float ssao_ao_channel_affect = 0.0;
 	SSAOBlur ssao_blur = SSAO_BLUR_3x3;
-	float ssao_edge_sharpness;
-
-	bool glow_enabled;
-	int glow_levels;
-	float glow_intensity;
-	float glow_strength;
-	float glow_mix;
-	float glow_bloom;
-	GlowBlendMode glow_blend_mode = GLOW_BLEND_MODE_ADDITIVE;
-	float glow_hdr_bleed_threshold;
-	float glow_hdr_bleed_scale;
-	float glow_hdr_luminance_cap;
-
-	bool fog_enabled;
-	Color fog_color;
-	Color fog_sun_color;
-	float fog_sun_amount;
-
-	bool fog_depth_enabled;
-	float fog_depth_begin;
-	float fog_depth_end;
-	float fog_depth_curve;
-
-	bool fog_transmit_enabled;
-	float fog_transmit_curve;
-
-	bool fog_height_enabled;
-	float fog_height_min;
-	float fog_height_max;
-	float fog_height_curve;
-
-	bool sdfgi_enabled;
-	SDFGICascades sdfgi_cascades;
-	float sdfgi_min_cell_size;
-	bool sdfgi_use_occlusion;
-	bool sdfgi_use_multibounce;
-	bool sdfgi_read_sky_light;
-	bool sdfgi_enhance_ssr;
-	float sdfgi_energy;
-	float sdfgi_normal_bias;
-	float sdfgi_probe_bias;
-	SDFGIYScale sdfgi_y_scale;
-
+	float ssao_edge_sharpness = 4.0;
+	void _update_ssao();
+
+	// SDFGI
+	bool sdfgi_enabled = false;
+	SDFGICascades sdfgi_cascades = SDFGI_CASCADES_6;
+	float sdfgi_min_cell_size = 0.2;
+	SDFGIYScale sdfgi_y_scale = SDFGI_Y_SCALE_DISABLED;
+	bool sdfgi_use_occlusion = false;
+	bool sdfgi_use_multibounce = false;
+	bool sdfgi_read_sky_light = false;
+	float sdfgi_energy = 1.0;
+	float sdfgi_normal_bias = 1.1;
+	float sdfgi_probe_bias = 1.1;
 	void _update_sdfgi();
 
+	// Glow
+	bool glow_enabled = false;
+	int glow_levels = (1 << 2) | (1 << 4);
+	float glow_intensity = 0.8;
+	float glow_strength = 1.0;
+	float glow_mix = 0.05;
+	float glow_bloom = 0.0;
+	GlowBlendMode glow_blend_mode = GLOW_BLEND_MODE_SOFTLIGHT;
+	float glow_hdr_bleed_threshold = 1.0;
+	float glow_hdr_bleed_scale = 2.0;
+	float glow_hdr_luminance_cap = 12.0;
+	void _update_glow();
+
+	// Fog
+	bool fog_enabled = false;
+	Color fog_color = Color(0.5, 0.6, 0.7);
+	Color fog_sun_color = Color(1.0, 0.9, 0.7);
+	float fog_sun_amount = 0.0;
+	void _update_fog();
+
+	bool fog_depth_enabled = true;
+	float fog_depth_begin = 10.0;
+	float fog_depth_end = 100.0;
+	float fog_depth_curve = 1.0;
+	bool fog_transmit_enabled = false;
+	float fog_transmit_curve = 1.0;
+	void _update_fog_depth();
+
+	bool fog_height_enabled = false;
+	float fog_height_min = 10.0;
+	float fog_height_max = 0.0;
+	float fog_height_curve = 1.0;
+	void _update_fog_height();
+
+	// Adjustment
+	bool adjustment_enabled = false;
+	float adjustment_brightness = 1.0;
+	float adjustment_contrast = 1.0;
+	float adjustment_saturation = 1.0;
+	Ref<Texture2D> adjustment_color_correction;
+	void _update_adjustment();
+
 protected:
 	static void _bind_methods();
 	virtual void _validate_property(PropertyInfo &property) const;
@@ -198,228 +213,179 @@ protected:
 #endif
 
 public:
-	void set_background(BGMode p_bg);
+	virtual RID get_rid() const;
 
+	// Background
+	void set_background(BGMode p_bg);
+	BGMode get_background() const;
 	void set_sky(const Ref<Sky> &p_sky);
+	Ref<Sky> get_sky() const;
 	void set_sky_custom_fov(float p_scale);
+	float get_sky_custom_fov() const;
 	void set_sky_rotation(const Vector3 &p_rotation);
+	Vector3 get_sky_rotation() const;
 	void set_bg_color(const Color &p_color);
+	Color get_bg_color() const;
 	void set_bg_energy(float p_energy);
+	float get_bg_energy() const;
 	void set_canvas_max_layer(int p_max_layer);
+	int get_canvas_max_layer() const;
+	void set_camera_feed_id(int p_id);
+	int get_camera_feed_id() const;
+
+	// Ambient light
 	void set_ambient_light_color(const Color &p_color);
-	void set_ambient_light_energy(float p_energy);
-	void set_ambient_light_sky_contribution(float p_energy);
-	void set_camera_feed_id(int p_camera_feed_id);
+	Color get_ambient_light_color() const;
 	void set_ambient_source(AmbientSource p_source);
 	AmbientSource get_ambient_source() const;
-	void set_reflection_source(ReflectionSource p_source);
-	ReflectionSource get_reflection_source() const;
-
-	BGMode get_background() const;
-	Ref<Sky> get_sky() const;
-	float get_sky_custom_fov() const;
-	Vector3 get_sky_rotation() const;
-	Color get_bg_color() const;
-	float get_bg_energy() const;
-	int get_canvas_max_layer() const;
-	Color get_ambient_light_color() const;
+	void set_ambient_light_energy(float p_energy);
 	float get_ambient_light_energy() const;
+	void set_ambient_light_sky_contribution(float p_ratio);
 	float get_ambient_light_sky_contribution() const;
-	int get_camera_feed_id() const;
+	void set_reflection_source(ReflectionSource p_source);
+	ReflectionSource get_reflection_source() const;
+	void set_ao_color(const Color &p_color);
+	Color get_ao_color() const;
 
+	// Tonemap
 	void set_tonemapper(ToneMapper p_tone_mapper);
 	ToneMapper get_tonemapper() const;
-
 	void set_tonemap_exposure(float p_exposure);
 	float get_tonemap_exposure() const;
-
 	void set_tonemap_white(float p_white);
 	float get_tonemap_white() const;
-
-	void set_tonemap_auto_exposure(bool p_enabled);
-	bool get_tonemap_auto_exposure() const;
-
-	void set_tonemap_auto_exposure_max(float p_auto_exposure_max);
-	float get_tonemap_auto_exposure_max() const;
-
+	void set_tonemap_auto_exposure_enabled(bool p_enabled);
+	bool is_tonemap_auto_exposure_enabled() const;
 	void set_tonemap_auto_exposure_min(float p_auto_exposure_min);
 	float get_tonemap_auto_exposure_min() const;
-
+	void set_tonemap_auto_exposure_max(float p_auto_exposure_max);
+	float get_tonemap_auto_exposure_max() const;
 	void set_tonemap_auto_exposure_speed(float p_auto_exposure_speed);
 	float get_tonemap_auto_exposure_speed() const;
-
 	void set_tonemap_auto_exposure_grey(float p_auto_exposure_grey);
 	float get_tonemap_auto_exposure_grey() const;
 
-	void set_adjustment_enable(bool p_enable);
-	bool is_adjustment_enabled() const;
-
-	void set_adjustment_brightness(float p_brightness);
-	float get_adjustment_brightness() const;
-
-	void set_adjustment_contrast(float p_contrast);
-	float get_adjustment_contrast() const;
-
-	void set_adjustment_saturation(float p_saturation);
-	float get_adjustment_saturation() const;
-
-	void set_adjustment_color_correction(const Ref<Texture2D> &p_ramp);
-	Ref<Texture2D> get_adjustment_color_correction() const;
-
-	void set_ssr_enabled(bool p_enable);
+	// SSR
+	void set_ssr_enabled(bool p_enabled);
 	bool is_ssr_enabled() const;
-
 	void set_ssr_max_steps(int p_steps);
 	int get_ssr_max_steps() const;
-
 	void set_ssr_fade_in(float p_fade_in);
 	float get_ssr_fade_in() const;
-
 	void set_ssr_fade_out(float p_fade_out);
 	float get_ssr_fade_out() const;
-
 	void set_ssr_depth_tolerance(float p_depth_tolerance);
 	float get_ssr_depth_tolerance() const;
 
-	void set_ssao_enabled(bool p_enable);
+	// SSAO
+	void set_ssao_enabled(bool p_enabled);
 	bool is_ssao_enabled() const;
-
 	void set_ssao_radius(float p_radius);
 	float get_ssao_radius() const;
-
 	void set_ssao_intensity(float p_intensity);
 	float get_ssao_intensity() const;
-
 	void set_ssao_bias(float p_bias);
 	float get_ssao_bias() const;
-
 	void set_ssao_direct_light_affect(float p_direct_light_affect);
 	float get_ssao_direct_light_affect() const;
-
 	void set_ssao_ao_channel_affect(float p_ao_channel_affect);
 	float get_ssao_ao_channel_affect() const;
-
-	void set_ao_color(const Color &p_color);
-	Color get_ao_color() const;
-
 	void set_ssao_blur(SSAOBlur p_blur);
 	SSAOBlur get_ssao_blur() const;
-
 	void set_ssao_edge_sharpness(float p_edge_sharpness);
 	float get_ssao_edge_sharpness() const;
 
+	// SDFGI
+	void set_sdfgi_enabled(bool p_enabled);
+	bool is_sdfgi_enabled() const;
+	void set_sdfgi_cascades(SDFGICascades p_cascades);
+	SDFGICascades get_sdfgi_cascades() const;
+	void set_sdfgi_min_cell_size(float p_size);
+	float get_sdfgi_min_cell_size() const;
+	void set_sdfgi_max_distance(float p_distance);
+	float get_sdfgi_max_distance() const;
+	void set_sdfgi_cascade0_distance(float p_distance);
+	float get_sdfgi_cascade0_distance() const;
+	void set_sdfgi_y_scale(SDFGIYScale p_y_scale);
+	SDFGIYScale get_sdfgi_y_scale() const;
+	void set_sdfgi_use_occlusion(bool p_enabled);
+	bool is_sdfgi_using_occlusion() const;
+	void set_sdfgi_use_multi_bounce(bool p_enabled);
+	bool is_sdfgi_using_multi_bounce() const;
+	void set_sdfgi_read_sky_light(bool p_enabled);
+	bool is_sdfgi_reading_sky_light() const;
+	void set_sdfgi_energy(float p_energy);
+	float get_sdfgi_energy() const;
+	void set_sdfgi_normal_bias(float p_bias);
+	float get_sdfgi_normal_bias() const;
+	void set_sdfgi_probe_bias(float p_bias);
+	float get_sdfgi_probe_bias() const;
+
+	// Glow
 	void set_glow_enabled(bool p_enabled);
 	bool is_glow_enabled() const;
-
-	void set_glow_level(int p_level, bool p_enabled);
+	void set_glow_level_enabled(int p_level, bool p_enabled);
 	bool is_glow_level_enabled(int p_level) const;
-
 	void set_glow_intensity(float p_intensity);
 	float get_glow_intensity() const;
-
 	void set_glow_strength(float p_strength);
 	float get_glow_strength() const;
-
 	void set_glow_mix(float p_mix);
 	float get_glow_mix() const;
-
 	void set_glow_bloom(float p_threshold);
 	float get_glow_bloom() const;
-
 	void set_glow_blend_mode(GlowBlendMode p_mode);
 	GlowBlendMode get_glow_blend_mode() const;
-
 	void set_glow_hdr_bleed_threshold(float p_threshold);
 	float get_glow_hdr_bleed_threshold() const;
-
-	void set_glow_hdr_luminance_cap(float p_amount);
-	float get_glow_hdr_luminance_cap() const;
-
 	void set_glow_hdr_bleed_scale(float p_scale);
 	float get_glow_hdr_bleed_scale() const;
+	void set_glow_hdr_luminance_cap(float p_amount);
+	float get_glow_hdr_luminance_cap() const;
 
+	// Fog
 	void set_fog_enabled(bool p_enabled);
 	bool is_fog_enabled() const;
-
 	void set_fog_color(const Color &p_color);
 	Color get_fog_color() const;
-
 	void set_fog_sun_color(const Color &p_color);
 	Color get_fog_sun_color() const;
-
 	void set_fog_sun_amount(float p_amount);
 	float get_fog_sun_amount() const;
 
 	void set_fog_depth_enabled(bool p_enabled);
 	bool is_fog_depth_enabled() const;
-
 	void set_fog_depth_begin(float p_distance);
 	float get_fog_depth_begin() const;
-
 	void set_fog_depth_end(float p_distance);
 	float get_fog_depth_end() const;
-
 	void set_fog_depth_curve(float p_curve);
 	float get_fog_depth_curve() const;
-
 	void set_fog_transmit_enabled(bool p_enabled);
 	bool is_fog_transmit_enabled() const;
-
 	void set_fog_transmit_curve(float p_curve);
 	float get_fog_transmit_curve() const;
 
 	void set_fog_height_enabled(bool p_enabled);
 	bool is_fog_height_enabled() const;
-
 	void set_fog_height_min(float p_distance);
 	float get_fog_height_min() const;
-
 	void set_fog_height_max(float p_distance);
 	float get_fog_height_max() const;
-
 	void set_fog_height_curve(float p_distance);
 	float get_fog_height_curve() const;
 
-	void set_sdfgi_enabled(bool p_enabled);
-	bool is_sdfgi_enabled() const;
-
-	void set_sdfgi_cascades(SDFGICascades p_cascades);
-	SDFGICascades get_sdfgi_cascades() const;
-
-	void set_sdfgi_min_cell_size(float p_size);
-	float get_sdfgi_min_cell_size() const;
-
-	void set_sdfgi_cascade0_distance(float p_size);
-	float get_sdfgi_cascade0_distance() const;
-
-	void set_sdfgi_max_distance(float p_size);
-	float get_sdfgi_max_distance() const;
-
-	void set_sdfgi_use_occlusion(bool p_enable);
-	bool is_sdfgi_using_occlusion() const;
-
-	void set_sdfgi_use_multi_bounce(bool p_enable);
-	bool is_sdfgi_using_multi_bounce() const;
-
-	void set_sdfgi_use_enhance_ssr(bool p_enable);
-	bool is_sdfgi_using_enhance_ssr() const;
-
-	void set_sdfgi_read_sky_light(bool p_enable);
-	bool is_sdfgi_reading_sky_light() const;
-
-	void set_sdfgi_energy(float p_energy);
-	float get_sdfgi_energy() const;
-
-	void set_sdfgi_normal_bias(float p_bias);
-	float get_sdfgi_normal_bias() const;
-
-	void set_sdfgi_probe_bias(float p_bias);
-	float get_sdfgi_probe_bias() const;
-
-	void set_sdfgi_y_scale(SDFGIYScale p_y_scale);
-	SDFGIYScale get_sdfgi_y_scale() const;
-
-	virtual RID get_rid() const;
+	// Adjustment
+	void set_adjustment_enabled(bool p_enabled);
+	bool is_adjustment_enabled() const;
+	void set_adjustment_brightness(float p_brightness);
+	float get_adjustment_brightness() const;
+	void set_adjustment_contrast(float p_contrast);
+	float get_adjustment_contrast() const;
+	void set_adjustment_saturation(float p_saturation);
+	float get_adjustment_saturation() const;
+	void set_adjustment_color_correction(const Ref<Texture2D> &p_ramp);
+	Ref<Texture2D> get_adjustment_color_correction() const;
 
 	Environment();
 	~Environment();
@@ -429,65 +395,9 @@ VARIANT_ENUM_CAST(Environment::BGMode)
 VARIANT_ENUM_CAST(Environment::AmbientSource)
 VARIANT_ENUM_CAST(Environment::ReflectionSource)
 VARIANT_ENUM_CAST(Environment::ToneMapper)
-VARIANT_ENUM_CAST(Environment::GlowBlendMode)
 VARIANT_ENUM_CAST(Environment::SSAOBlur)
 VARIANT_ENUM_CAST(Environment::SDFGICascades)
 VARIANT_ENUM_CAST(Environment::SDFGIYScale)
-
-class CameraEffects : public Resource {
-	GDCLASS(CameraEffects, Resource);
-
-private:
-	RID camera_effects;
-
-	bool dof_blur_far_enabled;
-	float dof_blur_far_distance;
-	float dof_blur_far_transition;
-
-	bool dof_blur_near_enabled;
-	float dof_blur_near_distance;
-	float dof_blur_near_transition;
-
-	float dof_blur_amount;
-
-	bool override_exposure_enabled;
-	float override_exposure;
-
-protected:
-	static void _bind_methods();
-
-public:
-	void set_dof_blur_far_enabled(bool p_enable);
-	bool is_dof_blur_far_enabled() const;
-
-	void set_dof_blur_far_distance(float p_distance);
-	float get_dof_blur_far_distance() const;
-
-	void set_dof_blur_far_transition(float p_distance);
-	float get_dof_blur_far_transition() const;
-
-	void set_dof_blur_near_enabled(bool p_enable);
-	bool is_dof_blur_near_enabled() const;
-
-	void set_dof_blur_near_distance(float p_distance);
-	float get_dof_blur_near_distance() const;
-
-	void set_dof_blur_near_transition(float p_distance);
-	float get_dof_blur_near_transition() const;
-
-	void set_dof_blur_amount(float p_amount);
-	float get_dof_blur_amount() const;
-
-	void set_override_exposure_enabled(bool p_enabled);
-	bool is_override_exposure_enabled() const;
-
-	void set_override_exposure(float p_exposure);
-	float get_override_exposure() const;
-
-	virtual RID get_rid() const;
-
-	CameraEffects();
-	~CameraEffects();
-};
+VARIANT_ENUM_CAST(Environment::GlowBlendMode)
 
 #endif // ENVIRONMENT_H
diff --git a/scene/resources/world_3d.h b/scene/resources/world_3d.h
index 81a27a7349..02a821637f 100644
--- a/scene/resources/world_3d.h
+++ b/scene/resources/world_3d.h
@@ -32,6 +32,7 @@
 #define WORLD_3D_H
 
 #include "core/resource.h"
+#include "scene/resources/camera_effects.h"
 #include "scene/resources/environment.h"
 #include "servers/physics_server_3d.h"
 #include "servers/rendering_server.h"