Restructure environment in render implementation

2025-11-04 12:00:25 +00:00 · 2022-07-27 16:14:23 +10:00
parent eac22e3eb4
commit f579125eeb
21 changed files with 2211 additions and 1310 deletions
--- a/drivers/gles3/rasterizer_scene_gles3.cpp
+++ b/drivers/gles3/rasterizer_scene_gles3.cpp
@@ -32,6 +32,7 @@
 #include "core/config/project_settings.h"
 #include "core/templates/sort_array.h"
 #include "servers/rendering/rendering_server_default.h"
+#include "servers/rendering/rendering_server_globals.h"
 #include "storage/config.h"
 #include "storage/light_storage.h"
 #include "storage/mesh_storage.h"
@@ -39,8 +40,6 @@

 #ifdef GLES3_ENABLED

-uint64_t RasterizerSceneGLES3::auto_exposure_counter = 2;
-
 RasterizerSceneGLES3 *RasterizerSceneGLES3::singleton = nullptr;

 RenderGeometryInstance *RasterizerSceneGLES3::geometry_instance_create(RID p_base) {
@@ -561,13 +560,13 @@ void RasterizerSceneGLES3::_update_dirty_skys() {
 	dirty_sky_list = nullptr;
 }

-void RasterizerSceneGLES3::_setup_sky(Environment *p_env, RID p_render_buffers, const PagedArray<RID> &p_lights, const Projection &p_projection, const Transform3D &p_transform, const Size2i p_screen_size) {
+void RasterizerSceneGLES3::_setup_sky(RID p_env, RID p_render_buffers, const PagedArray<RID> &p_lights, const Projection &p_projection, const Transform3D &p_transform, const Size2i p_screen_size) {
 	GLES3::LightStorage *light_storage = GLES3::LightStorage::get_singleton();
 	GLES3::MaterialStorage *material_storage = GLES3::MaterialStorage::get_singleton();
-	ERR_FAIL_COND(!p_env);
+	ERR_FAIL_COND(p_env.is_null());

 	GLES3::SkyMaterialData *material = nullptr;
-	Sky *sky = sky_owner.get_or_null(p_env->sky);
+	Sky *sky = sky_owner.get_or_null(environment_get_sky(p_env));

 	RID sky_material;

@@ -707,17 +706,17 @@ void RasterizerSceneGLES3::_setup_sky(Environment *p_env, RID p_render_buffers,
 	}
 }

-void RasterizerSceneGLES3::_draw_sky(Environment *p_env, const Projection &p_projection, const Transform3D &p_transform) {
+void RasterizerSceneGLES3::_draw_sky(RID p_env, const Projection &p_projection, const Transform3D &p_transform) {
 	GLES3::MaterialStorage *material_storage = GLES3::MaterialStorage::get_singleton();
-	ERR_FAIL_COND(!p_env);
+	ERR_FAIL_COND(p_env.is_null());

-	Sky *sky = sky_owner.get_or_null(p_env->sky);
+	Sky *sky = sky_owner.get_or_null(environment_get_sky(p_env));
 	ERR_FAIL_COND(!sky);

 	GLES3::SkyMaterialData *material_data = nullptr;
 	RID sky_material;

-	RS::EnvironmentBG background = p_env->background;
+	RS::EnvironmentBG background = environment_get_background(p_env);

 	if (sky) {
 		ERR_FAIL_COND(!sky);
@@ -749,16 +748,16 @@ void RasterizerSceneGLES3::_draw_sky(Environment *p_env, const Projection &p_pro
 	// Camera
 	Projection camera;

-	if (p_env->sky_custom_fov) {
+	if (environment_get_sky_custom_fov(p_env)) {
 		float near_plane = p_projection.get_z_near();
 		float far_plane = p_projection.get_z_far();
 		float aspect = p_projection.get_aspect();

-		camera.set_perspective(p_env->sky_custom_fov, aspect, near_plane, far_plane);
+		camera.set_perspective(environment_get_sky_custom_fov(p_env), aspect, near_plane, far_plane);
 	} else {
 		camera = p_projection;
 	}
-	Basis sky_transform = p_env->sky_orientation;
+	Basis sky_transform = environment_get_sky_orientation(p_env);
 	sky_transform.invert();
 	sky_transform = p_transform.basis * sky_transform;

@@ -772,17 +771,17 @@ void RasterizerSceneGLES3::_draw_sky(Environment *p_env, const Projection &p_pro
 	glDrawArrays(GL_TRIANGLES, 0, 3);
 }

-void RasterizerSceneGLES3::_update_sky_radiance(Environment *p_env, const Projection &p_projection, const Transform3D &p_transform) {
+void RasterizerSceneGLES3::_update_sky_radiance(RID p_env, const Projection &p_projection, const Transform3D &p_transform) {
 	GLES3::MaterialStorage *material_storage = GLES3::MaterialStorage::get_singleton();
-	ERR_FAIL_COND(!p_env);
+	ERR_FAIL_COND(p_env.is_null());

-	Sky *sky = sky_owner.get_or_null(p_env->sky);
+	Sky *sky = sky_owner.get_or_null(environment_get_sky(p_env));
 	ERR_FAIL_COND(!sky);

 	GLES3::SkyMaterialData *material_data = nullptr;
 	RID sky_material;

-	RS::EnvironmentBG background = p_env->background;
+	RS::EnvironmentBG background = environment_get_background(p_env);

 	if (sky) {
 		ERR_FAIL_COND(!sky);
@@ -1023,84 +1022,6 @@ Ref<Image> RasterizerSceneGLES3::sky_bake_panorama(RID p_sky, float p_energy, bo

 /* ENVIRONMENT API */

-RID RasterizerSceneGLES3::environment_allocate() {
-	return environment_owner.allocate_rid();
-}
-
-void RasterizerSceneGLES3::environment_initialize(RID p_rid) {
-	environment_owner.initialize_rid(p_rid);
-}
-
-void RasterizerSceneGLES3::environment_set_background(RID p_env, RS::EnvironmentBG p_bg) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->background = p_bg;
-}
-
-void RasterizerSceneGLES3::environment_set_sky(RID p_env, RID p_sky) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->sky = p_sky;
-}
-
-void RasterizerSceneGLES3::environment_set_sky_custom_fov(RID p_env, float p_scale) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->sky_custom_fov = p_scale;
-}
-
-void RasterizerSceneGLES3::environment_set_sky_orientation(RID p_env, const Basis &p_orientation) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->sky_orientation = p_orientation;
-}
-
-void RasterizerSceneGLES3::environment_set_bg_color(RID p_env, const Color &p_color) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->bg_color = p_color;
-}
-
-void RasterizerSceneGLES3::environment_set_bg_energy(RID p_env, float p_energy) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->bg_energy = p_energy;
-}
-
-void RasterizerSceneGLES3::environment_set_canvas_max_layer(RID p_env, int p_max_layer) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->canvas_max_layer = p_max_layer;
-}
-
-void RasterizerSceneGLES3::environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient, float p_energy, float p_sky_contribution, RS::EnvironmentReflectionSource p_reflection_source) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->ambient_light = p_color;
-	env->ambient_source = p_ambient;
-	env->ambient_light_energy = p_energy;
-	env->ambient_sky_contribution = p_sky_contribution;
-	env->reflection_source = p_reflection_source;
-}
-
-void RasterizerSceneGLES3::environment_set_glow(RID p_env, bool p_enable, Vector<float> p_levels, float p_intensity, float p_strength, float p_mix, float p_bloom_threshold, RS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, float p_hdr_luminance_cap, float p_glow_map_strength, RID p_glow_map) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	ERR_FAIL_COND_MSG(p_levels.size() != 7, "Size of array of glow levels must be 7");
-	env->glow_enabled = p_enable;
-	env->glow_levels = p_levels;
-	env->glow_intensity = p_intensity;
-	env->glow_strength = p_strength;
-	env->glow_mix = p_mix;
-	env->glow_bloom = p_bloom_threshold;
-	env->glow_blend_mode = p_blend_mode;
-	env->glow_hdr_bleed_threshold = p_hdr_bleed_threshold;
-	env->glow_hdr_bleed_scale = p_hdr_bleed_scale;
-	env->glow_hdr_luminance_cap = p_hdr_luminance_cap;
-	env->glow_map_strength = p_glow_map_strength;
-	env->glow_map = p_glow_map;
-}
-
 void RasterizerSceneGLES3::environment_glow_set_use_bicubic_upscale(bool p_enable) {
 	glow_bicubic_upscale = p_enable;
 }
@@ -1109,35 +1030,15 @@ void RasterizerSceneGLES3::environment_glow_set_use_high_quality(bool p_enable)
 	glow_high_quality = p_enable;
 }

-void RasterizerSceneGLES3::environment_set_ssr(RID p_env, bool p_enable, int p_max_steps, float p_fade_int, float p_fade_out, float p_depth_tolerance) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->ssr_enabled = p_enable;
-	env->ssr_max_steps = p_max_steps;
-	env->ssr_fade_in = p_fade_int;
-	env->ssr_fade_out = p_fade_out;
-	env->ssr_depth_tolerance = p_depth_tolerance;
-}
-
 void RasterizerSceneGLES3::environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) {
 }

-void RasterizerSceneGLES3::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_power, float p_detail, float p_horizon, float p_sharpness, float p_light_affect, float p_ao_channel_affect) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-}
-
 void RasterizerSceneGLES3::environment_set_ssao_quality(RS::EnvironmentSSAOQuality p_quality, bool p_half_size, float p_adaptive_target, int p_blur_passes, float p_fadeout_from, float p_fadeout_to) {
 }

-void RasterizerSceneGLES3::environment_set_ssil(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_sharpness, float p_normal_rejection) {
-}
 void RasterizerSceneGLES3::environment_set_ssil_quality(RS::EnvironmentSSILQuality p_quality, bool p_half_size, float p_adaptive_target, int p_blur_passes, float p_fadeout_from, float p_fadeout_to) {
 }

-void RasterizerSceneGLES3::environment_set_sdfgi(RID p_env, bool p_enable, int p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, float p_bounce_feedback, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) {
-}
-
 void RasterizerSceneGLES3::environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) {
 }

@@ -1147,49 +1048,6 @@ void RasterizerSceneGLES3::environment_set_sdfgi_frames_to_converge(RS::Environm
 void RasterizerSceneGLES3::environment_set_sdfgi_frames_to_update_light(RS::EnvironmentSDFGIFramesToUpdateLight p_update) {
 }

-void RasterizerSceneGLES3::environment_set_tonemap(RID p_env, RS::EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white, bool p_auto_exposure, float p_min_luminance, float p_max_luminance, float p_auto_exp_speed, float p_auto_exp_scale) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->exposure = p_exposure;
-	env->tone_mapper = p_tone_mapper;
-	if (!env->auto_exposure && p_auto_exposure) {
-		env->auto_exposure_version = ++auto_exposure_counter;
-	}
-	env->auto_exposure = p_auto_exposure;
-	env->white = p_white;
-	env->min_luminance = p_min_luminance;
-	env->max_luminance = p_max_luminance;
-	env->auto_exp_speed = p_auto_exp_speed;
-	env->auto_exp_scale = p_auto_exp_scale;
-}
-
-void RasterizerSceneGLES3::environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, bool p_use_1d_color_correction, RID p_color_correction) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->adjustments_enabled = p_enable;
-	env->adjustments_brightness = p_brightness;
-	env->adjustments_contrast = p_contrast;
-	env->adjustments_saturation = p_saturation;
-	env->use_1d_color_correction = p_use_1d_color_correction;
-	env->color_correction = p_color_correction;
-}
-
-void RasterizerSceneGLES3::environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_aerial_perspective) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND(!env);
-	env->fog_enabled = p_enable;
-	env->fog_light_color = p_light_color;
-	env->fog_light_energy = p_light_energy;
-	env->fog_sun_scatter = p_sun_scatter;
-	env->fog_density = p_density;
-	env->fog_height = p_height;
-	env->fog_height_density = p_height_density;
-	env->fog_aerial_perspective = p_aerial_perspective;
-}
-
-void RasterizerSceneGLES3::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_albedo, const Color &p_emission, float p_emission_energy, float p_anisotropy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount, float p_ambient_inject) {
-}
-
 void RasterizerSceneGLES3::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
 }

@@ -1197,27 +1055,9 @@ void RasterizerSceneGLES3::environment_set_volumetric_fog_filter_active(bool p_e
 }

 Ref<Image> RasterizerSceneGLES3::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND_V(!env, Ref<Image>());
 	return Ref<Image>();
 }

-bool RasterizerSceneGLES3::is_environment(RID p_env) const {
-	return environment_owner.owns(p_env);
-}
-
-RS::EnvironmentBG RasterizerSceneGLES3::environment_get_background(RID p_env) const {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND_V(!env, RS::ENV_BG_MAX);
-	return env->background;
-}
-
-int RasterizerSceneGLES3::environment_get_canvas_max_layer(RID p_env) const {
-	Environment *env = environment_owner.get_or_null(p_env);
-	ERR_FAIL_COND_V(!env, 0);
-	return env->canvas_max_layer;
-}
-
 RID RasterizerSceneGLES3::camera_effects_allocate() {
 	return RID();
 }
@@ -1557,18 +1397,17 @@ void RasterizerSceneGLES3::_setup_environment(const RenderDataGLES3 *p_render_da
 	scene_state.ubo.time = time;

 	if (is_environment(p_render_data->environment)) {
-		Environment *env = environment_owner.get_or_null(p_render_data->environment);
-		RS::EnvironmentBG env_bg = env->background;
-		RS::EnvironmentAmbientSource ambient_src = env->ambient_source;
+		RS::EnvironmentBG env_bg = environment_get_background(p_render_data->environment);
+		RS::EnvironmentAmbientSource ambient_src = environment_get_ambient_source(p_render_data->environment);

-		float bg_energy = env->bg_energy;
+		float bg_energy = environment_get_bg_energy(p_render_data->environment);
 		scene_state.ubo.ambient_light_color_energy[3] = bg_energy;

-		scene_state.ubo.ambient_color_sky_mix = env->ambient_sky_contribution;
+		scene_state.ubo.ambient_color_sky_mix = environment_get_ambient_sky_contribution(p_render_data->environment);

 		//ambient
 		if (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && (env_bg == RS::ENV_BG_CLEAR_COLOR || env_bg == RS::ENV_BG_COLOR)) {
-			Color color = env_bg == RS::ENV_BG_CLEAR_COLOR ? p_default_bg_color : env->bg_color;
+			Color color = env_bg == RS::ENV_BG_CLEAR_COLOR ? p_default_bg_color : environment_get_bg_color(p_render_data->environment);
 			color = color.srgb_to_linear();

 			scene_state.ubo.ambient_light_color_energy[0] = color.r * bg_energy;
@@ -1577,14 +1416,14 @@ void RasterizerSceneGLES3::_setup_environment(const RenderDataGLES3 *p_render_da
 			scene_state.ubo.use_ambient_light = true;
 			scene_state.ubo.use_ambient_cubemap = false;
 		} else {
-			float energy = env->ambient_light_energy;
-			Color color = env->ambient_light;
+			float energy = environment_get_ambient_light_energy(p_render_data->environment);
+			Color color = environment_get_ambient_light(p_render_data->environment);
 			color = color.srgb_to_linear();
 			scene_state.ubo.ambient_light_color_energy[0] = color.r * energy;
 			scene_state.ubo.ambient_light_color_energy[1] = color.g * energy;
 			scene_state.ubo.ambient_light_color_energy[2] = color.b * energy;

-			Basis sky_transform = env->sky_orientation;
+			Basis sky_transform = environment_get_sky_orientation(p_render_data->environment);
 			sky_transform = sky_transform.inverse() * p_render_data->cam_transform.basis;
 			GLES3::MaterialStorage::store_transform_3x3(sky_transform, scene_state.ubo.radiance_inverse_xform);
 			scene_state.ubo.use_ambient_cubemap = (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && env_bg == RS::ENV_BG_SKY) || ambient_src == RS::ENV_AMBIENT_SOURCE_SKY;
@@ -1592,27 +1431,27 @@ void RasterizerSceneGLES3::_setup_environment(const RenderDataGLES3 *p_render_da
 		}

 		//specular
-		RS::EnvironmentReflectionSource ref_src = env->reflection_source;
+		RS::EnvironmentReflectionSource ref_src = environment_get_reflection_source(p_render_data->environment);
 		if ((ref_src == RS::ENV_REFLECTION_SOURCE_BG && env_bg == RS::ENV_BG_SKY) || ref_src == RS::ENV_REFLECTION_SOURCE_SKY) {
 			scene_state.ubo.use_reflection_cubemap = true;
 		} else {
 			scene_state.ubo.use_reflection_cubemap = false;
 		}

-		scene_state.ubo.fog_enabled = env->fog_enabled;
-		scene_state.ubo.fog_density = env->fog_density;
-		scene_state.ubo.fog_height = env->fog_height;
-		scene_state.ubo.fog_height_density = env->fog_height_density;
-		scene_state.ubo.fog_aerial_perspective = env->fog_aerial_perspective;
+		scene_state.ubo.fog_enabled = environment_get_fog_enabled(p_render_data->environment);
+		scene_state.ubo.fog_density = environment_get_fog_density(p_render_data->environment);
+		scene_state.ubo.fog_height = environment_get_fog_height(p_render_data->environment);
+		scene_state.ubo.fog_height_density = environment_get_fog_height_density(p_render_data->environment);
+		scene_state.ubo.fog_aerial_perspective = environment_get_fog_aerial_perspective(p_render_data->environment);

-		Color fog_color = env->fog_light_color.srgb_to_linear();
-		float fog_energy = env->fog_light_energy;
+		Color fog_color = environment_get_fog_light_color(p_render_data->environment).srgb_to_linear();
+		float fog_energy = environment_get_fog_light_energy(p_render_data->environment);

 		scene_state.ubo.fog_light_color[0] = fog_color.r * fog_energy;
 		scene_state.ubo.fog_light_color[1] = fog_color.g * fog_energy;
 		scene_state.ubo.fog_light_color[2] = fog_color.b * fog_energy;

-		scene_state.ubo.fog_sun_scatter = env->fog_sun_scatter;
+		scene_state.ubo.fog_sun_scatter = environment_get_fog_sun_scatter(p_render_data->environment);

 	} else {
 	}
@@ -1904,8 +1743,6 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 		clear_color = texture_storage->get_default_clear_color();
 	}

-	Environment *env = environment_owner.get_or_null(p_environment);
-
 	bool fb_cleared = false;

 	Size2i screen_size;
@@ -1915,10 +1752,10 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 	bool use_wireframe = get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME;

 	SceneState::TonemapUBO tonemap_ubo;
-	if (env) {
-		tonemap_ubo.exposure = env->exposure;
-		tonemap_ubo.white = env->white;
-		tonemap_ubo.tonemapper = int32_t(env->tone_mapper);
+	if (render_data.environment.is_valid()) {
+		tonemap_ubo.exposure = environment_get_exposure(render_data.environment);
+		tonemap_ubo.white = environment_get_white(render_data.environment);
+		tonemap_ubo.tonemapper = int32_t(environment_get_tone_mapper(render_data.environment));
 	}

 	if (scene_state.tonemap_buffer == 0) {
@@ -1941,25 +1778,25 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *

 	if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_OVERDRAW) {
 		clear_color = Color(0, 0, 0, 1); //in overdraw mode, BG should always be black
-	} else if (env) {
-		RS::EnvironmentBG bg_mode = env->background;
-		float bg_energy = env->bg_energy;
+	} else if (render_data.environment.is_valid()) {
+		RS::EnvironmentBG bg_mode = environment_get_background(render_data.environment);
+		float bg_energy = environment_get_bg_energy(render_data.environment);
 		switch (bg_mode) {
 			case RS::ENV_BG_CLEAR_COLOR: {
 				clear_color.r *= bg_energy;
 				clear_color.g *= bg_energy;
 				clear_color.b *= bg_energy;
-				if (env->fog_enabled) {
+				if (environment_get_fog_enabled(render_data.environment)) {
 					draw_sky_fog_only = true;
 					GLES3::MaterialStorage::get_singleton()->material_set_param(sky_globals.fog_material, "clear_color", Variant(clear_color));
 				}
 			} break;
 			case RS::ENV_BG_COLOR: {
-				clear_color = env->bg_color;
+				clear_color = environment_get_bg_color(render_data.environment);
 				clear_color.r *= bg_energy;
 				clear_color.g *= bg_energy;
 				clear_color.b *= bg_energy;
-				if (env->fog_enabled) {
+				if (environment_get_fog_enabled(render_data.environment)) {
 					draw_sky_fog_only = true;
 					GLES3::MaterialStorage::get_singleton()->material_set_param(sky_globals.fog_material, "clear_color", Variant(clear_color));
 				}
@@ -1979,7 +1816,7 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 			}
 		}
 		// setup sky if used for ambient, reflections, or background
-		if (draw_sky || draw_sky_fog_only || env->reflection_source == RS::ENV_REFLECTION_SOURCE_SKY || env->ambient_source == RS::ENV_AMBIENT_SOURCE_SKY) {
+		if (draw_sky || draw_sky_fog_only || environment_get_reflection_source(render_data.environment) == RS::ENV_REFLECTION_SOURCE_SKY || environment_get_ambient_source(render_data.environment) == RS::ENV_AMBIENT_SOURCE_SKY) {
 			RENDER_TIMESTAMP("Setup Sky");
 			Projection projection = render_data.cam_projection;
 			if (render_data.reflection_probe.is_valid()) {
@@ -1988,11 +1825,11 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 				projection = correction * render_data.cam_projection;
 			}

-			_setup_sky(env, p_render_buffers, *render_data.lights, projection, render_data.cam_transform, screen_size);
+			_setup_sky(render_data.environment, p_render_buffers, *render_data.lights, projection, render_data.cam_transform, screen_size);

-			if (env->sky.is_valid()) {
-				if (env->reflection_source == RS::ENV_REFLECTION_SOURCE_SKY || env->ambient_source == RS::ENV_AMBIENT_SOURCE_SKY || (env->reflection_source == RS::ENV_REFLECTION_SOURCE_BG && env->background == RS::ENV_BG_SKY)) {
-					_update_sky_radiance(env, projection, render_data.cam_transform);
+			if (environment_get_sky(render_data.environment).is_valid()) {
+				if (environment_get_reflection_source(render_data.environment) == RS::ENV_REFLECTION_SOURCE_SKY || environment_get_ambient_source(render_data.environment) == RS::ENV_AMBIENT_SOURCE_SKY || (environment_get_reflection_source(render_data.environment) == RS::ENV_REFLECTION_SOURCE_BG && environment_get_background(render_data.environment) == RS::ENV_BG_SKY)) {
+					_update_sky_radiance(render_data.environment, projection, render_data.cam_transform);
 				}
 			} else {
 				// do not try to draw sky if invalid
@@ -2072,7 +1909,7 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 			spec_constant_base_flags |= 1 << SPEC_CONSTANT_DISABLE_DIRECTIONAL_LIGHTS;
 		}

-		if (!env || (env && !env->fog_enabled)) {
+		if (render_data.environment.is_null() || (render_data.environment.is_valid() && !environment_get_fog_enabled(render_data.environment))) {
 			spec_constant_base_flags |= 1 << SPEC_CONSTANT_DISABLE_FOG;
 		}
 	}
@@ -2096,7 +1933,7 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 		scene_state.current_depth_draw = GLES3::SceneShaderData::DEPTH_DRAW_DISABLED;
 		scene_state.cull_mode = GLES3::SceneShaderData::CULL_BACK;

-		_draw_sky(env, render_data.cam_projection, render_data.cam_transform);
+		_draw_sky(render_data.environment, render_data.cam_projection, render_data.cam_transform);
 	}

 	RENDER_TIMESTAMP("Render 3D Transparent Pass");
@@ -2145,11 +1982,10 @@ void RasterizerSceneGLES3::_render_list_template(RenderListParameters *p_params,
 	}

 	if (p_pass_mode == PASS_MODE_COLOR || p_pass_mode == PASS_MODE_COLOR_TRANSPARENT) {
-		Environment *env = environment_owner.get_or_null(p_render_data->environment);
 		glActiveTexture(GL_TEXTURE0 + config->max_texture_image_units - 2);
 		GLuint texture_to_bind = texture_storage->get_texture(texture_storage->texture_gl_get_default(GLES3::DEFAULT_GL_TEXTURE_CUBEMAP_BLACK))->tex_id;
-		if (env) {
-			Sky *sky = sky_owner.get_or_null(env->sky);
+		if (p_render_data->environment.is_valid()) {
+			Sky *sky = sky_owner.get_or_null(environment_get_sky(p_render_data->environment));
 			if (sky && sky->radiance != 0) {
 				texture_to_bind = sky->radiance;
 				// base_spec_constant |= USE_RADIANCE_MAP;
@@ -2548,8 +2384,8 @@ TypedArray<Image> RasterizerSceneGLES3::bake_render_uv2(RID p_base, const Vector
 }

 bool RasterizerSceneGLES3::free(RID p_rid) {
-	if (environment_owner.owns(p_rid)) {
-		environment_owner.free(p_rid);
+	if (is_environment(p_rid)) {
+		environment_free(p_rid);
 	} else if (sky_owner.owns(p_rid)) {
 		Sky *sky = sky_owner.get_or_null(p_rid);
 		ERR_FAIL_COND_V(!sky, false);