95 files changed, 6760 insertions, 4064 deletions

diff --git a/servers/rendering/SCsub b/servers/rendering/SCsub
index 5ea0d40486..0939b68482 100644
--- a/servers/rendering/SCsub
+++ b/servers/rendering/SCsub
@@ -4,4 +4,4 @@ Import("env")
 
 env.add_source_files(env.servers_sources, "*.cpp")
 
-SConscript("rasterizer_rd/SCsub")
+SConscript("renderer_rd/SCsub")
diff --git a/servers/rendering/rasterizer.h b/servers/rendering/rasterizer.h
deleted file mode 100644
index efaa8f138a..0000000000
--- a/servers/rendering/rasterizer.h
+++ /dev/null
@@ -1,1408 +0,0 @@
-/*************************************************************************/
-/*  rasterizer.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 RASTERIZER_H
-#define RASTERIZER_H
-
-#include "core/math/camera_matrix.h"
-#include "core/templates/pair.h"
-#include "core/templates/self_list.h"
-#include "servers/rendering_server.h"
-
-class RasterizerScene {
-public:
-	/* SHADOW ATLAS API */
-
-	virtual RID shadow_atlas_create() = 0;
-	virtual void shadow_atlas_set_size(RID p_atlas, int p_size) = 0;
-	virtual void shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) = 0;
-	virtual bool shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version) = 0;
-
-	virtual void directional_shadow_atlas_set_size(int p_size) = 0;
-	virtual int get_directional_light_shadow_size(RID p_light_intance) = 0;
-	virtual void set_directional_shadow_count(int p_count) = 0;
-
-	/* SDFGI UPDATE */
-
-	struct InstanceBase;
-
-	virtual void sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position) = 0;
-	virtual int sdfgi_get_pending_region_count(RID p_render_buffers) const = 0;
-	virtual AABB sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const = 0;
-	virtual uint32_t sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const = 0;
-	virtual void sdfgi_update_probes(RID p_render_buffers, RID p_environment, const RID *p_directional_light_instances, uint32_t p_directional_light_count, const RID *p_positional_light_instances, uint32_t p_positional_light_count) = 0;
-
-	/* SKY API */
-
-	virtual RID sky_create() = 0;
-	virtual void sky_set_radiance_size(RID p_sky, int p_radiance_size) = 0;
-	virtual void sky_set_mode(RID p_sky, RS::SkyMode p_samples) = 0;
-	virtual void sky_set_material(RID p_sky, RID p_material) = 0;
-	virtual Ref<Image> sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) = 0;
-
-	/* ENVIRONMENT API */
-
-	virtual RID environment_create() = 0;
-
-	virtual void environment_set_background(RID p_env, RS::EnvironmentBG p_bg) = 0;
-	virtual void environment_set_sky(RID p_env, RID p_sky) = 0;
-	virtual void environment_set_sky_custom_fov(RID p_env, float p_scale) = 0;
-	virtual void environment_set_sky_orientation(RID p_env, const Basis &p_orientation) = 0;
-	virtual void environment_set_bg_color(RID p_env, const Color &p_color) = 0;
-	virtual void environment_set_bg_energy(RID p_env, float p_energy) = 0;
-	virtual void environment_set_canvas_max_layer(RID p_env, int p_max_layer) = 0;
-	virtual void environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient = RS::ENV_AMBIENT_SOURCE_BG, float p_energy = 1.0, float p_sky_contribution = 0.0, RS::EnvironmentReflectionSource p_reflection_source = RS::ENV_REFLECTION_SOURCE_BG, const Color &p_ao_color = Color()) = 0;
-// FIXME: Disabled during Vulkan refactoring, should be ported.
-#if 0
-	virtual void environment_set_camera_feed_id(RID p_env, int p_camera_feed_id) = 0;
-#endif
-
-	virtual void 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) = 0;
-	virtual void environment_glow_set_use_bicubic_upscale(bool p_enable) = 0;
-	virtual void environment_glow_set_use_high_quality(bool p_enable) = 0;
-
-	virtual void environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, RS::EnvVolumetricFogShadowFilter p_shadow_filter) = 0;
-
-	virtual void environment_set_volumetric_fog_volume_size(int p_size, int p_depth) = 0;
-	virtual void environment_set_volumetric_fog_filter_active(bool p_enable) = 0;
-	virtual void environment_set_volumetric_fog_directional_shadow_shrink_size(int p_shrink_size) = 0;
-	virtual void environment_set_volumetric_fog_positional_shadow_shrink_size(int p_shrink_size) = 0;
-
-	virtual void 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) = 0;
-	virtual void environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) = 0;
-
-	virtual void environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_bias, float p_light_affect, float p_ao_channel_affect, RS::EnvironmentSSAOBlur p_blur, float p_bilateral_sharpness) = 0;
-
-	virtual void environment_set_ssao_quality(RS::EnvironmentSSAOQuality p_quality, bool p_half_size) = 0;
-
-	virtual void environment_set_sdfgi(RID p_env, bool p_enable, RS::EnvironmentSDFGICascades p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, bool p_use_multibounce, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) = 0;
-
-	virtual void environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) = 0;
-	virtual void environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) = 0;
-
-	virtual void 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) = 0;
-
-	virtual void environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, RID p_ramp) = 0;
-
-	virtual void environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_aerial_perspective) = 0;
-
-	virtual Ref<Image> environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) = 0;
-
-	virtual bool is_environment(RID p_env) const = 0;
-	virtual RS::EnvironmentBG environment_get_background(RID p_env) const = 0;
-	virtual int environment_get_canvas_max_layer(RID p_env) const = 0;
-
-	virtual RID camera_effects_create() = 0;
-
-	virtual void camera_effects_set_dof_blur_quality(RS::DOFBlurQuality p_quality, bool p_use_jitter) = 0;
-	virtual void camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape p_shape) = 0;
-
-	virtual void camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) = 0;
-	virtual void camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) = 0;
-
-	virtual void shadows_quality_set(RS::ShadowQuality p_quality) = 0;
-	virtual void directional_shadow_quality_set(RS::ShadowQuality p_quality) = 0;
-
-	struct InstanceDependency {
-		void instance_notify_changed(bool p_aabb, bool p_dependencies);
-		void instance_notify_deleted(RID p_deleted);
-
-		~InstanceDependency();
-
-	private:
-		friend struct InstanceBase;
-		Map<InstanceBase *, uint32_t> instances;
-	};
-
-	struct InstanceBase {
-		RS::InstanceType base_type;
-		RID base;
-
-		RID skeleton;
-		RID material_override;
-
-		RID instance_data;
-
-		Transform transform;
-
-		int depth_layer;
-		uint32_t layer_mask;
-		uint32_t instance_version;
-
-		//RID sampled_light;
-
-		Vector<RID> materials;
-		Vector<RID> light_instances;
-		Vector<RID> reflection_probe_instances;
-		Vector<RID> gi_probe_instances;
-
-		Vector<float> blend_values;
-
-		RS::ShadowCastingSetting cast_shadows;
-
-		//fit in 32 bits
-		bool mirror : 8;
-		bool receive_shadows : 8;
-		bool visible : 8;
-		bool baked_light : 2; //this flag is only to know if it actually did use baked light
-		bool dynamic_gi : 2; //this flag is only to know if it actually did use baked light
-		bool redraw_if_visible : 4;
-
-		float depth; //used for sorting
-
-		SelfList<InstanceBase> dependency_item;
-
-		InstanceBase *lightmap;
-		Rect2 lightmap_uv_scale;
-		int lightmap_slice_index;
-		uint32_t lightmap_cull_index;
-		Vector<Color> lightmap_sh; //spherical harmonic
-
-		AABB aabb;
-		AABB transformed_aabb;
-
-		struct InstanceShaderParameter {
-			int32_t index = -1;
-			Variant value;
-			Variant default_value;
-			PropertyInfo info;
-		};
-
-		Map<StringName, InstanceShaderParameter> instance_shader_parameters;
-		bool instance_allocated_shader_parameters = false;
-		int32_t instance_allocated_shader_parameters_offset = -1;
-
-		virtual void dependency_deleted(RID p_dependency) {}
-		virtual void dependency_changed(bool p_aabb, bool p_dependencies) {}
-
-		Set<InstanceDependency *> dependencies;
-
-		void instance_increase_version() {
-			instance_version++;
-		}
-
-		void update_dependency(InstanceDependency *p_dependency) {
-			dependencies.insert(p_dependency);
-			p_dependency->instances[this] = instance_version;
-		}
-
-		void clean_up_dependencies() {
-			List<Pair<InstanceDependency *, Map<InstanceBase *, uint32_t>::Element *>> to_clean_up;
-			for (Set<InstanceDependency *>::Element *E = dependencies.front(); E; E = E->next()) {
-				InstanceDependency *dep = E->get();
-				Map<InstanceBase *, uint32_t>::Element *F = dep->instances.find(this);
-				ERR_CONTINUE(!F);
-				if (F->get() != instance_version) {
-					Pair<InstanceDependency *, Map<InstanceBase *, uint32_t>::Element *> p;
-					p.first = dep;
-					p.second = F;
-					to_clean_up.push_back(p);
-				}
-			}
-
-			while (to_clean_up.size()) {
-				to_clean_up.front()->get().first->instances.erase(to_clean_up.front()->get().second);
-				to_clean_up.pop_front();
-			}
-		}
-
-		void clear_dependencies() {
-			for (Set<InstanceDependency *>::Element *E = dependencies.front(); E; E = E->next()) {
-				InstanceDependency *dep = E->get();
-				dep->instances.erase(this);
-			}
-			dependencies.clear();
-		}
-
-		InstanceBase() :
-				dependency_item(this) {
-			base_type = RS::INSTANCE_NONE;
-			cast_shadows = RS::SHADOW_CASTING_SETTING_ON;
-			receive_shadows = true;
-			visible = true;
-			depth_layer = 0;
-			layer_mask = 1;
-			instance_version = 0;
-			baked_light = false;
-			dynamic_gi = false;
-			redraw_if_visible = false;
-			lightmap_slice_index = 0;
-			lightmap = nullptr;
-			lightmap_cull_index = 0;
-		}
-
-		virtual ~InstanceBase() {
-			clear_dependencies();
-		}
-	};
-
-	virtual RID light_instance_create(RID p_light) = 0;
-	virtual void light_instance_set_transform(RID p_light_instance, const Transform &p_transform) = 0;
-	virtual void light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb) = 0;
-	virtual void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale = 1.0, float p_range_begin = 0, const Vector2 &p_uv_scale = Vector2()) = 0;
-	virtual void light_instance_mark_visible(RID p_light_instance) = 0;
-	virtual bool light_instances_can_render_shadow_cube() const {
-		return true;
-	}
-
-	virtual RID reflection_atlas_create() = 0;
-	virtual void reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count) = 0;
-
-	virtual RID reflection_probe_instance_create(RID p_probe) = 0;
-	virtual void reflection_probe_instance_set_transform(RID p_instance, const Transform &p_transform) = 0;
-	virtual void reflection_probe_release_atlas_index(RID p_instance) = 0;
-	virtual bool reflection_probe_instance_needs_redraw(RID p_instance) = 0;
-	virtual bool reflection_probe_instance_has_reflection(RID p_instance) = 0;
-	virtual bool reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) = 0;
-	virtual bool reflection_probe_instance_postprocess_step(RID p_instance) = 0;
-
-	virtual RID decal_instance_create(RID p_decal) = 0;
-	virtual void decal_instance_set_transform(RID p_decal, const Transform &p_transform) = 0;
-
-	virtual RID gi_probe_instance_create(RID p_gi_probe) = 0;
-	virtual void gi_probe_instance_set_transform_to_data(RID p_probe, const Transform &p_xform) = 0;
-	virtual bool gi_probe_needs_update(RID p_probe) const = 0;
-	virtual void gi_probe_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, int p_dynamic_object_count, InstanceBase **p_dynamic_objects) = 0;
-
-	virtual void gi_probe_set_quality(RS::GIProbeQuality) = 0;
-
-	virtual void render_scene(RID p_render_buffers, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass) = 0;
-
-	virtual void render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count) = 0;
-	virtual void render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) = 0;
-	virtual void render_sdfgi(RID p_render_buffers, int p_region, InstanceBase **p_cull_result, int p_cull_count) = 0;
-	virtual void render_sdfgi_static_lights(RID p_render_buffers, uint32_t p_cascade_count, const uint32_t *p_cascade_indices, const RID **p_positional_light_cull_result, const uint32_t *p_positional_light_cull_count) = 0;
-	virtual void render_particle_collider_heightfield(RID p_collider, const Transform &p_transform, InstanceBase **p_cull_result, int p_cull_count) = 0;
-
-	virtual void set_scene_pass(uint64_t p_pass) = 0;
-	virtual void set_time(double p_time, double p_step) = 0;
-	virtual void set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) = 0;
-
-	virtual RID render_buffers_create() = 0;
-	virtual void render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, RS::ViewportMSAA p_msaa, RS::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_debanding) = 0;
-
-	virtual void screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) = 0;
-	virtual bool screen_space_roughness_limiter_is_active() const = 0;
-
-	virtual void sub_surface_scattering_set_quality(RS::SubSurfaceScatteringQuality p_quality) = 0;
-	virtual void sub_surface_scattering_set_scale(float p_scale, float p_depth_scale) = 0;
-
-	virtual TypedArray<Image> bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) = 0;
-
-	virtual bool free(RID p_rid) = 0;
-
-	virtual void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) = 0;
-
-	virtual void update() = 0;
-	virtual ~RasterizerScene() {}
-};
-
-class RasterizerStorage {
-	Color default_clear_color;
-
-public:
-	/* TEXTURE API */
-
-	virtual RID texture_2d_create(const Ref<Image> &p_image) = 0;
-	virtual RID texture_2d_layered_create(const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) = 0;
-	virtual RID texture_3d_create(Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) = 0;
-	virtual RID texture_proxy_create(RID p_base) = 0; //all slices, then all the mipmaps, must be coherent
-
-	virtual void texture_2d_update_immediate(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) = 0; //mostly used for video and streaming
-	virtual void texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) = 0;
-	virtual void texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) = 0;
-	virtual void texture_proxy_update(RID p_proxy, RID p_base) = 0;
-
-	//these two APIs can be used together or in combination with the others.
-	virtual RID texture_2d_placeholder_create() = 0;
-	virtual RID texture_2d_layered_placeholder_create(RenderingServer::TextureLayeredType p_layered_type) = 0;
-	virtual RID texture_3d_placeholder_create() = 0;
-
-	virtual Ref<Image> texture_2d_get(RID p_texture) const = 0;
-	virtual Ref<Image> texture_2d_layer_get(RID p_texture, int p_layer) const = 0;
-	virtual Vector<Ref<Image>> texture_3d_get(RID p_texture) const = 0;
-
-	virtual void texture_replace(RID p_texture, RID p_by_texture) = 0;
-	virtual void texture_set_size_override(RID p_texture, int p_width, int p_height) = 0;
-
-	virtual void texture_set_path(RID p_texture, const String &p_path) = 0;
-	virtual String texture_get_path(RID p_texture) const = 0;
-
-	virtual void texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) = 0;
-	virtual void texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) = 0;
-	virtual void texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) = 0;
-
-	virtual void texture_debug_usage(List<RS::TextureInfo> *r_info) = 0;
-
-	virtual void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) = 0;
-
-	virtual Size2 texture_size_with_proxy(RID p_proxy) = 0;
-
-	virtual void texture_add_to_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) = 0;
-	virtual void texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) = 0;
-
-	/* CANVAS TEXTURE API */
-
-	virtual RID canvas_texture_create() = 0;
-	virtual void canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) = 0;
-	virtual void canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_base_color, float p_shininess) = 0;
-
-	virtual void canvas_texture_set_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) = 0;
-	virtual void canvas_texture_set_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) = 0;
-
-	/* SHADER API */
-
-	virtual RID shader_create() = 0;
-
-	virtual void shader_set_code(RID p_shader, const String &p_code) = 0;
-	virtual String shader_get_code(RID p_shader) const = 0;
-	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const = 0;
-
-	virtual void shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) = 0;
-	virtual RID shader_get_default_texture_param(RID p_shader, const StringName &p_name) const = 0;
-	virtual Variant shader_get_param_default(RID p_material, const StringName &p_param) const = 0;
-
-	/* COMMON MATERIAL API */
-
-	virtual RID material_create() = 0;
-
-	virtual void material_set_render_priority(RID p_material, int priority) = 0;
-	virtual void material_set_shader(RID p_shader_material, RID p_shader) = 0;
-
-	virtual void material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) = 0;
-	virtual Variant material_get_param(RID p_material, const StringName &p_param) const = 0;
-
-	virtual void material_set_next_pass(RID p_material, RID p_next_material) = 0;
-
-	virtual bool material_is_animated(RID p_material) = 0;
-	virtual bool material_casts_shadows(RID p_material) = 0;
-
-	struct InstanceShaderParam {
-		PropertyInfo info;
-		int index;
-		Variant default_value;
-	};
-
-	virtual void material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) = 0;
-
-	virtual void material_update_dependency(RID p_material, RasterizerScene::InstanceBase *p_instance) = 0;
-
-	/* MESH API */
-
-	virtual RID mesh_create() = 0;
-
-	/// Returns stride
-	virtual void mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) = 0;
-
-	virtual int mesh_get_blend_shape_count(RID p_mesh) const = 0;
-
-	virtual void mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode p_mode) = 0;
-	virtual RS::BlendShapeMode mesh_get_blend_shape_mode(RID p_mesh) const = 0;
-
-	virtual void mesh_surface_update_region(RID p_mesh, int p_surface, int p_offset, const Vector<uint8_t> &p_data) = 0;
-
-	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material) = 0;
-	virtual RID mesh_surface_get_material(RID p_mesh, int p_surface) const = 0;
-
-	virtual RS::SurfaceData mesh_get_surface(RID p_mesh, int p_surface) const = 0;
-
-	virtual int mesh_get_surface_count(RID p_mesh) const = 0;
-
-	virtual void mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) = 0;
-	virtual AABB mesh_get_custom_aabb(RID p_mesh) const = 0;
-
-	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton = RID()) = 0;
-
-	virtual void mesh_clear(RID p_mesh) = 0;
-
-	/* MULTIMESH API */
-
-	virtual RID multimesh_create() = 0;
-
-	virtual void multimesh_allocate(RID p_multimesh, int p_instances, RS::MultimeshTransformFormat p_transform_format, bool p_use_colors = false, bool p_use_custom_data = false) = 0;
-
-	virtual int multimesh_get_instance_count(RID p_multimesh) const = 0;
-
-	virtual void multimesh_set_mesh(RID p_multimesh, RID p_mesh) = 0;
-	virtual void multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) = 0;
-	virtual void multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) = 0;
-	virtual void multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) = 0;
-	virtual void multimesh_instance_set_custom_data(RID p_multimesh, int p_index, const Color &p_color) = 0;
-
-	virtual RID multimesh_get_mesh(RID p_multimesh) const = 0;
-
-	virtual Transform multimesh_instance_get_transform(RID p_multimesh, int p_index) const = 0;
-	virtual Transform2D multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const = 0;
-	virtual Color multimesh_instance_get_color(RID p_multimesh, int p_index) const = 0;
-	virtual Color multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const = 0;
-
-	virtual void multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) = 0;
-	virtual Vector<float> multimesh_get_buffer(RID p_multimesh) const = 0;
-
-	virtual void multimesh_set_visible_instances(RID p_multimesh, int p_visible) = 0;
-	virtual int multimesh_get_visible_instances(RID p_multimesh) const = 0;
-
-	virtual AABB multimesh_get_aabb(RID p_multimesh) const = 0;
-
-	/* IMMEDIATE API */
-
-	virtual RID immediate_create() = 0;
-	virtual void immediate_begin(RID p_immediate, RS::PrimitiveType p_rimitive, RID p_texture = RID()) = 0;
-	virtual void immediate_vertex(RID p_immediate, const Vector3 &p_vertex) = 0;
-	virtual void immediate_normal(RID p_immediate, const Vector3 &p_normal) = 0;
-	virtual void immediate_tangent(RID p_immediate, const Plane &p_tangent) = 0;
-	virtual void immediate_color(RID p_immediate, const Color &p_color) = 0;
-	virtual void immediate_uv(RID p_immediate, const Vector2 &tex_uv) = 0;
-	virtual void immediate_uv2(RID p_immediate, const Vector2 &tex_uv) = 0;
-	virtual void immediate_end(RID p_immediate) = 0;
-	virtual void immediate_clear(RID p_immediate) = 0;
-	virtual void immediate_set_material(RID p_immediate, RID p_material) = 0;
-	virtual RID immediate_get_material(RID p_immediate) const = 0;
-	virtual AABB immediate_get_aabb(RID p_immediate) const = 0;
-
-	/* SKELETON API */
-
-	virtual RID skeleton_create() = 0;
-	virtual void skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton = false) = 0;
-	virtual int skeleton_get_bone_count(RID p_skeleton) const = 0;
-	virtual void skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) = 0;
-	virtual Transform skeleton_bone_get_transform(RID p_skeleton, int p_bone) const = 0;
-	virtual void skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) = 0;
-	virtual Transform2D skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const = 0;
-	virtual void skeleton_set_base_transform_2d(RID p_skeleton, const Transform2D &p_base_transform) = 0;
-
-	/* Light API */
-
-	virtual RID light_create(RS::LightType p_type) = 0;
-
-	RID directional_light_create() { return light_create(RS::LIGHT_DIRECTIONAL); }
-	RID omni_light_create() { return light_create(RS::LIGHT_OMNI); }
-	RID spot_light_create() { return light_create(RS::LIGHT_SPOT); }
-
-	virtual void light_set_color(RID p_light, const Color &p_color) = 0;
-	virtual void light_set_param(RID p_light, RS::LightParam p_param, float p_value) = 0;
-	virtual void light_set_shadow(RID p_light, bool p_enabled) = 0;
-	virtual void light_set_shadow_color(RID p_light, const Color &p_color) = 0;
-	virtual void light_set_projector(RID p_light, RID p_texture) = 0;
-	virtual void light_set_negative(RID p_light, bool p_enable) = 0;
-	virtual void light_set_cull_mask(RID p_light, uint32_t p_mask) = 0;
-	virtual void light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) = 0;
-	virtual void light_set_bake_mode(RID p_light, RS::LightBakeMode p_bake_mode) = 0;
-	virtual void light_set_max_sdfgi_cascade(RID p_light, uint32_t p_cascade) = 0;
-
-	virtual void light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMode p_mode) = 0;
-
-	virtual void light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode) = 0;
-	virtual void light_directional_set_blend_splits(RID p_light, bool p_enable) = 0;
-	virtual bool light_directional_get_blend_splits(RID p_light) const = 0;
-	virtual void light_directional_set_shadow_depth_range_mode(RID p_light, RS::LightDirectionalShadowDepthRangeMode p_range_mode) = 0;
-	virtual RS::LightDirectionalShadowDepthRangeMode light_directional_get_shadow_depth_range_mode(RID p_light) const = 0;
-
-	virtual RS::LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light) = 0;
-	virtual RS::LightOmniShadowMode light_omni_get_shadow_mode(RID p_light) = 0;
-
-	virtual bool light_has_shadow(RID p_light) const = 0;
-
-	virtual RS::LightType light_get_type(RID p_light) const = 0;
-	virtual AABB light_get_aabb(RID p_light) const = 0;
-	virtual float light_get_param(RID p_light, RS::LightParam p_param) = 0;
-	virtual Color light_get_color(RID p_light) = 0;
-	virtual RS::LightBakeMode light_get_bake_mode(RID p_light) = 0;
-	virtual uint32_t light_get_max_sdfgi_cascade(RID p_light) = 0;
-	virtual uint64_t light_get_version(RID p_light) const = 0;
-
-	/* PROBE API */
-
-	virtual RID reflection_probe_create() = 0;
-
-	virtual void reflection_probe_set_update_mode(RID p_probe, RS::ReflectionProbeUpdateMode p_mode) = 0;
-	virtual void reflection_probe_set_resolution(RID p_probe, int p_resolution) = 0;
-	virtual void reflection_probe_set_intensity(RID p_probe, float p_intensity) = 0;
-	virtual void reflection_probe_set_ambient_mode(RID p_probe, RS::ReflectionProbeAmbientMode p_mode) = 0;
-	virtual void reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) = 0;
-	virtual void reflection_probe_set_ambient_energy(RID p_probe, float p_energy) = 0;
-	virtual void reflection_probe_set_max_distance(RID p_probe, float p_distance) = 0;
-	virtual void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) = 0;
-	virtual void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) = 0;
-	virtual void reflection_probe_set_as_interior(RID p_probe, bool p_enable) = 0;
-	virtual void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) = 0;
-	virtual void reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) = 0;
-	virtual void reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) = 0;
-
-	virtual AABB reflection_probe_get_aabb(RID p_probe) const = 0;
-	virtual RS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const = 0;
-	virtual uint32_t reflection_probe_get_cull_mask(RID p_probe) const = 0;
-	virtual Vector3 reflection_probe_get_extents(RID p_probe) const = 0;
-	virtual Vector3 reflection_probe_get_origin_offset(RID p_probe) const = 0;
-	virtual float reflection_probe_get_origin_max_distance(RID p_probe) const = 0;
-	virtual bool reflection_probe_renders_shadows(RID p_probe) const = 0;
-
-	virtual void base_update_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance) = 0;
-	virtual void skeleton_update_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance) = 0;
-
-	/* DECAL API */
-
-	virtual RID decal_create() = 0;
-	virtual void decal_set_extents(RID p_decal, const Vector3 &p_extents) = 0;
-	virtual void decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) = 0;
-	virtual void decal_set_emission_energy(RID p_decal, float p_energy) = 0;
-	virtual void decal_set_albedo_mix(RID p_decal, float p_mix) = 0;
-	virtual void decal_set_modulate(RID p_decal, const Color &p_modulate) = 0;
-	virtual void decal_set_cull_mask(RID p_decal, uint32_t p_layers) = 0;
-	virtual void decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) = 0;
-	virtual void decal_set_fade(RID p_decal, float p_above, float p_below) = 0;
-	virtual void decal_set_normal_fade(RID p_decal, float p_fade) = 0;
-
-	virtual AABB decal_get_aabb(RID p_decal) const = 0;
-
-	/* GI PROBE API */
-
-	virtual RID gi_probe_create() = 0;
-
-	virtual void gi_probe_allocate(RID p_gi_probe, const Transform &p_to_cell_xform, const AABB &p_aabb, const Vector3i &p_octree_size, const Vector<uint8_t> &p_octree_cells, const Vector<uint8_t> &p_data_cells, const Vector<uint8_t> &p_distance_field, const Vector<int> &p_level_counts) = 0;
-
-	virtual AABB gi_probe_get_bounds(RID p_gi_probe) const = 0;
-	virtual Vector3i gi_probe_get_octree_size(RID p_gi_probe) const = 0;
-	virtual Vector<uint8_t> gi_probe_get_octree_cells(RID p_gi_probe) const = 0;
-	virtual Vector<uint8_t> gi_probe_get_data_cells(RID p_gi_probe) const = 0;
-	virtual Vector<uint8_t> gi_probe_get_distance_field(RID p_gi_probe) const = 0;
-
-	virtual Vector<int> gi_probe_get_level_counts(RID p_gi_probe) const = 0;
-	virtual Transform gi_probe_get_to_cell_xform(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_dynamic_range(RID p_gi_probe, float p_range) = 0;
-	virtual float gi_probe_get_dynamic_range(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_propagation(RID p_gi_probe, float p_range) = 0;
-	virtual float gi_probe_get_propagation(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_energy(RID p_gi_probe, float p_energy) = 0;
-	virtual float gi_probe_get_energy(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_ao(RID p_gi_probe, float p_ao) = 0;
-	virtual float gi_probe_get_ao(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_ao_size(RID p_gi_probe, float p_strength) = 0;
-	virtual float gi_probe_get_ao_size(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_bias(RID p_gi_probe, float p_bias) = 0;
-	virtual float gi_probe_get_bias(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_normal_bias(RID p_gi_probe, float p_range) = 0;
-	virtual float gi_probe_get_normal_bias(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_interior(RID p_gi_probe, bool p_enable) = 0;
-	virtual bool gi_probe_is_interior(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_use_two_bounces(RID p_gi_probe, bool p_enable) = 0;
-	virtual bool gi_probe_is_using_two_bounces(RID p_gi_probe) const = 0;
-
-	virtual void gi_probe_set_anisotropy_strength(RID p_gi_probe, float p_strength) = 0;
-	virtual float gi_probe_get_anisotropy_strength(RID p_gi_probe) const = 0;
-
-	virtual uint32_t gi_probe_get_version(RID p_probe) = 0;
-
-	/* LIGHTMAP CAPTURE */
-
-	virtual RID lightmap_create() = 0;
-
-	virtual void lightmap_set_textures(RID p_lightmap, RID p_light, bool p_uses_spherical_haromics) = 0;
-	virtual void lightmap_set_probe_bounds(RID p_lightmap, const AABB &p_bounds) = 0;
-	virtual void lightmap_set_probe_interior(RID p_lightmap, bool p_interior) = 0;
-	virtual void lightmap_set_probe_capture_data(RID p_lightmap, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) = 0;
-	virtual PackedVector3Array lightmap_get_probe_capture_points(RID p_lightmap) const = 0;
-	virtual PackedColorArray lightmap_get_probe_capture_sh(RID p_lightmap) const = 0;
-	virtual PackedInt32Array lightmap_get_probe_capture_tetrahedra(RID p_lightmap) const = 0;
-	virtual PackedInt32Array lightmap_get_probe_capture_bsp_tree(RID p_lightmap) const = 0;
-	virtual AABB lightmap_get_aabb(RID p_lightmap) const = 0;
-	virtual void lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) = 0;
-	virtual bool lightmap_is_interior(RID p_lightmap) const = 0;
-	virtual void lightmap_set_probe_capture_update_speed(float p_speed) = 0;
-	virtual float lightmap_get_probe_capture_update_speed() const = 0;
-
-	/* PARTICLES */
-
-	virtual RID particles_create() = 0;
-
-	virtual void particles_set_emitting(RID p_particles, bool p_emitting) = 0;
-	virtual bool particles_get_emitting(RID p_particles) = 0;
-
-	virtual void particles_set_amount(RID p_particles, int p_amount) = 0;
-	virtual void particles_set_lifetime(RID p_particles, float p_lifetime) = 0;
-	virtual void particles_set_one_shot(RID p_particles, bool p_one_shot) = 0;
-	virtual void particles_set_pre_process_time(RID p_particles, float p_time) = 0;
-	virtual void particles_set_explosiveness_ratio(RID p_particles, float p_ratio) = 0;
-	virtual void particles_set_randomness_ratio(RID p_particles, float p_ratio) = 0;
-	virtual void particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) = 0;
-	virtual void particles_set_speed_scale(RID p_particles, float p_scale) = 0;
-	virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable) = 0;
-	virtual void particles_set_process_material(RID p_particles, RID p_material) = 0;
-	virtual void particles_set_fixed_fps(RID p_particles, int p_fps) = 0;
-	virtual void particles_set_fractional_delta(RID p_particles, bool p_enable) = 0;
-	virtual void particles_set_collision_base_size(RID p_particles, float p_size) = 0;
-	virtual void particles_restart(RID p_particles) = 0;
-	virtual void particles_emit(RID p_particles, const Transform &p_transform, const Vector3 &p_velocity, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) = 0;
-	virtual void particles_set_subemitter(RID p_particles, RID p_subemitter_particles) = 0;
-
-	virtual bool particles_is_inactive(RID p_particles) const = 0;
-
-	virtual void particles_set_draw_order(RID p_particles, RS::ParticlesDrawOrder p_order) = 0;
-
-	virtual void particles_set_draw_passes(RID p_particles, int p_count) = 0;
-	virtual void particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) = 0;
-
-	virtual void particles_request_process(RID p_particles) = 0;
-	virtual AABB particles_get_current_aabb(RID p_particles) = 0;
-	virtual AABB particles_get_aabb(RID p_particles) const = 0;
-
-	virtual void particles_set_emission_transform(RID p_particles, const Transform &p_transform) = 0;
-
-	virtual int particles_get_draw_passes(RID p_particles) const = 0;
-	virtual RID particles_get_draw_pass_mesh(RID p_particles, int p_pass) const = 0;
-
-	virtual void particles_set_view_axis(RID p_particles, const Vector3 &p_axis) = 0;
-
-	virtual void particles_add_collision(RID p_particles, RasterizerScene::InstanceBase *p_instance) = 0;
-	virtual void particles_remove_collision(RID p_particles, RasterizerScene::InstanceBase *p_instance) = 0;
-
-	virtual void update_particles() = 0;
-
-	/* PARTICLES COLLISION */
-
-	virtual RID particles_collision_create() = 0;
-	virtual void particles_collision_set_collision_type(RID p_particles_collision, RS::ParticlesCollisionType p_type) = 0;
-	virtual void particles_collision_set_cull_mask(RID p_particles_collision, uint32_t p_cull_mask) = 0;
-	virtual void particles_collision_set_sphere_radius(RID p_particles_collision, float p_radius) = 0; //for spheres
-	virtual void particles_collision_set_box_extents(RID p_particles_collision, const Vector3 &p_extents) = 0; //for non-spheres
-	virtual void particles_collision_set_attractor_strength(RID p_particles_collision, float p_strength) = 0;
-	virtual void particles_collision_set_attractor_directionality(RID p_particles_collision, float p_directionality) = 0;
-	virtual void particles_collision_set_attractor_attenuation(RID p_particles_collision, float p_curve) = 0;
-	virtual void particles_collision_set_field_texture(RID p_particles_collision, RID p_texture) = 0; //for SDF and vector field, heightfield is dynamic
-	virtual void particles_collision_height_field_update(RID p_particles_collision) = 0; //for SDF and vector field
-	virtual void particles_collision_set_height_field_resolution(RID p_particles_collision, RS::ParticlesCollisionHeightfieldResolution p_resolution) = 0; //for SDF and vector field
-	virtual AABB particles_collision_get_aabb(RID p_particles_collision) const = 0;
-	virtual bool particles_collision_is_heightfield(RID p_particles_collision) const = 0;
-	virtual RID particles_collision_get_heightfield_framebuffer(RID p_particles_collision) const = 0;
-
-	/* GLOBAL VARIABLES */
-
-	virtual void global_variable_add(const StringName &p_name, RS::GlobalVariableType p_type, const Variant &p_value) = 0;
-	virtual void global_variable_remove(const StringName &p_name) = 0;
-	virtual Vector<StringName> global_variable_get_list() const = 0;
-
-	virtual void global_variable_set(const StringName &p_name, const Variant &p_value) = 0;
-	virtual void global_variable_set_override(const StringName &p_name, const Variant &p_value) = 0;
-	virtual Variant global_variable_get(const StringName &p_name) const = 0;
-	virtual RS::GlobalVariableType global_variable_get_type(const StringName &p_name) const = 0;
-
-	virtual void global_variables_load_settings(bool p_load_textures = true) = 0;
-	virtual void global_variables_clear() = 0;
-
-	virtual int32_t global_variables_instance_allocate(RID p_instance) = 0;
-	virtual void global_variables_instance_free(RID p_instance) = 0;
-	virtual void global_variables_instance_update(RID p_instance, int p_index, const Variant &p_value) = 0;
-
-	/* RENDER TARGET */
-
-	enum RenderTargetFlags {
-		RENDER_TARGET_TRANSPARENT,
-		RENDER_TARGET_DIRECT_TO_SCREEN,
-		RENDER_TARGET_FLAG_MAX
-	};
-
-	virtual RID render_target_create() = 0;
-	virtual void render_target_set_position(RID p_render_target, int p_x, int p_y) = 0;
-	virtual void render_target_set_size(RID p_render_target, int p_width, int p_height) = 0;
-	virtual RID render_target_get_texture(RID p_render_target) = 0;
-	virtual void render_target_set_external_texture(RID p_render_target, unsigned int p_texture_id) = 0;
-	virtual void render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value) = 0;
-	virtual bool render_target_was_used(RID p_render_target) = 0;
-	virtual void render_target_set_as_unused(RID p_render_target) = 0;
-
-	virtual void render_target_request_clear(RID p_render_target, const Color &p_clear_color) = 0;
-	virtual bool render_target_is_clear_requested(RID p_render_target) = 0;
-	virtual Color render_target_get_clear_request_color(RID p_render_target) = 0;
-	virtual void render_target_disable_clear_request(RID p_render_target) = 0;
-	virtual void render_target_do_clear_request(RID p_render_target) = 0;
-
-	virtual RS::InstanceType get_base_type(RID p_rid) const = 0;
-	virtual bool free(RID p_rid) = 0;
-
-	virtual bool has_os_feature(const String &p_feature) const = 0;
-
-	virtual void update_dirty_resources() = 0;
-
-	virtual void set_debug_generate_wireframes(bool p_generate) = 0;
-
-	virtual void render_info_begin_capture() = 0;
-	virtual void render_info_end_capture() = 0;
-	virtual int get_captured_render_info(RS::RenderInfo p_info) = 0;
-
-	virtual int get_render_info(RS::RenderInfo p_info) = 0;
-	virtual String get_video_adapter_name() const = 0;
-	virtual String get_video_adapter_vendor() const = 0;
-
-	static RasterizerStorage *base_singleton;
-
-	void set_default_clear_color(const Color &p_color) {
-		default_clear_color = p_color;
-	}
-
-	Color get_default_clear_color() const {
-		return default_clear_color;
-	}
-#define TIMESTAMP_BEGIN()                             \
-	{                                                 \
-		if (RSG::storage->capturing_timestamps)       \
-			RSG::storage->capture_timestamps_begin(); \
-	}
-
-#define RENDER_TIMESTAMP(m_text)                     \
-	{                                                \
-		if (RSG::storage->capturing_timestamps)      \
-			RSG::storage->capture_timestamp(m_text); \
-	}
-
-	bool capturing_timestamps = false;
-
-	virtual void capture_timestamps_begin() = 0;
-	virtual void capture_timestamp(const String &p_name) = 0;
-	virtual uint32_t get_captured_timestamps_count() const = 0;
-	virtual uint64_t get_captured_timestamps_frame() const = 0;
-	virtual uint64_t get_captured_timestamp_gpu_time(uint32_t p_index) const = 0;
-	virtual uint64_t get_captured_timestamp_cpu_time(uint32_t p_index) const = 0;
-	virtual String get_captured_timestamp_name(uint32_t p_index) const = 0;
-
-	RasterizerStorage();
-	virtual ~RasterizerStorage() {}
-};
-
-class RasterizerCanvas {
-public:
-	static RasterizerCanvas *singleton;
-
-	enum CanvasRectFlags {
-
-		CANVAS_RECT_REGION = 1,
-		CANVAS_RECT_TILE = 2,
-		CANVAS_RECT_FLIP_H = 4,
-		CANVAS_RECT_FLIP_V = 8,
-		CANVAS_RECT_TRANSPOSE = 16,
-		CANVAS_RECT_CLIP_UV = 32,
-		CANVAS_RECT_IS_GROUP = 64,
-	};
-
-	struct Light {
-		bool enabled;
-		Color color;
-		Transform2D xform;
-		float height;
-		float energy;
-		float scale;
-		int z_min;
-		int z_max;
-		int layer_min;
-		int layer_max;
-		int item_mask;
-		int item_shadow_mask;
-		float directional_distance;
-		RS::CanvasLightMode mode;
-		RS::CanvasLightBlendMode blend_mode;
-		RID texture;
-		Vector2 texture_offset;
-		RID canvas;
-		bool use_shadow;
-		int shadow_buffer_size;
-		RS::CanvasLightShadowFilter shadow_filter;
-		Color shadow_color;
-		float shadow_smooth;
-
-		//void *texture_cache; // implementation dependent
-		Rect2 rect_cache;
-		Transform2D xform_cache;
-		float radius_cache; //used for shadow far plane
-		//CameraMatrix shadow_matrix_cache;
-
-		Transform2D light_shader_xform;
-		//Vector2 light_shader_pos;
-
-		Light *shadows_next_ptr;
-		Light *filter_next_ptr;
-		Light *next_ptr;
-		Light *directional_next_ptr;
-
-		RID light_internal;
-		uint64_t version;
-
-		int32_t render_index_cache;
-
-		Light() {
-			version = 0;
-			enabled = true;
-			color = Color(1, 1, 1);
-			shadow_color = Color(0, 0, 0, 0);
-			height = 0;
-			z_min = -1024;
-			z_max = 1024;
-			layer_min = 0;
-			layer_max = 0;
-			item_mask = 1;
-			scale = 1.0;
-			energy = 1.0;
-			item_shadow_mask = 1;
-			mode = RS::CANVAS_LIGHT_MODE_POINT;
-			blend_mode = RS::CANVAS_LIGHT_BLEND_MODE_ADD;
-			//			texture_cache = nullptr;
-			next_ptr = nullptr;
-			directional_next_ptr = nullptr;
-			filter_next_ptr = nullptr;
-			use_shadow = false;
-			shadow_buffer_size = 2048;
-			shadow_filter = RS::CANVAS_LIGHT_FILTER_NONE;
-			shadow_smooth = 0.0;
-			render_index_cache = -1;
-			directional_distance = 10000.0;
-		}
-	};
-
-	//easier wrap to avoid mistakes
-
-	struct Item;
-
-	typedef uint64_t PolygonID;
-	virtual PolygonID request_polygon(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), const Vector<int> &p_bones = Vector<int>(), const Vector<float> &p_weights = Vector<float>()) = 0;
-	virtual void free_polygon(PolygonID p_polygon) = 0;
-
-	//also easier to wrap to avoid mistakes
-	struct Polygon {
-		PolygonID polygon_id;
-		Rect2 rect_cache;
-
-		_FORCE_INLINE_ void create(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), const Vector<int> &p_bones = Vector<int>(), const Vector<float> &p_weights = Vector<float>()) {
-			ERR_FAIL_COND(polygon_id != 0);
-			{
-				uint32_t pc = p_points.size();
-				const Vector2 *v2 = p_points.ptr();
-				rect_cache.position = *v2;
-				for (uint32_t i = 1; i < pc; i++) {
-					rect_cache.expand_to(v2[i]);
-				}
-			}
-			polygon_id = singleton->request_polygon(p_indices, p_points, p_colors, p_uvs, p_bones, p_weights);
-		}
-
-		_FORCE_INLINE_ Polygon() { polygon_id = 0; }
-		_FORCE_INLINE_ ~Polygon() {
-			if (polygon_id) {
-				singleton->free_polygon(polygon_id);
-			}
-		}
-	};
-
-	//item
-
-	struct Item {
-		//commands are allocated in blocks of 4k to improve performance
-		//and cache coherence.
-		//blocks always grow but never shrink.
-
-		struct CommandBlock {
-			enum {
-				MAX_SIZE = 4096
-			};
-			uint32_t usage;
-			uint8_t *memory;
-		};
-
-		struct Command {
-			enum Type {
-
-				TYPE_RECT,
-				TYPE_NINEPATCH,
-				TYPE_POLYGON,
-				TYPE_PRIMITIVE,
-				TYPE_MESH,
-				TYPE_MULTIMESH,
-				TYPE_PARTICLES,
-				TYPE_TRANSFORM,
-				TYPE_CLIP_IGNORE,
-			};
-
-			Command *next;
-			Type type;
-			virtual ~Command() {}
-		};
-
-		struct CommandRect : public Command {
-			Rect2 rect;
-			Color modulate;
-			Rect2 source;
-			uint8_t flags;
-
-			RID texture;
-
-			CommandRect() {
-				flags = 0;
-				type = TYPE_RECT;
-			}
-		};
-
-		struct CommandNinePatch : public Command {
-			Rect2 rect;
-			Rect2 source;
-			float margin[4];
-			bool draw_center;
-			Color color;
-			RS::NinePatchAxisMode axis_x;
-			RS::NinePatchAxisMode axis_y;
-
-			RID texture;
-
-			CommandNinePatch() {
-				draw_center = true;
-				type = TYPE_NINEPATCH;
-			}
-		};
-
-		struct CommandPolygon : public Command {
-			RS::PrimitiveType primitive;
-			Polygon polygon;
-
-			RID texture;
-
-			CommandPolygon() {
-				type = TYPE_POLYGON;
-			}
-		};
-
-		struct CommandPrimitive : public Command {
-			uint32_t point_count;
-			Vector2 points[4];
-			Vector2 uvs[4];
-			Color colors[4];
-
-			RID texture;
-
-			CommandPrimitive() {
-				type = TYPE_PRIMITIVE;
-			}
-		};
-
-		struct CommandMesh : public Command {
-			RID mesh;
-			Transform2D transform;
-			Color modulate;
-
-			RID texture;
-
-			CommandMesh() { type = TYPE_MESH; }
-		};
-
-		struct CommandMultiMesh : public Command {
-			RID multimesh;
-
-			RID texture;
-
-			CommandMultiMesh() { type = TYPE_MULTIMESH; }
-		};
-
-		struct CommandParticles : public Command {
-			RID particles;
-
-			RID texture;
-
-			CommandParticles() { type = TYPE_PARTICLES; }
-		};
-
-		struct CommandTransform : public Command {
-			Transform2D xform;
-			CommandTransform() { type = TYPE_TRANSFORM; }
-		};
-
-		struct CommandClipIgnore : public Command {
-			bool ignore;
-			CommandClipIgnore() {
-				type = TYPE_CLIP_IGNORE;
-				ignore = false;
-			}
-		};
-
-		struct ViewportRender {
-			RenderingServer *owner;
-			void *udata;
-			Rect2 rect;
-		};
-
-		Transform2D xform;
-		bool clip;
-		bool visible;
-		bool behind;
-		bool update_when_visible;
-
-		struct CanvasGroup {
-			RS::CanvasGroupMode mode;
-			bool fit_empty;
-			float fit_margin;
-			bool blur_mipmaps;
-			float clear_margin;
-		};
-
-		CanvasGroup *canvas_group = nullptr;
-		int light_mask;
-		int z_final;
-
-		mutable bool custom_rect;
-		mutable bool rect_dirty;
-		mutable Rect2 rect;
-		RID material;
-		RID skeleton;
-
-		Item *next;
-
-		struct CopyBackBuffer {
-			Rect2 rect;
-			Rect2 screen_rect;
-			bool full;
-		};
-		CopyBackBuffer *copy_back_buffer;
-
-		Color final_modulate;
-		Transform2D final_transform;
-		Rect2 final_clip_rect;
-		Item *final_clip_owner;
-		Item *material_owner;
-		Item *canvas_group_owner;
-		ViewportRender *vp_render;
-		bool distance_field;
-		bool light_masked;
-
-		Rect2 global_rect_cache;
-
-		const Rect2 &get_rect() const {
-			if (custom_rect || (!rect_dirty && !update_when_visible)) {
-				return rect;
-			}
-
-			//must update rect
-
-			if (commands == nullptr) {
-				rect = Rect2();
-				rect_dirty = false;
-				return rect;
-			}
-
-			Transform2D xf;
-			bool found_xform = false;
-			bool first = true;
-
-			const Item::Command *c = commands;
-
-			while (c) {
-				Rect2 r;
-
-				switch (c->type) {
-					case Item::Command::TYPE_RECT: {
-						const Item::CommandRect *crect = static_cast<const Item::CommandRect *>(c);
-						r = crect->rect;
-
-					} break;
-					case Item::Command::TYPE_NINEPATCH: {
-						const Item::CommandNinePatch *style = static_cast<const Item::CommandNinePatch *>(c);
-						r = style->rect;
-					} break;
-
-					case Item::Command::TYPE_POLYGON: {
-						const Item::CommandPolygon *polygon = static_cast<const Item::CommandPolygon *>(c);
-						r = polygon->polygon.rect_cache;
-					} break;
-					case Item::Command::TYPE_PRIMITIVE: {
-						const Item::CommandPrimitive *primitive = static_cast<const Item::CommandPrimitive *>(c);
-						for (uint32_t j = 0; j < primitive->point_count; j++) {
-							if (j == 0) {
-								r.position = primitive->points[0];
-							} else {
-								r.expand_to(primitive->points[j]);
-							}
-						}
-					} break;
-					case Item::Command::TYPE_MESH: {
-						const Item::CommandMesh *mesh = static_cast<const Item::CommandMesh *>(c);
-						AABB aabb = RasterizerStorage::base_singleton->mesh_get_aabb(mesh->mesh, RID());
-
-						r = Rect2(aabb.position.x, aabb.position.y, aabb.size.x, aabb.size.y);
-
-					} break;
-					case Item::Command::TYPE_MULTIMESH: {
-						const Item::CommandMultiMesh *multimesh = static_cast<const Item::CommandMultiMesh *>(c);
-						AABB aabb = RasterizerStorage::base_singleton->multimesh_get_aabb(multimesh->multimesh);
-
-						r = Rect2(aabb.position.x, aabb.position.y, aabb.size.x, aabb.size.y);
-
-					} break;
-					case Item::Command::TYPE_PARTICLES: {
-						const Item::CommandParticles *particles_cmd = static_cast<const Item::CommandParticles *>(c);
-						if (particles_cmd->particles.is_valid()) {
-							AABB aabb = RasterizerStorage::base_singleton->particles_get_aabb(particles_cmd->particles);
-							r = Rect2(aabb.position.x, aabb.position.y, aabb.size.x, aabb.size.y);
-						}
-
-					} break;
-					case Item::Command::TYPE_TRANSFORM: {
-						const Item::CommandTransform *transform = static_cast<const Item::CommandTransform *>(c);
-						xf = transform->xform;
-						found_xform = true;
-						[[fallthrough]];
-					}
-					default: {
-						c = c->next;
-						continue;
-					}
-				}
-
-				if (found_xform) {
-					r = xf.xform(r);
-					found_xform = false;
-				}
-
-				if (first) {
-					rect = r;
-					first = false;
-				} else {
-					rect = rect.merge(r);
-				}
-				c = c->next;
-			}
-
-			rect_dirty = false;
-			return rect;
-		}
-
-		Command *commands;
-		Command *last_command;
-		Vector<CommandBlock> blocks;
-		uint32_t current_block;
-
-		template <class T>
-		T *alloc_command() {
-			T *command;
-			if (commands == nullptr) {
-				// As the most common use case of canvas items is to
-				// use only one command, the first is done with it's
-				// own allocation. The rest of them use blocks.
-				command = memnew(T);
-				command->next = nullptr;
-				commands = command;
-				last_command = command;
-			} else {
-				//Subsequent commands go into a block.
-
-				while (true) {
-					if (unlikely(current_block == (uint32_t)blocks.size())) {
-						// If we need more blocks, we allocate them
-						// (they won't be freed until this CanvasItem is
-						// deleted, though).
-						CommandBlock cb;
-						cb.memory = (uint8_t *)memalloc(CommandBlock::MAX_SIZE);
-						cb.usage = 0;
-						blocks.push_back(cb);
-					}
-
-					CommandBlock *c = &blocks.write[current_block];
-					size_t space_left = CommandBlock::MAX_SIZE - c->usage;
-					if (space_left < sizeof(T)) {
-						current_block++;
-						continue;
-					}
-
-					//allocate block and add to the linked list
-					void *memory = c->memory + c->usage;
-					command = memnew_placement(memory, T);
-					command->next = nullptr;
-					last_command->next = command;
-					last_command = command;
-					c->usage += sizeof(T);
-					break;
-				}
-			}
-
-			rect_dirty = true;
-			return command;
-		}
-
-		void clear() {
-			// The first one is always allocated on heap
-			// the rest go in the blocks
-			Command *c = commands;
-			while (c) {
-				Command *n = c->next;
-				if (c == commands) {
-					memdelete(commands);
-					commands = nullptr;
-				} else {
-					c->~Command();
-				}
-				c = n;
-			}
-			{
-				uint32_t cbc = MIN((current_block + 1), (uint32_t)blocks.size());
-				CommandBlock *blockptr = blocks.ptrw();
-				for (uint32_t i = 0; i < cbc; i++) {
-					blockptr[i].usage = 0;
-				}
-			}
-
-			last_command = nullptr;
-			commands = nullptr;
-			current_block = 0;
-			clip = false;
-			rect_dirty = true;
-			final_clip_owner = nullptr;
-			material_owner = nullptr;
-			light_masked = false;
-		}
-
-		RS::CanvasItemTextureFilter texture_filter;
-		RS::CanvasItemTextureRepeat texture_repeat;
-
-		Item() {
-			commands = nullptr;
-			last_command = nullptr;
-			current_block = 0;
-			light_mask = 1;
-			vp_render = nullptr;
-			next = nullptr;
-			final_clip_owner = nullptr;
-			canvas_group_owner = nullptr;
-			clip = false;
-			final_modulate = Color(1, 1, 1, 1);
-			visible = true;
-			rect_dirty = true;
-			custom_rect = false;
-			behind = false;
-			material_owner = nullptr;
-			copy_back_buffer = nullptr;
-			distance_field = false;
-			light_masked = false;
-			update_when_visible = false;
-			z_final = 0;
-			texture_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT;
-			texture_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT;
-		}
-		virtual ~Item() {
-			clear();
-			for (int i = 0; i < blocks.size(); i++) {
-				memfree(blocks[i].memory);
-			}
-			if (copy_back_buffer) {
-				memdelete(copy_back_buffer);
-			}
-		}
-	};
-
-	virtual void canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_list, const Transform2D &p_canvas_transform, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel) = 0;
-	virtual void canvas_debug_viewport_shadows(Light *p_lights_with_shadow) = 0;
-
-	struct LightOccluderInstance {
-		bool enabled;
-		RID canvas;
-		RID polygon;
-		RID occluder;
-		Rect2 aabb_cache;
-		Transform2D xform;
-		Transform2D xform_cache;
-		int light_mask;
-		RS::CanvasOccluderPolygonCullMode cull_cache;
-
-		LightOccluderInstance *next;
-
-		LightOccluderInstance() {
-			enabled = true;
-			next = nullptr;
-			light_mask = 1;
-			cull_cache = RS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
-		}
-	};
-
-	virtual RID light_create() = 0;
-	virtual void light_set_texture(RID p_rid, RID p_texture) = 0;
-	virtual void light_set_use_shadow(RID p_rid, bool p_enable) = 0;
-	virtual void light_update_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders) = 0;
-	virtual void light_update_directional_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_cull_distance, const Rect2 &p_clip_rect, LightOccluderInstance *p_occluders) = 0;
-
-	virtual RID occluder_polygon_create() = 0;
-	virtual void occluder_polygon_set_shape_as_lines(RID p_occluder, const Vector<Vector2> &p_lines) = 0;
-	virtual void occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode) = 0;
-	virtual void set_shadow_texture_size(int p_size) = 0;
-
-	virtual void draw_window_margins(int *p_margins, RID *p_margin_textures) = 0;
-
-	virtual bool free(RID p_rid) = 0;
-	virtual void update() = 0;
-
-	RasterizerCanvas() { singleton = this; }
-	virtual ~RasterizerCanvas() {}
-};
-
-class Rasterizer {
-protected:
-	static Rasterizer *(*_create_func)();
-
-public:
-	static Rasterizer *create();
-
-	virtual RasterizerStorage *get_storage() = 0;
-	virtual RasterizerCanvas *get_canvas() = 0;
-	virtual RasterizerScene *get_scene() = 0;
-
-	virtual void set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter = true) = 0;
-
-	virtual void initialize() = 0;
-	virtual void begin_frame(double frame_step) = 0;
-
-	struct BlitToScreen {
-		RID render_target;
-		Rect2i rect;
-		//lens distorted parameters for VR should go here
-	};
-
-	virtual void prepare_for_blitting_render_targets() = 0;
-	virtual void blit_render_targets_to_screen(DisplayServer::WindowID p_screen, const BlitToScreen *p_render_targets, int p_amount) = 0;
-
-	virtual void end_frame(bool p_swap_buffers) = 0;
-	virtual void finalize() = 0;
-	virtual uint64_t get_frame_number() const = 0;
-	virtual float get_frame_delta_time() const = 0;
-
-	virtual bool is_low_end() const = 0;
-
-	virtual ~Rasterizer() {}
-};
-
-#endif // RASTERIZER_H
diff --git a/servers/rendering/rendering_server_canvas.cpp b/servers/rendering/renderer_canvas_cull.cpp
index 4480b79f75..53deba512e 100644
--- a/servers/rendering/rendering_server_canvas.cpp
+++ b/servers/rendering/renderer_canvas_cull.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_canvas.cpp                                          */
+/*  renderer_canvas_cull.cpp                                             */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,20 +28,20 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rendering_server_canvas.h"
+#include "renderer_canvas_cull.h"
 
 #include "core/math/geometry_2d.h"
+#include "renderer_viewport.h"
+#include "rendering_server_default.h"
 #include "rendering_server_globals.h"
-#include "rendering_server_raster.h"
-#include "rendering_server_viewport.h"
 
 static const int z_range = RS::CANVAS_ITEM_Z_MAX - RS::CANVAS_ITEM_Z_MIN + 1;
 
-void RenderingServerCanvas::_render_canvas_item_tree(RID p_to_render_target, Canvas::ChildItem *p_child_items, int p_child_item_count, Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, RasterizerCanvas::Light *p_lights, RasterizerCanvas::Light *p_directional_lights, RenderingServer::CanvasItemTextureFilter p_default_filter, RenderingServer::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel) {
+void RendererCanvasCull::_render_canvas_item_tree(RID p_to_render_target, Canvas::ChildItem *p_child_items, int p_child_item_count, Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, RendererCanvasRender::Light *p_lights, RendererCanvasRender::Light *p_directional_lights, RenderingServer::CanvasItemTextureFilter p_default_filter, RenderingServer::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel) {
 	RENDER_TIMESTAMP("Cull CanvasItem Tree");
 
-	memset(z_list, 0, z_range * sizeof(RasterizerCanvas::Item *));
-	memset(z_last_list, 0, z_range * sizeof(RasterizerCanvas::Item *));
+	memset(z_list, 0, z_range * sizeof(RendererCanvasRender::Item *));
+	memset(z_last_list, 0, z_range * sizeof(RendererCanvasRender::Item *));
 
 	for (int i = 0; i < p_child_item_count; i++) {
 		_cull_canvas_item(p_child_items[i].item, p_transform, p_clip_rect, Color(1, 1, 1, 1), 0, z_list, z_last_list, nullptr, nullptr);
@@ -50,8 +50,8 @@ void RenderingServerCanvas::_render_canvas_item_tree(RID p_to_render_target, Can
 		_cull_canvas_item(p_canvas_item, p_transform, p_clip_rect, Color(1, 1, 1, 1), 0, z_list, z_last_list, nullptr, nullptr);
 	}
 
-	RasterizerCanvas::Item *list = nullptr;
-	RasterizerCanvas::Item *list_end = nullptr;
+	RendererCanvasRender::Item *list = nullptr;
+	RendererCanvasRender::Item *list_end = nullptr;
 
 	for (int i = 0; i < z_range; i++) {
 		if (!z_list[i]) {
@@ -68,12 +68,16 @@ void RenderingServerCanvas::_render_canvas_item_tree(RID p_to_render_target, Can
 
 	RENDER_TIMESTAMP("Render Canvas Items");
 
-	RSG::canvas_render->canvas_render_items(p_to_render_target, list, p_modulate, p_lights, p_directional_lights, p_transform, p_default_filter, p_default_repeat, p_snap_2d_vertices_to_pixel);
+	bool sdf_flag;
+	RSG::canvas_render->canvas_render_items(p_to_render_target, list, p_modulate, p_lights, p_directional_lights, p_transform, p_default_filter, p_default_repeat, p_snap_2d_vertices_to_pixel, sdf_flag);
+	if (sdf_flag) {
+		sdf_used = true;
+	}
 }
 
-void _collect_ysort_children(RenderingServerCanvas::Item *p_canvas_item, Transform2D p_transform, RenderingServerCanvas::Item *p_material_owner, RenderingServerCanvas::Item **r_items, int &r_index) {
+void _collect_ysort_children(RendererCanvasCull::Item *p_canvas_item, Transform2D p_transform, RendererCanvasCull::Item *p_material_owner, RendererCanvasCull::Item **r_items, int &r_index) {
 	int child_item_count = p_canvas_item->child_items.size();
-	RenderingServerCanvas::Item **child_items = p_canvas_item->child_items.ptrw();
+	RendererCanvasCull::Item **child_items = p_canvas_item->child_items.ptrw();
 	for (int i = 0; i < child_item_count; i++) {
 		if (child_items[i]->visible) {
 			if (r_items) {
@@ -93,14 +97,14 @@ void _collect_ysort_children(RenderingServerCanvas::Item *p_canvas_item, Transfo
 	}
 }
 
-void _mark_ysort_dirty(RenderingServerCanvas::Item *ysort_owner, RID_PtrOwner<RenderingServerCanvas::Item> &canvas_item_owner) {
+void _mark_ysort_dirty(RendererCanvasCull::Item *ysort_owner, RID_PtrOwner<RendererCanvasCull::Item> &canvas_item_owner) {
 	do {
 		ysort_owner->ysort_children_count = -1;
 		ysort_owner = canvas_item_owner.owns(ysort_owner->parent) ? canvas_item_owner.getornull(ysort_owner->parent) : nullptr;
 	} while (ysort_owner && ysort_owner->sort_y);
 }
 
-void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, int p_z, RasterizerCanvas::Item **z_list, RasterizerCanvas::Item **z_last_list, Item *p_canvas_clip, Item *p_material_owner) {
+void RendererCanvasCull::_cull_canvas_item(Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, int p_z, RendererCanvasRender::Item **z_list, RendererCanvasRender::Item **z_last_list, Item *p_canvas_clip, Item *p_material_owner) {
 	Item *ci = p_canvas_item;
 
 	if (!ci->visible) {
@@ -115,7 +119,7 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 	Rect2 rect = ci->get_rect();
 	Transform2D xform = ci->xform;
 	if (snapping_2d_transforms_to_pixel) {
-		xform.elements[2].floor();
+		xform.elements[2] = xform.elements[2].floor();
 	}
 	xform = p_transform * xform;
 
@@ -140,7 +144,7 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 
 	if (ci->clip) {
 		if (p_canvas_clip != nullptr) {
-			ci->final_clip_rect = p_canvas_clip->final_clip_rect.clip(global_rect);
+			ci->final_clip_rect = p_canvas_clip->final_clip_rect.intersection(global_rect);
 		} else {
 			ci->final_clip_rect = global_rect;
 		}
@@ -172,7 +176,7 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 		p_z = ci->z_index;
 	}
 
-	RasterizerCanvas::Item *canvas_group_from = nullptr;
+	RendererCanvasRender::Item *canvas_group_from = nullptr;
 	bool use_canvas_group = ci->canvas_group != nullptr && (ci->canvas_group->fit_empty || ci->commands != nullptr);
 	if (use_canvas_group) {
 		int zidx = p_z - RS::CANVAS_ITEM_Z_MIN;
@@ -191,7 +195,7 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 	}
 
 	if (ci->copy_back_buffer) {
-		ci->copy_back_buffer->screen_rect = xform.xform(ci->copy_back_buffer->rect).clip(p_clip_rect);
+		ci->copy_back_buffer->screen_rect = xform.xform(ci->copy_back_buffer->rect).intersection(p_clip_rect);
 	}
 
 	if (use_canvas_group) {
@@ -209,7 +213,7 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 
 			//compute a global rect (in global coords) for children in the same z layer
 			Rect2 rect_accum;
-			RasterizerCanvas::Item *c = canvas_group_from;
+			RendererCanvasRender::Item *c = canvas_group_from;
 			while (c) {
 				if (c == canvas_group_from) {
 					rect_accum = c->global_rect_cache;
@@ -223,7 +227,7 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 			// We have two choices now, if user has drawn something, we must assume users wants to draw the "mask", so compute the size based on this.
 			// If nothing has been drawn, we just take it over and draw it ourselves.
 			if (ci->canvas_group->fit_empty && (ci->commands == nullptr ||
-													   (ci->commands->next == nullptr && ci->commands->type == Item::Command::TYPE_RECT && (static_cast<Item::CommandRect *>(ci->commands)->flags & RasterizerCanvas::CANVAS_RECT_IS_GROUP)))) {
+													   (ci->commands->next == nullptr && ci->commands->type == Item::Command::TYPE_RECT && (static_cast<Item::CommandRect *>(ci->commands)->flags & RendererCanvasRender::CANVAS_RECT_IS_GROUP)))) {
 				// No commands, or sole command is the one used to draw, so we (re)create the draw command.
 				ci->clear();
 
@@ -234,9 +238,9 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 				rect_accum = rect_accum.grow(ci->canvas_group->fit_margin);
 
 				//draw it?
-				RasterizerCanvas::Item::CommandRect *crect = ci->alloc_command<RasterizerCanvas::Item::CommandRect>();
+				RendererCanvasRender::Item::CommandRect *crect = ci->alloc_command<RendererCanvasRender::Item::CommandRect>();
 
-				crect->flags = RasterizerCanvas::CANVAS_RECT_IS_GROUP; // so we can recognize it later
+				crect->flags = RendererCanvasRender::CANVAS_RECT_IS_GROUP; // so we can recognize it later
 				crect->rect = xform.affine_inverse().xform(rect_accum);
 				crect->modulate = Color(1, 1, 1, 1);
 
@@ -252,14 +256,14 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 				global_rect.position += p_clip_rect.position;
 			}
 
-			// Very important that this is cleared after used in RasterizerCanvas to avoid
+			// Very important that this is cleared after used in RendererCanvasRender to avoid
 			// potential crashes.
 			canvas_group_from->canvas_group_owner = ci;
 		}
 	}
 
 	if (ci->update_when_visible) {
-		RenderingServerRaster::redraw_request();
+		RenderingServerDefault::redraw_request();
 	}
 
 	if ((ci->commands != nullptr && p_clip_rect.intersects(global_rect, true)) || ci->vp_render || ci->copy_back_buffer) {
@@ -298,9 +302,10 @@ void RenderingServerCanvas::_cull_canvas_item(Item *p_canvas_item, const Transfo
 	}
 }
 
-void RenderingServerCanvas::render_canvas(RID p_render_target, Canvas *p_canvas, const Transform2D &p_transform, RasterizerCanvas::Light *p_lights, RasterizerCanvas::Light *p_directional_lights, const Rect2 &p_clip_rect, RenderingServer::CanvasItemTextureFilter p_default_filter, RenderingServer::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_transforms_to_pixel, bool p_snap_2d_vertices_to_pixel) {
+void RendererCanvasCull::render_canvas(RID p_render_target, Canvas *p_canvas, const Transform2D &p_transform, RendererCanvasRender::Light *p_lights, RendererCanvasRender::Light *p_directional_lights, const Rect2 &p_clip_rect, RenderingServer::CanvasItemTextureFilter p_default_filter, RenderingServer::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_transforms_to_pixel, bool p_snap_2d_vertices_to_pixel) {
 	RENDER_TIMESTAMP(">Render Canvas");
 
+	sdf_used = false;
 	snapping_2d_transforms_to_pixel = p_snap_2d_transforms_to_pixel;
 
 	if (p_canvas->children_order_dirty) {
@@ -347,7 +352,11 @@ void RenderingServerCanvas::render_canvas(RID p_render_target, Canvas *p_canvas,
 	RENDER_TIMESTAMP("<End Render Canvas");
 }
 
-RID RenderingServerCanvas::canvas_create() {
+bool RendererCanvasCull::was_sdf_used() {
+	return sdf_used;
+}
+
+RID RendererCanvasCull::canvas_create() {
 	Canvas *canvas = memnew(Canvas);
 	ERR_FAIL_COND_V(!canvas, RID());
 	RID rid = canvas_owner.make_rid(canvas);
@@ -355,7 +364,7 @@ RID RenderingServerCanvas::canvas_create() {
 	return rid;
 }
 
-void RenderingServerCanvas::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring) {
+void RendererCanvasCull::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring) {
 	Canvas *canvas = canvas_owner.getornull(p_canvas);
 	ERR_FAIL_COND(!canvas);
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
@@ -366,17 +375,17 @@ void RenderingServerCanvas::canvas_set_item_mirroring(RID p_canvas, RID p_item,
 	canvas->child_items.write[idx].mirror = p_mirroring;
 }
 
-void RenderingServerCanvas::canvas_set_modulate(RID p_canvas, const Color &p_color) {
+void RendererCanvasCull::canvas_set_modulate(RID p_canvas, const Color &p_color) {
 	Canvas *canvas = canvas_owner.getornull(p_canvas);
 	ERR_FAIL_COND(!canvas);
 	canvas->modulate = p_color;
 }
 
-void RenderingServerCanvas::canvas_set_disable_scale(bool p_disable) {
+void RendererCanvasCull::canvas_set_disable_scale(bool p_disable) {
 	disable_scale = p_disable;
 }
 
-void RenderingServerCanvas::canvas_set_parent(RID p_canvas, RID p_parent, float p_scale) {
+void RendererCanvasCull::canvas_set_parent(RID p_canvas, RID p_parent, float p_scale) {
 	Canvas *canvas = canvas_owner.getornull(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
@@ -384,14 +393,14 @@ void RenderingServerCanvas::canvas_set_parent(RID p_canvas, RID p_parent, float
 	canvas->parent_scale = p_scale;
 }
 
-RID RenderingServerCanvas::canvas_item_create() {
+RID RendererCanvasCull::canvas_item_create() {
 	Item *canvas_item = memnew(Item);
 	ERR_FAIL_COND_V(!canvas_item, RID());
 
 	return canvas_item_owner.make_rid(canvas_item);
 }
 
-void RenderingServerCanvas::canvas_item_set_parent(RID p_item, RID p_parent) {
+void RendererCanvasCull::canvas_item_set_parent(RID p_item, RID p_parent) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -435,7 +444,7 @@ void RenderingServerCanvas::canvas_item_set_parent(RID p_item, RID p_parent) {
 	canvas_item->parent = p_parent;
 }
 
-void RenderingServerCanvas::canvas_item_set_visible(RID p_item, bool p_visible) {
+void RendererCanvasCull::canvas_item_set_visible(RID p_item, bool p_visible) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -444,35 +453,35 @@ void RenderingServerCanvas::canvas_item_set_visible(RID p_item, bool p_visible)
 	_mark_ysort_dirty(canvas_item, canvas_item_owner);
 }
 
-void RenderingServerCanvas::canvas_item_set_light_mask(RID p_item, int p_mask) {
+void RendererCanvasCull::canvas_item_set_light_mask(RID p_item, int p_mask) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->light_mask = p_mask;
 }
 
-void RenderingServerCanvas::canvas_item_set_transform(RID p_item, const Transform2D &p_transform) {
+void RendererCanvasCull::canvas_item_set_transform(RID p_item, const Transform2D &p_transform) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->xform = p_transform;
 }
 
-void RenderingServerCanvas::canvas_item_set_clip(RID p_item, bool p_clip) {
+void RendererCanvasCull::canvas_item_set_clip(RID p_item, bool p_clip) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->clip = p_clip;
 }
 
-void RenderingServerCanvas::canvas_item_set_distance_field_mode(RID p_item, bool p_enable) {
+void RendererCanvasCull::canvas_item_set_distance_field_mode(RID p_item, bool p_enable) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->distance_field = p_enable;
 }
 
-void RenderingServerCanvas::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect) {
+void RendererCanvasCull::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -480,35 +489,35 @@ void RenderingServerCanvas::canvas_item_set_custom_rect(RID p_item, bool p_custo
 	canvas_item->rect = p_rect;
 }
 
-void RenderingServerCanvas::canvas_item_set_modulate(RID p_item, const Color &p_color) {
+void RendererCanvasCull::canvas_item_set_modulate(RID p_item, const Color &p_color) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->modulate = p_color;
 }
 
-void RenderingServerCanvas::canvas_item_set_self_modulate(RID p_item, const Color &p_color) {
+void RendererCanvasCull::canvas_item_set_self_modulate(RID p_item, const Color &p_color) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->self_modulate = p_color;
 }
 
-void RenderingServerCanvas::canvas_item_set_draw_behind_parent(RID p_item, bool p_enable) {
+void RendererCanvasCull::canvas_item_set_draw_behind_parent(RID p_item, bool p_enable) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->behind = p_enable;
 }
 
-void RenderingServerCanvas::canvas_item_set_update_when_visible(RID p_item, bool p_update) {
+void RendererCanvasCull::canvas_item_set_update_when_visible(RID p_item, bool p_update) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->update_when_visible = p_update;
 }
 
-void RenderingServerCanvas::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width) {
+void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -531,60 +540,64 @@ void RenderingServerCanvas::canvas_item_add_line(RID p_item, const Point2 &p_fro
 	}
 }
 
-void RenderingServerCanvas::canvas_item_add_polyline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width) {
+void RendererCanvasCull::canvas_item_add_polyline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width, bool p_antialiased) {
 	ERR_FAIL_COND(p_points.size() < 2);
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
+	Color color = Color(1, 1, 1, 1);
+
+	Vector<int> indices;
+	int pc = p_points.size();
+	int pc2 = pc * 2;
+
+	Vector2 prev_t;
+	int j2;
+
 	Item::CommandPolygon *pline = canvas_item->alloc_command<Item::CommandPolygon>();
 	ERR_FAIL_COND(!pline);
 
-	if (true || p_width <= 1) {
-#define TODO make thick lines possible
-		Vector<int> indices;
-		int pc = p_points.size();
-		indices.resize((pc - 1) * 2);
-		{
-			int *iptr = indices.ptrw();
-			for (int i = 0; i < (pc - 1); i++) {
-				iptr[i * 2 + 0] = i;
-				iptr[i * 2 + 1] = i + 1;
-			}
-		}
+	PackedColorArray colors;
+	PackedVector2Array points;
 
-		pline->primitive = RS::PRIMITIVE_LINES;
-		pline->polygon.create(indices, p_points, p_colors);
-	} else {
-#if 0
-		//make a trianglestrip for drawing the line...
-		Vector2 prev_t;
-		pline->triangles.resize(p_points.size() * 2);
-		if (p_antialiased) {
-			pline->lines.resize(p_points.size() * 2);
-		}
+	colors.resize(pc2);
+	points.resize(pc2);
 
-		if (p_colors.size() == 0) {
-			pline->triangle_colors.push_back(Color(1, 1, 1, 1));
-			if (p_antialiased) {
-				pline->line_colors.push_back(Color(1, 1, 1, 1));
-			}
-		} else if (p_colors.size() == 1) {
-			pline->triangle_colors = p_colors;
-			pline->line_colors = p_colors;
-		} else {
-			if (p_colors.size() != p_points.size()) {
-				pline->triangle_colors.push_back(p_colors[0]);
-				pline->line_colors.push_back(p_colors[0]);
-			} else {
-				pline->triangle_colors.resize(pline->triangles.size());
-				pline->line_colors.resize(pline->lines.size());
-			}
-		}
+	Vector2 *points_ptr = points.ptrw();
+	Color *colors_ptr = colors.ptrw();
+
+	if (p_antialiased) {
+		Color color2 = Color(1, 1, 1, 0);
+
+		PackedColorArray colors_top;
+		PackedVector2Array points_top;
+
+		colors_top.resize(pc2);
+		points_top.resize(pc2);
+
+		PackedColorArray colors_bottom;
+		PackedVector2Array points_bottom;
+
+		colors_bottom.resize(pc2);
+		points_bottom.resize(pc2);
+
+		Item::CommandPolygon *pline_top = canvas_item->alloc_command<Item::CommandPolygon>();
+		ERR_FAIL_COND(!pline_top);
+
+		Item::CommandPolygon *pline_bottom = canvas_item->alloc_command<Item::CommandPolygon>();
+		ERR_FAIL_COND(!pline_bottom);
+
+		//make three trianglestrip's for drawing the antialiased line...
+
+		Vector2 *points_top_ptr = points_top.ptrw();
+		Vector2 *points_bottom_ptr = points_bottom.ptrw();
 
-		for (int i = 0; i < p_points.size(); i++) {
+		Color *colors_top_ptr = colors_top.ptrw();
+		Color *colors_bottom_ptr = colors_bottom.ptrw();
 
+		for (int i = 0, j = 0; i < pc; i++, j += 2) {
 			Vector2 t;
-			if (i == p_points.size() - 1) {
+			if (i == pc - 1) {
 				t = prev_t;
 			} else {
 				t = (p_points[i + 1] - p_points[i]).normalized().tangent();
@@ -593,33 +606,80 @@ void RenderingServerCanvas::canvas_item_add_polyline(RID p_item, const Vector<Po
 				}
 			}
 
+			j2 = j + 1;
+
 			Vector2 tangent = ((t + prev_t).normalized()) * p_width * 0.5;
+			Vector2 pos = p_points[i];
+
+			points_ptr[j] = pos + tangent;
+			points_ptr[j2] = pos - tangent;
+
+			points_top_ptr[j] = pos + tangent + tangent;
+			points_top_ptr[j2] = pos + tangent;
+
+			points_bottom_ptr[j] = pos - tangent;
+			points_bottom_ptr[j2] = pos - tangent - tangent;
+
+			if (i < p_colors.size()) {
+				color = p_colors[i];
+				color2 = Color(color.r, color.g, color.b, 0);
+			}
+
+			colors_ptr[j] = color;
+			colors_ptr[j2] = color;
+
+			colors_top_ptr[j] = color2;
+			colors_top_ptr[j2] = color;
+
+			colors_bottom_ptr[j] = color;
+			colors_bottom_ptr[j2] = color2;
 
-			if (p_antialiased) {
-				pline->lines.write[i] = p_points[i] + tangent;
-				pline->lines.write[p_points.size() * 2 - i - 1] = p_points[i] - tangent;
-				if (pline->line_colors.size() > 1) {
-					pline->line_colors.write[i] = p_colors[i];
-					pline->line_colors.write[p_points.size() * 2 - i - 1] = p_colors[i];
+			prev_t = t;
+		}
+
+		pline_top->primitive = RS::PRIMITIVE_TRIANGLE_STRIP;
+		pline_top->polygon.create(indices, points_top, colors_top);
+
+		pline_bottom->primitive = RS::PRIMITIVE_TRIANGLE_STRIP;
+		pline_bottom->polygon.create(indices, points_bottom, colors_bottom);
+	} else {
+		//make a trianglestrip for drawing the line...
+
+		for (int i = 0, j = 0; i < pc; i++, j += 2) {
+			Vector2 t;
+			if (i == pc - 1) {
+				t = prev_t;
+			} else {
+				t = (p_points[i + 1] - p_points[i]).normalized().tangent();
+				if (i == 0) {
+					prev_t = t;
 				}
 			}
 
-			pline->triangles.write[i * 2 + 0] = p_points[i] + tangent;
-			pline->triangles.write[i * 2 + 1] = p_points[i] - tangent;
+			j2 = j + 1;
+
+			Vector2 tangent = ((t + prev_t).normalized()) * p_width * 0.5;
+			Vector2 pos = p_points[i];
 
-			if (pline->triangle_colors.size() > 1) {
+			points_ptr[j] = pos + tangent;
+			points_ptr[j2] = pos - tangent;
 
-				pline->triangle_colors.write[i * 2 + 0] = p_colors[i];
-				pline->triangle_colors.write[i * 2 + 1] = p_colors[i];
+			if (i < p_colors.size()) {
+				color = p_colors[i];
 			}
 
+			colors_ptr[j] = color;
+			colors_ptr[j2] = color;
+
 			prev_t = t;
 		}
-#endif
 	}
+
+	pline->primitive = RS::PRIMITIVE_TRIANGLE_STRIP;
+	pline->polygon.create(indices, points, colors);
 }
 
-void RenderingServerCanvas::canvas_item_add_multiline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width) {
+void RendererCanvasCull::canvas_item_add_multiline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width) {
 	ERR_FAIL_COND(p_points.size() < 2);
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
@@ -636,7 +696,7 @@ void RenderingServerCanvas::canvas_item_add_multiline(RID p_item, const Vector<P
 	}
 }
 
-void RenderingServerCanvas::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color) {
+void RendererCanvasCull::canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -646,7 +706,7 @@ void RenderingServerCanvas::canvas_item_add_rect(RID p_item, const Rect2 &p_rect
 	rect->rect = p_rect;
 }
 
-void RenderingServerCanvas::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color) {
+void RendererCanvasCull::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -680,7 +740,7 @@ void RenderingServerCanvas::canvas_item_add_circle(RID p_item, const Point2 &p_p
 	circle->polygon.create(indices, points, color);
 }
 
-void RenderingServerCanvas::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose) {
+void RendererCanvasCull::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -690,28 +750,28 @@ void RenderingServerCanvas::canvas_item_add_texture_rect(RID p_item, const Rect2
 	rect->rect = p_rect;
 	rect->flags = 0;
 	if (p_tile) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_TILE;
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_REGION;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_TILE;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_REGION;
 		rect->source = Rect2(0, 0, fabsf(p_rect.size.width), fabsf(p_rect.size.height));
 	}
 
 	if (p_rect.size.x < 0) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_H;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_FLIP_H;
 		rect->rect.size.x = -rect->rect.size.x;
 	}
 	if (p_rect.size.y < 0) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_V;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_FLIP_V;
 		rect->rect.size.y = -rect->rect.size.y;
 	}
 	if (p_transpose) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_TRANSPOSE;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_TRANSPOSE;
 		SWAP(rect->rect.size.x, rect->rect.size.y);
 	}
 
 	rect->texture = p_texture;
 }
 
-void RenderingServerCanvas::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) {
+void RendererCanvasCull::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -723,36 +783,36 @@ void RenderingServerCanvas::canvas_item_add_texture_rect_region(RID p_item, cons
 	rect->texture = p_texture;
 
 	rect->source = p_src_rect;
-	rect->flags = RasterizerCanvas::CANVAS_RECT_REGION;
+	rect->flags = RendererCanvasRender::CANVAS_RECT_REGION;
 
 	if (p_rect.size.x < 0) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_H;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_FLIP_H;
 		rect->rect.size.x = -rect->rect.size.x;
 	}
 	if (p_src_rect.size.x < 0) {
-		rect->flags ^= RasterizerCanvas::CANVAS_RECT_FLIP_H;
+		rect->flags ^= RendererCanvasRender::CANVAS_RECT_FLIP_H;
 		rect->source.size.x = -rect->source.size.x;
 	}
 	if (p_rect.size.y < 0) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_FLIP_V;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_FLIP_V;
 		rect->rect.size.y = -rect->rect.size.y;
 	}
 	if (p_src_rect.size.y < 0) {
-		rect->flags ^= RasterizerCanvas::CANVAS_RECT_FLIP_V;
+		rect->flags ^= RendererCanvasRender::CANVAS_RECT_FLIP_V;
 		rect->source.size.y = -rect->source.size.y;
 	}
 
 	if (p_transpose) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_TRANSPOSE;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_TRANSPOSE;
 		SWAP(rect->rect.size.x, rect->rect.size.y);
 	}
 
 	if (p_clip_uv) {
-		rect->flags |= RasterizerCanvas::CANVAS_RECT_CLIP_UV;
+		rect->flags |= RendererCanvasRender::CANVAS_RECT_CLIP_UV;
 	}
 }
 
-void RenderingServerCanvas::canvas_item_add_nine_patch(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, RS::NinePatchAxisMode p_x_axis_mode, RS::NinePatchAxisMode p_y_axis_mode, bool p_draw_center, const Color &p_modulate) {
+void RendererCanvasCull::canvas_item_add_nine_patch(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, RS::NinePatchAxisMode p_x_axis_mode, RS::NinePatchAxisMode p_y_axis_mode, bool p_draw_center, const Color &p_modulate) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -773,7 +833,7 @@ void RenderingServerCanvas::canvas_item_add_nine_patch(RID p_item, const Rect2 &
 	style->axis_y = p_y_axis_mode;
 }
 
-void RenderingServerCanvas::canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width) {
+void RendererCanvasCull::canvas_item_add_primitive(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture, float p_width) {
 	uint32_t pc = p_points.size();
 	ERR_FAIL_COND(pc == 0 || pc > 4);
 
@@ -802,7 +862,7 @@ void RenderingServerCanvas::canvas_item_add_primitive(RID p_item, const Vector<P
 	prim->texture = p_texture;
 }
 
-void RenderingServerCanvas::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture) {
+void RendererCanvasCull::canvas_item_add_polygon(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, RID p_texture) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 #ifdef DEBUG_ENABLED
@@ -823,7 +883,7 @@ void RenderingServerCanvas::canvas_item_add_polygon(RID p_item, const Vector<Poi
 	polygon->polygon.create(indices, p_points, p_colors, p_uvs);
 }
 
-void RenderingServerCanvas::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, const Vector<int> &p_bones, const Vector<float> &p_weights, RID p_texture, int p_count) {
+void RendererCanvasCull::canvas_item_add_triangle_array(RID p_item, const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, const Vector<int> &p_bones, const Vector<float> &p_weights, RID p_texture, int p_count) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -846,7 +906,7 @@ void RenderingServerCanvas::canvas_item_add_triangle_array(RID p_item, const Vec
 	polygon->primitive = RS::PRIMITIVE_TRIANGLES;
 }
 
-void RenderingServerCanvas::canvas_item_add_set_transform(RID p_item, const Transform2D &p_transform) {
+void RendererCanvasCull::canvas_item_add_set_transform(RID p_item, const Transform2D &p_transform) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -855,7 +915,7 @@ void RenderingServerCanvas::canvas_item_add_set_transform(RID p_item, const Tran
 	tr->xform = p_transform;
 }
 
-void RenderingServerCanvas::canvas_item_add_mesh(RID p_item, const RID &p_mesh, const Transform2D &p_transform, const Color &p_modulate, RID p_texture) {
+void RendererCanvasCull::canvas_item_add_mesh(RID p_item, const RID &p_mesh, const Transform2D &p_transform, const Color &p_modulate, RID p_texture) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -869,7 +929,7 @@ void RenderingServerCanvas::canvas_item_add_mesh(RID p_item, const RID &p_mesh,
 	m->modulate = p_modulate;
 }
 
-void RenderingServerCanvas::canvas_item_add_particles(RID p_item, RID p_particles, RID p_texture) {
+void RendererCanvasCull::canvas_item_add_particles(RID p_item, RID p_particles, RID p_texture) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -883,7 +943,7 @@ void RenderingServerCanvas::canvas_item_add_particles(RID p_item, RID p_particle
 	RSG::storage->particles_request_process(p_particles);
 }
 
-void RenderingServerCanvas::canvas_item_add_multimesh(RID p_item, RID p_mesh, RID p_texture) {
+void RendererCanvasCull::canvas_item_add_multimesh(RID p_item, RID p_mesh, RID p_texture) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -894,7 +954,7 @@ void RenderingServerCanvas::canvas_item_add_multimesh(RID p_item, RID p_mesh, RI
 	mm->texture = p_texture;
 }
 
-void RenderingServerCanvas::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
+void RendererCanvasCull::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -903,7 +963,7 @@ void RenderingServerCanvas::canvas_item_add_clip_ignore(RID p_item, bool p_ignor
 	ci->ignore = p_ignore;
 }
 
-void RenderingServerCanvas::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
+void RendererCanvasCull::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -912,7 +972,7 @@ void RenderingServerCanvas::canvas_item_set_sort_children_by_y(RID p_item, bool
 	_mark_ysort_dirty(canvas_item, canvas_item_owner);
 }
 
-void RenderingServerCanvas::canvas_item_set_z_index(RID p_item, int p_z) {
+void RendererCanvasCull::canvas_item_set_z_index(RID p_item, int p_z) {
 	ERR_FAIL_COND(p_z < RS::CANVAS_ITEM_Z_MIN || p_z > RS::CANVAS_ITEM_Z_MAX);
 
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
@@ -921,25 +981,25 @@ void RenderingServerCanvas::canvas_item_set_z_index(RID p_item, int p_z) {
 	canvas_item->z_index = p_z;
 }
 
-void RenderingServerCanvas::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
+void RendererCanvasCull::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->z_relative = p_enable;
 }
 
-void RenderingServerCanvas::canvas_item_attach_skeleton(RID p_item, RID p_skeleton) {
+void RendererCanvasCull::canvas_item_attach_skeleton(RID p_item, RID p_skeleton) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->skeleton = p_skeleton;
 }
 
-void RenderingServerCanvas::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) {
+void RendererCanvasCull::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 	if (p_enable && (canvas_item->copy_back_buffer == nullptr)) {
-		canvas_item->copy_back_buffer = memnew(RasterizerCanvas::Item::CopyBackBuffer);
+		canvas_item->copy_back_buffer = memnew(RendererCanvasRender::Item::CopyBackBuffer);
 	}
 	if (!p_enable && (canvas_item->copy_back_buffer != nullptr)) {
 		memdelete(canvas_item->copy_back_buffer);
@@ -952,14 +1012,14 @@ void RenderingServerCanvas::canvas_item_set_copy_to_backbuffer(RID p_item, bool
 	}
 }
 
-void RenderingServerCanvas::canvas_item_clear(RID p_item) {
+void RendererCanvasCull::canvas_item_clear(RID p_item) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->clear();
 }
 
-void RenderingServerCanvas::canvas_item_set_draw_index(RID p_item, int p_index) {
+void RendererCanvasCull::canvas_item_set_draw_index(RID p_item, int p_index) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -978,21 +1038,21 @@ void RenderingServerCanvas::canvas_item_set_draw_index(RID p_item, int p_index)
 	}
 }
 
-void RenderingServerCanvas::canvas_item_set_material(RID p_item, RID p_material) {
+void RendererCanvasCull::canvas_item_set_material(RID p_item, RID p_material) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->material = p_material;
 }
 
-void RenderingServerCanvas::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
+void RendererCanvasCull::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
 	canvas_item->use_parent_material = p_enable;
 }
 
-void RenderingServerCanvas::canvas_item_set_canvas_group_mode(RID p_item, RS::CanvasGroupMode p_mode, float p_clear_margin, bool p_fit_empty, float p_fit_margin, bool p_blur_mipmaps) {
+void RendererCanvasCull::canvas_item_set_canvas_group_mode(RID p_item, RS::CanvasGroupMode p_mode, float p_clear_margin, bool p_fit_empty, float p_fit_margin, bool p_blur_mipmaps) {
 	Item *canvas_item = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!canvas_item);
 
@@ -1003,7 +1063,7 @@ void RenderingServerCanvas::canvas_item_set_canvas_group_mode(RID p_item, RS::Ca
 		}
 	} else {
 		if (canvas_item->canvas_group == nullptr) {
-			canvas_item->canvas_group = memnew(RasterizerCanvas::Item::CanvasGroup);
+			canvas_item->canvas_group = memnew(RendererCanvasRender::Item::CanvasGroup);
 		}
 		canvas_item->canvas_group->mode = p_mode;
 		canvas_item->canvas_group->fit_empty = p_fit_empty;
@@ -1013,14 +1073,14 @@ void RenderingServerCanvas::canvas_item_set_canvas_group_mode(RID p_item, RS::Ca
 	}
 }
 
-RID RenderingServerCanvas::canvas_light_create() {
-	RasterizerCanvas::Light *clight = memnew(RasterizerCanvas::Light);
+RID RendererCanvasCull::canvas_light_create() {
+	RendererCanvasRender::Light *clight = memnew(RendererCanvasRender::Light);
 	clight->light_internal = RSG::canvas_render->light_create();
 	return canvas_light_owner.make_rid(clight);
 }
 
-void RenderingServerCanvas::canvas_light_set_mode(RID p_light, RS::CanvasLightMode p_mode) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_mode(RID p_light, RS::CanvasLightMode p_mode) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->mode == p_mode) {
@@ -1040,8 +1100,8 @@ void RenderingServerCanvas::canvas_light_set_mode(RID p_light, RS::CanvasLightMo
 	}
 }
 
-void RenderingServerCanvas::canvas_light_attach_to_canvas(RID p_light, RID p_canvas) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_attach_to_canvas(RID p_light, RID p_canvas) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->canvas.is_valid()) {
@@ -1069,29 +1129,29 @@ void RenderingServerCanvas::canvas_light_attach_to_canvas(RID p_light, RID p_can
 	}
 }
 
-void RenderingServerCanvas::canvas_light_set_enabled(RID p_light, bool p_enabled) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_enabled(RID p_light, bool p_enabled) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->enabled = p_enabled;
 }
 
-void RenderingServerCanvas::canvas_light_set_texture_scale(RID p_light, float p_scale) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_texture_scale(RID p_light, float p_scale) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->scale = p_scale;
 }
 
-void RenderingServerCanvas::canvas_light_set_transform(RID p_light, const Transform2D &p_transform) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_transform(RID p_light, const Transform2D &p_transform) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->xform = p_transform;
 }
 
-void RenderingServerCanvas::canvas_light_set_texture(RID p_light, RID p_texture) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_texture(RID p_light, RID p_texture) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->texture == p_texture) {
@@ -1102,80 +1162,80 @@ void RenderingServerCanvas::canvas_light_set_texture(RID p_light, RID p_texture)
 	RSG::canvas_render->light_set_texture(clight->light_internal, p_texture);
 }
 
-void RenderingServerCanvas::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->texture_offset = p_offset;
 }
 
-void RenderingServerCanvas::canvas_light_set_color(RID p_light, const Color &p_color) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_color(RID p_light, const Color &p_color) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->color = p_color;
 }
 
-void RenderingServerCanvas::canvas_light_set_height(RID p_light, float p_height) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_height(RID p_light, float p_height) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->height = p_height;
 }
 
-void RenderingServerCanvas::canvas_light_set_energy(RID p_light, float p_energy) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_energy(RID p_light, float p_energy) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->energy = p_energy;
 }
 
-void RenderingServerCanvas::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->z_min = p_min_z;
 	clight->z_max = p_max_z;
 }
 
-void RenderingServerCanvas::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->layer_max = p_max_layer;
 	clight->layer_min = p_min_layer;
 }
 
-void RenderingServerCanvas::canvas_light_set_item_cull_mask(RID p_light, int p_mask) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_item_cull_mask(RID p_light, int p_mask) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->item_mask = p_mask;
 }
 
-void RenderingServerCanvas::canvas_light_set_item_shadow_cull_mask(RID p_light, int p_mask) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_item_shadow_cull_mask(RID p_light, int p_mask) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->item_shadow_mask = p_mask;
 }
 
-void RenderingServerCanvas::canvas_light_set_directional_distance(RID p_light, float p_distance) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_directional_distance(RID p_light, float p_distance) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->directional_distance = p_distance;
 }
 
-void RenderingServerCanvas::canvas_light_set_blend_mode(RID p_light, RS::CanvasLightBlendMode p_mode) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_blend_mode(RID p_light, RS::CanvasLightBlendMode p_mode) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->blend_mode = p_mode;
 }
 
-void RenderingServerCanvas::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	if (clight->use_shadow == p_enabled) {
@@ -1186,34 +1246,34 @@ void RenderingServerCanvas::canvas_light_set_shadow_enabled(RID p_light, bool p_
 	RSG::canvas_render->light_set_use_shadow(clight->light_internal, clight->use_shadow);
 }
 
-void RenderingServerCanvas::canvas_light_set_shadow_filter(RID p_light, RS::CanvasLightShadowFilter p_filter) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_shadow_filter(RID p_light, RS::CanvasLightShadowFilter p_filter) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->shadow_filter = p_filter;
 }
 
-void RenderingServerCanvas::canvas_light_set_shadow_color(RID p_light, const Color &p_color) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_shadow_color(RID p_light, const Color &p_color) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 
 	clight->shadow_color = p_color;
 }
 
-void RenderingServerCanvas::canvas_light_set_shadow_smooth(RID p_light, float p_smooth) {
-	RasterizerCanvas::Light *clight = canvas_light_owner.getornull(p_light);
+void RendererCanvasCull::canvas_light_set_shadow_smooth(RID p_light, float p_smooth) {
+	RendererCanvasRender::Light *clight = canvas_light_owner.getornull(p_light);
 	ERR_FAIL_COND(!clight);
 	clight->shadow_smooth = p_smooth;
 }
 
-RID RenderingServerCanvas::canvas_light_occluder_create() {
-	RasterizerCanvas::LightOccluderInstance *occluder = memnew(RasterizerCanvas::LightOccluderInstance);
+RID RendererCanvasCull::canvas_light_occluder_create() {
+	RendererCanvasRender::LightOccluderInstance *occluder = memnew(RendererCanvasRender::LightOccluderInstance);
 
 	return canvas_light_occluder_owner.make_rid(occluder);
 }
 
-void RenderingServerCanvas::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas) {
-	RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+void RendererCanvasCull::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas) {
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	if (occluder->canvas.is_valid()) {
@@ -1233,15 +1293,15 @@ void RenderingServerCanvas::canvas_light_occluder_attach_to_canvas(RID p_occlude
 	}
 }
 
-void RenderingServerCanvas::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled) {
-	RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+void RendererCanvasCull::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled) {
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	occluder->enabled = p_enabled;
 }
 
-void RenderingServerCanvas::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon) {
-	RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+void RendererCanvasCull::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon) {
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	if (occluder->polygon.is_valid()) {
@@ -1268,134 +1328,110 @@ void RenderingServerCanvas::canvas_light_occluder_set_polygon(RID p_occluder, RI
 	}
 }
 
-void RenderingServerCanvas::canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform) {
-	RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+void RendererCanvasCull::canvas_light_occluder_set_as_sdf_collision(RID p_occluder, bool p_enable) {
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+	ERR_FAIL_COND(!occluder);
+}
+
+void RendererCanvasCull::canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform) {
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	occluder->xform = p_xform;
 }
 
-void RenderingServerCanvas::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) {
-	RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
+void RendererCanvasCull::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) {
+	RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_occluder);
 	ERR_FAIL_COND(!occluder);
 
 	occluder->light_mask = p_mask;
 }
 
-RID RenderingServerCanvas::canvas_occluder_polygon_create() {
+RID RendererCanvasCull::canvas_occluder_polygon_create() {
 	LightOccluderPolygon *occluder_poly = memnew(LightOccluderPolygon);
 	occluder_poly->occluder = RSG::canvas_render->occluder_polygon_create();
 	return canvas_light_occluder_polygon_owner.make_rid(occluder_poly);
 }
 
-void RenderingServerCanvas::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const Vector<Vector2> &p_shape, bool p_closed) {
-	if (p_shape.size() < 3) {
-		canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, p_shape);
-		return;
-	}
-
-	Vector<Vector2> lines;
-	int lc = p_shape.size() * 2;
-
-	lines.resize(lc - (p_closed ? 0 : 2));
-	{
-		Vector2 *w = lines.ptrw();
-		const Vector2 *r = p_shape.ptr();
-
-		int max = lc / 2;
-		if (!p_closed) {
-			max--;
-		}
-		for (int i = 0; i < max; i++) {
-			Vector2 a = r[i];
-			Vector2 b = r[(i + 1) % (lc / 2)];
-			w[i * 2 + 0] = a;
-			w[i * 2 + 1] = b;
-		}
-	}
-
-	canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon, lines);
-}
-
-void RenderingServerCanvas::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const Vector<Vector2> &p_shape) {
+void RendererCanvasCull::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const Vector<Vector2> &p_shape, bool p_closed) {
 	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_occluder_polygon);
 	ERR_FAIL_COND(!occluder_poly);
-	ERR_FAIL_COND(p_shape.size() & 1);
 
-	int lc = p_shape.size();
+	uint32_t pc = p_shape.size();
+	ERR_FAIL_COND(pc < 2);
+
 	occluder_poly->aabb = Rect2();
-	{
-		const Vector2 *r = p_shape.ptr();
-		for (int i = 0; i < lc; i++) {
-			if (i == 0) {
-				occluder_poly->aabb.position = r[i];
-			} else {
-				occluder_poly->aabb.expand_to(r[i]);
-			}
+	const Vector2 *r = p_shape.ptr();
+	for (uint32_t i = 0; i < pc; i++) {
+		if (i == 0) {
+			occluder_poly->aabb.position = r[i];
+		} else {
+			occluder_poly->aabb.expand_to(r[i]);
 		}
 	}
 
-	RSG::canvas_render->occluder_polygon_set_shape_as_lines(occluder_poly->occluder, p_shape);
-	for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
+	RSG::canvas_render->occluder_polygon_set_shape(occluder_poly->occluder, p_shape, p_closed);
+
+	for (Set<RendererCanvasRender::LightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
 		E->get()->aabb_cache = occluder_poly->aabb;
 	}
 }
 
-void RenderingServerCanvas::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, RS::CanvasOccluderPolygonCullMode p_mode) {
+void RendererCanvasCull::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, RS::CanvasOccluderPolygonCullMode p_mode) {
 	LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.getornull(p_occluder_polygon);
 	ERR_FAIL_COND(!occluder_poly);
 	occluder_poly->cull_mode = p_mode;
 	RSG::canvas_render->occluder_polygon_set_cull_mode(occluder_poly->occluder, p_mode);
-	for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
+	for (Set<RendererCanvasRender::LightOccluderInstance *>::Element *E = occluder_poly->owners.front(); E; E = E->next()) {
 		E->get()->cull_cache = p_mode;
 	}
 }
 
-void RenderingServerCanvas::canvas_set_shadow_texture_size(int p_size) {
+void RendererCanvasCull::canvas_set_shadow_texture_size(int p_size) {
 	RSG::canvas_render->set_shadow_texture_size(p_size);
 }
 
-RID RenderingServerCanvas::canvas_texture_create() {
+RID RendererCanvasCull::canvas_texture_create() {
 	return RSG::storage->canvas_texture_create();
 }
 
-void RenderingServerCanvas::canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) {
+void RendererCanvasCull::canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) {
 	RSG::storage->canvas_texture_set_channel(p_canvas_texture, p_channel, p_texture);
 }
 
-void RenderingServerCanvas::canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_base_color, float p_shininess) {
+void RendererCanvasCull::canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_base_color, float p_shininess) {
 	RSG::storage->canvas_texture_set_shading_parameters(p_canvas_texture, p_base_color, p_shininess);
 }
 
-void RenderingServerCanvas::canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) {
+void RendererCanvasCull::canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) {
 	RSG::storage->canvas_texture_set_texture_filter(p_canvas_texture, p_filter);
 }
 
-void RenderingServerCanvas::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {
+void RendererCanvasCull::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {
 	RSG::storage->canvas_texture_set_texture_repeat(p_canvas_texture, p_repeat);
 }
 
-void RenderingServerCanvas::canvas_item_set_default_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) {
+void RendererCanvasCull::canvas_item_set_default_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) {
 	Item *ci = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!ci);
 	ci->texture_filter = p_filter;
 }
-void RenderingServerCanvas::canvas_item_set_default_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) {
+void RendererCanvasCull::canvas_item_set_default_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) {
 	Item *ci = canvas_item_owner.getornull(p_item);
 	ERR_FAIL_COND(!ci);
 	ci->texture_repeat = p_repeat;
 }
 
-bool RenderingServerCanvas::free(RID p_rid) {
+bool RendererCanvasCull::free(RID p_rid) {
 	if (canvas_owner.owns(p_rid)) {
 		Canvas *canvas = canvas_owner.getornull(p_rid);
 		ERR_FAIL_COND_V(!canvas, false);
 
 		while (canvas->viewports.size()) {
-			RenderingServerViewport::Viewport *vp = RSG::viewport->viewport_owner.getornull(canvas->viewports.front()->get());
+			RendererViewport::Viewport *vp = RSG::viewport->viewport_owner.getornull(canvas->viewports.front()->get());
 			ERR_FAIL_COND_V(!vp, true);
 
-			Map<RID, RenderingServerViewport::Viewport::CanvasData>::Element *E = vp->canvas_map.find(p_rid);
+			Map<RID, RendererViewport::Viewport::CanvasData>::Element *E = vp->canvas_map.find(p_rid);
 			ERR_FAIL_COND_V(!E, true);
 			vp->canvas_map.erase(p_rid);
 
@@ -1406,11 +1442,11 @@ bool RenderingServerCanvas::free(RID p_rid) {
 			canvas->child_items[i].item->parent = RID();
 		}
 
-		for (Set<RasterizerCanvas::Light *>::Element *E = canvas->lights.front(); E; E = E->next()) {
+		for (Set<RendererCanvasRender::Light *>::Element *E = canvas->lights.front(); E; E = E->next()) {
 			E->get()->canvas = RID();
 		}
 
-		for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *E = canvas->occluders.front(); E; E = E->next()) {
+		for (Set<RendererCanvasRender::LightOccluderInstance *>::Element *E = canvas->occluders.front(); E; E = E->next()) {
 			E->get()->canvas = RID();
 		}
 
@@ -1451,7 +1487,7 @@ bool RenderingServerCanvas::free(RID p_rid) {
 		memdelete(canvas_item);
 
 	} else if (canvas_light_owner.owns(p_rid)) {
-		RasterizerCanvas::Light *canvas_light = canvas_light_owner.getornull(p_rid);
+		RendererCanvasRender::Light *canvas_light = canvas_light_owner.getornull(p_rid);
 		ERR_FAIL_COND_V(!canvas_light, true);
 
 		if (canvas_light->canvas.is_valid()) {
@@ -1467,7 +1503,7 @@ bool RenderingServerCanvas::free(RID p_rid) {
 		memdelete(canvas_light);
 
 	} else if (canvas_light_occluder_owner.owns(p_rid)) {
-		RasterizerCanvas::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_rid);
+		RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.getornull(p_rid);
 		ERR_FAIL_COND_V(!occluder, true);
 
 		if (occluder->polygon.is_valid()) {
@@ -1504,14 +1540,14 @@ bool RenderingServerCanvas::free(RID p_rid) {
 	return true;
 }
 
-RenderingServerCanvas::RenderingServerCanvas() {
-	z_list = (RasterizerCanvas::Item **)memalloc(z_range * sizeof(RasterizerCanvas::Item *));
-	z_last_list = (RasterizerCanvas::Item **)memalloc(z_range * sizeof(RasterizerCanvas::Item *));
+RendererCanvasCull::RendererCanvasCull() {
+	z_list = (RendererCanvasRender::Item **)memalloc(z_range * sizeof(RendererCanvasRender::Item *));
+	z_last_list = (RendererCanvasRender::Item **)memalloc(z_range * sizeof(RendererCanvasRender::Item *));
 
 	disable_scale = false;
 }
 
-RenderingServerCanvas::~RenderingServerCanvas() {
+RendererCanvasCull::~RendererCanvasCull() {
 	memfree(z_list);
 	memfree(z_last_list);
 }
diff --git a/servers/rendering/rendering_server_canvas.h b/servers/rendering/renderer_canvas_cull.h
index 36e2f77e95..ec2389bcb5 100644
--- a/servers/rendering/rendering_server_canvas.h
+++ b/servers/rendering/renderer_canvas_cull.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_canvas.h                                            */
+/*  renderer_canvas_cull.h                                               */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,15 +28,15 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef VISUALSERVERCANVAS_H
-#define VISUALSERVERCANVAS_H
+#ifndef RENDERING_SERVER_CANVAS_CULL_H
+#define RENDERING_SERVER_CANVAS_CULL_H
 
-#include "rasterizer.h"
-#include "rendering_server_viewport.h"
+#include "renderer_compositor.h"
+#include "renderer_viewport.h"
 
-class RenderingServerCanvas {
+class RendererCanvasCull {
 public:
-	struct Item : public RasterizerCanvas::Item {
+	struct Item : public RendererCanvasRender::Item {
 		RID parent; // canvas it belongs to
 		List<Item *>::Element *E;
 		int z_index;
@@ -93,7 +93,7 @@ public:
 		Rect2 aabb;
 		RS::CanvasOccluderPolygonCullMode cull_mode;
 		RID occluder;
-		Set<RasterizerCanvas::LightOccluderInstance *> owners;
+		Set<RendererCanvasRender::LightOccluderInstance *> owners;
 
 		LightOccluderPolygon() {
 			active = false;
@@ -103,9 +103,9 @@ public:
 
 	RID_PtrOwner<LightOccluderPolygon> canvas_light_occluder_polygon_owner;
 
-	RID_PtrOwner<RasterizerCanvas::LightOccluderInstance> canvas_light_occluder_owner;
+	RID_PtrOwner<RendererCanvasRender::LightOccluderInstance> canvas_light_occluder_owner;
 
-	struct Canvas : public RenderingServerViewport::CanvasBase {
+	struct Canvas : public RendererViewport::CanvasBase {
 		Set<RID> viewports;
 		struct ChildItem {
 			Point2 mirror;
@@ -115,10 +115,10 @@ public:
 			}
 		};
 
-		Set<RasterizerCanvas::Light *> lights;
-		Set<RasterizerCanvas::Light *> directional_lights;
+		Set<RendererCanvasRender::Light *> lights;
+		Set<RendererCanvasRender::Light *> directional_lights;
 
-		Set<RasterizerCanvas::LightOccluderInstance *> occluders;
+		Set<RendererCanvasRender::LightOccluderInstance *> occluders;
 
 		bool children_order_dirty;
 		Vector<ChildItem> child_items;
@@ -150,20 +150,23 @@ public:
 
 	mutable RID_PtrOwner<Canvas> canvas_owner;
 	RID_PtrOwner<Item> canvas_item_owner;
-	RID_PtrOwner<RasterizerCanvas::Light> canvas_light_owner;
+	RID_PtrOwner<RendererCanvasRender::Light> canvas_light_owner;
 
 	bool disable_scale;
+	bool sdf_used = false;
 	bool snapping_2d_transforms_to_pixel = false;
 
 private:
-	void _render_canvas_item_tree(RID p_to_render_target, Canvas::ChildItem *p_child_items, int p_child_item_count, Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, RasterizerCanvas::Light *p_lights, RasterizerCanvas::Light *p_directional_lights, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel);
-	void _cull_canvas_item(Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, int p_z, RasterizerCanvas::Item **z_list, RasterizerCanvas::Item **z_last_list, Item *p_canvas_clip, Item *p_material_owner);
+	void _render_canvas_item_tree(RID p_to_render_target, Canvas::ChildItem *p_child_items, int p_child_item_count, Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, RendererCanvasRender::Light *p_lights, RendererCanvasRender::Light *p_directional_lights, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel);
+	void _cull_canvas_item(Item *p_canvas_item, const Transform2D &p_transform, const Rect2 &p_clip_rect, const Color &p_modulate, int p_z, RendererCanvasRender::Item **z_list, RendererCanvasRender::Item **z_last_list, Item *p_canvas_clip, Item *p_material_owner);
 
-	RasterizerCanvas::Item **z_list;
-	RasterizerCanvas::Item **z_last_list;
+	RendererCanvasRender::Item **z_list;
+	RendererCanvasRender::Item **z_last_list;
 
 public:
-	void render_canvas(RID p_render_target, Canvas *p_canvas, const Transform2D &p_transform, RasterizerCanvas::Light *p_lights, RasterizerCanvas::Light *p_directional_lights, const Rect2 &p_clip_rect, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_transforms_to_pixel, bool p_snap_2d_vertices_to_pixel);
+	void render_canvas(RID p_render_target, Canvas *p_canvas, const Transform2D &p_transform, RendererCanvasRender::Light *p_lights, RendererCanvasRender::Light *p_directional_lights, const Rect2 &p_clip_rect, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_transforms_to_pixel, bool p_snap_2d_vertices_to_pixel);
+
+	bool was_sdf_used();
 
 	RID canvas_create();
 	void canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring);
@@ -189,7 +192,7 @@ public:
 	void canvas_item_set_update_when_visible(RID p_item, bool p_update);
 
 	void canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width = 1.0);
-	void canvas_item_add_polyline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width = 1.0);
+	void canvas_item_add_polyline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width = 1.0, bool p_antialiased = false);
 	void canvas_item_add_multiline(RID p_item, const Vector<Point2> &p_points, const Vector<Color> &p_colors, float p_width = 1.0);
 	void canvas_item_add_rect(RID p_item, const Rect2 &p_rect, const Color &p_color);
 	void canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color);
@@ -247,12 +250,12 @@ public:
 	void canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas);
 	void canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled);
 	void canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon);
+	void canvas_light_occluder_set_as_sdf_collision(RID p_occluder, bool p_enable);
 	void canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform);
 	void canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask);
 
 	RID canvas_occluder_polygon_create();
 	void canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const Vector<Vector2> &p_shape, bool p_closed);
-	void canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon, const Vector<Vector2> &p_shape);
 
 	void canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, RS::CanvasOccluderPolygonCullMode p_mode);
 
@@ -269,8 +272,8 @@ public:
 	void canvas_item_set_default_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat);
 
 	bool free(RID p_rid);
-	RenderingServerCanvas();
-	~RenderingServerCanvas();
+	RendererCanvasCull();
+	~RendererCanvasCull();
 };
 
 #endif // VISUALSERVERCANVAS_H
diff --git a/servers/rendering/renderer_canvas_render.cpp b/servers/rendering/renderer_canvas_render.cpp
new file mode 100644
index 0000000000..9c7251763d
--- /dev/null
+++ b/servers/rendering/renderer_canvas_render.cpp
@@ -0,0 +1,31 @@
+/*************************************************************************/
+/*  renderer_canvas_render.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 "renderer_canvas_render.h"
diff --git a/servers/rendering/renderer_canvas_render.h b/servers/rendering/renderer_canvas_render.h
new file mode 100644
index 0000000000..ca95abcf65
--- /dev/null
+++ b/servers/rendering/renderer_canvas_render.h
@@ -0,0 +1,604 @@
+/*************************************************************************/
+/*  renderer_canvas_render.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 RENDERINGSERVERCANVASRENDER_H
+#define RENDERINGSERVERCANVASRENDER_H
+
+#include "servers/rendering/renderer_storage.h"
+
+class RendererCanvasRender {
+public:
+	static RendererCanvasRender *singleton;
+
+	enum CanvasRectFlags {
+		CANVAS_RECT_REGION = 1,
+		CANVAS_RECT_TILE = 2,
+		CANVAS_RECT_FLIP_H = 4,
+		CANVAS_RECT_FLIP_V = 8,
+		CANVAS_RECT_TRANSPOSE = 16,
+		CANVAS_RECT_CLIP_UV = 32,
+		CANVAS_RECT_IS_GROUP = 64,
+	};
+
+	struct Light {
+		bool enabled;
+		Color color;
+		Transform2D xform;
+		float height;
+		float energy;
+		float scale;
+		int z_min;
+		int z_max;
+		int layer_min;
+		int layer_max;
+		int item_mask;
+		int item_shadow_mask;
+		float directional_distance;
+		RS::CanvasLightMode mode;
+		RS::CanvasLightBlendMode blend_mode;
+		RID texture;
+		Vector2 texture_offset;
+		RID canvas;
+		bool use_shadow;
+		int shadow_buffer_size;
+		RS::CanvasLightShadowFilter shadow_filter;
+		Color shadow_color;
+		float shadow_smooth;
+
+		//void *texture_cache; // implementation dependent
+		Rect2 rect_cache;
+		Transform2D xform_cache;
+		float radius_cache; //used for shadow far plane
+		//CameraMatrix shadow_matrix_cache;
+
+		Transform2D light_shader_xform;
+		//Vector2 light_shader_pos;
+
+		Light *shadows_next_ptr;
+		Light *filter_next_ptr;
+		Light *next_ptr;
+		Light *directional_next_ptr;
+
+		RID light_internal;
+		uint64_t version;
+
+		int32_t render_index_cache;
+
+		Light() {
+			version = 0;
+			enabled = true;
+			color = Color(1, 1, 1);
+			shadow_color = Color(0, 0, 0, 0);
+			height = 0;
+			z_min = -1024;
+			z_max = 1024;
+			layer_min = 0;
+			layer_max = 0;
+			item_mask = 1;
+			scale = 1.0;
+			energy = 1.0;
+			item_shadow_mask = 1;
+			mode = RS::CANVAS_LIGHT_MODE_POINT;
+			blend_mode = RS::CANVAS_LIGHT_BLEND_MODE_ADD;
+			//			texture_cache = nullptr;
+			next_ptr = nullptr;
+			directional_next_ptr = nullptr;
+			filter_next_ptr = nullptr;
+			use_shadow = false;
+			shadow_buffer_size = 2048;
+			shadow_filter = RS::CANVAS_LIGHT_FILTER_NONE;
+			shadow_smooth = 0.0;
+			render_index_cache = -1;
+			directional_distance = 10000.0;
+		}
+	};
+
+	//easier wrap to avoid mistakes
+
+	struct Item;
+
+	typedef uint64_t PolygonID;
+	virtual PolygonID request_polygon(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), const Vector<int> &p_bones = Vector<int>(), const Vector<float> &p_weights = Vector<float>()) = 0;
+	virtual void free_polygon(PolygonID p_polygon) = 0;
+
+	//also easier to wrap to avoid mistakes
+	struct Polygon {
+		PolygonID polygon_id;
+		Rect2 rect_cache;
+
+		_FORCE_INLINE_ void create(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs = Vector<Point2>(), const Vector<int> &p_bones = Vector<int>(), const Vector<float> &p_weights = Vector<float>()) {
+			ERR_FAIL_COND(polygon_id != 0);
+			{
+				uint32_t pc = p_points.size();
+				const Vector2 *v2 = p_points.ptr();
+				rect_cache.position = *v2;
+				for (uint32_t i = 1; i < pc; i++) {
+					rect_cache.expand_to(v2[i]);
+				}
+			}
+			polygon_id = singleton->request_polygon(p_indices, p_points, p_colors, p_uvs, p_bones, p_weights);
+		}
+
+		_FORCE_INLINE_ Polygon() { polygon_id = 0; }
+		_FORCE_INLINE_ ~Polygon() {
+			if (polygon_id) {
+				singleton->free_polygon(polygon_id);
+			}
+		}
+	};
+
+	//item
+
+	struct Item {
+		//commands are allocated in blocks of 4k to improve performance
+		//and cache coherence.
+		//blocks always grow but never shrink.
+
+		struct CommandBlock {
+			enum {
+				MAX_SIZE = 4096
+			};
+			uint32_t usage;
+			uint8_t *memory;
+		};
+
+		struct Command {
+			enum Type {
+				TYPE_RECT,
+				TYPE_NINEPATCH,
+				TYPE_POLYGON,
+				TYPE_PRIMITIVE,
+				TYPE_MESH,
+				TYPE_MULTIMESH,
+				TYPE_PARTICLES,
+				TYPE_TRANSFORM,
+				TYPE_CLIP_IGNORE,
+			};
+
+			Command *next;
+			Type type;
+			virtual ~Command() {}
+		};
+
+		struct CommandRect : public Command {
+			Rect2 rect;
+			Color modulate;
+			Rect2 source;
+			uint8_t flags;
+
+			RID texture;
+
+			CommandRect() {
+				flags = 0;
+				type = TYPE_RECT;
+			}
+		};
+
+		struct CommandNinePatch : public Command {
+			Rect2 rect;
+			Rect2 source;
+			float margin[4];
+			bool draw_center;
+			Color color;
+			RS::NinePatchAxisMode axis_x;
+			RS::NinePatchAxisMode axis_y;
+
+			RID texture;
+
+			CommandNinePatch() {
+				draw_center = true;
+				type = TYPE_NINEPATCH;
+			}
+		};
+
+		struct CommandPolygon : public Command {
+			RS::PrimitiveType primitive;
+			Polygon polygon;
+
+			RID texture;
+
+			CommandPolygon() {
+				type = TYPE_POLYGON;
+			}
+		};
+
+		struct CommandPrimitive : public Command {
+			uint32_t point_count;
+			Vector2 points[4];
+			Vector2 uvs[4];
+			Color colors[4];
+
+			RID texture;
+
+			CommandPrimitive() {
+				type = TYPE_PRIMITIVE;
+			}
+		};
+
+		struct CommandMesh : public Command {
+			RID mesh;
+			Transform2D transform;
+			Color modulate;
+
+			RID texture;
+
+			CommandMesh() { type = TYPE_MESH; }
+		};
+
+		struct CommandMultiMesh : public Command {
+			RID multimesh;
+
+			RID texture;
+
+			CommandMultiMesh() { type = TYPE_MULTIMESH; }
+		};
+
+		struct CommandParticles : public Command {
+			RID particles;
+
+			RID texture;
+
+			CommandParticles() { type = TYPE_PARTICLES; }
+		};
+
+		struct CommandTransform : public Command {
+			Transform2D xform;
+			CommandTransform() { type = TYPE_TRANSFORM; }
+		};
+
+		struct CommandClipIgnore : public Command {
+			bool ignore;
+			CommandClipIgnore() {
+				type = TYPE_CLIP_IGNORE;
+				ignore = false;
+			}
+		};
+
+		struct ViewportRender {
+			RenderingServer *owner;
+			void *udata;
+			Rect2 rect;
+		};
+
+		Transform2D xform;
+		bool clip;
+		bool visible;
+		bool behind;
+		bool update_when_visible;
+
+		struct CanvasGroup {
+			RS::CanvasGroupMode mode;
+			bool fit_empty;
+			float fit_margin;
+			bool blur_mipmaps;
+			float clear_margin;
+		};
+
+		CanvasGroup *canvas_group = nullptr;
+		int light_mask;
+		int z_final;
+
+		mutable bool custom_rect;
+		mutable bool rect_dirty;
+		mutable Rect2 rect;
+		RID material;
+		RID skeleton;
+
+		Item *next;
+
+		struct CopyBackBuffer {
+			Rect2 rect;
+			Rect2 screen_rect;
+			bool full;
+		};
+		CopyBackBuffer *copy_back_buffer;
+
+		Color final_modulate;
+		Transform2D final_transform;
+		Rect2 final_clip_rect;
+		Item *final_clip_owner;
+		Item *material_owner;
+		Item *canvas_group_owner;
+		ViewportRender *vp_render;
+		bool distance_field;
+		bool light_masked;
+
+		Rect2 global_rect_cache;
+
+		const Rect2 &get_rect() const {
+			if (custom_rect || (!rect_dirty && !update_when_visible)) {
+				return rect;
+			}
+
+			//must update rect
+
+			if (commands == nullptr) {
+				rect = Rect2();
+				rect_dirty = false;
+				return rect;
+			}
+
+			Transform2D xf;
+			bool found_xform = false;
+			bool first = true;
+
+			const Item::Command *c = commands;
+
+			while (c) {
+				Rect2 r;
+
+				switch (c->type) {
+					case Item::Command::TYPE_RECT: {
+						const Item::CommandRect *crect = static_cast<const Item::CommandRect *>(c);
+						r = crect->rect;
+
+					} break;
+					case Item::Command::TYPE_NINEPATCH: {
+						const Item::CommandNinePatch *style = static_cast<const Item::CommandNinePatch *>(c);
+						r = style->rect;
+					} break;
+
+					case Item::Command::TYPE_POLYGON: {
+						const Item::CommandPolygon *polygon = static_cast<const Item::CommandPolygon *>(c);
+						r = polygon->polygon.rect_cache;
+					} break;
+					case Item::Command::TYPE_PRIMITIVE: {
+						const Item::CommandPrimitive *primitive = static_cast<const Item::CommandPrimitive *>(c);
+						for (uint32_t j = 0; j < primitive->point_count; j++) {
+							if (j == 0) {
+								r.position = primitive->points[0];
+							} else {
+								r.expand_to(primitive->points[j]);
+							}
+						}
+					} break;
+					case Item::Command::TYPE_MESH: {
+						const Item::CommandMesh *mesh = static_cast<const Item::CommandMesh *>(c);
+						AABB aabb = RendererStorage::base_singleton->mesh_get_aabb(mesh->mesh, RID());
+
+						r = Rect2(aabb.position.x, aabb.position.y, aabb.size.x, aabb.size.y);
+
+					} break;
+					case Item::Command::TYPE_MULTIMESH: {
+						const Item::CommandMultiMesh *multimesh = static_cast<const Item::CommandMultiMesh *>(c);
+						AABB aabb = RendererStorage::base_singleton->multimesh_get_aabb(multimesh->multimesh);
+
+						r = Rect2(aabb.position.x, aabb.position.y, aabb.size.x, aabb.size.y);
+
+					} break;
+					case Item::Command::TYPE_PARTICLES: {
+						const Item::CommandParticles *particles_cmd = static_cast<const Item::CommandParticles *>(c);
+						if (particles_cmd->particles.is_valid()) {
+							AABB aabb = RendererStorage::base_singleton->particles_get_aabb(particles_cmd->particles);
+							r = Rect2(aabb.position.x, aabb.position.y, aabb.size.x, aabb.size.y);
+						}
+
+					} break;
+					case Item::Command::TYPE_TRANSFORM: {
+						const Item::CommandTransform *transform = static_cast<const Item::CommandTransform *>(c);
+						xf = transform->xform;
+						found_xform = true;
+						[[fallthrough]];
+					}
+					default: {
+						c = c->next;
+						continue;
+					}
+				}
+
+				if (found_xform) {
+					r = xf.xform(r);
+					found_xform = false;
+				}
+
+				if (first) {
+					rect = r;
+					first = false;
+				} else {
+					rect = rect.merge(r);
+				}
+				c = c->next;
+			}
+
+			rect_dirty = false;
+			return rect;
+		}
+
+		Command *commands;
+		Command *last_command;
+		Vector<CommandBlock> blocks;
+		uint32_t current_block;
+
+		template <class T>
+		T *alloc_command() {
+			T *command;
+			if (commands == nullptr) {
+				// As the most common use case of canvas items is to
+				// use only one command, the first is done with it's
+				// own allocation. The rest of them use blocks.
+				command = memnew(T);
+				command->next = nullptr;
+				commands = command;
+				last_command = command;
+			} else {
+				//Subsequent commands go into a block.
+
+				while (true) {
+					if (unlikely(current_block == (uint32_t)blocks.size())) {
+						// If we need more blocks, we allocate them
+						// (they won't be freed until this CanvasItem is
+						// deleted, though).
+						CommandBlock cb;
+						cb.memory = (uint8_t *)memalloc(CommandBlock::MAX_SIZE);
+						cb.usage = 0;
+						blocks.push_back(cb);
+					}
+
+					CommandBlock *c = &blocks.write[current_block];
+					size_t space_left = CommandBlock::MAX_SIZE - c->usage;
+					if (space_left < sizeof(T)) {
+						current_block++;
+						continue;
+					}
+
+					//allocate block and add to the linked list
+					void *memory = c->memory + c->usage;
+					command = memnew_placement(memory, T);
+					command->next = nullptr;
+					last_command->next = command;
+					last_command = command;
+					c->usage += sizeof(T);
+					break;
+				}
+			}
+
+			rect_dirty = true;
+			return command;
+		}
+
+		void clear() {
+			// The first one is always allocated on heap
+			// the rest go in the blocks
+			Command *c = commands;
+			while (c) {
+				Command *n = c->next;
+				if (c == commands) {
+					memdelete(commands);
+					commands = nullptr;
+				} else {
+					c->~Command();
+				}
+				c = n;
+			}
+			{
+				uint32_t cbc = MIN((current_block + 1), (uint32_t)blocks.size());
+				CommandBlock *blockptr = blocks.ptrw();
+				for (uint32_t i = 0; i < cbc; i++) {
+					blockptr[i].usage = 0;
+				}
+			}
+
+			last_command = nullptr;
+			commands = nullptr;
+			current_block = 0;
+			clip = false;
+			rect_dirty = true;
+			final_clip_owner = nullptr;
+			material_owner = nullptr;
+			light_masked = false;
+		}
+
+		RS::CanvasItemTextureFilter texture_filter;
+		RS::CanvasItemTextureRepeat texture_repeat;
+
+		Item() {
+			commands = nullptr;
+			last_command = nullptr;
+			current_block = 0;
+			light_mask = 1;
+			vp_render = nullptr;
+			next = nullptr;
+			final_clip_owner = nullptr;
+			canvas_group_owner = nullptr;
+			clip = false;
+			final_modulate = Color(1, 1, 1, 1);
+			visible = true;
+			rect_dirty = true;
+			custom_rect = false;
+			behind = false;
+			material_owner = nullptr;
+			copy_back_buffer = nullptr;
+			distance_field = false;
+			light_masked = false;
+			update_when_visible = false;
+			z_final = 0;
+			texture_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT;
+			texture_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT;
+		}
+		virtual ~Item() {
+			clear();
+			for (int i = 0; i < blocks.size(); i++) {
+				memfree(blocks[i].memory);
+			}
+			if (copy_back_buffer) {
+				memdelete(copy_back_buffer);
+			}
+		}
+	};
+
+	virtual void canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_list, const Transform2D &p_canvas_transform, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel, bool &r_sdf_used) = 0;
+	virtual void canvas_debug_viewport_shadows(Light *p_lights_with_shadow) = 0;
+
+	struct LightOccluderInstance {
+		bool enabled;
+		RID canvas;
+		RID polygon;
+		RID occluder;
+		Rect2 aabb_cache;
+		Transform2D xform;
+		Transform2D xform_cache;
+		int light_mask;
+		bool sdf_collision;
+		RS::CanvasOccluderPolygonCullMode cull_cache;
+
+		LightOccluderInstance *next;
+
+		LightOccluderInstance() {
+			enabled = true;
+			sdf_collision = false;
+			next = nullptr;
+			light_mask = 1;
+			cull_cache = RS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+		}
+	};
+
+	virtual RID light_create() = 0;
+	virtual void light_set_texture(RID p_rid, RID p_texture) = 0;
+	virtual void light_set_use_shadow(RID p_rid, bool p_enable) = 0;
+	virtual void light_update_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders) = 0;
+	virtual void light_update_directional_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_cull_distance, const Rect2 &p_clip_rect, LightOccluderInstance *p_occluders) = 0;
+
+	virtual void render_sdf(RID p_render_target, LightOccluderInstance *p_occluders) = 0;
+
+	virtual RID occluder_polygon_create() = 0;
+	virtual void occluder_polygon_set_shape(RID p_occluder, const Vector<Vector2> &p_points, bool p_closed) = 0;
+	virtual void occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode) = 0;
+	virtual void set_shadow_texture_size(int p_size) = 0;
+
+	virtual void draw_window_margins(int *p_margins, RID *p_margin_textures) = 0;
+
+	virtual bool free(RID p_rid) = 0;
+	virtual void update() = 0;
+
+	RendererCanvasRender() { singleton = this; }
+	virtual ~RendererCanvasRender() {}
+};
+
+#endif // RENDERINGSERVERCANVASRENDER_H
diff --git a/servers/rendering/renderer_compositor.cpp b/servers/rendering/renderer_compositor.cpp
new file mode 100644
index 0000000000..e8c4a236fa
--- /dev/null
+++ b/servers/rendering/renderer_compositor.cpp
@@ -0,0 +1,42 @@
+/*************************************************************************/
+/*  renderer_compositor.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 "renderer_compositor.h"
+
+#include "core/os/os.h"
+#include "core/string/print_string.h"
+
+RendererCompositor *(*RendererCompositor::_create_func)() = nullptr;
+
+RendererCompositor *RendererCompositor::create() {
+	return _create_func();
+}
+
+RendererCanvasRender *RendererCanvasRender::singleton = nullptr;
diff --git a/servers/rendering/renderer_compositor.h b/servers/rendering/renderer_compositor.h
new file mode 100644
index 0000000000..f328330efa
--- /dev/null
+++ b/servers/rendering/renderer_compositor.h
@@ -0,0 +1,78 @@
+/*************************************************************************/
+/*  renderer_compositor.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 RENDERING_SERVER_COMPOSITOR_H
+#define RENDERING_SERVER_COMPOSITOR_H
+
+#include "core/math/camera_matrix.h"
+#include "core/templates/pair.h"
+#include "core/templates/self_list.h"
+#include "servers/rendering/renderer_canvas_render.h"
+#include "servers/rendering/renderer_scene.h"
+#include "servers/rendering/renderer_scene_render.h"
+#include "servers/rendering/renderer_storage.h"
+#include "servers/rendering_server.h"
+
+class RendererCompositor {
+protected:
+	static RendererCompositor *(*_create_func)();
+
+public:
+	static RendererCompositor *create();
+
+	virtual RendererStorage *get_storage() = 0;
+	virtual RendererCanvasRender *get_canvas() = 0;
+	virtual RendererSceneRender *get_scene() = 0;
+
+	virtual void set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter = true) = 0;
+
+	virtual void initialize() = 0;
+	virtual void begin_frame(double frame_step) = 0;
+
+	struct BlitToScreen {
+		RID render_target;
+		Rect2i rect;
+		//lens distorted parameters for VR should go here
+	};
+
+	virtual void prepare_for_blitting_render_targets() = 0;
+	virtual void blit_render_targets_to_screen(DisplayServer::WindowID p_screen, const BlitToScreen *p_render_targets, int p_amount) = 0;
+
+	virtual void end_frame(bool p_swap_buffers) = 0;
+	virtual void finalize() = 0;
+	virtual uint64_t get_frame_number() const = 0;
+	virtual float get_frame_delta_time() const = 0;
+
+	virtual bool is_low_end() const = 0;
+
+	virtual ~RendererCompositor() {}
+};
+
+#endif // RASTERIZER_H
diff --git a/servers/rendering/rasterizer_rd/SCsub b/servers/rendering/renderer_rd/SCsub
index 6a2e682c67..6a2e682c67 100644
--- a/servers/rendering/rasterizer_rd/SCsub
+++ b/servers/rendering/renderer_rd/SCsub
diff --git a/servers/rendering/rasterizer_rd/rasterizer_effects_rd.cpp b/servers/rendering/renderer_rd/effects_rd.cpp
index 97c1e7ba70..cbb000cb8c 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_effects_rd.cpp
+++ b/servers/rendering/renderer_rd/effects_rd.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_effects_rd.cpp                                            */
+/*  effects_rd.cpp                                                       */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,7 +28,7 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rasterizer_effects_rd.h"
+#include "effects_rd.h"
 
 #include "core/config/project_settings.h"
 #include "core/os/os.h"
@@ -58,7 +58,7 @@ static _FORCE_INLINE_ void store_camera(const CameraMatrix &p_mtx, float *p_arra
 	}
 }
 
-RID RasterizerEffectsRD::_get_uniform_set_from_image(RID p_image) {
+RID EffectsRD::_get_uniform_set_from_image(RID p_image) {
 	if (image_to_uniform_set_cache.has(p_image)) {
 		RID uniform_set = image_to_uniform_set_cache[p_image];
 		if (RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
@@ -67,7 +67,7 @@ RID RasterizerEffectsRD::_get_uniform_set_from_image(RID p_image) {
 	}
 	Vector<RD::Uniform> uniforms;
 	RD::Uniform u;
-	u.type = RD::UNIFORM_TYPE_IMAGE;
+	u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 	u.binding = 0;
 	u.ids.push_back(p_image);
 	uniforms.push_back(u);
@@ -79,7 +79,7 @@ RID RasterizerEffectsRD::_get_uniform_set_from_image(RID p_image) {
 	return uniform_set;
 }
 
-RID RasterizerEffectsRD::_get_uniform_set_from_texture(RID p_texture, bool p_use_mipmaps) {
+RID EffectsRD::_get_uniform_set_from_texture(RID p_texture, bool p_use_mipmaps) {
 	if (texture_to_uniform_set_cache.has(p_texture)) {
 		RID uniform_set = texture_to_uniform_set_cache[p_texture];
 		if (RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
@@ -89,12 +89,12 @@ RID RasterizerEffectsRD::_get_uniform_set_from_texture(RID p_texture, bool p_use
 
 	Vector<RD::Uniform> uniforms;
 	RD::Uniform u;
-	u.type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
+	u.uniform_type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
 	u.binding = 0;
 	u.ids.push_back(p_use_mipmaps ? default_mipmap_sampler : default_sampler);
 	u.ids.push_back(p_texture);
 	uniforms.push_back(u);
-	//any thing with the same configuration (one texture in binding 0 for set 0), is good
+	//anything with the same configuration (one texture in binding 0 for set 0), is good
 	RID uniform_set = RD::get_singleton()->uniform_set_create(uniforms, tonemap.shader.version_get_shader(tonemap.shader_version, 0), 0);
 
 	texture_to_uniform_set_cache[p_texture] = uniform_set;
@@ -102,7 +102,7 @@ RID RasterizerEffectsRD::_get_uniform_set_from_texture(RID p_texture, bool p_use
 	return uniform_set;
 }
 
-RID RasterizerEffectsRD::_get_compute_uniform_set_from_texture(RID p_texture, bool p_use_mipmaps) {
+RID EffectsRD::_get_compute_uniform_set_from_texture(RID p_texture, bool p_use_mipmaps) {
 	if (texture_to_compute_uniform_set_cache.has(p_texture)) {
 		RID uniform_set = texture_to_compute_uniform_set_cache[p_texture];
 		if (RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
@@ -112,7 +112,7 @@ RID RasterizerEffectsRD::_get_compute_uniform_set_from_texture(RID p_texture, bo
 
 	Vector<RD::Uniform> uniforms;
 	RD::Uniform u;
-	u.type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
+	u.uniform_type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
 	u.binding = 0;
 	u.ids.push_back(p_use_mipmaps ? default_mipmap_sampler : default_sampler);
 	u.ids.push_back(p_texture);
@@ -125,7 +125,7 @@ RID RasterizerEffectsRD::_get_compute_uniform_set_from_texture(RID p_texture, bo
 	return uniform_set;
 }
 
-RID RasterizerEffectsRD::_get_compute_uniform_set_from_texture_pair(RID p_texture1, RID p_texture2, bool p_use_mipmaps) {
+RID EffectsRD::_get_compute_uniform_set_from_texture_pair(RID p_texture1, RID p_texture2, bool p_use_mipmaps) {
 	TexturePair tp;
 	tp.texture1 = p_texture1;
 	tp.texture2 = p_texture2;
@@ -140,7 +140,7 @@ RID RasterizerEffectsRD::_get_compute_uniform_set_from_texture_pair(RID p_textur
 	Vector<RD::Uniform> uniforms;
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
 		u.binding = 0;
 		u.ids.push_back(p_use_mipmaps ? default_mipmap_sampler : default_sampler);
 		u.ids.push_back(p_texture1);
@@ -148,7 +148,7 @@ RID RasterizerEffectsRD::_get_compute_uniform_set_from_texture_pair(RID p_textur
 	}
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
 		u.binding = 1;
 		u.ids.push_back(p_use_mipmaps ? default_mipmap_sampler : default_sampler);
 		u.ids.push_back(p_texture2);
@@ -162,7 +162,7 @@ RID RasterizerEffectsRD::_get_compute_uniform_set_from_texture_pair(RID p_textur
 	return uniform_set;
 }
 
-RID RasterizerEffectsRD::_get_compute_uniform_set_from_image_pair(RID p_texture1, RID p_texture2) {
+RID EffectsRD::_get_compute_uniform_set_from_image_pair(RID p_texture1, RID p_texture2) {
 	TexturePair tp;
 	tp.texture1 = p_texture1;
 	tp.texture2 = p_texture2;
@@ -177,14 +177,14 @@ RID RasterizerEffectsRD::_get_compute_uniform_set_from_image_pair(RID p_texture1
 	Vector<RD::Uniform> uniforms;
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_IMAGE;
+		u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 		u.binding = 0;
 		u.ids.push_back(p_texture1);
 		uniforms.push_back(u);
 	}
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_IMAGE;
+		u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 		u.binding = 1;
 		u.ids.push_back(p_texture2);
 		uniforms.push_back(u);
@@ -197,7 +197,7 @@ RID RasterizerEffectsRD::_get_compute_uniform_set_from_image_pair(RID p_texture1
 	return uniform_set;
 }
 
-void RasterizerEffectsRD::copy_to_atlas_fb(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2 &p_uv_rect, RD::DrawListID p_draw_list, bool p_flip_y, bool p_panorama) {
+void EffectsRD::copy_to_atlas_fb(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2 &p_uv_rect, RD::DrawListID p_draw_list, bool p_flip_y, bool p_panorama) {
 	zeromem(&copy_to_fb.push_constant, sizeof(CopyToFbPushConstant));
 
 	copy_to_fb.push_constant.use_section = true;
@@ -218,7 +218,7 @@ void RasterizerEffectsRD::copy_to_atlas_fb(RID p_source_rd_texture, RID p_dest_f
 	RD::get_singleton()->draw_list_draw(draw_list, true);
 }
 
-void RasterizerEffectsRD::copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y, bool p_force_luminance, bool p_alpha_to_zero, bool p_srgb, RID p_secondary) {
+void EffectsRD::copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y, bool p_force_luminance, bool p_alpha_to_zero, bool p_srgb, RID p_secondary) {
 	zeromem(&copy_to_fb.push_constant, sizeof(CopyToFbPushConstant));
 
 	if (p_flip_y) {
@@ -246,7 +246,7 @@ void RasterizerEffectsRD::copy_to_fb_rect(RID p_source_rd_texture, RID p_dest_fr
 	RD::get_singleton()->draw_list_end();
 }
 
-void RasterizerEffectsRD::copy_to_rect(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y, bool p_force_luminance, bool p_all_source, bool p_8_bit_dst, bool p_alpha_to_one) {
+void EffectsRD::copy_to_rect(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y, bool p_force_luminance, bool p_all_source, bool p_8_bit_dst, bool p_alpha_to_one) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 	if (p_flip_y) {
 		copy.push_constant.flags |= COPY_FLAG_FLIP_Y;
@@ -283,7 +283,7 @@ void RasterizerEffectsRD::copy_to_rect(RID p_source_rd_texture, RID p_dest_textu
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::copy_cubemap_to_panorama(RID p_source_cube, RID p_dest_panorama, const Size2i &p_panorama_size, float p_lod, bool p_is_array) {
+void EffectsRD::copy_cubemap_to_panorama(RID p_source_cube, RID p_dest_panorama, const Size2i &p_panorama_size, float p_lod, bool p_is_array) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 
 	copy.push_constant.section[0] = 0;
@@ -306,7 +306,7 @@ void RasterizerEffectsRD::copy_cubemap_to_panorama(RID p_source_cube, RID p_dest
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::copy_depth_to_rect_and_linearize(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y, float p_z_near, float p_z_far) {
+void EffectsRD::copy_depth_to_rect_and_linearize(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y, float p_z_near, float p_z_far) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 	if (p_flip_y) {
 		copy.push_constant.flags |= COPY_FLAG_FLIP_Y;
@@ -333,7 +333,7 @@ void RasterizerEffectsRD::copy_depth_to_rect_and_linearize(RID p_source_rd_textu
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::copy_depth_to_rect(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y) {
+void EffectsRD::copy_depth_to_rect(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 	if (p_flip_y) {
 		copy.push_constant.flags |= COPY_FLAG_FLIP_Y;
@@ -358,7 +358,7 @@ void RasterizerEffectsRD::copy_depth_to_rect(RID p_source_rd_texture, RID p_dest
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::set_color(RID p_dest_texture, const Color &p_color, const Rect2i &p_region, bool p_8bit_dst) {
+void EffectsRD::set_color(RID p_dest_texture, const Color &p_color, const Rect2i &p_region, bool p_8bit_dst) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 
 	copy.push_constant.section[0] = 0;
@@ -383,7 +383,7 @@ void RasterizerEffectsRD::set_color(RID p_dest_texture, const Color &p_color, co
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::gaussian_blur(RID p_source_rd_texture, RID p_texture, RID p_back_texture, const Rect2i &p_region, bool p_8bit_dst) {
+void EffectsRD::gaussian_blur(RID p_source_rd_texture, RID p_texture, RID p_back_texture, const Rect2i &p_region, bool p_8bit_dst) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 
 	uint32_t base_flags = 0;
@@ -418,7 +418,7 @@ void RasterizerEffectsRD::gaussian_blur(RID p_source_rd_texture, RID p_texture,
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::gaussian_glow(RID p_source_rd_texture, RID p_back_texture, const Size2i &p_size, float p_strength, bool p_high_quality, bool p_first_pass, float p_luminance_cap, float p_exposure, float p_bloom, float p_hdr_bleed_treshold, float p_hdr_bleed_scale, RID p_auto_exposure, float p_auto_exposure_grey) {
+void EffectsRD::gaussian_glow(RID p_source_rd_texture, RID p_back_texture, const Size2i &p_size, float p_strength, bool p_high_quality, bool p_first_pass, float p_luminance_cap, float p_exposure, float p_bloom, float p_hdr_bleed_treshold, float p_hdr_bleed_scale, RID p_auto_exposure, float p_auto_exposure_grey) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 
 	CopyMode copy_mode = p_first_pass && p_auto_exposure.is_valid() ? COPY_MODE_GAUSSIAN_GLOW_AUTO_EXPOSURE : COPY_MODE_GAUSSIAN_GLOW;
@@ -455,7 +455,7 @@ void RasterizerEffectsRD::gaussian_glow(RID p_source_rd_texture, RID p_back_text
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::screen_space_reflection(RID p_diffuse, RID p_normal_roughness, RenderingServer::EnvironmentSSRRoughnessQuality p_roughness_quality, RID p_blur_radius, RID p_blur_radius2, RID p_metallic, const Color &p_metallic_mask, RID p_depth, RID p_scale_depth, RID p_scale_normal, RID p_output, RID p_output_blur, const Size2i &p_screen_size, int p_max_steps, float p_fade_in, float p_fade_out, float p_tolerance, const CameraMatrix &p_camera) {
+void EffectsRD::screen_space_reflection(RID p_diffuse, RID p_normal_roughness, RenderingServer::EnvironmentSSRRoughnessQuality p_roughness_quality, RID p_blur_radius, RID p_blur_radius2, RID p_metallic, const Color &p_metallic_mask, RID p_depth, RID p_scale_depth, RID p_scale_normal, RID p_output, RID p_output_blur, const Size2i &p_screen_size, int p_max_steps, float p_fade_in, float p_fade_out, float p_tolerance, const CameraMatrix &p_camera) {
 	RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
 
 	int32_t x_groups = (p_screen_size.width - 1) / 8 + 1;
@@ -578,7 +578,7 @@ void RasterizerEffectsRD::screen_space_reflection(RID p_diffuse, RID p_normal_ro
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::sub_surface_scattering(RID p_diffuse, RID p_diffuse2, RID p_depth, const CameraMatrix &p_camera, const Size2i &p_screen_size, float p_scale, float p_depth_scale, RenderingServer::SubSurfaceScatteringQuality p_quality) {
+void EffectsRD::sub_surface_scattering(RID p_diffuse, RID p_diffuse2, RID p_depth, const CameraMatrix &p_camera, const Size2i &p_screen_size, float p_scale, float p_depth_scale, RenderingServer::SubSurfaceScatteringQuality p_quality) {
 	RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
 
 	int32_t x_groups = (p_screen_size.width - 1) / 8 + 1;
@@ -624,7 +624,7 @@ void RasterizerEffectsRD::sub_surface_scattering(RID p_diffuse, RID p_diffuse2,
 	}
 }
 
-void RasterizerEffectsRD::merge_specular(RID p_dest_framebuffer, RID p_specular, RID p_base, RID p_reflection) {
+void EffectsRD::merge_specular(RID p_dest_framebuffer, RID p_specular, RID p_base, RID p_reflection) {
 	RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_dest_framebuffer, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD, Vector<Color>());
 
 	if (p_reflection.is_valid()) {
@@ -654,7 +654,7 @@ void RasterizerEffectsRD::merge_specular(RID p_dest_framebuffer, RID p_specular,
 	RD::get_singleton()->draw_list_end();
 }
 
-void RasterizerEffectsRD::make_mipmap(RID p_source_rd_texture, RID p_dest_texture, const Size2i &p_size) {
+void EffectsRD::make_mipmap(RID p_source_rd_texture, RID p_dest_texture, const Size2i &p_size) {
 	zeromem(&copy.push_constant, sizeof(CopyPushConstant));
 
 	copy.push_constant.section[0] = 0;
@@ -674,7 +674,7 @@ void RasterizerEffectsRD::make_mipmap(RID p_source_rd_texture, RID p_dest_textur
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, float p_z_near, float p_z_far, float p_bias, bool p_dp_flip) {
+void EffectsRD::copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, float p_z_near, float p_z_far, float p_bias, bool p_dp_flip) {
 	CopyToDPPushConstant push_constant;
 	push_constant.screen_size[0] = p_rect.size.x;
 	push_constant.screen_size[1] = p_rect.size.y;
@@ -697,7 +697,7 @@ void RasterizerEffectsRD::copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dest
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::tonemapper(RID p_source_color, RID p_dst_framebuffer, const TonemapSettings &p_settings) {
+void EffectsRD::tonemapper(RID p_source_color, RID p_dst_framebuffer, const TonemapSettings &p_settings) {
 	zeromem(&tonemap.push_constant, sizeof(TonemapPushConstant));
 
 	tonemap.push_constant.use_bcs = p_settings.use_bcs;
@@ -718,7 +718,10 @@ void RasterizerEffectsRD::tonemapper(RID p_source_color, RID p_dst_framebuffer,
 	tonemap.push_constant.glow_texture_size[1] = p_settings.glow_texture_size.y;
 	tonemap.push_constant.glow_mode = p_settings.glow_mode;
 
-	TonemapMode mode = p_settings.glow_use_bicubic_upscale ? TONEMAP_MODE_BICUBIC_GLOW_FILTER : TONEMAP_MODE_NORMAL;
+	int mode = p_settings.glow_use_bicubic_upscale ? TONEMAP_MODE_BICUBIC_GLOW_FILTER : TONEMAP_MODE_NORMAL;
+	if (p_settings.use_1d_color_correction) {
+		mode += 2;
+	}
 
 	tonemap.push_constant.tonemapper = p_settings.tonemap_mode;
 	tonemap.push_constant.use_auto_exposure = p_settings.use_auto_exposure;
@@ -746,7 +749,7 @@ void RasterizerEffectsRD::tonemapper(RID p_source_color, RID p_dst_framebuffer,
 	RD::get_singleton()->draw_list_end();
 }
 
-void RasterizerEffectsRD::luminance_reduction(RID p_source_texture, const Size2i p_source_size, const Vector<RID> p_reduce, RID p_prev_luminance, float p_min_luminance, float p_max_luminance, float p_adjust, bool p_set) {
+void EffectsRD::luminance_reduction(RID p_source_texture, const Size2i p_source_size, const Vector<RID> p_reduce, RID p_prev_luminance, float p_min_luminance, float p_max_luminance, float p_adjust, bool p_set) {
 	luminance_reduce.push_constant.source_size[0] = p_source_size.x;
 	luminance_reduce.push_constant.source_size[1] = p_source_size.y;
 	luminance_reduce.push_constant.max_luminance = p_max_luminance;
@@ -788,7 +791,7 @@ void RasterizerEffectsRD::luminance_reduction(RID p_source_texture, const Size2i
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::bokeh_dof(RID p_base_texture, RID p_depth_texture, const Size2i &p_base_texture_size, RID p_secondary_texture, RID p_halfsize_texture1, RID p_halfsize_texture2, bool p_dof_far, float p_dof_far_begin, float p_dof_far_size, bool p_dof_near, float p_dof_near_begin, float p_dof_near_size, float p_bokeh_size, RenderingServer::DOFBokehShape p_bokeh_shape, RS::DOFBlurQuality p_quality, bool p_use_jitter, float p_cam_znear, float p_cam_zfar, bool p_cam_orthogonal) {
+void EffectsRD::bokeh_dof(RID p_base_texture, RID p_depth_texture, const Size2i &p_base_texture_size, RID p_secondary_texture, RID p_halfsize_texture1, RID p_halfsize_texture2, bool p_dof_far, float p_dof_far_begin, float p_dof_far_size, bool p_dof_near, float p_dof_near_begin, float p_dof_near_size, float p_bokeh_size, RenderingServer::DOFBokehShape p_bokeh_shape, RS::DOFBlurQuality p_quality, bool p_use_jitter, float p_cam_znear, float p_cam_zfar, bool p_cam_orthogonal) {
 	bokeh.push_constant.blur_far_active = p_dof_far;
 	bokeh.push_constant.blur_far_begin = p_dof_far_begin;
 	bokeh.push_constant.blur_far_end = p_dof_far_begin + p_dof_far_size;
@@ -948,7 +951,7 @@ void RasterizerEffectsRD::bokeh_dof(RID p_base_texture, RID p_depth_texture, con
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::generate_ssao(RID p_depth_buffer, RID p_normal_buffer, const Size2i &p_depth_buffer_size, RID p_depth_mipmaps_texture, const Vector<RID> &depth_mipmaps, RID p_ao1, bool p_half_size, RID p_ao2, RID p_upscale_buffer, float p_intensity, float p_radius, float p_bias, const CameraMatrix &p_projection, RS::EnvironmentSSAOQuality p_quality, RS::EnvironmentSSAOBlur p_blur, float p_edge_sharpness) {
+void EffectsRD::generate_ssao(RID p_depth_buffer, RID p_normal_buffer, const Size2i &p_depth_buffer_size, RID p_depth_mipmaps_texture, const Vector<RID> &depth_mipmaps, RID p_ao1, bool p_half_size, RID p_ao2, RID p_upscale_buffer, float p_intensity, float p_radius, float p_bias, const CameraMatrix &p_projection, RS::EnvironmentSSAOQuality p_quality, RS::EnvironmentSSAOBlur p_blur, float p_edge_sharpness) {
 	//minify first
 	ssao.minify_push_constant.orthogonal = p_projection.is_orthogonal();
 	ssao.minify_push_constant.z_near = p_projection.get_z_near();
@@ -1101,7 +1104,7 @@ void RasterizerEffectsRD::generate_ssao(RID p_depth_buffer, RID p_normal_buffer,
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::roughness_limit(RID p_source_normal, RID p_roughness, const Size2i &p_size, float p_curve) {
+void EffectsRD::roughness_limit(RID p_source_normal, RID p_roughness, const Size2i &p_size, float p_curve) {
 	roughness_limiter.push_constant.screen_size[0] = p_size.x;
 	roughness_limiter.push_constant.screen_size[1] = p_size.y;
 	roughness_limiter.push_constant.curve = p_curve;
@@ -1121,7 +1124,7 @@ void RasterizerEffectsRD::roughness_limit(RID p_source_normal, RID p_roughness,
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::cubemap_roughness(RID p_source_rd_texture, RID p_dest_framebuffer, uint32_t p_face_id, uint32_t p_sample_count, float p_roughness, float p_size) {
+void EffectsRD::cubemap_roughness(RID p_source_rd_texture, RID p_dest_framebuffer, uint32_t p_face_id, uint32_t p_sample_count, float p_roughness, float p_size) {
 	zeromem(&roughness.push_constant, sizeof(CubemapRoughnessPushConstant));
 
 	roughness.push_constant.face_id = p_face_id > 9 ? 0 : p_face_id;
@@ -1146,7 +1149,7 @@ void RasterizerEffectsRD::cubemap_roughness(RID p_source_rd_texture, RID p_dest_
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::cubemap_downsample(RID p_source_cubemap, RID p_dest_cubemap, const Size2i &p_size) {
+void EffectsRD::cubemap_downsample(RID p_source_cubemap, RID p_dest_cubemap, const Size2i &p_size) {
 	cubemap_downsampler.push_constant.face_size = p_size.x;
 
 	RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
@@ -1164,11 +1167,11 @@ void RasterizerEffectsRD::cubemap_downsample(RID p_source_cubemap, RID p_dest_cu
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::cubemap_filter(RID p_source_cubemap, Vector<RID> p_dest_cubemap, bool p_use_array) {
+void EffectsRD::cubemap_filter(RID p_source_cubemap, Vector<RID> p_dest_cubemap, bool p_use_array) {
 	Vector<RD::Uniform> uniforms;
 	for (int i = 0; i < p_dest_cubemap.size(); i++) {
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_IMAGE;
+		u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 		u.binding = i;
 		u.ids.push_back(p_dest_cubemap[i]);
 		uniforms.push_back(u);
@@ -1193,7 +1196,7 @@ void RasterizerEffectsRD::cubemap_filter(RID p_source_cubemap, Vector<RID> p_des
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::render_sky(RD::DrawListID p_list, float p_time, RID p_fb, RID p_samplers, RID p_fog, RenderPipelineVertexFormatCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const CameraMatrix &p_camera, const Basis &p_orientation, float p_multiplier, const Vector3 &p_position) {
+void EffectsRD::render_sky(RD::DrawListID p_list, float p_time, RID p_fb, RID p_samplers, RID p_fog, PipelineCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const CameraMatrix &p_camera, const Basis &p_orientation, float p_multiplier, const Vector3 &p_position) {
 	SkyPushConstant sky_push_constant;
 
 	zeromem(&sky_push_constant, sizeof(SkyPushConstant));
@@ -1229,7 +1232,7 @@ void RasterizerEffectsRD::render_sky(RD::DrawListID p_list, float p_time, RID p_
 	RD::get_singleton()->draw_list_draw(draw_list, true);
 }
 
-void RasterizerEffectsRD::resolve_gi(RID p_source_depth, RID p_source_normal_roughness, RID p_source_giprobe, RID p_dest_depth, RID p_dest_normal_roughness, RID p_dest_giprobe, Vector2i p_screen_size, int p_samples) {
+void EffectsRD::resolve_gi(RID p_source_depth, RID p_source_normal_roughness, RID p_source_giprobe, RID p_dest_depth, RID p_dest_normal_roughness, RID p_dest_giprobe, Vector2i p_screen_size, int p_samples) {
 	ResolvePushConstant push_constant;
 	push_constant.screen_size[0] = p_screen_size.x;
 	push_constant.screen_size[1] = p_screen_size.y;
@@ -1251,7 +1254,7 @@ void RasterizerEffectsRD::resolve_gi(RID p_source_depth, RID p_source_normal_rou
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerEffectsRD::reduce_shadow(RID p_source_shadow, RID p_dest_shadow, const Size2i &p_source_size, const Rect2i &p_source_rect, int p_shrink_limit, RD::ComputeListID compute_list) {
+void EffectsRD::reduce_shadow(RID p_source_shadow, RID p_dest_shadow, const Size2i &p_source_size, const Rect2i &p_source_rect, int p_shrink_limit, RD::ComputeListID compute_list) {
 	uint32_t push_constant[8] = { (uint32_t)p_source_size.x, (uint32_t)p_source_size.y, (uint32_t)p_source_rect.position.x, (uint32_t)p_source_rect.position.y, (uint32_t)p_shrink_limit, 0, 0, 0 };
 
 	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, shadow_reduce.pipelines[SHADOW_REDUCE_REDUCE]);
@@ -1260,7 +1263,7 @@ void RasterizerEffectsRD::reduce_shadow(RID p_source_shadow, RID p_dest_shadow,
 
 	RD::get_singleton()->compute_list_dispatch_threads(compute_list, p_source_rect.size.width, p_source_rect.size.height, 1, 8, 8, 1);
 }
-void RasterizerEffectsRD::filter_shadow(RID p_shadow, RID p_backing_shadow, const Size2i &p_source_size, const Rect2i &p_source_rect, RenderingServer::EnvVolumetricFogShadowFilter p_filter, RD::ComputeListID compute_list, bool p_vertical, bool p_horizontal) {
+void EffectsRD::filter_shadow(RID p_shadow, RID p_backing_shadow, const Size2i &p_source_size, const Rect2i &p_source_rect, RenderingServer::EnvVolumetricFogShadowFilter p_filter, RD::ComputeListID compute_list, bool p_vertical, bool p_horizontal) {
 	uint32_t push_constant[8] = { (uint32_t)p_source_size.x, (uint32_t)p_source_size.y, (uint32_t)p_source_rect.position.x, (uint32_t)p_source_rect.position.y, 0, 0, 0, 0 };
 
 	switch (p_filter) {
@@ -1296,7 +1299,7 @@ void RasterizerEffectsRD::filter_shadow(RID p_shadow, RID p_backing_shadow, cons
 	}
 }
 
-void RasterizerEffectsRD::sort_buffer(RID p_uniform_set, int p_size) {
+void EffectsRD::sort_buffer(RID p_uniform_set, int p_size) {
 	Sort::PushConstant push_constant;
 	push_constant.total_elements = p_size;
 
@@ -1365,7 +1368,7 @@ void RasterizerEffectsRD::sort_buffer(RID p_uniform_set, int p_size) {
 	RD::get_singleton()->compute_list_end();
 }
 
-RasterizerEffectsRD::RasterizerEffectsRD() {
+EffectsRD::EffectsRD() {
 	{ // Initialize copy
 		Vector<String> copy_modes;
 		copy_modes.push_back("\n#define MODE_GAUSSIAN_BLUR\n");
@@ -1423,6 +1426,8 @@ RasterizerEffectsRD::RasterizerEffectsRD() {
 		Vector<String> tonemap_modes;
 		tonemap_modes.push_back("\n");
 		tonemap_modes.push_back("\n#define USE_GLOW_FILTER_BICUBIC\n");
+		tonemap_modes.push_back("\n#define USE_1D_LUT\n");
+		tonemap_modes.push_back("\n#define USE_GLOW_FILTER_BICUBIC\n#define USE_1D_LUT\n");
 
 		tonemap.shader.initialize(tonemap_modes);
 
@@ -1586,7 +1591,7 @@ RasterizerEffectsRD::RasterizerEffectsRD() {
 		Vector<RD::Uniform> uniforms;
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(filter.coefficient_buffer);
 			uniforms.push_back(u);
@@ -1758,7 +1763,7 @@ RasterizerEffectsRD::RasterizerEffectsRD() {
 	}
 }
 
-RasterizerEffectsRD::~RasterizerEffectsRD() {
+EffectsRD::~EffectsRD() {
 	if (RD::get_singleton()->uniform_set_is_valid(filter.image_uniform_set)) {
 		RD::get_singleton()->free(filter.image_uniform_set);
 	}
diff --git a/servers/rendering/rasterizer_rd/rasterizer_effects_rd.h b/servers/rendering/renderer_rd/effects_rd.h
index a0bdd59fd2..3afc111b9d 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_effects_rd.h
+++ b/servers/rendering/renderer_rd/effects_rd.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_effects_rd.h                                              */
+/*  effects_rd.h                                                         */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,36 +28,36 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RASTERIZER_EFFECTS_RD_H
-#define RASTERIZER_EFFECTS_RD_H
+#ifndef EFFECTS_RD_H
+#define EFFECTS_RD_H
 
 #include "core/math/camera_matrix.h"
-#include "servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.h"
-#include "servers/rendering/rasterizer_rd/shaders/bokeh_dof.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/copy.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/copy_to_fb.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/cube_to_dp.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/cubemap_downsampler.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/cubemap_filter.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/cubemap_roughness.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/luminance_reduce.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/resolve.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/roughness_limiter.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/screen_space_reflection.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/screen_space_reflection_filter.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/screen_space_reflection_scale.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/shadow_reduce.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/sort.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/specular_merge.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/ssao.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/ssao_blur.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/ssao_minify.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/subsurface_scattering.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/tonemap.glsl.gen.h"
+#include "servers/rendering/renderer_rd/pipeline_cache_rd.h"
+#include "servers/rendering/renderer_rd/shaders/bokeh_dof.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/copy.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/copy_to_fb.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/cube_to_dp.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/cubemap_downsampler.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/cubemap_filter.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/cubemap_roughness.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/luminance_reduce.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/resolve.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/roughness_limiter.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/screen_space_reflection.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/screen_space_reflection_filter.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/screen_space_reflection_scale.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/shadow_reduce.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/sort.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/specular_merge.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/ssao.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/ssao_blur.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/ssao_minify.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/subsurface_scattering.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/tonemap.glsl.gen.h"
 
 #include "servers/rendering_server.h"
 
-class RasterizerEffectsRD {
+class EffectsRD {
 	enum CopyMode {
 		COPY_MODE_GAUSSIAN_COPY,
 		COPY_MODE_GAUSSIAN_COPY_8BIT,
@@ -144,7 +144,7 @@ class RasterizerEffectsRD {
 		CopyToFbPushConstant push_constant;
 		CopyToFbShaderRD shader;
 		RID shader_version;
-		RenderPipelineVertexFormatCacheRD pipelines[COPY_TO_FB_MAX];
+		PipelineCacheRD pipelines[COPY_TO_FB_MAX];
 
 	} copy_to_fb;
 
@@ -167,6 +167,8 @@ class RasterizerEffectsRD {
 	enum TonemapMode {
 		TONEMAP_MODE_NORMAL,
 		TONEMAP_MODE_BICUBIC_GLOW_FILTER,
+		TONEMAP_MODE_1D_LUT,
+		TONEMAP_MODE_BICUBIC_GLOW_FILTER_1D_LUT,
 		TONEMAP_MODE_MAX
 	};
 
@@ -198,13 +200,13 @@ class RasterizerEffectsRD {
 
 	/* tonemap actually writes to a framebuffer, which is
 	 * better to do using the raster pipeline rather than
-	 * comptute, as that framebuffer might be in different formats
+	 * compute, as that framebuffer might be in different formats
 	 */
 	struct Tonemap {
 		TonemapPushConstant push_constant;
 		TonemapShaderRD shader;
 		RID shader_version;
-		RenderPipelineVertexFormatCacheRD pipelines[TONEMAP_MODE_MAX];
+		PipelineCacheRD pipelines[TONEMAP_MODE_MAX];
 	} tonemap;
 
 	enum LuminanceReduceMode {
@@ -424,7 +426,7 @@ class RasterizerEffectsRD {
 	struct SpecularMerge {
 		SpecularMergeShaderRD shader;
 		RID shader_version;
-		RenderPipelineVertexFormatCacheRD pipelines[SPECULAR_MERGE_MAX];
+		PipelineCacheRD pipelines[SPECULAR_MERGE_MAX];
 
 	} specular_merge;
 
@@ -654,6 +656,7 @@ public:
 		float saturation = 1.0;
 
 		bool use_color_correction = false;
+		bool use_1d_color_correction = false;
 		RID color_correction_texture;
 
 		bool use_fxaa = false;
@@ -668,7 +671,7 @@ public:
 	void roughness_limit(RID p_source_normal, RID p_roughness, const Size2i &p_size, float p_curve);
 	void cubemap_downsample(RID p_source_cubemap, RID p_dest_cubemap, const Size2i &p_size);
 	void cubemap_filter(RID p_source_cubemap, Vector<RID> p_dest_cubemap, bool p_use_array);
-	void render_sky(RD::DrawListID p_list, float p_time, RID p_fb, RID p_samplers, RID p_fog, RenderPipelineVertexFormatCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const CameraMatrix &p_camera, const Basis &p_orientation, float p_multiplier, const Vector3 &p_position);
+	void render_sky(RD::DrawListID p_list, float p_time, RID p_fb, RID p_samplers, RID p_fog, PipelineCacheRD *p_pipeline, RID p_uniform_set, RID p_texture_set, const CameraMatrix &p_camera, const Basis &p_orientation, float p_multiplier, const Vector3 &p_position);
 
 	void screen_space_reflection(RID p_diffuse, RID p_normal_roughness, RS::EnvironmentSSRRoughnessQuality p_roughness_quality, RID p_blur_radius, RID p_blur_radius2, RID p_metallic, const Color &p_metallic_mask, RID p_depth, RID p_scale_depth, RID p_scale_normal, RID p_output, RID p_output_blur, const Size2i &p_screen_size, int p_max_steps, float p_fade_in, float p_fade_out, float p_tolerance, const CameraMatrix &p_camera);
 	void merge_specular(RID p_dest_framebuffer, RID p_specular, RID p_base, RID p_reflection);
@@ -681,8 +684,8 @@ public:
 
 	void sort_buffer(RID p_uniform_set, int p_size);
 
-	RasterizerEffectsRD();
-	~RasterizerEffectsRD();
+	EffectsRD();
+	~EffectsRD();
 };
 
 #endif // !RASTERIZER_EFFECTS_RD_H
diff --git a/servers/rendering/rasterizer_rd/light_cluster_builder.cpp b/servers/rendering/renderer_rd/light_cluster_builder.cpp
index efb48e6df7..b76b41ba26 100644
--- a/servers/rendering/rasterizer_rd/light_cluster_builder.cpp
+++ b/servers/rendering/renderer_rd/light_cluster_builder.cpp
@@ -190,7 +190,7 @@ void LightClusterBuilder::setup(uint32_t p_width, uint32_t p_height, uint32_t p_
 	{
 		RD::TextureFormat tf;
 		tf.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
-		tf.type = RD::TEXTURE_TYPE_3D;
+		tf.texture_type = RD::TEXTURE_TYPE_3D;
 		tf.width = width;
 		tf.height = height;
 		tf.depth = depth;
diff --git a/servers/rendering/rasterizer_rd/light_cluster_builder.h b/servers/rendering/renderer_rd/light_cluster_builder.h
index b1da083dad..0767a96817 100644
--- a/servers/rendering/rasterizer_rd/light_cluster_builder.h
+++ b/servers/rendering/renderer_rd/light_cluster_builder.h
@@ -31,7 +31,7 @@
 #ifndef LIGHT_CLUSTER_BUILDER_H
 #define LIGHT_CLUSTER_BUILDER_H
 
-#include "servers/rendering/rasterizer_rd/rasterizer_storage_rd.h"
+#include "servers/rendering/renderer_rd/renderer_storage_rd.h"
 
 class LightClusterBuilder {
 public:
diff --git a/servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.cpp b/servers/rendering/renderer_rd/pipeline_cache_rd.cpp
index 5cc3da8d4e..8319e3eed1 100644
--- a/servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.cpp
+++ b/servers/rendering/renderer_rd/pipeline_cache_rd.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  render_pipeline_vertex_format_cache_rd.cpp                           */
+/*  pipeline_cache_rd.cpp                                                */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,10 +28,10 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "render_pipeline_vertex_format_cache_rd.h"
+#include "pipeline_cache_rd.h"
 #include "core/os/memory.h"
 
-RID RenderPipelineVertexFormatCacheRD::_generate_version(RD::VertexFormatID p_vertex_format_id, RD::FramebufferFormatID p_framebuffer_format_id, bool p_wireframe) {
+RID PipelineCacheRD::_generate_version(RD::VertexFormatID p_vertex_format_id, RD::FramebufferFormatID p_framebuffer_format_id, bool p_wireframe) {
 	RD::PipelineMultisampleState multisample_state_version = multisample_state;
 	multisample_state_version.sample_count = RD::get_singleton()->framebuffer_format_get_texture_samples(p_framebuffer_format_id);
 
@@ -49,7 +49,7 @@ RID RenderPipelineVertexFormatCacheRD::_generate_version(RD::VertexFormatID p_ve
 	return pipeline;
 }
 
-void RenderPipelineVertexFormatCacheRD::_clear() {
+void PipelineCacheRD::_clear() {
 	if (versions) {
 		for (uint32_t i = 0; i < version_count; i++) {
 			//shader may be gone, so this may not be valid
@@ -63,7 +63,7 @@ void RenderPipelineVertexFormatCacheRD::_clear() {
 	}
 }
 
-void RenderPipelineVertexFormatCacheRD::setup(RID p_shader, RD::RenderPrimitive p_primitive, const RD::PipelineRasterizationState &p_rasterization_state, RD::PipelineMultisampleState p_multisample, const RD::PipelineDepthStencilState &p_depth_stencil_state, const RD::PipelineColorBlendState &p_blend_state, int p_dynamic_state_flags) {
+void PipelineCacheRD::setup(RID p_shader, RD::RenderPrimitive p_primitive, const RD::PipelineRasterizationState &p_rasterization_state, RD::PipelineMultisampleState p_multisample, const RD::PipelineDepthStencilState &p_depth_stencil_state, const RD::PipelineColorBlendState &p_blend_state, int p_dynamic_state_flags) {
 	ERR_FAIL_COND(p_shader.is_null());
 	_clear();
 	shader = p_shader;
@@ -76,24 +76,24 @@ void RenderPipelineVertexFormatCacheRD::setup(RID p_shader, RD::RenderPrimitive
 	dynamic_state_flags = p_dynamic_state_flags;
 }
 
-void RenderPipelineVertexFormatCacheRD::update_shader(RID p_shader) {
+void PipelineCacheRD::update_shader(RID p_shader) {
 	ERR_FAIL_COND(p_shader.is_null());
 	_clear();
 	setup(p_shader, render_primitive, rasterization_state, multisample_state, depth_stencil_state, blend_state, dynamic_state_flags);
 }
 
-void RenderPipelineVertexFormatCacheRD::clear() {
+void PipelineCacheRD::clear() {
 	_clear();
 	shader = RID(); //clear shader
 	input_mask = 0;
 }
 
-RenderPipelineVertexFormatCacheRD::RenderPipelineVertexFormatCacheRD() {
+PipelineCacheRD::PipelineCacheRD() {
 	version_count = 0;
 	versions = nullptr;
 	input_mask = 0;
 }
 
-RenderPipelineVertexFormatCacheRD::~RenderPipelineVertexFormatCacheRD() {
+PipelineCacheRD::~PipelineCacheRD() {
 	_clear();
 }
diff --git a/servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.h b/servers/rendering/renderer_rd/pipeline_cache_rd.h
index 6a72dbc77c..2f91c3c3b5 100644
--- a/servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.h
+++ b/servers/rendering/renderer_rd/pipeline_cache_rd.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  render_pipeline_vertex_format_cache_rd.h                             */
+/*  pipeline_cache_rd.h                                                  */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,13 +28,13 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RENDER_PIPELINE_CACHE_RD_H
-#define RENDER_PIPELINE_CACHE_RD_H
+#ifndef PIPELINE_CACHE_RD_H
+#define PIPELINE_CACHE_RD_H
 
 #include "core/os/spin_lock.h"
 #include "servers/rendering/rendering_device.h"
 
-class RenderPipelineVertexFormatCacheRD {
+class PipelineCacheRD {
 	SpinLock spin_lock;
 
 	RID shader;
@@ -89,8 +89,8 @@ public:
 		return input_mask;
 	}
 	void clear();
-	RenderPipelineVertexFormatCacheRD();
-	~RenderPipelineVertexFormatCacheRD();
+	PipelineCacheRD();
+	~PipelineCacheRD();
 };
 
 #endif // RENDER_PIPELINE_CACHE_RD_H
diff --git a/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.cpp b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
index 01ed7b8d6a..8fa56b182c 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_canvas_rd.cpp                                             */
+/*  renderer_canvas_render_rd.cpp                                        */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,12 +28,13 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rasterizer_canvas_rd.h"
+#include "renderer_canvas_render_rd.h"
 #include "core/config/project_settings.h"
+#include "core/math/geometry_2d.h"
 #include "core/math/math_funcs.h"
-#include "rasterizer_rd.h"
+#include "renderer_compositor_rd.h"
 
-void RasterizerCanvasRD::_update_transform_2d_to_mat4(const Transform2D &p_transform, float *p_mat4) {
+void RendererCanvasRenderRD::_update_transform_2d_to_mat4(const Transform2D &p_transform, float *p_mat4) {
 	p_mat4[0] = p_transform.elements[0][0];
 	p_mat4[1] = p_transform.elements[0][1];
 	p_mat4[2] = 0;
@@ -52,7 +53,7 @@ void RasterizerCanvasRD::_update_transform_2d_to_mat4(const Transform2D &p_trans
 	p_mat4[15] = 1;
 }
 
-void RasterizerCanvasRD::_update_transform_2d_to_mat2x4(const Transform2D &p_transform, float *p_mat2x4) {
+void RendererCanvasRenderRD::_update_transform_2d_to_mat2x4(const Transform2D &p_transform, float *p_mat2x4) {
 	p_mat2x4[0] = p_transform.elements[0][0];
 	p_mat2x4[1] = p_transform.elements[1][0];
 	p_mat2x4[2] = 0;
@@ -64,7 +65,7 @@ void RasterizerCanvasRD::_update_transform_2d_to_mat2x4(const Transform2D &p_tra
 	p_mat2x4[7] = p_transform.elements[2][1];
 }
 
-void RasterizerCanvasRD::_update_transform_2d_to_mat2x3(const Transform2D &p_transform, float *p_mat2x3) {
+void RendererCanvasRenderRD::_update_transform_2d_to_mat2x3(const Transform2D &p_transform, float *p_mat2x3) {
 	p_mat2x3[0] = p_transform.elements[0][0];
 	p_mat2x3[1] = p_transform.elements[0][1];
 	p_mat2x3[2] = p_transform.elements[1][0];
@@ -73,7 +74,7 @@ void RasterizerCanvasRD::_update_transform_2d_to_mat2x3(const Transform2D &p_tra
 	p_mat2x3[5] = p_transform.elements[2][1];
 }
 
-void RasterizerCanvasRD::_update_transform_to_mat4(const Transform &p_transform, float *p_mat4) {
+void RendererCanvasRenderRD::_update_transform_to_mat4(const Transform &p_transform, float *p_mat4) {
 	p_mat4[0] = p_transform.basis.elements[0][0];
 	p_mat4[1] = p_transform.basis.elements[1][0];
 	p_mat4[2] = p_transform.basis.elements[2][0];
@@ -92,7 +93,7 @@ void RasterizerCanvasRD::_update_transform_to_mat4(const Transform &p_transform,
 	p_mat4[15] = 1;
 }
 
-RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, const Vector<int> &p_bones, const Vector<float> &p_weights) {
+RendererCanvasRender::PolygonID RendererCanvasRenderRD::request_polygon(const Vector<int> &p_indices, const Vector<Point2> &p_points, const Vector<Color> &p_colors, const Vector<Point2> &p_uvs, const Vector<int> &p_bones, const Vector<float> &p_weights) {
 	// Care must be taken to generate array formats
 	// in ways where they could be reused, so we will
 	// put single-occuring elements first, and repeated
@@ -118,9 +119,9 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 	Vector<uint8_t> polygon_buffer;
 	polygon_buffer.resize(buffer_size * sizeof(float));
 	Vector<RD::VertexAttribute> descriptions;
-	descriptions.resize(4);
+	descriptions.resize(5);
 	Vector<RID> buffers;
-	buffers.resize(4);
+	buffers.resize(5);
 
 	{
 		const uint8_t *r = polygon_buffer.ptr();
@@ -183,7 +184,7 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 			vd.stride = 0;
 
 			descriptions.write[1] = vd;
-			buffers.write[1] = storage->mesh_get_default_rd_buffer(RasterizerStorageRD::DEFAULT_RD_BUFFER_COLOR);
+			buffers.write[1] = storage->mesh_get_default_rd_buffer(RendererStorageRD::DEFAULT_RD_BUFFER_COLOR);
 		}
 
 		//uvs
@@ -211,13 +212,13 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 			vd.stride = 0;
 
 			descriptions.write[2] = vd;
-			buffers.write[2] = storage->mesh_get_default_rd_buffer(RasterizerStorageRD::DEFAULT_RD_BUFFER_TEX_UV);
+			buffers.write[2] = storage->mesh_get_default_rd_buffer(RendererStorageRD::DEFAULT_RD_BUFFER_TEX_UV);
 		}
 
 		//bones
 		if ((uint32_t)p_indices.size() == vertex_count * 4 && (uint32_t)p_weights.size() == vertex_count * 4) {
 			RD::VertexAttribute vd;
-			vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+			vd.format = RD::DATA_FORMAT_R16G16B16A16_UINT;
 			vd.offset = base_offset * sizeof(float);
 			vd.location = RS::ARRAY_BONES;
 			vd.stride = stride * sizeof(float);
@@ -225,16 +226,42 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 			descriptions.write[3] = vd;
 
 			const int *bone_ptr = p_bones.ptr();
-			const float *weight_ptr = p_weights.ptr();
 
 			for (uint32_t i = 0; i < vertex_count; i++) {
 				uint16_t *bone16w = (uint16_t *)&uptr[base_offset + i * stride];
-				uint16_t *weight16w = (uint16_t *)&uptr[base_offset + i * stride + 2];
 
 				bone16w[0] = bone_ptr[i * 4 + 0];
 				bone16w[1] = bone_ptr[i * 4 + 1];
 				bone16w[2] = bone_ptr[i * 4 + 2];
 				bone16w[3] = bone_ptr[i * 4 + 3];
+			}
+
+			base_offset += 2;
+		} else {
+			RD::VertexAttribute vd;
+			vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+			vd.offset = 0;
+			vd.location = RS::ARRAY_BONES;
+			vd.stride = 0;
+
+			descriptions.write[3] = vd;
+			buffers.write[3] = storage->mesh_get_default_rd_buffer(RendererStorageRD::DEFAULT_RD_BUFFER_BONES);
+		}
+
+		//weights
+		if ((uint32_t)p_weights.size() == vertex_count * 4) {
+			RD::VertexAttribute vd;
+			vd.format = RD::DATA_FORMAT_R16G16B16A16_UNORM;
+			vd.offset = base_offset * sizeof(float);
+			vd.location = RS::ARRAY_WEIGHTS;
+			vd.stride = stride * sizeof(float);
+
+			descriptions.write[4] = vd;
+
+			const float *weight_ptr = p_weights.ptr();
+
+			for (uint32_t i = 0; i < vertex_count; i++) {
+				uint16_t *weight16w = (uint16_t *)&uptr[base_offset + i * stride];
 
 				weight16w[0] = CLAMP(weight_ptr[i * 4 + 0] * 65535, 0, 65535);
 				weight16w[1] = CLAMP(weight_ptr[i * 4 + 1] * 65535, 0, 65535);
@@ -242,16 +269,16 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 				weight16w[3] = CLAMP(weight_ptr[i * 4 + 3] * 65535, 0, 65535);
 			}
 
-			base_offset += 4;
+			base_offset += 2;
 		} else {
 			RD::VertexAttribute vd;
-			vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+			vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
 			vd.offset = 0;
-			vd.location = RS::ARRAY_BONES;
+			vd.location = RS::ARRAY_WEIGHTS;
 			vd.stride = 0;
 
-			descriptions.write[3] = vd;
-			buffers.write[3] = storage->mesh_get_default_rd_buffer(RasterizerStorageRD::DEFAULT_RD_BUFFER_BONES);
+			descriptions.write[4] = vd;
+			buffers.write[4] = storage->mesh_get_default_rd_buffer(RendererStorageRD::DEFAULT_RD_BUFFER_BONES);
 		}
 
 		//check that everything is as it should be
@@ -292,7 +319,7 @@ RasterizerCanvas::PolygonID RasterizerCanvasRD::request_polygon(const Vector<int
 	return id;
 }
 
-void RasterizerCanvasRD::free_polygon(PolygonID p_polygon) {
+void RendererCanvasRenderRD::free_polygon(PolygonID p_polygon) {
 	PolygonBuffers *pb_ptr = polygon_buffers.polygons.getptr(p_polygon);
 	ERR_FAIL_COND(!pb_ptr);
 
@@ -313,7 +340,7 @@ void RasterizerCanvasRD::free_polygon(PolygonID p_polygon) {
 
 ////////////////////
 
-void RasterizerCanvasRD::_bind_canvas_texture(RD::DrawListID p_draw_list, RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID &r_last_texture, PushConstant &push_constant, Size2 &r_texpixel_size) {
+void RendererCanvasRenderRD::_bind_canvas_texture(RD::DrawListID p_draw_list, RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID &r_last_texture, PushConstant &push_constant, Size2 &r_texpixel_size) {
 	if (p_texture == RID()) {
 		p_texture = default_canvas_texture;
 	}
@@ -363,7 +390,7 @@ void RasterizerCanvasRD::_bind_canvas_texture(RD::DrawListID p_draw_list, RID p_
 	r_last_texture = p_texture;
 }
 
-void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_item, RD::FramebufferFormatID p_framebuffer_format, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, PipelineVariants *p_pipeline_variants) {
+void RendererCanvasRenderRD::_render_item(RD::DrawListID p_draw_list, const Item *p_item, RD::FramebufferFormatID p_framebuffer_format, const Transform2D &p_canvas_transform_inverse, Item *&current_clip, Light *p_lights, PipelineVariants *p_pipeline_variants) {
 	//create an empty push constant
 
 	RS::CanvasItemTextureFilter current_filter = default_filter;
@@ -687,7 +714,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 
 #if 0
 			case Item::Command::TYPE_MESH: {
-
 				Item::CommandMesh *mesh = static_cast<Item::CommandMesh *>(c);
 				_set_texture_rect_mode(false);
 
@@ -702,7 +728,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 
 				RasterizerStorageGLES3::Mesh *mesh_data = storage->mesh_owner.getornull(mesh->mesh);
 				if (mesh_data) {
-
 					for (int j = 0; j < mesh_data->surfaces.size(); j++) {
 						RasterizerStorageGLES3::Surface *s = mesh_data->surfaces[j];
 						// materials are ignored in 2D meshes, could be added but many things (ie, lighting mode, reading from screen, etc) would break as they are not meant be set up at this point of drawing
@@ -723,7 +748,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 
 			} break;
 			case Item::Command::TYPE_MULTIMESH: {
-
 				Item::CommandMultiMesh *mmesh = static_cast<Item::CommandMultiMesh *>(c);
 
 				RasterizerStorageGLES3::MultiMesh *multi_mesh = storage->multimesh_owner.getornull(mmesh->multimesh);
@@ -786,7 +810,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 					int custom_data_ofs = color_ofs;
 
 					switch (multi_mesh->color_format) {
-
 						case RS::MULTIMESH_COLOR_NONE: {
 							glDisableVertexAttribArray(11);
 							glVertexAttrib4f(11, 1, 1, 1, 1);
@@ -807,7 +830,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 					}
 
 					switch (multi_mesh->custom_data_format) {
-
 						case RS::MULTIMESH_CUSTOM_DATA_NONE: {
 							glDisableVertexAttribArray(12);
 							glVertexAttrib4f(12, 1, 1, 1, 1);
@@ -841,7 +863,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 
 			} break;
 			case Item::Command::TYPE_PARTICLES: {
-
 				Item::CommandParticles *particles_cmd = static_cast<Item::CommandParticles *>(c);
 
 				RasterizerStorageGLES3::Particles *particles = storage->particles_owner.getornull(particles_cmd->particles);
@@ -853,7 +874,7 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 
 				glVertexAttrib4f(RS::ARRAY_COLOR, 1, 1, 1, 1); //not used, so keep white
 
-				RenderingServerRaster::redraw_request();
+				RenderingServerDefault::redraw_request();
 
 				storage->particles_request_process(particles_cmd->particles);
 				//enable instancing
@@ -875,7 +896,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 				}
 
 				if (!particles->use_local_coords) {
-
 					Transform2D inv_xf;
 					inv_xf.set_axis(0, Vector2(particles->emission_transform.basis.get_axis(0).x, particles->emission_transform.basis.get_axis(0).y));
 					inv_xf.set_axis(1, Vector2(particles->emission_transform.basis.get_axis(1).x, particles->emission_transform.basis.get_axis(1).y));
@@ -893,7 +913,6 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 				int amount = particles->amount;
 
 				if (particles->draw_order != RS::PARTICLES_DRAW_ORDER_LIFETIME) {
-
 					glEnableVertexAttribArray(8); //xform x
 					glVertexAttribPointer(8, 4, GL_FLOAT, GL_FALSE, stride, CAST_INT_TO_UCHAR_PTR(sizeof(float) * 4 * 3));
 					glVertexAttribDivisor(8, 1);
@@ -997,13 +1016,13 @@ void RasterizerCanvasRD::_render_item(RD::DrawListID p_draw_list, const Item *p_
 	}
 }
 
-RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_backbuffer) {
+RID RendererCanvasRenderRD::_create_base_uniform_set(RID p_to_render_target, bool p_backbuffer) {
 	//re create canvas state
 	Vector<RD::Uniform> uniforms;
 
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+		u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 		u.binding = 1;
 		u.ids.push_back(state.canvas_state_buffer);
 		uniforms.push_back(u);
@@ -1011,7 +1030,7 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+		u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 		u.binding = 2;
 		u.ids.push_back(state.lights_uniform_buffer);
 		uniforms.push_back(u);
@@ -1019,7 +1038,7 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 3;
 		u.ids.push_back(storage->decal_atlas_get_texture());
 		uniforms.push_back(u);
@@ -1027,7 +1046,7 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 4;
 		u.ids.push_back(state.shadow_texture);
 		uniforms.push_back(u);
@@ -1035,7 +1054,7 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_SAMPLER;
+		u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 		u.binding = 5;
 		u.ids.push_back(state.shadow_sampler);
 		uniforms.push_back(u);
@@ -1043,7 +1062,7 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 6;
 		RID screen;
 		if (p_backbuffer) {
@@ -1051,7 +1070,7 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 		} else {
 			screen = storage->render_target_get_rd_backbuffer(p_to_render_target);
 			if (screen.is_null()) { //unallocated backbuffer
-				screen = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE);
+				screen = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
 			}
 		}
 		u.ids.push_back(screen);
@@ -1059,10 +1078,19 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 	}
 
 	{
-		//needs samplers for the material (uses custom textures) create them
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_SAMPLER;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 7;
+		RID sdf = storage->render_target_get_sdf_texture(p_to_render_target);
+		u.ids.push_back(sdf);
+		uniforms.push_back(u);
+	}
+
+	{
+		//needs samplers for the material (uses custom textures) create them
+		RD::Uniform u;
+		u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
+		u.binding = 8;
 		u.ids.resize(12);
 		RID *ids_ptr = u.ids.ptrw();
 		ids_ptr[0] = storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
@@ -1082,8 +1110,8 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
-		u.binding = 8;
+		u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+		u.binding = 9;
 		u.ids.push_back(storage->global_variables_get_storage_buffer());
 		uniforms.push_back(u);
 	}
@@ -1098,7 +1126,7 @@ RID RasterizerCanvasRD::_create_base_uniform_set(RID p_to_render_target, bool p_
 	return uniform_set;
 }
 
-void RasterizerCanvasRD::_render_items(RID p_to_render_target, int p_item_count, const Transform2D &p_canvas_transform_inverse, Light *p_lights, bool p_to_backbuffer) {
+void RendererCanvasRenderRD::_render_items(RID p_to_render_target, int p_item_count, const Transform2D &p_canvas_transform_inverse, Light *p_lights, bool p_to_backbuffer) {
 	Item *current_clip = nullptr;
 
 	Transform2D canvas_transform_inverse = p_canvas_transform_inverse;
@@ -1165,7 +1193,7 @@ void RasterizerCanvasRD::_render_items(RID p_to_render_target, int p_item_count,
 		if (material != prev_material) {
 			MaterialData *material_data = nullptr;
 			if (material.is_valid()) {
-				material_data = (MaterialData *)storage->material_get_data(material, RasterizerStorageRD::SHADER_TYPE_2D);
+				material_data = (MaterialData *)storage->material_get_data(material, RendererStorageRD::SHADER_TYPE_2D);
 			}
 
 			if (material_data) {
@@ -1190,7 +1218,8 @@ void RasterizerCanvasRD::_render_items(RID p_to_render_target, int p_item_count,
 	RD::get_singleton()->draw_list_end();
 }
 
-void RasterizerCanvasRD::canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_light_list, const Transform2D &p_canvas_transform, RenderingServer::CanvasItemTextureFilter p_default_filter, RenderingServer::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel) {
+void RendererCanvasRenderRD::canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_light_list, const Transform2D &p_canvas_transform, RenderingServer::CanvasItemTextureFilter p_default_filter, RenderingServer::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel, bool &r_sdf_used) {
+	r_sdf_used = false;
 	int item_count = 0;
 
 	//setup canvas state uniforms if needed
@@ -1373,6 +1402,25 @@ void RasterizerCanvasRD::canvas_render_items(RID p_to_render_target, Item *p_ite
 
 		state_buffer.directional_light_count = directional_light_count;
 
+		Vector2 canvas_scale = p_canvas_transform.get_scale();
+
+		state_buffer.sdf_to_screen[0] = render_target_size.width / canvas_scale.x;
+		state_buffer.sdf_to_screen[1] = render_target_size.height / canvas_scale.y;
+
+		state_buffer.screen_to_sdf[0] = 1.0 / state_buffer.sdf_to_screen[0];
+		state_buffer.screen_to_sdf[1] = 1.0 / state_buffer.sdf_to_screen[1];
+
+		Rect2 sdf_rect = storage->render_target_get_sdf_rect(p_to_render_target);
+		Rect2 sdf_tex_rect(sdf_rect.position / canvas_scale, sdf_rect.size / canvas_scale);
+
+		state_buffer.sdf_to_tex[0] = 1.0 / sdf_tex_rect.size.width;
+		state_buffer.sdf_to_tex[1] = 1.0 / sdf_tex_rect.size.height;
+		state_buffer.sdf_to_tex[2] = -sdf_tex_rect.position.x / sdf_tex_rect.size.width;
+		state_buffer.sdf_to_tex[3] = -sdf_tex_rect.position.y / sdf_tex_rect.size.height;
+
+		//print_line("w: " + itos(ssize.width) + " s: " + rtos(canvas_scale));
+		state_buffer.tex_to_sdf = 1.0 / ((canvas_scale.x + canvas_scale.y) * 0.5);
+
 		RD::get_singleton()->buffer_update(state.canvas_state_buffer, 0, sizeof(State::Buffer), &state_buffer, true);
 	}
 
@@ -1401,7 +1449,7 @@ void RasterizerCanvasRD::canvas_render_items(RID p_to_render_target, Item *p_ite
 		}
 
 		if (ci->material.is_valid()) {
-			MaterialData *md = (MaterialData *)storage->material_get_data(ci->material, RasterizerStorageRD::SHADER_TYPE_2D);
+			MaterialData *md = (MaterialData *)storage->material_get_data(ci->material, RendererStorageRD::SHADER_TYPE_2D);
 			if (md && md->shader_data->valid) {
 				if (md->shader_data->uses_screen_texture && canvas_group_owner == nullptr) {
 					if (!material_screen_texture_found) {
@@ -1410,12 +1458,15 @@ void RasterizerCanvasRD::canvas_render_items(RID p_to_render_target, Item *p_ite
 					}
 				}
 
-				if (md->last_frame != RasterizerRD::singleton->get_frame_number()) {
-					md->last_frame = RasterizerRD::singleton->get_frame_number();
+				if (md->shader_data->uses_sdf) {
+					r_sdf_used = true;
+				}
+				if (md->last_frame != RendererCompositorRD::singleton->get_frame_number()) {
+					md->last_frame = RendererCompositorRD::singleton->get_frame_number();
 					if (!RD::get_singleton()->uniform_set_is_valid(md->uniform_set)) {
 						// uniform set may be gone because a dependency was erased. In this case, it will happen
 						// if a texture is deleted, so just re-create it.
-						storage->material_force_update_textures(ci->material, RasterizerStorageRD::SHADER_TYPE_2D);
+						storage->material_force_update_textures(ci->material, RendererStorageRD::SHADER_TYPE_2D);
 					}
 				}
 			}
@@ -1476,12 +1527,12 @@ void RasterizerCanvasRD::canvas_render_items(RID p_to_render_target, Item *p_ite
 	}
 }
 
-RID RasterizerCanvasRD::light_create() {
+RID RendererCanvasRenderRD::light_create() {
 	CanvasLight canvas_light;
 	return canvas_light_owner.make_rid(canvas_light);
 }
 
-void RasterizerCanvasRD::light_set_texture(RID p_rid, RID p_texture) {
+void RendererCanvasRenderRD::light_set_texture(RID p_rid, RID p_texture) {
 	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
 	ERR_FAIL_COND(!cl);
 	if (cl->texture == p_texture) {
@@ -1497,14 +1548,14 @@ void RasterizerCanvasRD::light_set_texture(RID p_rid, RID p_texture) {
 	}
 }
 
-void RasterizerCanvasRD::light_set_use_shadow(RID p_rid, bool p_enable) {
+void RendererCanvasRenderRD::light_set_use_shadow(RID p_rid, bool p_enable) {
 	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
 	ERR_FAIL_COND(!cl);
 
 	cl->shadow.enabled = p_enable;
 }
 
-void RasterizerCanvasRD::_update_shadow_atlas() {
+void RendererCanvasRenderRD::_update_shadow_atlas() {
 	if (state.shadow_fb == RID()) {
 		//ah, we lack the shadow texture..
 		RD::get_singleton()->free(state.shadow_texture); //erase placeholder
@@ -1513,7 +1564,7 @@ void RasterizerCanvasRD::_update_shadow_atlas() {
 
 		{ //texture
 			RD::TextureFormat tf;
-			tf.type = RD::TEXTURE_TYPE_2D;
+			tf.texture_type = RD::TEXTURE_TYPE_2D;
 			tf.width = state.shadow_texture_size;
 			tf.height = state.max_lights_per_render * 2;
 			tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
@@ -1524,7 +1575,7 @@ void RasterizerCanvasRD::_update_shadow_atlas() {
 		}
 		{
 			RD::TextureFormat tf;
-			tf.type = RD::TEXTURE_TYPE_2D;
+			tf.texture_type = RD::TEXTURE_TYPE_2D;
 			tf.width = state.shadow_texture_size;
 			tf.height = state.max_lights_per_render * 2;
 			tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
@@ -1537,7 +1588,7 @@ void RasterizerCanvasRD::_update_shadow_atlas() {
 		state.shadow_fb = RD::get_singleton()->framebuffer_create(fb_textures);
 	}
 }
-void RasterizerCanvasRD::light_update_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders) {
+void RendererCanvasRenderRD::light_update_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders) {
 	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
 	ERR_FAIL_COND(!cl->shadow.enabled);
 
@@ -1615,7 +1666,7 @@ void RasterizerCanvasRD::light_update_shadow(RID p_rid, int p_shadow_index, cons
 	}
 }
 
-void RasterizerCanvasRD::light_update_directional_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_cull_distance, const Rect2 &p_clip_rect, LightOccluderInstance *p_occluders) {
+void RendererCanvasRenderRD::light_update_directional_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_cull_distance, const Rect2 &p_clip_rect, LightOccluderInstance *p_occluders) {
 	CanvasLight *cl = canvas_light_owner.getornull(p_rid);
 	ERR_FAIL_COND(!cl->shadow.enabled);
 
@@ -1695,18 +1746,105 @@ void RasterizerCanvasRD::light_update_directional_shadow(RID p_rid, int p_shadow
 	cl->shadow.directional_xform = to_shadow * to_light_xform;
 }
 
-RID RasterizerCanvasRD::occluder_polygon_create() {
+void RendererCanvasRenderRD::render_sdf(RID p_render_target, LightOccluderInstance *p_occluders) {
+	RID fb = storage->render_target_get_sdf_framebuffer(p_render_target);
+	Rect2i rect = storage->render_target_get_sdf_rect(p_render_target);
+
+	Transform2D to_sdf;
+	to_sdf.elements[0] *= rect.size.width;
+	to_sdf.elements[1] *= rect.size.height;
+	to_sdf.elements[2] = rect.position;
+
+	Transform2D to_clip;
+	to_clip.elements[0] *= 2.0;
+	to_clip.elements[1] *= 2.0;
+	to_clip.elements[2] = -Vector2(1.0, 1.0);
+
+	to_clip = to_clip * to_sdf.affine_inverse();
+
+	Vector<Color> cc;
+	cc.push_back(Color(0, 0, 0, 0));
+
+	RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(fb, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_DISCARD, cc);
+
+	CameraMatrix projection;
+
+	ShadowRenderPushConstant push_constant;
+	for (int y = 0; y < 4; y++) {
+		for (int x = 0; x < 4; x++) {
+			push_constant.projection[y * 4 + x] = projection.matrix[y][x];
+		}
+	}
+
+	push_constant.direction[0] = 0.0;
+	push_constant.direction[1] = 0.0;
+	push_constant.z_far = 0;
+	push_constant.pad = 0;
+
+	LightOccluderInstance *instance = p_occluders;
+
+	while (instance) {
+		OccluderPolygon *co = occluder_polygon_owner.getornull(instance->occluder);
+
+		if (!co || co->sdf_index_array.is_null()) {
+			instance = instance->next;
+			continue;
+		}
+
+		_update_transform_2d_to_mat2x4(to_clip * instance->xform_cache, push_constant.modelview);
+
+		RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, shadow_render.sdf_render_pipelines[co->sdf_is_lines ? SHADOW_RENDER_SDF_LINES : SHADOW_RENDER_SDF_TRIANGLES]);
+		RD::get_singleton()->draw_list_bind_vertex_array(draw_list, co->sdf_vertex_array);
+		RD::get_singleton()->draw_list_bind_index_array(draw_list, co->sdf_index_array);
+		RD::get_singleton()->draw_list_set_push_constant(draw_list, &push_constant, sizeof(ShadowRenderPushConstant));
+
+		RD::get_singleton()->draw_list_draw(draw_list, true);
+
+		instance = instance->next;
+	}
+
+	RD::get_singleton()->draw_list_end();
+
+	storage->render_target_sdf_process(p_render_target); //done rendering, process it
+}
+
+RID RendererCanvasRenderRD::occluder_polygon_create() {
 	OccluderPolygon occluder;
-	occluder.point_count = 0;
+	occluder.line_point_count = 0;
+	occluder.sdf_point_count = 0;
+	occluder.sdf_index_count = 0;
 	occluder.cull_mode = RS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
 	return occluder_polygon_owner.make_rid(occluder);
 }
 
-void RasterizerCanvasRD::occluder_polygon_set_shape_as_lines(RID p_occluder, const Vector<Vector2> &p_lines) {
+void RendererCanvasRenderRD::occluder_polygon_set_shape(RID p_occluder, const Vector<Vector2> &p_points, bool p_closed) {
 	OccluderPolygon *oc = occluder_polygon_owner.getornull(p_occluder);
 	ERR_FAIL_COND(!oc);
 
-	if (oc->point_count != p_lines.size() && oc->vertex_array.is_valid()) {
+	Vector<Vector2> lines;
+
+	if (p_points.size()) {
+		int lc = p_points.size() * 2;
+
+		lines.resize(lc - (p_closed ? 0 : 2));
+		{
+			Vector2 *w = lines.ptrw();
+			const Vector2 *r = p_points.ptr();
+
+			int max = lc / 2;
+			if (!p_closed) {
+				max--;
+			}
+			for (int i = 0; i < max; i++) {
+				Vector2 a = r[i];
+				Vector2 b = r[(i + 1) % (lc / 2)];
+				w[i * 2 + 0] = a;
+				w[i * 2 + 1] = b;
+			}
+		}
+	}
+
+	if (oc->line_point_count != lines.size() && oc->vertex_array.is_valid()) {
 		RD::get_singleton()->free(oc->vertex_array);
 		RD::get_singleton()->free(oc->vertex_buffer);
 		RD::get_singleton()->free(oc->index_array);
@@ -1716,12 +1854,14 @@ void RasterizerCanvasRD::occluder_polygon_set_shape_as_lines(RID p_occluder, con
 		oc->vertex_buffer = RID();
 		oc->index_array = RID();
 		oc->index_buffer = RID();
+
+		oc->line_point_count = lines.size();
 	}
 
-	if (p_lines.size()) {
+	if (lines.size()) {
 		Vector<uint8_t> geometry;
 		Vector<uint8_t> indices;
-		int lc = p_lines.size();
+		int lc = lines.size();
 
 		geometry.resize(lc * 6 * sizeof(float));
 		indices.resize(lc * 3 * sizeof(uint16_t));
@@ -1732,7 +1872,7 @@ void RasterizerCanvasRD::occluder_polygon_set_shape_as_lines(RID p_occluder, con
 			uint8_t *iw = indices.ptrw();
 			uint16_t *iwptr = (uint16_t *)iw;
 
-			const Vector2 *lr = p_lines.ptr();
+			const Vector2 *lr = lines.ptr();
 
 			const int POLY_HEIGHT = 16384;
 
@@ -1786,15 +1926,73 @@ void RasterizerCanvasRD::occluder_polygon_set_shape_as_lines(RID p_occluder, con
 			RD::get_singleton()->buffer_update(oc->index_buffer, 0, indices.size(), ir);
 		}
 	}
+
+	// sdf
+
+	Vector<int> sdf_indices;
+
+	if (p_points.size()) {
+		if (p_closed) {
+			sdf_indices = Geometry2D::triangulate_polygon(p_points);
+			oc->sdf_is_lines = false;
+		} else {
+			int max = p_points.size();
+			sdf_indices.resize(max * 2);
+
+			int *iw = sdf_indices.ptrw();
+			for (int i = 0; i < max; i++) {
+				iw[i * 2 + 0] = i;
+				iw[i * 2 + 1] = (i + 1) % max;
+			}
+			oc->sdf_is_lines = true;
+		}
+	}
+
+	if (oc->sdf_index_count != sdf_indices.size() && oc->sdf_point_count != p_points.size() && oc->sdf_vertex_array.is_valid()) {
+		RD::get_singleton()->free(oc->sdf_vertex_array);
+		RD::get_singleton()->free(oc->sdf_vertex_buffer);
+		RD::get_singleton()->free(oc->sdf_index_array);
+		RD::get_singleton()->free(oc->sdf_index_buffer);
+
+		oc->sdf_vertex_array = RID();
+		oc->sdf_vertex_buffer = RID();
+		oc->sdf_index_array = RID();
+		oc->sdf_index_buffer = RID();
+
+		oc->sdf_index_count = sdf_indices.size();
+		oc->sdf_point_count = p_points.size();
+
+		oc->sdf_is_lines = false;
+	}
+
+	if (sdf_indices.size()) {
+		if (oc->sdf_vertex_array.is_null()) {
+			//create from scratch
+			//vertices
+			oc->sdf_vertex_buffer = RD::get_singleton()->vertex_buffer_create(p_points.size() * 2 * sizeof(real_t), p_points.to_byte_array());
+			oc->sdf_index_buffer = RD::get_singleton()->index_buffer_create(sdf_indices.size(), RD::INDEX_BUFFER_FORMAT_UINT32, sdf_indices.to_byte_array());
+			oc->sdf_index_array = RD::get_singleton()->index_array_create(oc->sdf_index_buffer, 0, sdf_indices.size());
+
+			Vector<RID> buffer;
+			buffer.push_back(oc->sdf_vertex_buffer);
+			oc->sdf_vertex_array = RD::get_singleton()->vertex_array_create(p_points.size(), shadow_render.sdf_vertex_format, buffer);
+			//indices
+
+		} else {
+			//update existing
+			RD::get_singleton()->buffer_update(oc->vertex_buffer, 0, sizeof(real_t) * 2 * p_points.size(), p_points.ptr());
+			RD::get_singleton()->buffer_update(oc->index_buffer, 0, sdf_indices.size() * sizeof(int32_t), sdf_indices.ptr());
+		}
+	}
 }
 
-void RasterizerCanvasRD::occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode) {
+void RendererCanvasRenderRD::occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode) {
 	OccluderPolygon *oc = occluder_polygon_owner.getornull(p_occluder);
 	ERR_FAIL_COND(!oc);
 	oc->cull_mode = p_mode;
 }
 
-void RasterizerCanvasRD::ShaderData::set_code(const String &p_code) {
+void RendererCanvasRenderRD::ShaderData::set_code(const String &p_code) {
 	//compile
 
 	code = p_code;
@@ -1802,6 +2000,7 @@ void RasterizerCanvasRD::ShaderData::set_code(const String &p_code) {
 	ubo_size = 0;
 	uniforms.clear();
 	uses_screen_texture = false;
+	uses_sdf = false;
 
 	if (code == String()) {
 		return; //just invalid, but no error
@@ -1809,7 +2008,6 @@ void RasterizerCanvasRD::ShaderData::set_code(const String &p_code) {
 
 	ShaderCompilerRD::GeneratedCode gen_code;
 
-	int light_mode = LIGHT_MODE_NORMAL;
 	int blend_mode = BLEND_MODE_MIX;
 	uses_screen_texture = false;
 
@@ -1822,14 +2020,12 @@ void RasterizerCanvasRD::ShaderData::set_code(const String &p_code) {
 	actions.render_mode_values["blend_premul_alpha"] = Pair<int *, int>(&blend_mode, BLEND_MODE_PMALPHA);
 	actions.render_mode_values["blend_disabled"] = Pair<int *, int>(&blend_mode, BLEND_MODE_DISABLED);
 
-	actions.render_mode_values["unshaded"] = Pair<int *, int>(&light_mode, LIGHT_MODE_UNSHADED);
-	actions.render_mode_values["light_only"] = Pair<int *, int>(&light_mode, LIGHT_MODE_LIGHT_ONLY);
-
 	actions.usage_flag_pointers["SCREEN_TEXTURE"] = &uses_screen_texture;
+	actions.usage_flag_pointers["texture_sdf"] = &uses_sdf;
 
 	actions.uniforms = &uniforms;
 
-	RasterizerCanvasRD *canvas_singleton = (RasterizerCanvasRD *)RasterizerCanvas::singleton;
+	RendererCanvasRenderRD *canvas_singleton = (RendererCanvasRenderRD *)RendererCanvasRender::singleton;
 
 	Error err = canvas_singleton->shader.compiler.compile(RS::SHADER_CANVAS_ITEM, code, &actions, path, gen_code);
 
@@ -1974,7 +2170,7 @@ void RasterizerCanvasRD::ShaderData::set_code(const String &p_code) {
 	valid = true;
 }
 
-void RasterizerCanvasRD::ShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
+void RendererCanvasRenderRD::ShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
 	if (!p_texture.is_valid()) {
 		default_texture_params.erase(p_name);
 	} else {
@@ -1982,7 +2178,7 @@ void RasterizerCanvasRD::ShaderData::set_default_texture_param(const StringName
 	}
 }
 
-void RasterizerCanvasRD::ShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
+void RendererCanvasRenderRD::ShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
 	Map<int, StringName> order;
 
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
@@ -2003,13 +2199,13 @@ void RasterizerCanvasRD::ShaderData::get_param_list(List<PropertyInfo> *p_param_
 	}
 }
 
-void RasterizerCanvasRD::ShaderData::get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const {
+void RendererCanvasRenderRD::ShaderData::get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const {
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
 		if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
 			continue;
 		}
 
-		RasterizerStorage::InstanceShaderParam p;
+		RendererStorage::InstanceShaderParam p;
 		p.info = ShaderLanguage::uniform_to_property_info(E->get());
 		p.info.name = E->key(); //supply name
 		p.index = E->get().instance_index;
@@ -2018,7 +2214,7 @@ void RasterizerCanvasRD::ShaderData::get_instance_param_list(List<RasterizerStor
 	}
 }
 
-bool RasterizerCanvasRD::ShaderData::is_param_texture(const StringName &p_param) const {
+bool RendererCanvasRenderRD::ShaderData::is_param_texture(const StringName &p_param) const {
 	if (!uniforms.has(p_param)) {
 		return false;
 	}
@@ -2026,15 +2222,15 @@ bool RasterizerCanvasRD::ShaderData::is_param_texture(const StringName &p_param)
 	return uniforms[p_param].texture_order >= 0;
 }
 
-bool RasterizerCanvasRD::ShaderData::is_animated() const {
+bool RendererCanvasRenderRD::ShaderData::is_animated() const {
 	return false;
 }
 
-bool RasterizerCanvasRD::ShaderData::casts_shadows() const {
+bool RendererCanvasRenderRD::ShaderData::casts_shadows() const {
 	return false;
 }
 
-Variant RasterizerCanvasRD::ShaderData::get_default_parameter(const StringName &p_parameter) const {
+Variant RendererCanvasRenderRD::ShaderData::get_default_parameter(const StringName &p_parameter) const {
 	if (uniforms.has(p_parameter)) {
 		ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
 		Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
@@ -2043,13 +2239,14 @@ Variant RasterizerCanvasRD::ShaderData::get_default_parameter(const StringName &
 	return Variant();
 }
 
-RasterizerCanvasRD::ShaderData::ShaderData() {
+RendererCanvasRenderRD::ShaderData::ShaderData() {
 	valid = false;
 	uses_screen_texture = false;
+	uses_sdf = false;
 }
 
-RasterizerCanvasRD::ShaderData::~ShaderData() {
-	RasterizerCanvasRD *canvas_singleton = (RasterizerCanvasRD *)RasterizerCanvas::singleton;
+RendererCanvasRenderRD::ShaderData::~ShaderData() {
+	RendererCanvasRenderRD *canvas_singleton = (RendererCanvasRenderRD *)RendererCanvasRender::singleton;
 	ERR_FAIL_COND(!canvas_singleton);
 	//pipeline variants will clear themselves if shader is gone
 	if (version.is_valid()) {
@@ -2057,13 +2254,13 @@ RasterizerCanvasRD::ShaderData::~ShaderData() {
 	}
 }
 
-RasterizerStorageRD::ShaderData *RasterizerCanvasRD::_create_shader_func() {
+RendererStorageRD::ShaderData *RendererCanvasRenderRD::_create_shader_func() {
 	ShaderData *shader_data = memnew(ShaderData);
 	return shader_data;
 }
 
-void RasterizerCanvasRD::MaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
-	RasterizerCanvasRD *canvas_singleton = (RasterizerCanvasRD *)RasterizerCanvas::singleton;
+void RendererCanvasRenderRD::MaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
+	RendererCanvasRenderRD *canvas_singleton = (RendererCanvasRenderRD *)RendererCanvasRender::singleton;
 
 	if ((uint32_t)ubo_data.size() != shader_data->ubo_size) {
 		p_uniform_dirty = true;
@@ -2123,7 +2320,7 @@ void RasterizerCanvasRD::MaterialData::update_parameters(const Map<StringName, V
 	{
 		if (shader_data->ubo_size) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(uniform_buffer);
 			uniforms.push_back(u);
@@ -2132,7 +2329,7 @@ void RasterizerCanvasRD::MaterialData::update_parameters(const Map<StringName, V
 		const RID *textures = texture_cache.ptrw();
 		for (uint32_t i = 0; i < tex_uniform_count; i++) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1 + i;
 			u.ids.push_back(textures[i]);
 			uniforms.push_back(u);
@@ -2142,7 +2339,7 @@ void RasterizerCanvasRD::MaterialData::update_parameters(const Map<StringName, V
 	uniform_set = RD::get_singleton()->uniform_set_create(uniforms, canvas_singleton->shader.canvas_shader.version_get_shader(shader_data->version, 0), MATERIAL_UNIFORM_SET);
 }
 
-RasterizerCanvasRD::MaterialData::~MaterialData() {
+RendererCanvasRenderRD::MaterialData::~MaterialData() {
 	if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
 		RD::get_singleton()->free(uniform_set);
 	}
@@ -2152,7 +2349,7 @@ RasterizerCanvasRD::MaterialData::~MaterialData() {
 	}
 }
 
-RasterizerStorageRD::MaterialData *RasterizerCanvasRD::_create_material_func(ShaderData *p_shader) {
+RendererStorageRD::MaterialData *RendererCanvasRenderRD::_create_material_func(ShaderData *p_shader) {
 	MaterialData *material_data = memnew(MaterialData);
 	material_data->shader_data = p_shader;
 	material_data->last_frame = false;
@@ -2160,14 +2357,14 @@ RasterizerStorageRD::MaterialData *RasterizerCanvasRD::_create_material_func(Sha
 	return material_data;
 }
 
-void RasterizerCanvasRD::set_time(double p_time) {
+void RendererCanvasRenderRD::set_time(double p_time) {
 	state.time = p_time;
 }
 
-void RasterizerCanvasRD::update() {
+void RendererCanvasRenderRD::update() {
 }
 
-RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
+RendererCanvasRenderRD::RendererCanvasRenderRD(RendererStorageRD *p_storage) {
 	storage = p_storage;
 
 	{ //create default samplers
@@ -2310,6 +2507,11 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 		actions.renames["LIGHT"] = "light";
 		actions.renames["SHADOW_MODULATE"] = "shadow_modulate";
 
+		actions.renames["texture_sdf"] = "texture_sdf";
+		actions.renames["texture_sdf_normal"] = "texture_sdf_normal";
+		actions.renames["sdf_to_screen_uv"] = "sdf_to_screen_uv";
+		actions.renames["screen_uv_to_sdf"] = "screen_uv_to_sdf";
+
 		actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
 		actions.usage_defines["SCREEN_TEXTURE"] = "#define SCREEN_TEXTURE_USED\n";
 		actions.usage_defines["SCREEN_UV"] = "#define SCREEN_UV_USED\n";
@@ -2319,6 +2521,8 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 		actions.usage_defines["LIGHT"] = "#define LIGHT_SHADER_CODE_USED\n";
 
 		actions.render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
+		actions.render_mode_defines["unshaded"] = "#define MODE_UNSHADED\n";
+		actions.render_mode_defines["light_only"] = "#define MODE_LIGHT_ONLY\n";
 
 		actions.custom_samplers["TEXTURE"] = "texture_sampler";
 		actions.custom_samplers["NORMAL_TEXTURE"] = "texture_sampler";
@@ -2339,7 +2543,8 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 
 	{ //shadow rendering
 		Vector<String> versions;
-		versions.push_back(String()); //no versions
+		versions.push_back("\n#define MODE_SHADOW\n"); //shadow
+		versions.push_back("\n#define MODE_SDF\n"); //sdf
 		shadow_render.shader.initialize(versions);
 
 		{
@@ -2360,16 +2565,34 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 			shadow_render.framebuffer_format = RD::get_singleton()->framebuffer_format_create(attachments);
 		}
 
+		{
+			Vector<RD::AttachmentFormat> attachments;
+
+			RD::AttachmentFormat af_color;
+			af_color.format = RD::DATA_FORMAT_R8_UNORM;
+			af_color.usage_flags = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
+
+			attachments.push_back(af_color);
+
+			shadow_render.sdf_framebuffer_format = RD::get_singleton()->framebuffer_format_create(attachments);
+		}
+
 		//pipelines
 		Vector<RD::VertexAttribute> vf;
 		RD::VertexAttribute vd;
-		vd.format = RD::DATA_FORMAT_R32G32B32_SFLOAT;
+		vd.format = sizeof(real_t) == sizeof(float) ? RD::DATA_FORMAT_R32G32B32_SFLOAT : RD::DATA_FORMAT_R64G64B64_SFLOAT;
 		vd.location = 0;
 		vd.offset = 0;
-		vd.stride = sizeof(float) * 3;
+		vd.stride = sizeof(real_t) * 3;
 		vf.push_back(vd);
 		shadow_render.vertex_format = RD::get_singleton()->vertex_format_create(vf);
 
+		vd.format = sizeof(real_t) == sizeof(float) ? RD::DATA_FORMAT_R32G32_SFLOAT : RD::DATA_FORMAT_R64G64_SFLOAT;
+		vd.stride = sizeof(real_t) * 2;
+
+		vf.write[0] = vd;
+		shadow_render.sdf_vertex_format = RD::get_singleton()->vertex_format_create(vf);
+
 		shadow_render.shader_version = shadow_render.shader.version_create();
 
 		for (int i = 0; i < 3; i++) {
@@ -2379,7 +2602,11 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 			ds.enable_depth_write = true;
 			ds.enable_depth_test = true;
 			ds.depth_compare_operator = RD::COMPARE_OP_LESS;
-			shadow_render.render_pipelines[i] = RD::get_singleton()->render_pipeline_create(shadow_render.shader.version_get_shader(shadow_render.shader_version, 0), shadow_render.framebuffer_format, shadow_render.vertex_format, RD::RENDER_PRIMITIVE_TRIANGLES, rs, RD::PipelineMultisampleState(), ds, RD::PipelineColorBlendState::create_disabled(), 0);
+			shadow_render.render_pipelines[i] = RD::get_singleton()->render_pipeline_create(shadow_render.shader.version_get_shader(shadow_render.shader_version, SHADOW_RENDER_MODE_SHADOW), shadow_render.framebuffer_format, shadow_render.vertex_format, RD::RENDER_PRIMITIVE_TRIANGLES, rs, RD::PipelineMultisampleState(), ds, RD::PipelineColorBlendState::create_disabled(), 0);
+		}
+
+		for (int i = 0; i < 2; i++) {
+			shadow_render.sdf_render_pipelines[i] = RD::get_singleton()->render_pipeline_create(shadow_render.shader.version_get_shader(shadow_render.shader_version, SHADOW_RENDER_MODE_SDF), shadow_render.sdf_framebuffer_format, shadow_render.sdf_vertex_format, i == 0 ? RD::RENDER_PRIMITIVE_TRIANGLES : RD::RENDER_PRIMITIVE_LINES, RD::PipelineRasterizationState(), RD::PipelineMultisampleState(), RD::PipelineDepthStencilState(), RD::PipelineColorBlendState::create_disabled(), 0);
 		}
 	}
 
@@ -2440,7 +2667,7 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 	{
 		//default shadow texture to keep uniform set happy
 		RD::TextureFormat tf;
-		tf.type = RD::TEXTURE_TYPE_2D;
+		tf.texture_type = RD::TEXTURE_TYPE_2D;
 		tf.width = 4;
 		tf.height = 4;
 		tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
@@ -2454,7 +2681,7 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(storage->get_default_rd_storage_buffer());
 			uniforms.push_back(u);
@@ -2468,8 +2695,8 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 	state.shadow_texture_size = GLOBAL_GET("rendering/quality/2d_shadow_atlas/size");
 
 	//create functions for shader and material
-	storage->shader_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_2D, _create_shader_funcs);
-	storage->material_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_2D, _create_material_funcs);
+	storage->shader_set_data_request_function(RendererStorageRD::SHADER_TYPE_2D, _create_shader_funcs);
+	storage->material_set_data_request_function(RendererStorageRD::SHADER_TYPE_2D, _create_material_funcs);
 
 	state.time = 0;
 
@@ -2483,14 +2710,14 @@ RasterizerCanvasRD::RasterizerCanvasRD(RasterizerStorageRD *p_storage) {
 	static_assert(sizeof(PushConstant) == 128);
 }
 
-bool RasterizerCanvasRD::free(RID p_rid) {
+bool RendererCanvasRenderRD::free(RID p_rid) {
 	if (canvas_light_owner.owns(p_rid)) {
 		CanvasLight *cl = canvas_light_owner.getornull(p_rid);
 		ERR_FAIL_COND_V(!cl, false);
 		light_set_use_shadow(p_rid, false);
 		canvas_light_owner.free(p_rid);
 	} else if (occluder_polygon_owner.owns(p_rid)) {
-		occluder_polygon_set_shape_as_lines(p_rid, Vector<Vector2>());
+		occluder_polygon_set_shape(p_rid, Vector<Vector2>(), false);
 		occluder_polygon_owner.free(p_rid);
 	} else {
 		return false;
@@ -2499,7 +2726,7 @@ bool RasterizerCanvasRD::free(RID p_rid) {
 	return true;
 }
 
-void RasterizerCanvasRD::set_shadow_texture_size(int p_size) {
+void RendererCanvasRenderRD::set_shadow_texture_size(int p_size) {
 	p_size = nearest_power_of_2_templated(p_size);
 	if (p_size == state.shadow_texture_size) {
 		return;
@@ -2513,7 +2740,7 @@ void RasterizerCanvasRD::set_shadow_texture_size(int p_size) {
 		{
 			//create a default shadow texture to keep uniform set happy (and that it gets erased when a new one is created)
 			RD::TextureFormat tf;
-			tf.type = RD::TEXTURE_TYPE_2D;
+			tf.texture_type = RD::TEXTURE_TYPE_2D;
 			tf.width = 4;
 			tf.height = 4;
 			tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
@@ -2524,7 +2751,7 @@ void RasterizerCanvasRD::set_shadow_texture_size(int p_size) {
 	}
 }
 
-RasterizerCanvasRD::~RasterizerCanvasRD() {
+RendererCanvasRenderRD::~RendererCanvasRenderRD() {
 	//canvas state
 
 	storage->free(default_canvas_group_material);
@@ -2567,6 +2794,4 @@ RasterizerCanvasRD::~RasterizerCanvasRD() {
 
 	storage->free(default_canvas_texture);
 	//pipelines don't need freeing, they are all gone after shaders are gone
-
-	RD::get_singleton()->free(state.default_transforms_uniform_set);
 }
diff --git a/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.h b/servers/rendering/renderer_rd/renderer_canvas_render_rd.h
index b516f63cbf..203d7a4890 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_canvas_rd.h
+++ b/servers/rendering/renderer_rd/renderer_canvas_render_rd.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_canvas_rd.h                                               */
+/*  renderer_canvas_render_rd.h                                          */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,19 +28,20 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RASTERIZER_CANVAS_RD_H
-#define RASTERIZER_CANVAS_RD_H
+#ifndef RENDERING_SERVER_CANVAS_RENDER_RD_H
+#define RENDERING_SERVER_CANVAS_RENDER_RD_H
 
-#include "servers/rendering/rasterizer.h"
-#include "servers/rendering/rasterizer_rd/rasterizer_storage_rd.h"
-#include "servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.h"
-#include "servers/rendering/rasterizer_rd/shader_compiler_rd.h"
-#include "servers/rendering/rasterizer_rd/shaders/canvas.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/canvas_occlusion.glsl.gen.h"
+#include "servers/rendering/renderer_canvas_render.h"
+#include "servers/rendering/renderer_compositor.h"
+#include "servers/rendering/renderer_rd/pipeline_cache_rd.h"
+#include "servers/rendering/renderer_rd/renderer_storage_rd.h"
+#include "servers/rendering/renderer_rd/shader_compiler_rd.h"
+#include "servers/rendering/renderer_rd/shaders/canvas.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/canvas_occlusion.glsl.gen.h"
 #include "servers/rendering/rendering_device.h"
 
-class RasterizerCanvasRD : public RasterizerCanvas {
-	RasterizerStorageRD *storage;
+class RendererCanvasRenderRD : public RendererCanvasRender {
+	RendererStorageRD *storage;
 
 	enum {
 		BASE_UNIFORM_SET = 0,
@@ -133,7 +134,7 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 	};
 
 	struct PipelineVariants {
-		RenderPipelineVertexFormatCacheRD variants[PIPELINE_LIGHT_MODE_MAX][PIPELINE_VARIANT_MAX];
+		PipelineCacheRD variants[PIPELINE_LIGHT_MODE_MAX][PIPELINE_VARIANT_MAX];
 	};
 
 	struct {
@@ -151,7 +152,7 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 		ShaderCompilerRD compiler;
 	} shader;
 
-	struct ShaderData : public RasterizerStorageRD::ShaderData {
+	struct ShaderData : public RendererStorageRD::ShaderData {
 		enum BlendMode { //used internally
 			BLEND_MODE_MIX,
 			BLEND_MODE_ADD,
@@ -161,12 +162,6 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 			BLEND_MODE_DISABLED,
 		};
 
-		enum LightMode {
-			LIGHT_MODE_NORMAL,
-			LIGHT_MODE_UNSHADED,
-			LIGHT_MODE_LIGHT_ONLY
-		};
-
 		bool valid;
 		RID version;
 		PipelineVariants pipeline_variants;
@@ -181,12 +176,13 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 		String code;
 		Map<StringName, RID> default_texture_params;
 
-		bool uses_screen_texture;
+		bool uses_screen_texture = false;
+		bool uses_sdf = false;
 
 		virtual void set_code(const String &p_Code);
 		virtual void set_default_texture_param(const StringName &p_name, RID p_texture);
 		virtual void get_param_list(List<PropertyInfo> *p_param_list) const;
-		virtual void get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const;
+		virtual void get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const;
 
 		virtual bool is_param_texture(const StringName &p_param) const;
 		virtual bool is_animated() const;
@@ -196,12 +192,12 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 		virtual ~ShaderData();
 	};
 
-	RasterizerStorageRD::ShaderData *_create_shader_func();
-	static RasterizerStorageRD::ShaderData *_create_shader_funcs() {
-		return static_cast<RasterizerCanvasRD *>(singleton)->_create_shader_func();
+	RendererStorageRD::ShaderData *_create_shader_func();
+	static RendererStorageRD::ShaderData *_create_shader_funcs() {
+		return static_cast<RendererCanvasRenderRD *>(singleton)->_create_shader_func();
 	}
 
-	struct MaterialData : public RasterizerStorageRD::MaterialData {
+	struct MaterialData : public RendererStorageRD::MaterialData {
 		uint64_t last_frame;
 		ShaderData *shader_data;
 		RID uniform_buffer;
@@ -215,9 +211,9 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 		virtual ~MaterialData();
 	};
 
-	RasterizerStorageRD::MaterialData *_create_material_func(ShaderData *p_shader);
-	static RasterizerStorageRD::MaterialData *_create_material_funcs(RasterizerStorageRD::ShaderData *p_shader) {
-		return static_cast<RasterizerCanvasRD *>(singleton)->_create_material_func(static_cast<ShaderData *>(p_shader));
+	RendererStorageRD::MaterialData *_create_material_func(ShaderData *p_shader);
+	static RendererStorageRD::MaterialData *_create_material_funcs(RendererStorageRD::ShaderData *p_shader) {
+		return static_cast<RendererCanvasRenderRD *>(singleton)->_create_material_func(static_cast<ShaderData *>(p_shader));
 	}
 
 	/**************************/
@@ -284,11 +280,19 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 
 	struct OccluderPolygon {
 		RS::CanvasOccluderPolygonCullMode cull_mode;
-		int point_count;
+		int line_point_count;
 		RID vertex_buffer;
 		RID vertex_array;
 		RID index_buffer;
 		RID index_array;
+
+		int sdf_point_count;
+		int sdf_index_count;
+		RID sdf_vertex_buffer;
+		RID sdf_vertex_array;
+		RID sdf_index_buffer;
+		RID sdf_index_array;
+		bool sdf_is_lines;
 	};
 
 	struct LightUniform {
@@ -310,12 +314,25 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 
 	RID_Owner<OccluderPolygon> occluder_polygon_owner;
 
+	enum ShadowRenderMode {
+		SHADOW_RENDER_MODE_SHADOW,
+		SHADOW_RENDER_MODE_SDF,
+	};
+
+	enum {
+		SHADOW_RENDER_SDF_TRIANGLES,
+		SHADOW_RENDER_SDF_LINES,
+	};
+
 	struct {
 		CanvasOcclusionShaderRD shader;
 		RID shader_version;
 		RID render_pipelines[3];
+		RID sdf_render_pipelines[2];
 		RD::VertexFormatID vertex_format;
+		RD::VertexFormatID sdf_vertex_format;
 		RD::FramebufferFormatID framebuffer_format;
+		RD::FramebufferFormatID sdf_framebuffer_format;
 	} shadow_render;
 
 	/***************/
@@ -336,8 +353,14 @@ class RasterizerCanvasRD : public RasterizerCanvas {
 			float time;
 			uint32_t use_pixel_snap;
 
+			float sdf_to_tex[4];
+			float sdf_to_screen[2];
+			float screen_to_sdf[2];
+
 			uint32_t directional_light_count;
-			uint32_t pad[3];
+			float tex_to_sdf;
+			uint32_t pad1;
+			uint32_t pad2;
 		};
 
 		LightUniform *light_uniforms;
@@ -423,11 +446,13 @@ public:
 	void light_update_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_near, float p_far, LightOccluderInstance *p_occluders);
 	void light_update_directional_shadow(RID p_rid, int p_shadow_index, const Transform2D &p_light_xform, int p_light_mask, float p_cull_distance, const Rect2 &p_clip_rect, LightOccluderInstance *p_occluders);
 
+	virtual void render_sdf(RID p_render_target, LightOccluderInstance *p_occluders);
+
 	RID occluder_polygon_create();
-	void occluder_polygon_set_shape_as_lines(RID p_occluder, const Vector<Vector2> &p_lines);
+	void occluder_polygon_set_shape(RID p_occluder, const Vector<Vector2> &p_points, bool p_closed);
 	void occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode);
 
-	void canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_light_list, const Transform2D &p_canvas_transform, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel);
+	void canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_light_list, const Transform2D &p_canvas_transform, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel, bool &r_sdf_used);
 
 	void canvas_debug_viewport_shadows(Light *p_lights_with_shadow) {}
 
@@ -438,8 +463,8 @@ public:
 	void set_time(double p_time);
 	void update();
 	bool free(RID p_rid);
-	RasterizerCanvasRD(RasterizerStorageRD *p_storage);
-	~RasterizerCanvasRD();
+	RendererCanvasRenderRD(RendererStorageRD *p_storage);
+	~RendererCanvasRenderRD();
 };
 
 #endif // RASTERIZER_CANVAS_RD_H
diff --git a/servers/rendering/rasterizer_rd/rasterizer_rd.cpp b/servers/rendering/renderer_rd/renderer_compositor_rd.cpp
index 5f8cf0ee8c..4ae7e68219 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_compositor_rd.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_rd.cpp                                                    */
+/*  renderer_compositor_rd.cpp                                           */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,15 +28,15 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rasterizer_rd.h"
+#include "renderer_compositor_rd.h"
 
 #include "core/config/project_settings.h"
 
-void RasterizerRD::prepare_for_blitting_render_targets() {
+void RendererCompositorRD::prepare_for_blitting_render_targets() {
 	RD::get_singleton()->prepare_screen_for_drawing();
 }
 
-void RasterizerRD::blit_render_targets_to_screen(DisplayServer::WindowID p_screen, const BlitToScreen *p_render_targets, int p_amount) {
+void RendererCompositorRD::blit_render_targets_to_screen(DisplayServer::WindowID p_screen, const BlitToScreen *p_render_targets, int p_amount) {
 	RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin_for_screen(p_screen);
 
 	for (int i = 0; i < p_amount; i++) {
@@ -47,7 +47,7 @@ void RasterizerRD::blit_render_targets_to_screen(DisplayServer::WindowID p_scree
 		if (!render_target_descriptors.has(rd_texture) || !RD::get_singleton()->uniform_set_is_valid(render_target_descriptors[rd_texture])) {
 			Vector<RD::Uniform> uniforms;
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;
 			u.binding = 0;
 			u.ids.push_back(copy_viewports_sampler);
 			u.ids.push_back(rd_texture);
@@ -76,7 +76,7 @@ void RasterizerRD::blit_render_targets_to_screen(DisplayServer::WindowID p_scree
 	RD::get_singleton()->draw_list_end();
 }
 
-void RasterizerRD::begin_frame(double frame_step) {
+void RendererCompositorRD::begin_frame(double frame_step) {
 	frame++;
 	delta = frame_step;
 	time += frame_step;
@@ -88,14 +88,14 @@ void RasterizerRD::begin_frame(double frame_step) {
 	scene->set_time(time, frame_step);
 }
 
-void RasterizerRD::end_frame(bool p_swap_buffers) {
+void RendererCompositorRD::end_frame(bool p_swap_buffers) {
 #ifndef _MSC_VER
 #warning TODO: likely pass a bool to swap buffers to avoid display?
 #endif
 	RD::get_singleton()->swap_buffers(); //probably should pass some bool to avoid display?
 }
 
-void RasterizerRD::initialize() {
+void RendererCompositorRD::initialize() {
 	{ //create framebuffer copy shader
 		RenderingDevice::ShaderStageData vert;
 		vert.shader_stage = RenderingDevice::SHADER_STAGE_VERTEX;
@@ -154,10 +154,10 @@ void RasterizerRD::initialize() {
 	}
 }
 
-ThreadWorkPool RasterizerRD::thread_work_pool;
-uint64_t RasterizerRD::frame = 1;
+ThreadWorkPool RendererCompositorRD::thread_work_pool;
+uint64_t RendererCompositorRD::frame = 1;
 
-void RasterizerRD::finalize() {
+void RendererCompositorRD::finalize() {
 	thread_work_pool.finish();
 
 	memdelete(scene);
@@ -170,14 +170,14 @@ void RasterizerRD::finalize() {
 	RD::get_singleton()->free(copy_viewports_sampler);
 }
 
-RasterizerRD *RasterizerRD::singleton = nullptr;
+RendererCompositorRD *RendererCompositorRD::singleton = nullptr;
 
-RasterizerRD::RasterizerRD() {
+RendererCompositorRD::RendererCompositorRD() {
 	singleton = this;
 	thread_work_pool.init();
 	time = 0;
 
-	storage = memnew(RasterizerStorageRD);
-	canvas = memnew(RasterizerCanvasRD(storage));
-	scene = memnew(RasterizerSceneHighEndRD(storage));
+	storage = memnew(RendererStorageRD);
+	canvas = memnew(RendererCanvasRenderRD(storage));
+	scene = memnew(RendererSceneRenderForward(storage));
 }
diff --git a/servers/rendering/rasterizer_rd/rasterizer_rd.h b/servers/rendering/renderer_rd/renderer_compositor_rd.h
index 59fb8d2049..877f47d702 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_rd.h
+++ b/servers/rendering/renderer_rd/renderer_compositor_rd.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_rd.h                                                      */
+/*  renderer_compositor_rd.h                                             */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,21 +28,21 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RASTERIZER_RD_H
-#define RASTERIZER_RD_H
+#ifndef RENDERING_SERVER_COMPOSITOR_RD_H
+#define RENDERING_SERVER_COMPOSITOR_RD_H
 
 #include "core/os/os.h"
 #include "core/templates/thread_work_pool.h"
-#include "servers/rendering/rasterizer.h"
-#include "servers/rendering/rasterizer_rd/rasterizer_canvas_rd.h"
-#include "servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h"
-#include "servers/rendering/rasterizer_rd/rasterizer_storage_rd.h"
+#include "servers/rendering/renderer_compositor.h"
+#include "servers/rendering/renderer_rd/renderer_canvas_render_rd.h"
+#include "servers/rendering/renderer_rd/renderer_scene_render_forward.h"
+#include "servers/rendering/renderer_rd/renderer_storage_rd.h"
 
-class RasterizerRD : public Rasterizer {
+class RendererCompositorRD : public RendererCompositor {
 protected:
-	RasterizerCanvasRD *canvas;
-	RasterizerStorageRD *storage;
-	RasterizerSceneHighEndRD *scene;
+	RendererCanvasRenderRD *canvas;
+	RendererStorageRD *storage;
+	RendererSceneRenderForward *scene;
 
 	RID copy_viewports_rd_shader;
 	RID copy_viewports_rd_pipeline;
@@ -58,9 +58,9 @@ protected:
 	static uint64_t frame;
 
 public:
-	RasterizerStorage *get_storage() { return storage; }
-	RasterizerCanvas *get_canvas() { return canvas; }
-	RasterizerScene *get_scene() { return scene; }
+	RendererStorage *get_storage() { return storage; }
+	RendererCanvasRender *get_canvas() { return canvas; }
+	RendererSceneRender *get_scene() { return scene; }
 
 	void set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter) {}
 
@@ -80,8 +80,8 @@ public:
 		return OK;
 	}
 
-	static Rasterizer *_create_current() {
-		return memnew(RasterizerRD);
+	static RendererCompositor *_create_current() {
+		return memnew(RendererCompositorRD);
 	}
 
 	static void make_current() {
@@ -92,8 +92,8 @@ public:
 
 	static ThreadWorkPool thread_work_pool;
 
-	static RasterizerRD *singleton;
-	RasterizerRD();
-	~RasterizerRD() {}
+	static RendererCompositorRD *singleton;
+	RendererCompositorRD();
+	~RendererCompositorRD() {}
 };
 #endif // RASTERIZER_RD_H
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp b/servers/rendering/renderer_rd/renderer_scene_render_forward.cpp
index a275e46473..93f4b7bc8e 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_scene_render_forward.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_scene_high_end_rd.cpp                                     */
+/*  renderer_scene_render_forward.cpp                                    */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,13 +28,13 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rasterizer_scene_high_end_rd.h"
+#include "renderer_scene_render_forward.h"
 #include "core/config/project_settings.h"
 #include "servers/rendering/rendering_device.h"
-#include "servers/rendering/rendering_server_raster.h"
+#include "servers/rendering/rendering_server_default.h"
 
 /* SCENE SHADER */
-void RasterizerSceneHighEndRD::ShaderData::set_code(const String &p_code) {
+void RendererSceneRenderForward::ShaderData::set_code(const String &p_code) {
 	//compile
 
 	code = p_code;
@@ -123,7 +123,7 @@ void RasterizerSceneHighEndRD::ShaderData::set_code(const String &p_code) {
 
 	actions.uniforms = &uniforms;
 
-	RasterizerSceneHighEndRD *scene_singleton = (RasterizerSceneHighEndRD *)RasterizerSceneHighEndRD::singleton;
+	RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
 
 	Error err = scene_singleton->shader.compiler.compile(RS::SHADER_SPATIAL, code, &actions, path, gen_code);
 
@@ -257,6 +257,9 @@ void RasterizerSceneHighEndRD::ShaderData::set_code(const String &p_code) {
 			RD::RenderPrimitive primitive_rd = uses_point_size ? RD::RENDER_PRIMITIVE_POINTS : primitive_rd_table[j];
 
 			for (int k = 0; k < SHADER_VERSION_MAX; k++) {
+				if (!static_cast<RendererSceneRenderForward *>(singleton)->shader.scene_shader.is_variant_enabled(k)) {
+					continue;
+				}
 				RD::PipelineRasterizationState raster_state;
 				raster_state.cull_mode = cull_mode_rd;
 				raster_state.wireframe = wireframe;
@@ -321,7 +324,7 @@ void RasterizerSceneHighEndRD::ShaderData::set_code(const String &p_code) {
 	valid = true;
 }
 
-void RasterizerSceneHighEndRD::ShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
+void RendererSceneRenderForward::ShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
 	if (!p_texture.is_valid()) {
 		default_texture_params.erase(p_name);
 	} else {
@@ -329,7 +332,7 @@ void RasterizerSceneHighEndRD::ShaderData::set_default_texture_param(const Strin
 	}
 }
 
-void RasterizerSceneHighEndRD::ShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
+void RendererSceneRenderForward::ShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
 	Map<int, StringName> order;
 
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
@@ -351,13 +354,13 @@ void RasterizerSceneHighEndRD::ShaderData::get_param_list(List<PropertyInfo> *p_
 	}
 }
 
-void RasterizerSceneHighEndRD::ShaderData::get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const {
+void RendererSceneRenderForward::ShaderData::get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const {
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
 		if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
 			continue;
 		}
 
-		RasterizerStorage::InstanceShaderParam p;
+		RendererStorage::InstanceShaderParam p;
 		p.info = ShaderLanguage::uniform_to_property_info(E->get());
 		p.info.name = E->key(); //supply name
 		p.index = E->get().instance_index;
@@ -366,7 +369,7 @@ void RasterizerSceneHighEndRD::ShaderData::get_instance_param_list(List<Rasteriz
 	}
 }
 
-bool RasterizerSceneHighEndRD::ShaderData::is_param_texture(const StringName &p_param) const {
+bool RendererSceneRenderForward::ShaderData::is_param_texture(const StringName &p_param) const {
 	if (!uniforms.has(p_param)) {
 		return false;
 	}
@@ -374,15 +377,15 @@ bool RasterizerSceneHighEndRD::ShaderData::is_param_texture(const StringName &p_
 	return uniforms[p_param].texture_order >= 0;
 }
 
-bool RasterizerSceneHighEndRD::ShaderData::is_animated() const {
+bool RendererSceneRenderForward::ShaderData::is_animated() const {
 	return false;
 }
 
-bool RasterizerSceneHighEndRD::ShaderData::casts_shadows() const {
+bool RendererSceneRenderForward::ShaderData::casts_shadows() const {
 	return false;
 }
 
-Variant RasterizerSceneHighEndRD::ShaderData::get_default_parameter(const StringName &p_parameter) const {
+Variant RendererSceneRenderForward::ShaderData::get_default_parameter(const StringName &p_parameter) const {
 	if (uniforms.has(p_parameter)) {
 		ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
 		Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
@@ -391,13 +394,13 @@ Variant RasterizerSceneHighEndRD::ShaderData::get_default_parameter(const String
 	return Variant();
 }
 
-RasterizerSceneHighEndRD::ShaderData::ShaderData() {
+RendererSceneRenderForward::ShaderData::ShaderData() {
 	valid = false;
 	uses_screen_texture = false;
 }
 
-RasterizerSceneHighEndRD::ShaderData::~ShaderData() {
-	RasterizerSceneHighEndRD *scene_singleton = (RasterizerSceneHighEndRD *)RasterizerSceneHighEndRD::singleton;
+RendererSceneRenderForward::ShaderData::~ShaderData() {
+	RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
 	ERR_FAIL_COND(!scene_singleton);
 	//pipeline variants will clear themselves if shader is gone
 	if (version.is_valid()) {
@@ -405,21 +408,21 @@ RasterizerSceneHighEndRD::ShaderData::~ShaderData() {
 	}
 }
 
-RasterizerStorageRD::ShaderData *RasterizerSceneHighEndRD::_create_shader_func() {
+RendererStorageRD::ShaderData *RendererSceneRenderForward::_create_shader_func() {
 	ShaderData *shader_data = memnew(ShaderData);
 	return shader_data;
 }
 
-void RasterizerSceneHighEndRD::MaterialData::set_render_priority(int p_priority) {
+void RendererSceneRenderForward::MaterialData::set_render_priority(int p_priority) {
 	priority = p_priority - RS::MATERIAL_RENDER_PRIORITY_MIN; //8 bits
 }
 
-void RasterizerSceneHighEndRD::MaterialData::set_next_pass(RID p_pass) {
+void RendererSceneRenderForward::MaterialData::set_next_pass(RID p_pass) {
 	next_pass = p_pass;
 }
 
-void RasterizerSceneHighEndRD::MaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
-	RasterizerSceneHighEndRD *scene_singleton = (RasterizerSceneHighEndRD *)RasterizerSceneHighEndRD::singleton;
+void RendererSceneRenderForward::MaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
+	RendererSceneRenderForward *scene_singleton = (RendererSceneRenderForward *)RendererSceneRenderForward::singleton;
 
 	if ((uint32_t)ubo_data.size() != shader_data->ubo_size) {
 		p_uniform_dirty = true;
@@ -479,7 +482,7 @@ void RasterizerSceneHighEndRD::MaterialData::update_parameters(const Map<StringN
 	{
 		if (shader_data->ubo_size) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(uniform_buffer);
 			uniforms.push_back(u);
@@ -488,7 +491,7 @@ void RasterizerSceneHighEndRD::MaterialData::update_parameters(const Map<StringN
 		const RID *textures = texture_cache.ptrw();
 		for (uint32_t i = 0; i < tex_uniform_count; i++) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1 + i;
 			u.ids.push_back(textures[i]);
 			uniforms.push_back(u);
@@ -498,7 +501,7 @@ void RasterizerSceneHighEndRD::MaterialData::update_parameters(const Map<StringN
 	uniform_set = RD::get_singleton()->uniform_set_create(uniforms, scene_singleton->shader.scene_shader.version_get_shader(shader_data->version, 0), MATERIAL_UNIFORM_SET);
 }
 
-RasterizerSceneHighEndRD::MaterialData::~MaterialData() {
+RendererSceneRenderForward::MaterialData::~MaterialData() {
 	if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
 		RD::get_singleton()->free(uniform_set);
 	}
@@ -508,7 +511,7 @@ RasterizerSceneHighEndRD::MaterialData::~MaterialData() {
 	}
 }
 
-RasterizerStorageRD::MaterialData *RasterizerSceneHighEndRD::_create_material_func(ShaderData *p_shader) {
+RendererStorageRD::MaterialData *RendererSceneRenderForward::_create_material_func(ShaderData *p_shader) {
 	MaterialData *material_data = memnew(MaterialData);
 	material_data->shader_data = p_shader;
 	material_data->last_frame = false;
@@ -516,11 +519,11 @@ RasterizerStorageRD::MaterialData *RasterizerSceneHighEndRD::_create_material_fu
 	return material_data;
 }
 
-RasterizerSceneHighEndRD::RenderBufferDataHighEnd::~RenderBufferDataHighEnd() {
+RendererSceneRenderForward::RenderBufferDataForward::~RenderBufferDataForward() {
 	clear();
 }
 
-void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::ensure_specular() {
+void RendererSceneRenderForward::RenderBufferDataForward::ensure_specular() {
 	if (!specular.is_valid()) {
 		RD::TextureFormat tf;
 		tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
@@ -574,7 +577,7 @@ void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::ensure_specular() {
 	}
 }
 
-void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::ensure_gi() {
+void RendererSceneRenderForward::RenderBufferDataForward::ensure_gi() {
 	if (!reflection_buffer.is_valid()) {
 		RD::TextureFormat tf;
 		tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
@@ -587,7 +590,7 @@ void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::ensure_gi() {
 	}
 }
 
-void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::ensure_giprobe() {
+void RendererSceneRenderForward::RenderBufferDataForward::ensure_giprobe() {
 	if (!giprobe_buffer.is_valid()) {
 		RD::TextureFormat tf;
 		tf.format = RD::DATA_FORMAT_R8G8_UINT;
@@ -623,7 +626,7 @@ void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::ensure_giprobe() {
 	}
 }
 
-void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::clear() {
+void RendererSceneRenderForward::RenderBufferDataForward::clear() {
 	if (ambient_buffer != RID() && ambient_buffer != color) {
 		RD::get_singleton()->free(ambient_buffer);
 		ambient_buffer = RID();
@@ -687,7 +690,7 @@ void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::clear() {
 	}
 }
 
-void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, RS::ViewportMSAA p_msaa) {
+void RendererSceneRenderForward::RenderBufferDataForward::configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, RS::ViewportMSAA p_msaa) {
 	clear();
 
 	msaa = p_msaa;
@@ -717,7 +720,7 @@ void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::configure(RID p_color_bu
 		tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
 		tf.width = p_width;
 		tf.height = p_height;
-		tf.type = RD::TEXTURE_TYPE_2D;
+		tf.texture_type = RD::TEXTURE_TYPE_2D;
 		tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
 
 		RD::TextureSamples ts[RS::VIEWPORT_MSAA_MAX] = {
@@ -754,7 +757,7 @@ void RasterizerSceneHighEndRD::RenderBufferDataHighEnd::configure(RID p_color_bu
 	}
 }
 
-void RasterizerSceneHighEndRD::_allocate_normal_roughness_texture(RenderBufferDataHighEnd *rb) {
+void RendererSceneRenderForward::_allocate_normal_roughness_texture(RenderBufferDataForward *rb) {
 	if (rb->normal_roughness_buffer.is_valid()) {
 		return;
 	}
@@ -792,18 +795,18 @@ void RasterizerSceneHighEndRD::_allocate_normal_roughness_texture(RenderBufferDa
 	_render_buffers_clear_uniform_set(rb);
 }
 
-RasterizerSceneRD::RenderBufferData *RasterizerSceneHighEndRD::_create_render_buffer_data() {
-	return memnew(RenderBufferDataHighEnd);
+RendererSceneRenderRD::RenderBufferData *RendererSceneRenderForward::_create_render_buffer_data() {
+	return memnew(RenderBufferDataForward);
 }
 
-bool RasterizerSceneHighEndRD::free(RID p_rid) {
-	if (RasterizerSceneRD::free(p_rid)) {
+bool RendererSceneRenderForward::free(RID p_rid) {
+	if (RendererSceneRenderRD::free(p_rid)) {
 		return true;
 	}
 	return false;
 }
 
-void RasterizerSceneHighEndRD::_fill_instances(RenderList::Element **p_elements, int p_element_count, bool p_for_depth, bool p_has_sdfgi, bool p_has_opaque_gi) {
+void RendererSceneRenderForward::_fill_instances(RenderList::Element **p_elements, int p_element_count, bool p_for_depth, bool p_has_sdfgi, bool p_has_opaque_gi) {
 	uint32_t lightmap_captures_used = 0;
 
 	for (int i = 0; i < p_element_count; i++) {
@@ -862,11 +865,11 @@ void RasterizerSceneHighEndRD::_fill_instances(RenderList::Element **p_elements,
 		}
 
 		if (store_transform) {
-			RasterizerStorageRD::store_transform(e->instance->transform, id.transform);
-			RasterizerStorageRD::store_transform(Transform(e->instance->transform.basis.inverse().transposed()), id.normal_transform);
+			RendererStorageRD::store_transform(e->instance->transform, id.transform);
+			RendererStorageRD::store_transform(Transform(e->instance->transform.basis.inverse().transposed()), id.normal_transform);
 		} else {
-			RasterizerStorageRD::store_transform(Transform(), id.transform);
-			RasterizerStorageRD::store_transform(Transform(), id.normal_transform);
+			RendererStorageRD::store_transform(Transform(), id.transform);
+			RendererStorageRD::store_transform(Transform(), id.normal_transform);
 		}
 
 		if (p_for_depth) {
@@ -911,7 +914,7 @@ void RasterizerSceneHighEndRD::_fill_instances(RenderList::Element **p_elements,
 				id.flags |= INSTANCE_DATA_FLAG_USE_GI_BUFFERS;
 			}
 
-			if (!e->instance->gi_probe_instances.empty()) {
+			if (!low_end && !e->instance->gi_probe_instances.empty()) {
 				uint32_t written = 0;
 				for (int j = 0; j < e->instance->gi_probe_instances.size(); j++) {
 					RID probe = e->instance->gi_probe_instances[j];
@@ -950,23 +953,13 @@ void RasterizerSceneHighEndRD::_fill_instances(RenderList::Element **p_elements,
 
 /// RENDERING ///
 
-void RasterizerSceneHighEndRD::_render_list(RenderingDevice::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_framebuffer_Format, RenderList::Element **p_elements, int p_element_count, bool p_reverse_cull, PassMode p_pass_mode, bool p_no_gi, RID p_radiance_uniform_set, RID p_render_buffers_uniform_set, bool p_force_wireframe, const Vector2 &p_uv_offset) {
+void RendererSceneRenderForward::_render_list(RenderingDevice::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_framebuffer_Format, RenderList::Element **p_elements, int p_element_count, bool p_reverse_cull, PassMode p_pass_mode, bool p_no_gi, RID p_render_pass_uniform_set, bool p_force_wireframe, const Vector2 &p_uv_offset, const Plane &p_lod_plane, float p_lod_distance_multiplier, float p_screen_lod_threshold) {
 	RD::DrawListID draw_list = p_draw_list;
 	RD::FramebufferFormatID framebuffer_format = p_framebuffer_Format;
 
 	//global scope bindings
 	RD::get_singleton()->draw_list_bind_uniform_set(draw_list, render_base_uniform_set, SCENE_UNIFORM_SET);
-	if (p_radiance_uniform_set.is_valid()) {
-		RD::get_singleton()->draw_list_bind_uniform_set(draw_list, p_radiance_uniform_set, RADIANCE_UNIFORM_SET);
-	} else {
-		RD::get_singleton()->draw_list_bind_uniform_set(draw_list, default_radiance_uniform_set, RADIANCE_UNIFORM_SET);
-	}
-	RD::get_singleton()->draw_list_bind_uniform_set(draw_list, view_dependant_uniform_set, VIEW_DEPENDANT_UNIFORM_SET);
-	if (p_render_buffers_uniform_set.is_valid()) {
-		RD::get_singleton()->draw_list_bind_uniform_set(draw_list, p_render_buffers_uniform_set, RENDER_BUFFERS_UNIFORM_SET);
-	} else {
-		RD::get_singleton()->draw_list_bind_uniform_set(draw_list, default_render_buffers_uniform_set, RENDER_BUFFERS_UNIFORM_SET);
-	}
+	RD::get_singleton()->draw_list_bind_uniform_set(draw_list, p_render_pass_uniform_set, RENDER_PASS_UNIFORM_SET);
 	RD::get_singleton()->draw_list_bind_uniform_set(draw_list, default_vec4_xform_uniform_set, TRANSFORMS_UNIFORM_SET);
 
 	MaterialData *prev_material = nullptr;
@@ -1003,10 +996,13 @@ void RasterizerSceneHighEndRD::_render_list(RenderingDevice::DrawListID p_draw_l
 
 		//find primitive and vertex format
 		RS::PrimitiveType primitive;
+		void *mesh_surface = nullptr;
 
 		switch (e->instance->base_type) {
 			case RS::INSTANCE_MESH: {
-				primitive = storage->mesh_surface_get_primitive(e->instance->base, e->surface_index);
+				mesh_surface = storage->mesh_get_surface(e->instance->base, e->surface_index);
+
+				primitive = storage->mesh_surface_get_primitive(mesh_surface);
 				if (e->instance->skeleton.is_valid()) {
 					xforms_uniform_set = storage->skeleton_get_3d_uniform_set(e->instance->skeleton, default_shader_rd, TRANSFORMS_UNIFORM_SET);
 				}
@@ -1014,7 +1010,10 @@ void RasterizerSceneHighEndRD::_render_list(RenderingDevice::DrawListID p_draw_l
 			case RS::INSTANCE_MULTIMESH: {
 				RID mesh = storage->multimesh_get_mesh(e->instance->base);
 				ERR_CONTINUE(!mesh.is_valid()); //should be a bug
-				primitive = storage->mesh_surface_get_primitive(mesh, e->surface_index);
+
+				mesh_surface = storage->mesh_get_surface(e->instance->base, e->surface_index);
+
+				primitive = storage->mesh_surface_get_primitive(mesh_surface);
 
 				xforms_uniform_set = storage->multimesh_get_3d_uniform_set(e->instance->base, default_shader_rd, TRANSFORMS_UNIFORM_SET);
 
@@ -1025,7 +1024,10 @@ void RasterizerSceneHighEndRD::_render_list(RenderingDevice::DrawListID p_draw_l
 			case RS::INSTANCE_PARTICLES: {
 				RID mesh = storage->particles_get_draw_pass_mesh(e->instance->base, e->surface_index >> 16);
 				ERR_CONTINUE(!mesh.is_valid()); //should be a bug
-				primitive = storage->mesh_surface_get_primitive(mesh, e->surface_index & 0xFFFF);
+
+				mesh_surface = storage->mesh_get_surface(e->instance->base, e->surface_index & 0xFFFF);
+
+				primitive = storage->mesh_surface_get_primitive(mesh_surface);
 
 				xforms_uniform_set = storage->particles_get_instance_buffer_uniform_set(e->instance->base, default_shader_rd, TRANSFORMS_UNIFORM_SET);
 
@@ -1076,7 +1078,7 @@ void RasterizerSceneHighEndRD::_render_list(RenderingDevice::DrawListID p_draw_l
 			} break;
 		}
 
-		RenderPipelineVertexFormatCacheRD *pipeline = nullptr;
+		PipelineCacheRD *pipeline = nullptr;
 
 		pipeline = &shader->pipelines[cull_variant][primitive][shader_version];
 
@@ -1084,25 +1086,39 @@ void RasterizerSceneHighEndRD::_render_list(RenderingDevice::DrawListID p_draw_l
 		RID vertex_array_rd;
 		RID index_array_rd;
 
-		switch (e->instance->base_type) {
-			case RS::INSTANCE_MESH: {
-				storage->mesh_surface_get_arrays_and_format(e->instance->base, e->surface_index, pipeline->get_vertex_input_mask(), vertex_array_rd, index_array_rd, vertex_format);
-			} break;
-			case RS::INSTANCE_MULTIMESH: {
-				RID mesh = storage->multimesh_get_mesh(e->instance->base);
-				ERR_CONTINUE(!mesh.is_valid()); //should be a bug
-				storage->mesh_surface_get_arrays_and_format(mesh, e->surface_index, pipeline->get_vertex_input_mask(), vertex_array_rd, index_array_rd, vertex_format);
-			} break;
-			case RS::INSTANCE_IMMEDIATE: {
-				ERR_CONTINUE(true); //should be a bug
-			} break;
-			case RS::INSTANCE_PARTICLES: {
-				RID mesh = storage->particles_get_draw_pass_mesh(e->instance->base, e->surface_index >> 16);
-				ERR_CONTINUE(!mesh.is_valid()); //should be a bug
-				storage->mesh_surface_get_arrays_and_format(mesh, e->surface_index & 0xFFFF, pipeline->get_vertex_input_mask(), vertex_array_rd, index_array_rd, vertex_format);
-			} break;
-			default: {
-				ERR_CONTINUE(true); //should be a bug
+		if (mesh_surface) {
+			if (e->instance->mesh_instance.is_valid()) { //skeleton and blend shape
+				storage->mesh_instance_surface_get_vertex_arrays_and_format(e->instance->mesh_instance, e->surface_index, pipeline->get_vertex_input_mask(), vertex_array_rd, vertex_format);
+			} else {
+				storage->mesh_surface_get_vertex_arrays_and_format(mesh_surface, pipeline->get_vertex_input_mask(), vertex_array_rd, vertex_format);
+			}
+
+			if (p_screen_lod_threshold > 0.0 && storage->mesh_surface_has_lod(mesh_surface)) {
+				Vector3 support_min = e->instance->transformed_aabb.get_support(-p_lod_plane.normal);
+				Vector3 support_max = e->instance->transformed_aabb.get_support(p_lod_plane.normal);
+
+				float distance_min = p_lod_plane.distance_to(support_min);
+				float distance_max = p_lod_plane.distance_to(support_max);
+
+				float distance = 0.0;
+
+				if (distance_min * distance_max < 0.0) {
+					//crossing plane
+					distance = 0.0;
+				} else if (distance_min >= 0.0) {
+					distance = distance_min;
+				} else if (distance_max <= 0.0) {
+					distance = -distance_max;
+				}
+
+				Vector3 model_scale_vec = e->instance->transform.basis.get_scale_abs();
+
+				float model_scale = MAX(model_scale_vec.x, MAX(model_scale_vec.y, model_scale_vec.z));
+
+				index_array_rd = storage->mesh_surface_get_index_array_with_lod(mesh_surface, model_scale * e->instance->lod_bias, distance * p_lod_distance_multiplier, p_screen_lod_threshold);
+
+			} else {
+				index_array_rd = storage->mesh_surface_get_index_array(mesh_surface);
 			}
 		}
 
@@ -1165,7 +1181,7 @@ void RasterizerSceneHighEndRD::_render_list(RenderingDevice::DrawListID p_draw_l
 	}
 }
 
-void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_render_buffers, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_reflection_probe, bool p_no_fog, const Size2 &p_screen_pixel_size, RID p_shadow_atlas, bool p_flip_y, const Color &p_default_bg_color, float p_znear, float p_zfar, bool p_opaque_render_buffers, bool p_pancake_shadows) {
+void RendererSceneRenderForward::_setup_environment(RID p_environment, RID p_render_buffers, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_reflection_probe, bool p_no_fog, const Size2 &p_screen_pixel_size, RID p_shadow_atlas, bool p_flip_y, const Color &p_default_bg_color, float p_znear, float p_zfar, bool p_opaque_render_buffers, bool p_pancake_shadows) {
 	//CameraMatrix projection = p_cam_projection;
 	//projection.flip_y(); // Vulkan and modern APIs use Y-Down
 	CameraMatrix correction;
@@ -1173,20 +1189,20 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_rende
 	CameraMatrix projection = correction * p_cam_projection;
 
 	//store camera into ubo
-	RasterizerStorageRD::store_camera(projection, scene_state.ubo.projection_matrix);
-	RasterizerStorageRD::store_camera(projection.inverse(), scene_state.ubo.inv_projection_matrix);
-	RasterizerStorageRD::store_transform(p_cam_transform, scene_state.ubo.camera_matrix);
-	RasterizerStorageRD::store_transform(p_cam_transform.affine_inverse(), scene_state.ubo.inv_camera_matrix);
+	RendererStorageRD::store_camera(projection, scene_state.ubo.projection_matrix);
+	RendererStorageRD::store_camera(projection.inverse(), scene_state.ubo.inv_projection_matrix);
+	RendererStorageRD::store_transform(p_cam_transform, scene_state.ubo.camera_matrix);
+	RendererStorageRD::store_transform(p_cam_transform.affine_inverse(), scene_state.ubo.inv_camera_matrix);
 
 	scene_state.ubo.z_far = p_zfar;
 	scene_state.ubo.z_near = p_znear;
 
 	scene_state.ubo.pancake_shadows = p_pancake_shadows;
 
-	RasterizerStorageRD::store_soft_shadow_kernel(directional_penumbra_shadow_kernel_get(), scene_state.ubo.directional_penumbra_shadow_kernel);
-	RasterizerStorageRD::store_soft_shadow_kernel(directional_soft_shadow_kernel_get(), scene_state.ubo.directional_soft_shadow_kernel);
-	RasterizerStorageRD::store_soft_shadow_kernel(penumbra_shadow_kernel_get(), scene_state.ubo.penumbra_shadow_kernel);
-	RasterizerStorageRD::store_soft_shadow_kernel(soft_shadow_kernel_get(), scene_state.ubo.soft_shadow_kernel);
+	RendererStorageRD::store_soft_shadow_kernel(directional_penumbra_shadow_kernel_get(), scene_state.ubo.directional_penumbra_shadow_kernel);
+	RendererStorageRD::store_soft_shadow_kernel(directional_soft_shadow_kernel_get(), scene_state.ubo.directional_soft_shadow_kernel);
+	RendererStorageRD::store_soft_shadow_kernel(penumbra_shadow_kernel_get(), scene_state.ubo.penumbra_shadow_kernel);
+	RendererStorageRD::store_soft_shadow_kernel(soft_shadow_kernel_get(), scene_state.ubo.soft_shadow_kernel);
 
 	scene_state.ubo.directional_penumbra_shadow_samples = directional_penumbra_shadow_samples_get();
 	scene_state.ubo.directional_soft_shadow_samples = directional_soft_shadow_samples_get();
@@ -1214,7 +1230,7 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_rende
 	scene_state.ubo.fog_enabled = false;
 
 	if (p_render_buffers.is_valid()) {
-		RenderBufferDataHighEnd *render_buffers = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffers);
+		RenderBufferDataForward *render_buffers = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
 		if (render_buffers->msaa != RS::VIEWPORT_MSAA_DISABLED) {
 			scene_state.ubo.gi_upscale_for_msaa = true;
 		}
@@ -1238,7 +1254,6 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_rende
 	}
 #if 0
 	if (p_render_buffers.is_valid() && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
-
 		scene_state.ubo.sdfgi_cascade_count = render_buffers_get_sdfgi_cascade_count(p_render_buffers);
 		scene_state.ubo.sdfgi_probe_axis_size = render_buffers_get_sdfgi_cascade_probe_count(p_render_buffers);
 		scene_state.ubo.sdfgi_cascade_probe_size[0] = scene_state.ubo.sdfgi_probe_axis_size - 1; //float version for performance
@@ -1331,7 +1346,7 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_rende
 
 			Basis sky_transform = environment_get_sky_orientation(p_environment);
 			sky_transform = sky_transform.inverse() * p_cam_transform.basis;
-			RasterizerStorageRD::store_transform_3x3(sky_transform, scene_state.ubo.radiance_inverse_xform);
+			RendererStorageRD::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;
 			scene_state.ubo.use_ambient_light = scene_state.ubo.use_ambient_cubemap || ambient_src == RS::ENV_AMBIENT_SOURCE_COLOR;
@@ -1398,7 +1413,7 @@ void RasterizerSceneHighEndRD::_setup_environment(RID p_environment, RID p_rende
 	RD::get_singleton()->buffer_update(scene_state.uniform_buffer, 0, sizeof(SceneState::UBO), &scene_state.ubo, true);
 }
 
-void RasterizerSceneHighEndRD::_add_geometry(InstanceBase *p_instance, uint32_t p_surface, RID p_material, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi) {
+void RendererSceneRenderForward::_add_geometry(InstanceBase *p_instance, uint32_t p_surface, RID p_material, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi) {
 	RID m_src;
 
 	m_src = p_instance->material_override.is_valid() ? p_instance->material_override : p_material;
@@ -1414,14 +1429,14 @@ void RasterizerSceneHighEndRD::_add_geometry(InstanceBase *p_instance, uint32_t
 	MaterialData *material = nullptr;
 
 	if (m_src.is_valid()) {
-		material = (MaterialData *)storage->material_get_data(m_src, RasterizerStorageRD::SHADER_TYPE_3D);
+		material = (MaterialData *)storage->material_get_data(m_src, RendererStorageRD::SHADER_TYPE_3D);
 		if (!material || !material->shader_data->valid) {
 			material = nullptr;
 		}
 	}
 
 	if (!material) {
-		material = (MaterialData *)storage->material_get_data(default_material, RasterizerStorageRD::SHADER_TYPE_3D);
+		material = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
 		m_src = default_material;
 	}
 
@@ -1430,7 +1445,7 @@ void RasterizerSceneHighEndRD::_add_geometry(InstanceBase *p_instance, uint32_t
 	_add_geometry_with_material(p_instance, p_surface, material, m_src, p_pass_mode, p_geometry_index, p_using_sdfgi);
 
 	while (material->next_pass.is_valid()) {
-		material = (MaterialData *)storage->material_get_data(material->next_pass, RasterizerStorageRD::SHADER_TYPE_3D);
+		material = (MaterialData *)storage->material_get_data(material->next_pass, RendererStorageRD::SHADER_TYPE_3D);
 		if (!material || !material->shader_data->valid) {
 			break;
 		}
@@ -1438,7 +1453,7 @@ void RasterizerSceneHighEndRD::_add_geometry(InstanceBase *p_instance, uint32_t
 	}
 }
 
-void RasterizerSceneHighEndRD::_add_geometry_with_material(InstanceBase *p_instance, uint32_t p_surface, MaterialData *p_material, RID p_material_rid, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi) {
+void RendererSceneRenderForward::_add_geometry_with_material(InstanceBase *p_instance, uint32_t p_surface, MaterialData *p_material, RID p_material_rid, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi) {
 	bool has_read_screen_alpha = p_material->shader_data->uses_screen_texture || p_material->shader_data->uses_depth_texture || p_material->shader_data->uses_normal_texture;
 	bool has_base_alpha = (p_material->shader_data->uses_alpha || has_read_screen_alpha);
 	bool has_blend_alpha = p_material->shader_data->uses_blend_alpha;
@@ -1469,9 +1484,9 @@ void RasterizerSceneHighEndRD::_add_geometry_with_material(InstanceBase *p_insta
 		if ((p_pass_mode != PASS_MODE_DEPTH_MATERIAL && p_pass_mode != PASS_MODE_SDF) && !p_material->shader_data->writes_modelview_or_projection && !p_material->shader_data->uses_vertex && !p_material->shader_data->uses_discard && !p_material->shader_data->uses_depth_pre_pass) {
 			//shader does not use discard and does not write a vertex position, use generic material
 			if (p_pass_mode == PASS_MODE_SHADOW || p_pass_mode == PASS_MODE_DEPTH) {
-				p_material = (MaterialData *)storage->material_get_data(default_material, RasterizerStorageRD::SHADER_TYPE_3D);
+				p_material = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
 			} else if ((p_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS || p_pass_mode == PASS_MODE_DEPTH_NORMAL_ROUGHNESS_GIPROBE) && !p_material->shader_data->uses_normal && !p_material->shader_data->uses_roughness) {
-				p_material = (MaterialData *)storage->material_get_data(default_material, RasterizerStorageRD::SHADER_TYPE_3D);
+				p_material = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
 			}
 		}
 
@@ -1494,7 +1509,7 @@ void RasterizerSceneHighEndRD::_add_geometry_with_material(InstanceBase *p_insta
 	if (e->material->last_pass != render_pass) {
 		if (!RD::get_singleton()->uniform_set_is_valid(e->material->uniform_set)) {
 			//uniform set no longer valid, probably a texture changed
-			storage->material_force_update_textures(p_material_rid, RasterizerStorageRD::SHADER_TYPE_3D);
+			storage->material_force_update_textures(p_material_rid, RendererStorageRD::SHADER_TYPE_3D);
 		}
 		e->material->last_pass = render_pass;
 		e->material->index = scene_state.current_material_index++;
@@ -1513,11 +1528,11 @@ void RasterizerSceneHighEndRD::_add_geometry_with_material(InstanceBase *p_insta
 	e->priority = p_material->priority;
 
 	if (p_material->shader_data->uses_time) {
-		RenderingServerRaster::redraw_request();
+		RenderingServerDefault::redraw_request();
 	}
 }
 
-void RasterizerSceneHighEndRD::_fill_render_list(InstanceBase **p_cull_result, int p_cull_count, PassMode p_pass_mode, bool p_using_sdfgi) {
+void RendererSceneRenderForward::_fill_render_list(InstanceBase **p_cull_result, int p_cull_count, PassMode p_pass_mode, bool p_using_sdfgi) {
 	scene_state.current_shader_index = 0;
 	scene_state.current_material_index = 0;
 	scene_state.used_sss = false;
@@ -1583,7 +1598,6 @@ void RasterizerSceneHighEndRD::_fill_render_list(InstanceBase **p_cull_result, i
 			} break;
 #if 0
 			case RS::INSTANCE_IMMEDIATE: {
-
 				RasterizerStorageGLES3::Immediate *immediate = storage->immediate_owner.getornull(inst->base);
 				ERR_CONTINUE(!immediate);
 
@@ -1621,7 +1635,7 @@ void RasterizerSceneHighEndRD::_fill_render_list(InstanceBase **p_cull_result, i
 	}
 }
 
-void RasterizerSceneHighEndRD::_setup_lightmaps(InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, const Transform &p_cam_transform) {
+void RendererSceneRenderForward::_setup_lightmaps(InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, const Transform &p_cam_transform) {
 	uint32_t lightmaps_used = 0;
 	for (int i = 0; i < p_lightmap_cull_count; i++) {
 		if (i >= (int)scene_state.max_lightmaps) {
@@ -1631,7 +1645,7 @@ void RasterizerSceneHighEndRD::_setup_lightmaps(InstanceBase **p_lightmap_cull_r
 		InstanceBase *lm = p_lightmap_cull_result[i];
 		Basis to_lm = lm->transform.basis.inverse() * p_cam_transform.basis;
 		to_lm = to_lm.inverse().transposed(); //will transform normals
-		RasterizerStorageRD::store_transform_3x3(to_lm, scene_state.lightmaps[i].normal_xform);
+		RendererStorageRD::store_transform_3x3(to_lm, scene_state.lightmaps[i].normal_xform);
 		lm->lightmap_cull_index = i;
 		lightmaps_used++;
 	}
@@ -1640,10 +1654,10 @@ void RasterizerSceneHighEndRD::_setup_lightmaps(InstanceBase **p_lightmap_cull_r
 	}
 }
 
-void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color) {
-	RenderBufferDataHighEnd *render_buffer = nullptr;
+void RendererSceneRenderForward::_render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color, float p_screen_lod_threshold) {
+	RenderBufferDataForward *render_buffer = nullptr;
 	if (p_render_buffer.is_valid()) {
-		render_buffer = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffer);
+		render_buffer = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffer);
 	}
 
 	//first of all, make a new render pass
@@ -1659,6 +1673,13 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 		scene_state.ubo.reflection_multiplier = 1.0;
 	}
 
+	float lod_distance_multiplier = p_cam_projection.get_lod_multiplier();
+	Plane lod_camera_plane(p_cam_transform.get_origin(), -p_cam_transform.basis.get_axis(Vector3::AXIS_Z));
+
+	if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_DISABLE_LOD) {
+		p_screen_lod_threshold = 0.0;
+	}
+
 	//scene_state.ubo.subsurface_scatter_width = subsurface_scatter_size;
 
 	Vector2 vp_he = p_cam_projection.get_viewport_half_extents();
@@ -1688,7 +1709,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 
 		opaque_framebuffer = render_buffer->color_fb;
 
-		if (p_gi_probe_cull_count > 0) {
+		if (!low_end && p_gi_probe_cull_count > 0) {
 			using_giprobe = true;
 			render_buffer->ensure_gi();
 		}
@@ -1763,7 +1784,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 	render_list.clear();
 	_fill_render_list(p_cull_result, p_cull_count, PASS_MODE_COLOR, using_sdfgi);
 
-	bool using_sss = render_buffer && scene_state.used_sss && sub_surface_scattering_get_quality() != RS::SUB_SURFACE_SCATTERING_QUALITY_DISABLED;
+	bool using_sss = !low_end && render_buffer && scene_state.used_sss && sub_surface_scattering_get_quality() != RS::SUB_SURFACE_SCATTERING_QUALITY_DISABLED;
 
 	if (using_sss) {
 		using_separate_specular = true;
@@ -1771,7 +1792,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 		using_separate_specular = true;
 		opaque_specular_framebuffer = render_buffer->color_specular_fb;
 	}
-	RID radiance_uniform_set;
+	RID radiance_texture;
 	bool draw_sky = false;
 	bool draw_sky_fog_only = false;
 
@@ -1833,7 +1854,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 			RID sky = environment_get_sky(p_environment);
 			if (sky.is_valid()) {
 				_update_sky(p_environment, projection, p_cam_transform);
-				radiance_uniform_set = sky_get_radiance_uniform_set_rd(sky, default_shader_rd, RADIANCE_UNIFORM_SET);
+				radiance_texture = sky_get_radiance_texture_rd(sky);
 			} else {
 				// do not try to draw sky if invalid
 				draw_sky = false;
@@ -1843,7 +1864,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 		clear_color = p_default_bg_color;
 	}
 
-	_setup_view_dependant_uniform_set(p_shadow_atlas, p_reflection_atlas, p_gi_probe_cull_result, p_gi_probe_cull_count);
+	RID rp_uniform_set = _setup_render_pass_uniform_set(p_render_buffer, radiance_texture, p_shadow_atlas, p_reflection_atlas, p_gi_probe_cull_result, p_gi_probe_cull_count);
 
 	render_list.sort_by_key(false);
 
@@ -1852,8 +1873,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 	bool debug_giprobes = get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_ALBEDO || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_LIGHTING || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_GI_PROBE_EMISSION;
 	bool debug_sdfgi_probes = get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_SDFGI_PROBES;
 
-	bool depth_pre_pass = depth_framebuffer.is_valid();
-	RID render_buffers_uniform_set;
+	bool depth_pre_pass = !low_end && depth_framebuffer.is_valid();
 
 	bool using_ssao = depth_pre_pass && p_render_buffer.is_valid() && p_environment.is_valid() && environment_is_ssao_enabled(p_environment);
 	bool continue_depth = false;
@@ -1862,7 +1882,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 
 		bool finish_depth = using_ssao || using_sdfgi || using_giprobe;
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(depth_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, finish_depth ? RD::FINAL_ACTION_READ : RD::FINAL_ACTION_CONTINUE, depth_pass_clear);
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(depth_framebuffer), render_list.elements, render_list.element_count, false, depth_pass_mode, render_buffer == nullptr, radiance_uniform_set, RID(), get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME);
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(depth_framebuffer), render_list.elements, render_list.element_count, false, depth_pass_mode, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, Vector2(), lod_camera_plane, lod_distance_multiplier, p_screen_lod_threshold);
 		RD::get_singleton()->draw_list_end();
 
 		if (render_buffer && render_buffer->msaa != RS::VIEWPORT_MSAA_DISABLED) {
@@ -1886,12 +1906,6 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 		_process_gi(p_render_buffer, render_buffer->normal_roughness_buffer, render_buffer->ambient_buffer, render_buffer->reflection_buffer, render_buffer->giprobe_buffer, p_environment, p_cam_projection, p_cam_transform, p_gi_probe_cull_result, p_gi_probe_cull_count);
 	}
 
-	if (p_render_buffer.is_valid()) {
-		//update the render buffers uniform set in case it changed
-		_update_render_buffers_uniform_set(p_render_buffer);
-		render_buffers_uniform_set = render_buffer->uniform_set;
-	}
-
 	_setup_environment(p_environment, p_render_buffer, p_cam_projection, p_cam_transform, p_reflection_probe, p_reflection_probe.is_valid(), screen_pixel_size, p_shadow_atlas, !p_reflection_probe.is_valid(), p_default_bg_color, p_cam_projection.get_z_near(), p_cam_projection.get_z_far(), p_render_buffer.is_valid());
 
 	RENDER_TIMESTAMP("Render Opaque Pass");
@@ -1916,7 +1930,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 
 		RID framebuffer = using_separate_specular ? opaque_specular_framebuffer : opaque_framebuffer;
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, keep_color ? RD::INITIAL_ACTION_KEEP : RD::INITIAL_ACTION_CLEAR, will_continue_color ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, depth_pre_pass ? (continue_depth ? RD::INITIAL_ACTION_KEEP : RD::INITIAL_ACTION_CONTINUE) : RD::INITIAL_ACTION_CLEAR, will_continue_depth ? RD::FINAL_ACTION_CONTINUE : RD::FINAL_ACTION_READ, c, 1.0, 0);
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(framebuffer), render_list.elements, render_list.element_count, false, using_separate_specular ? PASS_MODE_COLOR_SPECULAR : PASS_MODE_COLOR, render_buffer == nullptr, radiance_uniform_set, render_buffers_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME);
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(framebuffer), render_list.elements, render_list.element_count, false, using_separate_specular ? PASS_MODE_COLOR_SPECULAR : PASS_MODE_COLOR, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, Vector2(), lod_camera_plane, lod_distance_multiplier, p_screen_lod_threshold);
 		RD::get_singleton()->draw_list_end();
 
 		if (will_continue_color && using_separate_specular) {
@@ -2004,7 +2018,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 
 	{
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(alpha_framebuffer, can_continue_color ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, can_continue_depth ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ);
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(alpha_framebuffer), &render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, false, PASS_MODE_COLOR, render_buffer == nullptr, radiance_uniform_set, render_buffers_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME);
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(alpha_framebuffer), &render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, false, PASS_MODE_COLOR, render_buffer == nullptr, rp_uniform_set, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, Vector2(), lod_camera_plane, lod_distance_multiplier, p_screen_lod_threshold);
 		RD::get_singleton()->draw_list_end();
 	}
 
@@ -2013,7 +2027,7 @@ void RasterizerSceneHighEndRD::_render_scene(RID p_render_buffer, const Transfor
 	}
 }
 
-void RasterizerSceneHighEndRD::_render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake) {
+void RendererSceneRenderForward::_render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake, const Plane &p_camera_plane, float p_lod_distance_multiplier, float p_screen_lod_threshold) {
 	RENDER_TIMESTAMP("Setup Rendering Shadow");
 
 	_update_render_base_uniform_set();
@@ -2024,13 +2038,17 @@ void RasterizerSceneHighEndRD::_render_shadow(RID p_framebuffer, InstanceBase **
 
 	_setup_environment(RID(), RID(), p_projection, p_transform, RID(), true, Vector2(1, 1), RID(), true, Color(), 0, p_zfar, false, p_use_pancake);
 
+	if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_DISABLE_LOD) {
+		p_screen_lod_threshold = 0.0;
+	}
+
 	render_list.clear();
 
 	PassMode pass_mode = p_use_dp ? PASS_MODE_SHADOW_DP : PASS_MODE_SHADOW;
 
 	_fill_render_list(p_cull_result, p_cull_count, pass_mode);
 
-	_setup_view_dependant_uniform_set(RID(), RID(), nullptr, 0);
+	RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
 
 	RENDER_TIMESTAMP("Render Shadow");
 
@@ -2041,12 +2059,12 @@ void RasterizerSceneHighEndRD::_render_shadow(RID p_framebuffer, InstanceBase **
 	{
 		//regular forward for now
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ);
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, p_use_dp_flip, pass_mode, true, RID(), RID());
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, p_use_dp_flip, pass_mode, true, rp_uniform_set, false, Vector2(), p_camera_plane, p_lod_distance_multiplier, p_screen_lod_threshold);
 		RD::get_singleton()->draw_list_end();
 	}
 }
 
-void RasterizerSceneHighEndRD::_render_particle_collider_heightfield(RID p_fb, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, InstanceBase **p_cull_result, int p_cull_count) {
+void RendererSceneRenderForward::_render_particle_collider_heightfield(RID p_fb, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, InstanceBase **p_cull_result, int p_cull_count) {
 	RENDER_TIMESTAMP("Setup Render Collider Heightfield");
 
 	_update_render_base_uniform_set();
@@ -2063,7 +2081,7 @@ void RasterizerSceneHighEndRD::_render_particle_collider_heightfield(RID p_fb, c
 
 	_fill_render_list(p_cull_result, p_cull_count, pass_mode);
 
-	_setup_view_dependant_uniform_set(RID(), RID(), nullptr, 0);
+	RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
 
 	RENDER_TIMESTAMP("Render Collider Heightield");
 
@@ -2074,12 +2092,12 @@ void RasterizerSceneHighEndRD::_render_particle_collider_heightfield(RID p_fb, c
 	{
 		//regular forward for now
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_fb, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ);
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_fb), render_list.elements, render_list.element_count, false, pass_mode, true, RID(), RID());
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_fb), render_list.elements, render_list.element_count, false, pass_mode, true, rp_uniform_set);
 		RD::get_singleton()->draw_list_end();
 	}
 }
 
-void RasterizerSceneHighEndRD::_render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
+void RendererSceneRenderForward::_render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
 	RENDER_TIMESTAMP("Setup Rendering Material");
 
 	_update_render_base_uniform_set();
@@ -2096,7 +2114,7 @@ void RasterizerSceneHighEndRD::_render_material(const Transform &p_cam_transform
 	PassMode pass_mode = PASS_MODE_DEPTH_MATERIAL;
 	_fill_render_list(p_cull_result, p_cull_count, pass_mode);
 
-	_setup_view_dependant_uniform_set(RID(), RID(), nullptr, 0);
+	RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
 
 	RENDER_TIMESTAMP("Render Material");
 
@@ -2113,12 +2131,12 @@ void RasterizerSceneHighEndRD::_render_material(const Transform &p_cam_transform
 		clear.push_back(Color(0, 0, 0, 0));
 		clear.push_back(Color(0, 0, 0, 0));
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(p_framebuffer, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_CLEAR, RD::FINAL_ACTION_READ, clear, 1.0, 0, p_region);
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, RID(), RID());
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set);
 		RD::get_singleton()->draw_list_end();
 	}
 }
 
-void RasterizerSceneHighEndRD::_render_uv2(InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
+void RendererSceneRenderForward::_render_uv2(InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
 	RENDER_TIMESTAMP("Setup Rendering UV2");
 
 	_update_render_base_uniform_set();
@@ -2135,7 +2153,7 @@ void RasterizerSceneHighEndRD::_render_uv2(InstanceBase **p_cull_result, int p_c
 	PassMode pass_mode = PASS_MODE_DEPTH_MATERIAL;
 	_fill_render_list(p_cull_result, p_cull_count, pass_mode);
 
-	_setup_view_dependant_uniform_set(RID(), RID(), nullptr, 0);
+	RID rp_uniform_set = _setup_render_pass_uniform_set(RID(), RID(), RID(), RID(), nullptr, 0);
 
 	RENDER_TIMESTAMP("Render Material");
 
@@ -2171,20 +2189,20 @@ void RasterizerSceneHighEndRD::_render_uv2(InstanceBase **p_cull_result, int p_c
 			Vector2 ofs = uv_offsets[i];
 			ofs.x /= p_region.size.width;
 			ofs.y /= p_region.size.height;
-			_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, RID(), RID(), true, ofs); //first wireframe, for pseudo conservative
+			_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set, true, ofs); //first wireframe, for pseudo conservative
 		}
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, RID(), RID(), false); //second regular triangles
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(p_framebuffer), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set, false); //second regular triangles
 
 		RD::get_singleton()->draw_list_end();
 	}
 }
 
-void RasterizerSceneHighEndRD::_render_sdfgi(RID p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, InstanceBase **p_cull_result, int p_cull_count, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture) {
+void RendererSceneRenderForward::_render_sdfgi(RID p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, InstanceBase **p_cull_result, int p_cull_count, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture) {
 	RENDER_TIMESTAMP("Render SDFGI");
 
 	_update_render_base_uniform_set();
 
-	RenderBufferDataHighEnd *render_buffer = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffers);
+	RenderBufferDataForward *render_buffer = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
 	ERR_FAIL_COND(!render_buffer);
 
 	render_pass++;
@@ -2195,45 +2213,11 @@ void RasterizerSceneHighEndRD::_render_sdfgi(RID p_render_buffers, const Vector3
 	render_list.sort_by_key(false);
 	_fill_instances(render_list.elements, render_list.element_count, true);
 
-	_setup_view_dependant_uniform_set(RID(), RID(), nullptr, 0);
+	RID rp_uniform_set = _setup_sdfgi_render_pass_uniform_set(p_albedo_texture, p_emission_texture, p_emission_aniso_texture, p_geom_facing_texture);
 
 	Vector3 half_extents = p_bounds.size * 0.5;
 	Vector3 center = p_bounds.position + half_extents;
 
-	if (render_buffer->render_sdfgi_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(render_buffer->render_sdfgi_uniform_set)) {
-		Vector<RD::Uniform> uniforms;
-		{
-			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
-			u.binding = 0;
-			u.ids.push_back(p_albedo_texture);
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
-			u.binding = 1;
-			u.ids.push_back(p_emission_texture);
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
-			u.binding = 2;
-			u.ids.push_back(p_emission_aniso_texture);
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
-			u.binding = 3;
-			u.ids.push_back(p_geom_facing_texture);
-			uniforms.push_back(u);
-		}
-
-		render_buffer->render_sdfgi_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_sdfgi_rd, RENDER_BUFFERS_UNIFORM_SET);
-	}
-
 	Vector<RID> sbs;
 	sbs.push_back(p_albedo_texture);
 	sbs.push_back(p_emission_texture);
@@ -2278,7 +2262,7 @@ void RasterizerSceneHighEndRD::_render_sdfgi(RID p_render_buffers, const Vector3
 		to_bounds.origin = p_bounds.position;
 		to_bounds.basis.scale(p_bounds.size);
 
-		RasterizerStorageRD::store_transform(to_bounds.affine_inverse() * cam_xform, scene_state.ubo.sdf_to_bounds);
+		RendererStorageRD::store_transform(to_bounds.affine_inverse() * cam_xform, scene_state.ubo.sdf_to_bounds);
 
 		_setup_environment(RID(), RID(), camera_proj, cam_xform, RID(), true, Vector2(1, 1), RID(), false, Color(), 0, 0);
 
@@ -2289,19 +2273,19 @@ void RasterizerSceneHighEndRD::_render_sdfgi(RID p_render_buffers, const Vector3
 		}
 
 		RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(E->get(), RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, RD::INITIAL_ACTION_DROP, RD::FINAL_ACTION_DISCARD, Vector<Color>(), 1.0, 0, Rect2(), sbs);
-		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(E->get()), render_list.elements, render_list.element_count, true, pass_mode, true, RID(), render_buffer->render_sdfgi_uniform_set, false); //second regular triangles
+		_render_list(draw_list, RD::get_singleton()->framebuffer_get_format(E->get()), render_list.elements, render_list.element_count, true, pass_mode, true, rp_uniform_set, false); //second regular triangles
 		RD::get_singleton()->draw_list_end();
 	}
 }
 
-void RasterizerSceneHighEndRD::_base_uniforms_changed() {
+void RendererSceneRenderForward::_base_uniforms_changed() {
 	if (!render_base_uniform_set.is_null() && RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set)) {
 		RD::get_singleton()->free(render_base_uniform_set);
 	}
 	render_base_uniform_set = RID();
 }
 
-void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
+void RendererSceneRenderForward::_update_render_base_uniform_set() {
 	if (render_base_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set) || (lightmap_texture_array_version != storage->lightmap_array_get_version())) {
 		if (render_base_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(render_base_uniform_set)) {
 			RD::get_singleton()->free(render_base_uniform_set);
@@ -2313,7 +2297,7 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 1;
 			u.ids.resize(12);
 			RID *ids_ptr = u.ids.ptrw();
@@ -2335,7 +2319,7 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 2;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.ids.push_back(shadow_sampler);
 			uniforms.push_back(u);
 		}
@@ -2343,14 +2327,14 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 3;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.ids.push_back(scene_state.uniform_buffer);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 4;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.ids.push_back(scene_state.instance_buffer);
 			uniforms.push_back(u);
 		}
@@ -2358,7 +2342,7 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 5;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.ids.push_back(get_positional_light_buffer());
 			uniforms.push_back(u);
 		}
@@ -2366,42 +2350,42 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 6;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.ids.push_back(get_reflection_probe_buffer());
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 7;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.ids.push_back(get_directional_light_buffer());
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 10;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.ids.push_back(scene_state.lightmap_buffer);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 11;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.ids = storage->lightmap_array_get_textures();
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 12;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.ids.push_back(scene_state.lightmap_capture_buffer);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 13;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			RID decal_atlas = storage->decal_atlas_get_texture();
 			u.ids.push_back(decal_atlas);
 			uniforms.push_back(u);
@@ -2409,7 +2393,7 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 14;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			RID decal_atlas = storage->decal_atlas_get_texture_srgb();
 			u.ids.push_back(decal_atlas);
 			uniforms.push_back(u);
@@ -2417,7 +2401,7 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 15;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.ids.push_back(get_decal_buffer());
 			uniforms.push_back(u);
 		}
@@ -2425,14 +2409,14 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 16;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.ids.push_back(get_cluster_builder_texture());
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 17;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.ids.push_back(get_cluster_builder_indices_buffer());
 			uniforms.push_back(u);
 		}
@@ -2440,26 +2424,26 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 		{
 			RD::Uniform u;
 			u.binding = 18;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			if (directional_shadow_get_texture().is_valid()) {
 				u.ids.push_back(directional_shadow_get_texture());
 			} else {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE));
 			}
 			uniforms.push_back(u);
 		}
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 19;
 			u.ids.push_back(storage->global_variables_get_storage_buffer());
 			uniforms.push_back(u);
 		}
 
-		{
+		if (!low_end) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 20;
 			u.ids.push_back(sdfgi_get_ubo());
 			uniforms.push_back(u);
@@ -2469,9 +2453,14 @@ void RasterizerSceneHighEndRD::_update_render_base_uniform_set() {
 	}
 }
 
-void RasterizerSceneHighEndRD::_setup_view_dependant_uniform_set(RID p_shadow_atlas, RID p_reflection_atlas, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count) {
-	if (view_dependant_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(view_dependant_uniform_set)) {
-		RD::get_singleton()->free(view_dependant_uniform_set);
+RID RendererSceneRenderForward::_setup_render_pass_uniform_set(RID p_render_buffers, RID p_radiance_texture, RID p_shadow_atlas, RID p_reflection_atlas, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count) {
+	if (render_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(render_pass_uniform_set)) {
+		RD::get_singleton()->free(render_pass_uniform_set);
+	}
+
+	RenderBufferDataForward *rb = nullptr;
+	if (p_render_buffers.is_valid()) {
+		rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
 	}
 
 	//default render buffer and scene state uniform set
@@ -2479,28 +2468,42 @@ void RasterizerSceneHighEndRD::_setup_view_dependant_uniform_set(RID p_shadow_at
 	Vector<RD::Uniform> uniforms;
 
 	{
-		RID ref_texture = p_reflection_atlas.is_valid() ? reflection_atlas_get_texture(p_reflection_atlas) : RID();
+		RID radiance_texture;
+		if (p_radiance_texture.is_valid()) {
+			radiance_texture = p_radiance_texture;
+		} else {
+			radiance_texture = storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
+		}
 		RD::Uniform u;
 		u.binding = 0;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		u.ids.push_back(radiance_texture);
+		uniforms.push_back(u);
+	}
+
+	{
+		RID ref_texture = p_reflection_atlas.is_valid() ? reflection_atlas_get_texture(p_reflection_atlas) : RID();
+		RD::Uniform u;
+		u.binding = 1;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		if (ref_texture.is_valid()) {
 			u.ids.push_back(ref_texture);
 		} else {
-			u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK));
+			u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK));
 		}
 		uniforms.push_back(u);
 	}
 
 	{
 		RD::Uniform u;
-		u.binding = 1;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.binding = 2;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		RID texture;
 		if (p_shadow_atlas.is_valid()) {
 			texture = shadow_atlas_get_texture(p_shadow_atlas);
 		}
 		if (!texture.is_valid()) {
-			texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE);
+			texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
 		}
 		u.ids.push_back(texture);
 		uniforms.push_back(u);
@@ -2508,182 +2511,265 @@ void RasterizerSceneHighEndRD::_setup_view_dependant_uniform_set(RID p_shadow_at
 
 	{
 		RD::Uniform u;
-		u.binding = 2;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
-		RID default_tex = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+		u.binding = 3;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		u.ids.resize(MAX_GI_PROBES);
+		RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
 		for (int i = 0; i < MAX_GI_PROBES; i++) {
 			if (i < p_gi_probe_cull_count) {
 				RID tex = gi_probe_instance_get_texture(p_gi_probe_cull_result[i]);
 				if (!tex.is_valid()) {
 					tex = default_tex;
 				}
-				u.ids.push_back(tex);
+				u.ids.write[i] = tex;
 			} else {
-				u.ids.push_back(default_tex);
+				u.ids.write[i] = default_tex;
 			}
 		}
 
 		uniforms.push_back(u);
 	}
-	view_dependant_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, VIEW_DEPENDANT_UNIFORM_SET);
-}
 
-void RasterizerSceneHighEndRD::_render_buffers_clear_uniform_set(RenderBufferDataHighEnd *rb) {
-	if (!rb->uniform_set.is_null() && RD::get_singleton()->uniform_set_is_valid(rb->uniform_set)) {
-		RD::get_singleton()->free(rb->uniform_set);
+	{
+		RD::Uniform u;
+		u.binding = 4;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		RID texture = (false && rb && rb->depth.is_valid()) ? rb->depth : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
+		u.ids.push_back(texture);
+		uniforms.push_back(u);
 	}
-	rb->uniform_set = RID();
-}
-
-void RasterizerSceneHighEndRD::_render_buffers_uniform_set_changed(RID p_render_buffers) {
-	RenderBufferDataHighEnd *rb = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffers);
-
-	_render_buffers_clear_uniform_set(rb);
-}
-
-RID RasterizerSceneHighEndRD::_render_buffers_get_normal_texture(RID p_render_buffers) {
-	RenderBufferDataHighEnd *rb = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffers);
-
-	return rb->normal_roughness_buffer;
-}
-
-RID RasterizerSceneHighEndRD::_render_buffers_get_ambient_texture(RID p_render_buffers) {
-	RenderBufferDataHighEnd *rb = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffers);
-
-	return rb->ambient_buffer;
-}
-
-RID RasterizerSceneHighEndRD::_render_buffers_get_reflection_texture(RID p_render_buffers) {
-	RenderBufferDataHighEnd *rb = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffers);
-
-	return rb->reflection_buffer;
-}
-
-void RasterizerSceneHighEndRD::_update_render_buffers_uniform_set(RID p_render_buffers) {
-	RenderBufferDataHighEnd *rb = (RenderBufferDataHighEnd *)render_buffers_get_data(p_render_buffers);
-
-	if (rb->uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(rb->uniform_set)) {
-		Vector<RD::Uniform> uniforms;
-		{
-			RD::Uniform u;
-			u.binding = 0;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID texture = false && rb->depth.is_valid() ? rb->depth : storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE);
-			u.ids.push_back(texture);
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.binding = 1;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID bbt = render_buffers_get_back_buffer_texture(p_render_buffers);
-			RID texture = bbt.is_valid() ? bbt : storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK);
-			u.ids.push_back(texture);
-			uniforms.push_back(u);
-		}
+	{
+		RD::Uniform u;
+		u.binding = 5;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		RID bbt = rb ? render_buffers_get_back_buffer_texture(p_render_buffers) : RID();
+		RID texture = bbt.is_valid() ? bbt : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
+		u.ids.push_back(texture);
+		uniforms.push_back(u);
+	}
+	if (!low_end) {
 		{
 			RD::Uniform u;
-			u.binding = 2;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID texture = rb->normal_roughness_buffer.is_valid() ? rb->normal_roughness_buffer : storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_NORMAL);
+			u.binding = 6;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+			RID texture = rb && rb->normal_roughness_buffer.is_valid() ? rb->normal_roughness_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_NORMAL);
 			u.ids.push_back(texture);
 			uniforms.push_back(u);
 		}
 
 		{
 			RD::Uniform u;
-			u.binding = 4;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID aot = render_buffers_get_ao_texture(p_render_buffers);
-			RID texture = aot.is_valid() ? aot : storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK);
+			u.binding = 7;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+			RID aot = rb ? render_buffers_get_ao_texture(p_render_buffers) : RID();
+			RID texture = aot.is_valid() ? aot : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
 			u.ids.push_back(texture);
 			uniforms.push_back(u);
 		}
 
 		{
 			RD::Uniform u;
-			u.binding = 5;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID texture = rb->ambient_buffer.is_valid() ? rb->ambient_buffer : storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK);
+			u.binding = 8;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+			RID texture = rb && rb->ambient_buffer.is_valid() ? rb->ambient_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
 			u.ids.push_back(texture);
 			uniforms.push_back(u);
 		}
 
 		{
 			RD::Uniform u;
-			u.binding = 6;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID texture = rb->reflection_buffer.is_valid() ? rb->reflection_buffer : storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK);
+			u.binding = 9;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+			RID texture = rb && rb->reflection_buffer.is_valid() ? rb->reflection_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
 			u.ids.push_back(texture);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.binding = 7;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.binding = 10;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			RID t;
-			if (render_buffers_is_sdfgi_enabled(p_render_buffers)) {
+			if (rb && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
 				t = render_buffers_get_sdfgi_irradiance_probes(p_render_buffers);
 			} else {
-				t = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE);
+				t = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE);
 			}
 			u.ids.push_back(t);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.binding = 8;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			if (render_buffers_is_sdfgi_enabled(p_render_buffers)) {
+			u.binding = 11;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+			if (rb && render_buffers_is_sdfgi_enabled(p_render_buffers)) {
 				u.ids.push_back(render_buffers_get_sdfgi_occlusion_texture(p_render_buffers));
 			} else {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 			}
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.binding = 9;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
-			u.ids.push_back(render_buffers_get_gi_probe_buffer(p_render_buffers));
+			u.binding = 12;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.ids.push_back(rb ? render_buffers_get_gi_probe_buffer(p_render_buffers) : render_buffers_get_default_gi_probe_buffer());
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.binding = 10;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.binding = 13;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			RID vfog = RID();
-			if (p_render_buffers.is_valid() && render_buffers_has_volumetric_fog(p_render_buffers)) {
+			if (rb && render_buffers_has_volumetric_fog(p_render_buffers)) {
 				vfog = render_buffers_get_volumetric_fog_texture(p_render_buffers);
 				if (vfog.is_null()) {
-					vfog = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+					vfog = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
 				}
 			} else {
-				vfog = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+				vfog = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
 			}
 			u.ids.push_back(vfog);
 			uniforms.push_back(u);
 		}
-		rb->uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RENDER_BUFFERS_UNIFORM_SET);
 	}
+
+	render_pass_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RENDER_PASS_UNIFORM_SET);
+	return render_pass_uniform_set;
 }
 
-RasterizerSceneHighEndRD *RasterizerSceneHighEndRD::singleton = nullptr;
+RID RendererSceneRenderForward::_setup_sdfgi_render_pass_uniform_set(RID p_albedo_texture, RID p_emission_texture, RID p_emission_aniso_texture, RID p_geom_facing_texture) {
+	if (sdfgi_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sdfgi_pass_uniform_set)) {
+		RD::get_singleton()->free(sdfgi_pass_uniform_set);
+	}
+
+	Vector<RD::Uniform> uniforms;
+
+	{
+		// No radiance texture.
+		RID radiance_texture = storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
+		RD::Uniform u;
+		u.binding = 0;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		u.ids.push_back(radiance_texture);
+		uniforms.push_back(u);
+	}
+
+	{
+		// No reflection atlas.
+		RID ref_texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK);
+		RD::Uniform u;
+		u.binding = 1;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		u.ids.push_back(ref_texture);
+		uniforms.push_back(u);
+	}
+
+	{
+		// No shadow atlas.
+		RD::Uniform u;
+		u.binding = 2;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		RID texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
+		u.ids.push_back(texture);
+		uniforms.push_back(u);
+	}
+
+	{
+		// No GIProbes
+		RD::Uniform u;
+		u.binding = 3;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+		u.ids.resize(MAX_GI_PROBES);
+		RID default_tex = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+		for (int i = 0; i < MAX_GI_PROBES; i++) {
+			u.ids.write[i] = default_tex;
+		}
+
+		uniforms.push_back(u);
+	}
+	// actual sdfgi stuff
+
+	{
+		RD::Uniform u;
+		u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+		u.binding = 4;
+		u.ids.push_back(p_albedo_texture);
+		uniforms.push_back(u);
+	}
+	{
+		RD::Uniform u;
+		u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+		u.binding = 5;
+		u.ids.push_back(p_emission_texture);
+		uniforms.push_back(u);
+	}
+	{
+		RD::Uniform u;
+		u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+		u.binding = 6;
+		u.ids.push_back(p_emission_aniso_texture);
+		uniforms.push_back(u);
+	}
+	{
+		RD::Uniform u;
+		u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+		u.binding = 7;
+		u.ids.push_back(p_geom_facing_texture);
+		uniforms.push_back(u);
+	}
+
+	sdfgi_pass_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_sdfgi_rd, RENDER_PASS_UNIFORM_SET);
+	return sdfgi_pass_uniform_set;
+}
 
-void RasterizerSceneHighEndRD::set_time(double p_time, double p_step) {
+void RendererSceneRenderForward::_render_buffers_clear_uniform_set(RenderBufferDataForward *rb) {
+}
+
+void RendererSceneRenderForward::_render_buffers_uniform_set_changed(RID p_render_buffers) {
+	RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
+
+	_render_buffers_clear_uniform_set(rb);
+}
+
+RID RendererSceneRenderForward::_render_buffers_get_normal_texture(RID p_render_buffers) {
+	RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
+
+	return rb->normal_roughness_buffer;
+}
+
+RID RendererSceneRenderForward::_render_buffers_get_ambient_texture(RID p_render_buffers) {
+	RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
+
+	return rb->ambient_buffer;
+}
+
+RID RendererSceneRenderForward::_render_buffers_get_reflection_texture(RID p_render_buffers) {
+	RenderBufferDataForward *rb = (RenderBufferDataForward *)render_buffers_get_data(p_render_buffers);
+
+	return rb->reflection_buffer;
+}
+
+RendererSceneRenderForward *RendererSceneRenderForward::singleton = nullptr;
+
+void RendererSceneRenderForward::set_time(double p_time, double p_step) {
 	time = p_time;
-	RasterizerSceneRD::set_time(p_time, p_step);
+	RendererSceneRenderRD::set_time(p_time, p_step);
 }
 
-RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storage) :
-		RasterizerSceneRD(p_storage) {
+RendererSceneRenderForward::RendererSceneRenderForward(RendererStorageRD *p_storage) :
+		RendererSceneRenderRD(p_storage) {
 	singleton = this;
+	low_end = is_low_end();
 	storage = p_storage;
 
 	/* SCENE SHADER */
 
 	{
 		String defines;
+		if (low_end) {
+			defines += "\n#define LOW_END_MODE \n";
+		}
+
 		defines += "\n#define MAX_ROUGHNESS_LOD " + itos(get_roughness_layers() - 1) + ".0\n";
 		if (is_using_radiance_cubemap_array()) {
 			defines += "\n#define USE_RADIANCE_CUBEMAP_ARRAY \n";
@@ -2723,10 +2809,20 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		shader_versions.push_back("\n#define USE_LIGHTMAP\n");
 		shader_versions.push_back("\n#define MODE_MULTIPLE_RENDER_TARGETS\n#define USE_LIGHTMAP\n");
 		shader.scene_shader.initialize(shader_versions, defines);
+
+		if (is_low_end()) {
+			//disable the high end versions
+			shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS, false);
+			shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_NORMAL_AND_ROUGHNESS_AND_GIPROBE, false);
+			shader.scene_shader.set_variant_enabled(SHADER_VERSION_DEPTH_PASS_WITH_SDF, false);
+			shader.scene_shader.set_variant_enabled(SHADER_VERSION_COLOR_PASS_WITH_FORWARD_GI, false);
+			shader.scene_shader.set_variant_enabled(SHADER_VERSION_COLOR_PASS_WITH_SEPARATE_SPECULAR, false);
+			shader.scene_shader.set_variant_enabled(SHADER_VERSION_LIGHTMAP_COLOR_PASS_WITH_SEPARATE_SPECULAR, false);
+		}
 	}
 
-	storage->shader_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_3D, _create_shader_funcs);
-	storage->material_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_3D, _create_material_funcs);
+	storage->shader_set_data_request_function(RendererStorageRD::SHADER_TYPE_3D, _create_shader_funcs);
+	storage->material_set_data_request_function(RendererStorageRD::SHADER_TYPE_3D, _create_material_funcs);
 
 	{
 		//shader compiler
@@ -2797,6 +2893,12 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		actions.renames["FOG"] = "custom_fog";
 		actions.renames["RADIANCE"] = "custom_radiance";
 		actions.renames["IRRADIANCE"] = "custom_irradiance";
+		actions.renames["BONE_INDICES"] = "bone_attrib";
+		actions.renames["BONE_WEIGHTS"] = "weight_attrib";
+		actions.renames["CUSTOM0"] = "custom0_attrib";
+		actions.renames["CUSTOM1"] = "custom1_attrib";
+		actions.renames["CUSTOM2"] = "custom2_attrib";
+		actions.renames["CUSTOM3"] = "custom3_attrib";
 
 		//for light
 		actions.renames["VIEW"] = "view";
@@ -2807,6 +2909,7 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		actions.renames["DIFFUSE_LIGHT"] = "diffuse_light";
 		actions.renames["SPECULAR_LIGHT"] = "specular_light";
 
+		actions.usage_defines["NORMAL"] = "#define NORMAL_USED\n";
 		actions.usage_defines["TANGENT"] = "#define TANGENT_USED\n";
 		actions.usage_defines["BINORMAL"] = "@TANGENT";
 		actions.usage_defines["RIM"] = "#define LIGHT_RIM_USED\n";
@@ -2819,6 +2922,12 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		actions.usage_defines["AO_LIGHT_AFFECT"] = "#define AO_USED\n";
 		actions.usage_defines["UV"] = "#define UV_USED\n";
 		actions.usage_defines["UV2"] = "#define UV2_USED\n";
+		actions.usage_defines["BONE_INDICES"] = "#define BONES_USED\n";
+		actions.usage_defines["BONE_WEIGHTS"] = "#define WEIGHTS_USED\n";
+		actions.usage_defines["CUSTOM0"] = "#define CUSTOM0\n";
+		actions.usage_defines["CUSTOM1"] = "#define CUSTOM1\n";
+		actions.usage_defines["CUSTOM2"] = "#define CUSTOM2\n";
+		actions.usage_defines["CUSTOM3"] = "#define CUSTOM3\n";
 		actions.usage_defines["NORMALMAP"] = "#define NORMALMAP_USED\n";
 		actions.usage_defines["NORMALMAP_DEPTH"] = "@NORMALMAP";
 		actions.usage_defines["COLOR"] = "#define COLOR_USED\n";
@@ -2912,9 +3021,11 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		default_material = storage->material_create();
 		storage->material_set_shader(default_material, default_shader);
 
-		MaterialData *md = (MaterialData *)storage->material_get_data(default_material, RasterizerStorageRD::SHADER_TYPE_3D);
+		MaterialData *md = (MaterialData *)storage->material_get_data(default_material, RendererStorageRD::SHADER_TYPE_3D);
 		default_shader_rd = shader.scene_shader.version_get_shader(md->shader_data->version, SHADER_VERSION_COLOR_PASS);
-		default_shader_sdfgi_rd = shader.scene_shader.version_get_shader(md->shader_data->version, SHADER_VERSION_DEPTH_PASS_WITH_SDF);
+		if (!low_end) {
+			default_shader_sdfgi_rd = shader.scene_shader.version_get_shader(md->shader_data->version, SHADER_VERSION_DEPTH_PASS_WITH_SDF);
+		}
 	}
 
 	{
@@ -2933,7 +3044,7 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		default_vec4_xform_buffer = RD::get_singleton()->storage_buffer_create(256);
 		Vector<RD::Uniform> uniforms;
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+		u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 		u.ids.push_back(default_vec4_xform_buffer);
 		u.binding = 0;
 		uniforms.push_back(u);
@@ -2948,74 +3059,20 @@ RasterizerSceneHighEndRD::RasterizerSceneHighEndRD(RasterizerStorageRD *p_storag
 		sampler.compare_op = RD::COMPARE_OP_LESS;
 		shadow_sampler = RD::get_singleton()->sampler_create(sampler);
 	}
-
-	{
-		Vector<RD::Uniform> uniforms;
-
-		RD::Uniform u;
-		u.binding = 0;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
-		RID texture = storage->texture_rd_get_default(is_using_radiance_cubemap_array() ? RasterizerStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK : RasterizerStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK);
-		u.ids.push_back(texture);
-		uniforms.push_back(u);
-
-		default_radiance_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RADIANCE_UNIFORM_SET);
-	}
-
-	{ //render buffers
-		Vector<RD::Uniform> uniforms;
-		for (int i = 0; i < 7; i++) {
-			RD::Uniform u;
-			u.binding = i;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID texture = storage->texture_rd_get_default(i == 0 ? RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE : (i == 2 ? RasterizerStorageRD::DEFAULT_RD_TEXTURE_NORMAL : RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK));
-			u.ids.push_back(texture);
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.binding = 7;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE);
-			u.ids.push_back(texture);
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.binding = 8;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.binding = 9;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
-			u.ids.push_back(render_buffers_get_default_gi_probe_buffer());
-			uniforms.push_back(u);
-		}
-		{
-			RD::Uniform u;
-			u.binding = 10;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
-			uniforms.push_back(u);
-		}
-
-		default_render_buffers_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, default_shader_rd, RENDER_BUFFERS_UNIFORM_SET);
-	}
 }
 
-RasterizerSceneHighEndRD::~RasterizerSceneHighEndRD() {
+RendererSceneRenderForward::~RendererSceneRenderForward() {
 	directional_shadow_atlas_set_size(0);
 
 	//clear base uniform set if still valid
-	if (view_dependant_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(view_dependant_uniform_set)) {
-		RD::get_singleton()->free(view_dependant_uniform_set);
+	if (render_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(render_pass_uniform_set)) {
+		RD::get_singleton()->free(render_pass_uniform_set);
+	}
+
+	if (sdfgi_pass_uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sdfgi_pass_uniform_set)) {
+		RD::get_singleton()->free(sdfgi_pass_uniform_set);
 	}
 
-	RD::get_singleton()->free(default_render_buffers_uniform_set);
-	RD::get_singleton()->free(default_radiance_uniform_set);
 	RD::get_singleton()->free(default_vec4_xform_buffer);
 	RD::get_singleton()->free(shadow_sampler);
 
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h b/servers/rendering/renderer_rd/renderer_scene_render_forward.h
index db083a75cc..94284e509c 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_high_end_rd.h
+++ b/servers/rendering/renderer_rd/renderer_scene_render_forward.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_scene_high_end_rd.h                                       */
+/*  renderer_scene_render_forward.h                                      */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,22 +28,20 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RASTERIZER_SCENE_HIGHEND_RD_H
-#define RASTERIZER_SCENE_HIGHEND_RD_H
+#ifndef RENDERING_SERVER_SCENE_RENDER_FORWARD_H
+#define RENDERING_SERVER_SCENE_RENDER_FORWARD_H
 
-#include "servers/rendering/rasterizer_rd/rasterizer_scene_rd.h"
-#include "servers/rendering/rasterizer_rd/rasterizer_storage_rd.h"
-#include "servers/rendering/rasterizer_rd/render_pipeline_vertex_format_cache_rd.h"
-#include "servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl.gen.h"
+#include "servers/rendering/renderer_rd/pipeline_cache_rd.h"
+#include "servers/rendering/renderer_rd/renderer_scene_render_rd.h"
+#include "servers/rendering/renderer_rd/renderer_storage_rd.h"
+#include "servers/rendering/renderer_rd/shaders/scene_forward.glsl.gen.h"
 
-class RasterizerSceneHighEndRD : public RasterizerSceneRD {
+class RendererSceneRenderForward : public RendererSceneRenderRD {
 	enum {
 		SCENE_UNIFORM_SET = 0,
-		RADIANCE_UNIFORM_SET = 1,
-		VIEW_DEPENDANT_UNIFORM_SET = 2,
-		RENDER_BUFFERS_UNIFORM_SET = 3,
-		TRANSFORMS_UNIFORM_SET = 4,
-		MATERIAL_UNIFORM_SET = 5
+		RENDER_PASS_UNIFORM_SET = 1,
+		TRANSFORMS_UNIFORM_SET = 2,
+		MATERIAL_UNIFORM_SET = 3
 	};
 
 	enum {
@@ -69,15 +67,15 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 	};
 
 	struct {
-		SceneHighEndShaderRD scene_shader;
+		SceneForwardShaderRD scene_shader;
 		ShaderCompilerRD compiler;
 	} shader;
 
-	RasterizerStorageRD *storage;
+	RendererStorageRD *storage;
 
 	/* Material */
 
-	struct ShaderData : public RasterizerStorageRD::ShaderData {
+	struct ShaderData : public RendererStorageRD::ShaderData {
 		enum BlendMode { //used internally
 			BLEND_MODE_MIX,
 			BLEND_MODE_ADD,
@@ -120,7 +118,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		bool valid;
 		RID version;
 		uint32_t vertex_input_mask;
-		RenderPipelineVertexFormatCacheRD pipelines[CULL_VARIANT_MAX][RS::PRIMITIVE_MAX][SHADER_VERSION_MAX];
+		PipelineCacheRD pipelines[CULL_VARIANT_MAX][RS::PRIMITIVE_MAX][SHADER_VERSION_MAX];
 
 		String path;
 
@@ -162,7 +160,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		virtual void set_code(const String &p_Code);
 		virtual void set_default_texture_param(const StringName &p_name, RID p_texture);
 		virtual void get_param_list(List<PropertyInfo> *p_param_list) const;
-		void get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const;
+		void get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const;
 
 		virtual bool is_param_texture(const StringName &p_param) const;
 		virtual bool is_animated() const;
@@ -172,12 +170,12 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		virtual ~ShaderData();
 	};
 
-	RasterizerStorageRD::ShaderData *_create_shader_func();
-	static RasterizerStorageRD::ShaderData *_create_shader_funcs() {
-		return static_cast<RasterizerSceneHighEndRD *>(singleton)->_create_shader_func();
+	RendererStorageRD::ShaderData *_create_shader_func();
+	static RendererStorageRD::ShaderData *_create_shader_funcs() {
+		return static_cast<RendererSceneRenderForward *>(singleton)->_create_shader_func();
 	}
 
-	struct MaterialData : public RasterizerStorageRD::MaterialData {
+	struct MaterialData : public RendererStorageRD::MaterialData {
 		uint64_t last_frame;
 		ShaderData *shader_data;
 		RID uniform_buffer;
@@ -194,9 +192,9 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		virtual ~MaterialData();
 	};
 
-	RasterizerStorageRD::MaterialData *_create_material_func(ShaderData *p_shader);
-	static RasterizerStorageRD::MaterialData *_create_material_funcs(RasterizerStorageRD::ShaderData *p_shader) {
-		return static_cast<RasterizerSceneHighEndRD *>(singleton)->_create_material_func(static_cast<ShaderData *>(p_shader));
+	RendererStorageRD::MaterialData *_create_material_func(ShaderData *p_shader);
+	static RendererStorageRD::MaterialData *_create_material_funcs(RendererStorageRD::ShaderData *p_shader) {
+		return static_cast<RendererSceneRenderForward *>(singleton)->_create_material_func(static_cast<ShaderData *>(p_shader));
 	}
 
 	/* Push Constant */
@@ -209,7 +207,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 
 	/* Framebuffer */
 
-	struct RenderBufferDataHighEnd : public RenderBufferData {
+	struct RenderBufferDataForward : public RenderBufferData {
 		//for rendering, may be MSAAd
 
 		RID color;
@@ -246,30 +244,29 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		void clear();
 		virtual void configure(RID p_color_buffer, RID p_depth_buffer, int p_width, int p_height, RS::ViewportMSAA p_msaa);
 
-		RID uniform_set;
-
-		~RenderBufferDataHighEnd();
+		~RenderBufferDataForward();
 	};
 
 	virtual RenderBufferData *_create_render_buffer_data();
-	void _allocate_normal_roughness_texture(RenderBufferDataHighEnd *rb);
+	void _allocate_normal_roughness_texture(RenderBufferDataForward *rb);
 
 	RID shadow_sampler;
 	RID render_base_uniform_set;
-	RID view_dependant_uniform_set;
+	RID render_pass_uniform_set;
+	RID sdfgi_pass_uniform_set;
 
 	uint64_t lightmap_texture_array_version = 0xFFFFFFFF;
 
 	virtual void _base_uniforms_changed();
-	void _render_buffers_clear_uniform_set(RenderBufferDataHighEnd *rb);
+	void _render_buffers_clear_uniform_set(RenderBufferDataForward *rb);
 	virtual void _render_buffers_uniform_set_changed(RID p_render_buffers);
 	virtual RID _render_buffers_get_normal_texture(RID p_render_buffers);
 	virtual RID _render_buffers_get_ambient_texture(RID p_render_buffers);
 	virtual RID _render_buffers_get_reflection_texture(RID p_render_buffers);
 
 	void _update_render_base_uniform_set();
-	void _setup_view_dependant_uniform_set(RID p_shadow_atlas, RID p_reflection_atlas, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count);
-	void _update_render_buffers_uniform_set(RID p_render_buffers);
+	RID _setup_sdfgi_render_pass_uniform_set(RID p_albedo_texture, RID p_emission_texture, RID p_emission_aniso_texture, RID p_geom_facing_texture);
+	RID _setup_render_pass_uniform_set(RID p_render_buffers, RID p_radiance_texture, RID p_shadow_atlas, RID p_reflection_atlas, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count);
 
 	struct LightmapData {
 		float normal_xform[12];
@@ -415,7 +412,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 		int max_elements;
 
 		struct Element {
-			RasterizerScene::InstanceBase *instance;
+			RendererSceneRender::InstanceBase *instance;
 			MaterialData *material;
 			union {
 				struct {
@@ -541,7 +538,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 
 	RenderList render_list;
 
-	static RasterizerSceneHighEndRD *singleton;
+	static RendererSceneRenderForward *singleton;
 	uint64_t render_pass;
 	double time;
 	RID default_shader;
@@ -552,8 +549,6 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 	RID wireframe_material;
 	RID default_shader_rd;
 	RID default_shader_sdfgi_rd;
-	RID default_radiance_uniform_set;
-	RID default_render_buffers_uniform_set;
 
 	RID default_vec4_xform_buffer;
 	RID default_vec4_xform_uniform_set;
@@ -575,7 +570,7 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 	void _setup_lightmaps(InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, const Transform &p_cam_transform);
 
 	void _fill_instances(RenderList::Element **p_elements, int p_element_count, bool p_for_depth, bool p_has_sdfgi = false, bool p_has_opaque_gi = false);
-	void _render_list(RenderingDevice::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_framebuffer_Format, RenderList::Element **p_elements, int p_element_count, bool p_reverse_cull, PassMode p_pass_mode, bool p_no_gi, RID p_radiance_uniform_set, RID p_render_buffers_uniform_set, bool p_force_wireframe = false, const Vector2 &p_uv_offset = Vector2());
+	void _render_list(RenderingDevice::DrawListID p_draw_list, RenderingDevice::FramebufferFormatID p_framebuffer_Format, RenderList::Element **p_elements, int p_element_count, bool p_reverse_cull, PassMode p_pass_mode, bool p_no_gi, RID p_render_pass_uniform_set, bool p_force_wireframe = false, const Vector2 &p_uv_offset = Vector2(), const Plane &p_lod_plane = Plane(), float p_lod_distance_multiplier = 0.0, float p_screen_lod_threshold = 0.0);
 	_FORCE_INLINE_ void _add_geometry(InstanceBase *p_instance, uint32_t p_surface, RID p_material, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi = false);
 	_FORCE_INLINE_ void _add_geometry_with_material(InstanceBase *p_instance, uint32_t p_surface, MaterialData *p_material, RID p_material_rid, PassMode p_pass_mode, uint32_t p_geometry_index, bool p_using_sdfgi = false);
 
@@ -583,9 +578,11 @@ class RasterizerSceneHighEndRD : public RasterizerSceneRD {
 
 	Map<Size2i, RID> sdfgi_framebuffer_size_cache;
 
+	bool low_end = false;
+
 protected:
-	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color);
-	virtual void _render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake);
+	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_bg_color, float p_lod_threshold);
+	virtual void _render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake, const Plane &p_camera_plane = Plane(), float p_lod_distance_multiplier = 0, float p_screen_lod_threshold = 0.0);
 	virtual void _render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region);
 	virtual void _render_uv2(InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region);
 	virtual void _render_sdfgi(RID p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, InstanceBase **p_cull_result, int p_cull_count, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture);
@@ -596,7 +593,7 @@ public:
 
 	virtual bool free(RID p_rid);
 
-	RasterizerSceneHighEndRD(RasterizerStorageRD *p_storage);
-	~RasterizerSceneHighEndRD();
+	RendererSceneRenderForward(RendererStorageRD *p_storage);
+	~RendererSceneRenderForward();
 };
 #endif // RASTERIZER_SCENE_HIGHEND_RD_H
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp b/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
index e1be9b0ef4..4543ced8dc 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_scene_rd.cpp                                              */
+/*  renderer_scene_render_rd.cpp                                         */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,14 +28,14 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rasterizer_scene_rd.h"
+#include "renderer_scene_render_rd.h"
 
 #include "core/config/project_settings.h"
 #include "core/os/os.h"
-#include "rasterizer_rd.h"
-#include "servers/rendering/rendering_server_raster.h"
+#include "renderer_compositor_rd.h"
+#include "servers/rendering/rendering_server_default.h"
 
-uint64_t RasterizerSceneRD::auto_exposure_counter = 2;
+uint64_t RendererSceneRenderRD::auto_exposure_counter = 2;
 
 void get_vogel_disk(float *r_kernel, int p_sample_count) {
 	const float golden_angle = 2.4;
@@ -49,7 +49,7 @@ void get_vogel_disk(float *r_kernel, int p_sample_count) {
 	}
 }
 
-void RasterizerSceneRD::_clear_reflection_data(ReflectionData &rd) {
+void RendererSceneRenderRD::_clear_reflection_data(ReflectionData &rd) {
 	rd.layers.clear();
 	rd.radiance_base_cubemap = RID();
 	if (rd.downsampled_radiance_cubemap.is_valid()) {
@@ -60,7 +60,7 @@ void RasterizerSceneRD::_clear_reflection_data(ReflectionData &rd) {
 	rd.coefficient_buffer = RID();
 }
 
-void RasterizerSceneRD::_update_reflection_data(ReflectionData &rd, int p_size, int p_mipmaps, bool p_use_array, RID p_base_cube, int p_base_layer, bool p_low_quality) {
+void RendererSceneRenderRD::_update_reflection_data(ReflectionData &rd, int p_size, int p_mipmaps, bool p_use_array, RID p_base_cube, int p_base_layer, bool p_low_quality) {
 	//recreate radiance and all data
 
 	int mipmaps = p_mipmaps;
@@ -129,7 +129,7 @@ void RasterizerSceneRD::_update_reflection_data(ReflectionData &rd, int p_size,
 	tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
 	tf.width = 64; // Always 64x64
 	tf.height = 64;
-	tf.type = RD::TEXTURE_TYPE_CUBE;
+	tf.texture_type = RD::TEXTURE_TYPE_CUBE;
 	tf.array_layers = 6;
 	tf.mipmaps = 7;
 	tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
@@ -151,7 +151,7 @@ void RasterizerSceneRD::_update_reflection_data(ReflectionData &rd, int p_size,
 	}
 }
 
-void RasterizerSceneRD::_create_reflection_fast_filter(ReflectionData &rd, bool p_use_arrays) {
+void RendererSceneRenderRD::_create_reflection_fast_filter(ReflectionData &rd, bool p_use_arrays) {
 	storage->get_effects()->cubemap_downsample(rd.radiance_base_cubemap, rd.downsampled_layer.mipmaps[0].view, rd.downsampled_layer.mipmaps[0].size);
 
 	for (int i = 1; i < rd.downsampled_layer.mipmaps.size(); i++) {
@@ -172,7 +172,7 @@ void RasterizerSceneRD::_create_reflection_fast_filter(ReflectionData &rd, bool
 	storage->get_effects()->cubemap_filter(rd.downsampled_radiance_cubemap, views, p_use_arrays);
 }
 
-void RasterizerSceneRD::_create_reflection_importance_sample(ReflectionData &rd, bool p_use_arrays, int p_cube_side, int p_base_layer) {
+void RendererSceneRenderRD::_create_reflection_importance_sample(ReflectionData &rd, bool p_use_arrays, int p_cube_side, int p_base_layer) {
 	if (p_use_arrays) {
 		//render directly to the layers
 		storage->get_effects()->cubemap_roughness(rd.radiance_base_cubemap, rd.layers[p_base_layer].views[0], p_cube_side, sky_ggx_samples_quality, float(p_base_layer) / (rd.layers.size() - 1.0), rd.layers[p_base_layer].mipmaps[0].size.x);
@@ -181,7 +181,7 @@ void RasterizerSceneRD::_create_reflection_importance_sample(ReflectionData &rd,
 	}
 }
 
-void RasterizerSceneRD::_update_reflection_mipmaps(ReflectionData &rd, int p_start, int p_end) {
+void RendererSceneRenderRD::_update_reflection_mipmaps(ReflectionData &rd, int p_start, int p_end) {
 	for (int i = p_start; i < p_end; i++) {
 		for (int j = 0; j < rd.layers[i].mipmaps.size() - 1; j++) {
 			for (int k = 0; k < 6; k++) {
@@ -194,7 +194,7 @@ void RasterizerSceneRD::_update_reflection_mipmaps(ReflectionData &rd, int p_sta
 	}
 }
 
-void RasterizerSceneRD::_sdfgi_erase(RenderBuffers *rb) {
+void RendererSceneRenderRD::_sdfgi_erase(RenderBuffers *rb) {
 	for (uint32_t i = 0; i < rb->sdfgi->cascades.size(); i++) {
 		const SDFGI::Cascade &c = rb->sdfgi->cascades[i];
 		RD::get_singleton()->free(c.light_data);
@@ -236,9 +236,9 @@ void RasterizerSceneRD::_sdfgi_erase(RenderBuffers *rb) {
 	rb->sdfgi = nullptr;
 }
 
-const Vector3i RasterizerSceneRD::SDFGI::Cascade::DIRTY_ALL = Vector3i(0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF);
+const Vector3i RendererSceneRenderRD::SDFGI::Cascade::DIRTY_ALL = Vector3i(0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF);
 
-void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position) {
+void RendererSceneRenderRD::sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position) {
 	Environment *env = environment_owner.getornull(p_environment);
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	bool needs_sdfgi = env && env->sdfgi_enabled;
@@ -284,7 +284,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 		tf_sdf.width = sdfgi->cascade_size; // Always 64x64
 		tf_sdf.height = sdfgi->cascade_size;
 		tf_sdf.depth = sdfgi->cascade_size;
-		tf_sdf.type = RD::TEXTURE_TYPE_3D;
+		tf_sdf.texture_type = RD::TEXTURE_TYPE_3D;
 		tf_sdf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
 
 		{
@@ -341,7 +341,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 		tf_probes.width = sdfgi->probe_axis_count * sdfgi->probe_axis_count;
 		tf_probes.height = sdfgi->probe_axis_count * SDFGI::SH_SIZE;
 		tf_probes.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
-		tf_probes.type = RD::TEXTURE_TYPE_2D_ARRAY;
+		tf_probes.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
 
 		sdfgi->history_size = requested_history_size;
 
@@ -351,8 +351,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 
 		RD::TextureFormat tf_probe_average = tf_probes;
 		tf_probe_average.format = RD::DATA_FORMAT_R32G32B32A32_SINT; //signed integer because SH are signed
-		tf_probe_average.type = RD::TEXTURE_TYPE_2D_ARRAY;
-		tf_probe_average.array_layers = 1;
+		tf_probe_average.texture_type = RD::TEXTURE_TYPE_2D;
 
 		sdfgi->lightprobe_history_scroll = RD::get_singleton()->texture_create(tf_probe_history, RD::TextureView());
 		sdfgi->lightprobe_average_scroll = RD::get_singleton()->texture_create(tf_probe_average, RD::TextureView());
@@ -379,7 +378,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			tf_ambient.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT; //pack well with RGBE
 			tf_ambient.width = sdfgi->probe_axis_count * sdfgi->probe_axis_count;
 			tf_ambient.height = sdfgi->probe_axis_count;
-			tf_ambient.type = RD::TEXTURE_TYPE_2D_ARRAY;
+			tf_ambient.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
 			//lightprobe texture is an octahedral texture
 			sdfgi->ambient_texture = RD::get_singleton()->texture_create(tf_ambient, RD::TextureView());
 		}
@@ -444,21 +443,21 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 				Vector<RD::Uniform> uniforms;
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 1;
 					u.ids.push_back(sdfgi->render_sdf[(passes & 1) ? 1 : 0]); //if passes are even, we read from buffer 0, else we read from buffer 1
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 2;
 					u.ids.push_back(sdfgi->render_albedo);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 3;
 					for (int j = 0; j < 8; j++) {
 						u.ids.push_back(sdfgi->render_occlusion[j]);
@@ -467,21 +466,21 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 4;
 					u.ids.push_back(sdfgi->render_emission);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 5;
 					u.ids.push_back(sdfgi->render_emission_aniso);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 6;
 					u.ids.push_back(sdfgi->render_geom_facing);
 					uniforms.push_back(u);
@@ -489,28 +488,28 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 7;
 					u.ids.push_back(cascade.sdf_tex);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 8;
 					u.ids.push_back(sdfgi->occlusion_data);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+					u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 					u.binding = 10;
 					u.ids.push_back(cascade.solid_cell_dispatch_buffer);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+					u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 					u.binding = 11;
 					u.ids.push_back(cascade.solid_cell_buffer);
 					uniforms.push_back(u);
@@ -523,42 +522,42 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 				Vector<RD::Uniform> uniforms;
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 1;
 					u.ids.push_back(sdfgi->render_albedo);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 2;
 					u.ids.push_back(sdfgi->render_geom_facing);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 3;
 					u.ids.push_back(sdfgi->render_emission);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 4;
 					u.ids.push_back(sdfgi->render_emission_aniso);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+					u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 					u.binding = 5;
 					u.ids.push_back(cascade.solid_cell_dispatch_buffer);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+					u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 					u.binding = 6;
 					u.ids.push_back(cascade.solid_cell_buffer);
 					uniforms.push_back(u);
@@ -570,7 +569,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 				Vector<RD::Uniform> uniforms;
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 1;
 					for (int j = 0; j < 8; j++) {
 						u.ids.push_back(sdfgi->render_occlusion[j]);
@@ -579,7 +578,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 2;
 					u.ids.push_back(sdfgi->occlusion_data);
 					uniforms.push_back(u);
@@ -597,12 +596,12 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			{
 				RD::Uniform u;
 				u.binding = 1;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 					if (j < rb->sdfgi->cascades.size()) {
 						u.ids.push_back(rb->sdfgi->cascades[j].sdf_tex);
 					} else {
-						u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+						u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 					}
 				}
 				uniforms.push_back(u);
@@ -610,63 +609,63 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			{
 				RD::Uniform u;
 				u.binding = 2;
-				u.type = RD::UNIFORM_TYPE_SAMPLER;
+				u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 				u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 3;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.ids.push_back(cascade.solid_cell_dispatch_buffer);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 4;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.ids.push_back(cascade.solid_cell_buffer);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 5;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.ids.push_back(cascade.light_data);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 6;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.ids.push_back(cascade.light_aniso_0_tex);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 7;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.ids.push_back(cascade.light_aniso_1_tex);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 8;
-				u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 				u.ids.push_back(rb->sdfgi->cascades_ubo);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 9;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.ids.push_back(cascade.lights_buffer);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
 				u.binding = 10;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				u.ids.push_back(rb->sdfgi->lightprobe_texture);
 				uniforms.push_back(u);
 			}
@@ -679,14 +678,14 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 1;
 				u.ids.push_back(sdfgi->render_albedo);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 2;
 				u.ids.push_back(sdfgi->render_sdf[0]);
 				uniforms.push_back(u);
@@ -699,14 +698,14 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 1;
 				u.ids.push_back(sdfgi->render_albedo);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 2;
 				u.ids.push_back(sdfgi->render_sdf_half[0]);
 				uniforms.push_back(u);
@@ -720,14 +719,14 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 1;
 				u.ids.push_back(sdfgi->render_sdf[0]);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 2;
 				u.ids.push_back(sdfgi->render_sdf[1]);
 				uniforms.push_back(u);
@@ -742,14 +741,14 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 1;
 				u.ids.push_back(sdfgi->render_sdf_half[0]);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 2;
 				u.ids.push_back(sdfgi->render_sdf_half[1]);
 				uniforms.push_back(u);
@@ -765,21 +764,21 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 1;
 				u.ids.push_back(sdfgi->render_albedo);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 2;
 				u.ids.push_back(sdfgi->render_sdf_half[(passes & 1) ? 0 : 1]); //reverse pass order because half size
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 3;
 				u.ids.push_back(sdfgi->render_sdf[(passes & 1) ? 0 : 1]); //reverse pass order because it needs an extra JFA pass
 				uniforms.push_back(u);
@@ -794,14 +793,14 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 1;
 				u.ids.push_back(sdfgi->render_albedo);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 2;
 				for (int i = 0; i < 8; i++) {
 					u.ids.push_back(sdfgi->render_occlusion[i]);
@@ -810,7 +809,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 3;
 				u.ids.push_back(sdfgi->render_geom_facing);
 				uniforms.push_back(u);
@@ -827,12 +826,12 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			{
 				RD::Uniform u;
 				u.binding = 1;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 					if (j < sdfgi->cascades.size()) {
 						u.ids.push_back(sdfgi->cascades[j].sdf_tex);
 					} else {
-						u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+						u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 					}
 				}
 				uniforms.push_back(u);
@@ -840,12 +839,12 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			{
 				RD::Uniform u;
 				u.binding = 2;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 					if (j < sdfgi->cascades.size()) {
 						u.ids.push_back(sdfgi->cascades[j].light_tex);
 					} else {
-						u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+						u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 					}
 				}
 				uniforms.push_back(u);
@@ -853,12 +852,12 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			{
 				RD::Uniform u;
 				u.binding = 3;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 					if (j < sdfgi->cascades.size()) {
 						u.ids.push_back(sdfgi->cascades[j].light_aniso_0_tex);
 					} else {
-						u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+						u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 					}
 				}
 				uniforms.push_back(u);
@@ -866,19 +865,19 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			{
 				RD::Uniform u;
 				u.binding = 4;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 					if (j < sdfgi->cascades.size()) {
 						u.ids.push_back(sdfgi->cascades[j].light_aniso_1_tex);
 					} else {
-						u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+						u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 					}
 				}
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_SAMPLER;
+				u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 				u.binding = 6;
 				u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 				uniforms.push_back(u);
@@ -886,14 +885,14 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 				u.binding = 7;
 				u.ids.push_back(sdfgi->cascades_ubo);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 8;
 				u.ids.push_back(sdfgi->lightprobe_data);
 				uniforms.push_back(u);
@@ -901,14 +900,14 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 9;
 				u.ids.push_back(sdfgi->cascades[i].lightprobe_history_tex);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 10;
 				u.ids.push_back(sdfgi->cascades[i].lightprobe_average_tex);
 				uniforms.push_back(u);
@@ -916,21 +915,21 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 11;
 				u.ids.push_back(sdfgi->lightprobe_history_scroll);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 12;
 				u.ids.push_back(sdfgi->lightprobe_average_scroll);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 13;
 				RID parent_average;
 				if (i < sdfgi->cascades.size() - 1) {
@@ -943,7 +942,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 14;
 				u.ids.push_back(sdfgi->ambient_texture);
 				uniforms.push_back(u);
@@ -1022,7 +1021,7 @@ void RasterizerSceneRD::sdfgi_update(RID p_render_buffers, RID p_environment, co
 	}
 }
 
-int RasterizerSceneRD::sdfgi_get_pending_region_count(RID p_render_buffers) const {
+int RendererSceneRenderRD::sdfgi_get_pending_region_count(RID p_render_buffers) const {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 
 	ERR_FAIL_COND_V(rb == nullptr, 0);
@@ -1049,7 +1048,7 @@ int RasterizerSceneRD::sdfgi_get_pending_region_count(RID p_render_buffers) cons
 	return dirty_count;
 }
 
-int RasterizerSceneRD::_sdfgi_get_pending_region_data(RID p_render_buffers, int p_region, Vector3i &r_local_offset, Vector3i &r_local_size, AABB &r_bounds) const {
+int RendererSceneRenderRD::_sdfgi_get_pending_region_data(RID p_render_buffers, int p_region, Vector3i &r_local_offset, Vector3i &r_local_size, AABB &r_bounds) const {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(rb == nullptr, -1);
 	ERR_FAIL_COND_V(rb->sdfgi == nullptr, -1);
@@ -1109,7 +1108,7 @@ int RasterizerSceneRD::_sdfgi_get_pending_region_data(RID p_render_buffers, int
 	return -1;
 }
 
-AABB RasterizerSceneRD::sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const {
+AABB RendererSceneRenderRD::sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const {
 	AABB bounds;
 	Vector3i from;
 	Vector3i size;
@@ -1119,7 +1118,7 @@ AABB RasterizerSceneRD::sdfgi_get_pending_region_bounds(RID p_render_buffers, in
 	return bounds;
 }
 
-uint32_t RasterizerSceneRD::sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const {
+uint32_t RendererSceneRenderRD::sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const {
 	AABB bounds;
 	Vector3i from;
 	Vector3i size;
@@ -1127,7 +1126,7 @@ uint32_t RasterizerSceneRD::sdfgi_get_pending_region_cascade(RID p_render_buffer
 	return _sdfgi_get_pending_region_data(p_render_buffers, p_region, from, size, bounds);
 }
 
-void RasterizerSceneRD::_sdfgi_update_cascades(RID p_render_buffers) {
+void RendererSceneRenderRD::_sdfgi_update_cascades(RID p_render_buffers) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(rb == nullptr);
 	if (rb->sdfgi == nullptr) {
@@ -1154,7 +1153,7 @@ void RasterizerSceneRD::_sdfgi_update_cascades(RID p_render_buffers) {
 	RD::get_singleton()->buffer_update(rb->sdfgi->cascades_ubo, 0, sizeof(SDFGI::Cascade::UBO) * SDFGI::MAX_CASCADES, cascade_data, true);
 }
 
-void RasterizerSceneRD::sdfgi_update_probes(RID p_render_buffers, RID p_environment, const RID *p_directional_light_instances, uint32_t p_directional_light_count, const RID *p_positional_light_instances, uint32_t p_positional_light_count) {
+void RendererSceneRenderRD::sdfgi_update_probes(RID p_render_buffers, RID p_environment, const RID *p_directional_light_instances, uint32_t p_directional_light_count, const RID *p_positional_light_instances, uint32_t p_positional_light_count) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(rb == nullptr);
 	if (rb->sdfgi == nullptr) {
@@ -1187,6 +1186,11 @@ void RasterizerSceneRD::sdfgi_update_probes(RID p_render_buffers, RID p_environm
 
 				LightInstance *li = light_instance_owner.getornull(p_directional_light_instances[j]);
 				ERR_CONTINUE(!li);
+
+				if (storage->light_directional_is_sky_only(li->light)) {
+					continue;
+				}
+
 				Vector3 dir = -li->transform.basis.get_axis(Vector3::AXIS_Z);
 				dir.y *= rb->sdfgi->y_mult;
 				dir.normalize();
@@ -1334,7 +1338,7 @@ void RasterizerSceneRD::sdfgi_update_probes(RID p_render_buffers, RID p_environm
 
 					{
 						RD::Uniform u;
-						u.type = RD::UNIFORM_TYPE_TEXTURE;
+						u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 						u.binding = 0;
 						u.ids.push_back(sky->radiance);
 						uniforms.push_back(u);
@@ -1342,7 +1346,7 @@ void RasterizerSceneRD::sdfgi_update_probes(RID p_render_buffers, RID p_environm
 
 					{
 						RD::Uniform u;
-						u.type = RD::UNIFORM_TYPE_SAMPLER;
+						u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 						u.binding = 1;
 						u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 						uniforms.push_back(u);
@@ -1398,7 +1402,7 @@ void RasterizerSceneRD::sdfgi_update_probes(RID p_render_buffers, RID p_environm
 	RENDER_TIMESTAMP("<SDFGI Update Probes");
 }
 
-void RasterizerSceneRD::_setup_giprobes(RID p_render_buffers, const Transform &p_transform, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, uint32_t &r_gi_probes_used) {
+void RendererSceneRenderRD::_setup_giprobes(RID p_render_buffers, const Transform &p_transform, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, uint32_t &r_gi_probes_used) {
 	r_gi_probes_used = 0;
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(rb == nullptr);
@@ -1461,7 +1465,7 @@ void RasterizerSceneRD::_setup_giprobes(RID p_render_buffers, const Transform &p
 		}
 
 		if (texture == RID()) {
-			texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+			texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
 		}
 
 		if (texture != rb->giprobe_textures[i]) {
@@ -1471,7 +1475,9 @@ void RasterizerSceneRD::_setup_giprobes(RID p_render_buffers, const Transform &p
 	}
 
 	if (giprobes_changed) {
-		RD::get_singleton()->free(rb->gi_uniform_set);
+		if (RD::get_singleton()->uniform_set_is_valid(rb->gi_uniform_set)) {
+			RD::get_singleton()->free(rb->gi_uniform_set);
+		}
 		rb->gi_uniform_set = RID();
 		if (rb->volumetric_fog) {
 			if (RD::get_singleton()->uniform_set_is_valid(rb->volumetric_fog->uniform_set)) {
@@ -1488,7 +1494,7 @@ void RasterizerSceneRD::_setup_giprobes(RID p_render_buffers, const Transform &p
 	}
 }
 
-void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness_buffer, RID p_ambient_buffer, RID p_reflection_buffer, RID p_gi_probe_buffer, RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count) {
+void RendererSceneRenderRD::_process_gi(RID p_render_buffers, RID p_normal_roughness_buffer, RID p_ambient_buffer, RID p_reflection_buffer, RID p_gi_probe_buffer, RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count) {
 	RENDER_TIMESTAMP("Render GI");
 
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
@@ -1608,12 +1614,12 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 		{
 			RD::Uniform u;
 			u.binding = 1;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 				if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[j].sdf_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
@@ -1621,12 +1627,12 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 		{
 			RD::Uniform u;
 			u.binding = 2;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 				if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[j].light_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
@@ -1634,12 +1640,12 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 		{
 			RD::Uniform u;
 			u.binding = 3;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 				if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[j].light_aniso_0_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
@@ -1647,37 +1653,37 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 		{
 			RD::Uniform u;
 			u.binding = 4;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t j = 0; j < SDFGI::MAX_CASCADES; j++) {
 				if (rb->sdfgi && j < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[j].light_aniso_1_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 5;
 			if (rb->sdfgi) {
 				u.ids.push_back(rb->sdfgi->occlusion_texture);
 			} else {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 			}
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 6;
 			u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 7;
 			u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 			uniforms.push_back(u);
@@ -1685,7 +1691,7 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 			u.binding = 9;
 			u.ids.push_back(p_ambient_buffer);
 			uniforms.push_back(u);
@@ -1693,7 +1699,7 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 			u.binding = 10;
 			u.ids.push_back(p_reflection_buffer);
 			uniforms.push_back(u);
@@ -1701,54 +1707,54 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 11;
 			if (rb->sdfgi) {
 				u.ids.push_back(rb->sdfgi->lightprobe_texture);
 			} else {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE));
 			}
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 12;
 			u.ids.push_back(rb->depth_texture);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 13;
 			u.ids.push_back(p_normal_roughness_buffer);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 14;
-			RID buffer = p_gi_probe_buffer.is_valid() ? p_gi_probe_buffer : storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK);
+			RID buffer = p_gi_probe_buffer.is_valid() ? p_gi_probe_buffer : storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
 			u.ids.push_back(buffer);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 15;
 			u.ids.push_back(gi.sdfgi_ubo);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 16;
 			u.ids.push_back(rb->giprobe_buffer);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 17;
 			for (int i = 0; i < RenderBuffers::MAX_GIPROBES; i++) {
 				u.ids.push_back(rb->giprobe_textures[i]);
@@ -1767,11 +1773,11 @@ void RasterizerSceneRD::_process_gi(RID p_render_buffers, RID p_normal_roughness
 	RD::get_singleton()->compute_list_end();
 }
 
-RID RasterizerSceneRD::sky_create() {
+RID RendererSceneRenderRD::sky_create() {
 	return sky_owner.make_rid(Sky());
 }
 
-void RasterizerSceneRD::_sky_invalidate(Sky *p_sky) {
+void RendererSceneRenderRD::_sky_invalidate(Sky *p_sky) {
 	if (!p_sky->dirty) {
 		p_sky->dirty = true;
 		p_sky->dirty_list = dirty_sky_list;
@@ -1779,7 +1785,7 @@ void RasterizerSceneRD::_sky_invalidate(Sky *p_sky) {
 	}
 }
 
-void RasterizerSceneRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) {
+void RendererSceneRenderRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) {
 	Sky *sky = sky_owner.getornull(p_sky);
 	ERR_FAIL_COND(!sky);
 	ERR_FAIL_COND(p_radiance_size < 32 || p_radiance_size > 2048);
@@ -1801,7 +1807,7 @@ void RasterizerSceneRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) {
 	_clear_reflection_data(sky->reflection);
 }
 
-void RasterizerSceneRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) {
+void RendererSceneRenderRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) {
 	Sky *sky = sky_owner.getornull(p_sky);
 	ERR_FAIL_COND(!sky);
 
@@ -1824,14 +1830,14 @@ void RasterizerSceneRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) {
 	_clear_reflection_data(sky->reflection);
 }
 
-void RasterizerSceneRD::sky_set_material(RID p_sky, RID p_material) {
+void RendererSceneRenderRD::sky_set_material(RID p_sky, RID p_material) {
 	Sky *sky = sky_owner.getornull(p_sky);
 	ERR_FAIL_COND(!sky);
 	sky->material = p_material;
 	_sky_invalidate(sky);
 }
 
-Ref<Image> RasterizerSceneRD::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) {
+Ref<Image> RendererSceneRenderRD::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) {
 	Sky *sky = sky_owner.getornull(p_sky);
 	ERR_FAIL_COND_V(!sky, Ref<Image>());
 
@@ -1867,7 +1873,7 @@ Ref<Image> RasterizerSceneRD::sky_bake_panorama(RID p_sky, float p_energy, bool
 	return Ref<Image>();
 }
 
-void RasterizerSceneRD::_update_dirty_skys() {
+void RendererSceneRenderRD::_update_dirty_skys() {
 	Sky *sky = dirty_sky_list;
 
 	while (sky) {
@@ -1891,7 +1897,7 @@ void RasterizerSceneRD::_update_dirty_skys() {
 				RD::TextureFormat tf;
 				tf.array_layers = layers * 6;
 				tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
-				tf.type = RD::TEXTURE_TYPE_CUBE_ARRAY;
+				tf.texture_type = RD::TEXTURE_TYPE_CUBE_ARRAY;
 				tf.mipmaps = mipmaps;
 				tf.width = w;
 				tf.height = h;
@@ -1906,7 +1912,7 @@ void RasterizerSceneRD::_update_dirty_skys() {
 				RD::TextureFormat tf;
 				tf.array_layers = 6;
 				tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
-				tf.type = RD::TEXTURE_TYPE_CUBE;
+				tf.texture_type = RD::TEXTURE_TYPE_CUBE;
 				tf.mipmaps = MIN(mipmaps, layers);
 				tf.width = w;
 				tf.height = h;
@@ -1926,7 +1932,7 @@ void RasterizerSceneRD::_update_dirty_skys() {
 			tformat.width = sky->screen_size.x / 2;
 			tformat.height = sky->screen_size.y / 2;
 			tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
-			tformat.type = RD::TEXTURE_TYPE_2D;
+			tformat.texture_type = RD::TEXTURE_TYPE_2D;
 
 			sky->half_res_pass = RD::get_singleton()->texture_create(tformat, RD::TextureView());
 			Vector<RID> texs;
@@ -1941,7 +1947,7 @@ void RasterizerSceneRD::_update_dirty_skys() {
 			tformat.width = sky->screen_size.x / 4;
 			tformat.height = sky->screen_size.y / 4;
 			tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
-			tformat.type = RD::TEXTURE_TYPE_2D;
+			tformat.texture_type = RD::TEXTURE_TYPE_2D;
 
 			sky->quarter_res_pass = RD::get_singleton()->texture_create(tformat, RD::TextureView());
 			Vector<RID> texs;
@@ -1971,14 +1977,14 @@ void RasterizerSceneRD::_update_dirty_skys() {
 	dirty_sky_list = nullptr;
 }
 
-RID RasterizerSceneRD::sky_get_radiance_texture_rd(RID p_sky) const {
+RID RendererSceneRenderRD::sky_get_radiance_texture_rd(RID p_sky) const {
 	Sky *sky = sky_owner.getornull(p_sky);
 	ERR_FAIL_COND_V(!sky, RID());
 
 	return sky->radiance;
 }
 
-RID RasterizerSceneRD::sky_get_radiance_uniform_set_rd(RID p_sky, RID p_shader, int p_set) const {
+RID RendererSceneRenderRD::sky_get_radiance_uniform_set_rd(RID p_sky, RID p_shader, int p_set) const {
 	Sky *sky = sky_owner.getornull(p_sky);
 	ERR_FAIL_COND_V(!sky, RID());
 
@@ -1988,7 +1994,7 @@ RID RasterizerSceneRD::sky_get_radiance_uniform_set_rd(RID p_sky, RID p_shader,
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				u.binding = 0;
 				u.ids.push_back(sky->radiance);
 				uniforms.push_back(u);
@@ -2001,25 +2007,25 @@ RID RasterizerSceneRD::sky_get_radiance_uniform_set_rd(RID p_sky, RID p_shader,
 	return sky->uniform_set;
 }
 
-RID RasterizerSceneRD::_get_sky_textures(Sky *p_sky, SkyTextureSetVersion p_version) {
+RID RendererSceneRenderRD::_get_sky_textures(Sky *p_sky, SkyTextureSetVersion p_version) {
 	if (p_sky->texture_uniform_sets[p_version].is_valid() && RD::get_singleton()->uniform_set_is_valid(p_sky->texture_uniform_sets[p_version])) {
 		return p_sky->texture_uniform_sets[p_version];
 	}
 	Vector<RD::Uniform> uniforms;
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 0;
 		if (p_sky->radiance.is_valid() && p_version <= SKY_TEXTURE_SET_QUARTER_RES) {
 			u.ids.push_back(p_sky->radiance);
 		} else {
-			u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
+			u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
 		}
 		uniforms.push_back(u);
 	}
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 1; // half res
 		if (p_sky->half_res_pass.is_valid() && p_version != SKY_TEXTURE_SET_HALF_RES && p_version != SKY_TEXTURE_SET_CUBEMAP_HALF_RES) {
 			if (p_version >= SKY_TEXTURE_SET_CUBEMAP) {
@@ -2029,16 +2035,16 @@ RID RasterizerSceneRD::_get_sky_textures(Sky *p_sky, SkyTextureSetVersion p_vers
 			}
 		} else {
 			if (p_version < SKY_TEXTURE_SET_CUBEMAP) {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE));
 			} else {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
 			}
 		}
 		uniforms.push_back(u);
 	}
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 2; // quarter res
 		if (p_sky->quarter_res_pass.is_valid() && p_version != SKY_TEXTURE_SET_QUARTER_RES && p_version != SKY_TEXTURE_SET_CUBEMAP_QUARTER_RES) {
 			if (p_version >= SKY_TEXTURE_SET_CUBEMAP) {
@@ -2048,9 +2054,9 @@ RID RasterizerSceneRD::_get_sky_textures(Sky *p_sky, SkyTextureSetVersion p_vers
 			}
 		} else {
 			if (p_version < SKY_TEXTURE_SET_CUBEMAP) {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE));
 			} else {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
 			}
 		}
 		uniforms.push_back(u);
@@ -2060,14 +2066,14 @@ RID RasterizerSceneRD::_get_sky_textures(Sky *p_sky, SkyTextureSetVersion p_vers
 	return p_sky->texture_uniform_sets[p_version];
 }
 
-RID RasterizerSceneRD::sky_get_material(RID p_sky) const {
+RID RendererSceneRenderRD::sky_get_material(RID p_sky) const {
 	Sky *sky = sky_owner.getornull(p_sky);
 	ERR_FAIL_COND_V(!sky, RID());
 
 	return sky->material;
 }
 
-void RasterizerSceneRD::_draw_sky(bool p_can_continue_color, bool p_can_continue_depth, RID p_fb, RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform) {
+void RendererSceneRenderRD::_draw_sky(bool p_can_continue_color, bool p_can_continue_depth, RID p_fb, RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform) {
 	ERR_FAIL_COND(!is_environment(p_environment));
 
 	SkyMaterialData *material = nullptr;
@@ -2083,7 +2089,7 @@ void RasterizerSceneRD::_draw_sky(bool p_can_continue_color, bool p_can_continue
 		sky_material = sky_get_material(environment_get_sky(p_environment));
 
 		if (sky_material.is_valid()) {
-			material = (SkyMaterialData *)storage->material_get_data(sky_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+			material = (SkyMaterialData *)storage->material_get_data(sky_material, RendererStorageRD::SHADER_TYPE_SKY);
 			if (!material || !material->shader_data->valid) {
 				material = nullptr;
 			}
@@ -2091,13 +2097,13 @@ void RasterizerSceneRD::_draw_sky(bool p_can_continue_color, bool p_can_continue
 
 		if (!material) {
 			sky_material = sky_shader.default_material;
-			material = (SkyMaterialData *)storage->material_get_data(sky_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+			material = (SkyMaterialData *)storage->material_get_data(sky_material, RendererStorageRD::SHADER_TYPE_SKY);
 		}
 	}
 
 	if (background == RS::ENV_BG_CLEAR_COLOR || background == RS::ENV_BG_COLOR) {
 		sky_material = sky_scene_state.fog_material;
-		material = (SkyMaterialData *)storage->material_get_data(sky_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+		material = (SkyMaterialData *)storage->material_get_data(sky_material, RendererStorageRD::SHADER_TYPE_SKY);
 	}
 
 	ERR_FAIL_COND(!material);
@@ -2128,7 +2134,7 @@ void RasterizerSceneRD::_draw_sky(bool p_can_continue_color, bool p_can_continue
 	sky_transform = p_transform.basis * sky_transform;
 
 	if (shader_data->uses_quarter_res) {
-		RenderPipelineVertexFormatCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_QUARTER_RES];
+		PipelineCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_QUARTER_RES];
 
 		RID texture_uniform_set = _get_sky_textures(sky, SKY_TEXTURE_SET_QUARTER_RES);
 
@@ -2141,7 +2147,7 @@ void RasterizerSceneRD::_draw_sky(bool p_can_continue_color, bool p_can_continue
 	}
 
 	if (shader_data->uses_half_res) {
-		RenderPipelineVertexFormatCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_HALF_RES];
+		PipelineCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_HALF_RES];
 
 		RID texture_uniform_set = _get_sky_textures(sky, SKY_TEXTURE_SET_HALF_RES);
 
@@ -2153,7 +2159,7 @@ void RasterizerSceneRD::_draw_sky(bool p_can_continue_color, bool p_can_continue
 		RD::get_singleton()->draw_list_end();
 	}
 
-	RenderPipelineVertexFormatCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_BACKGROUND];
+	PipelineCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_BACKGROUND];
 
 	RID texture_uniform_set;
 	if (sky) {
@@ -2167,7 +2173,7 @@ void RasterizerSceneRD::_draw_sky(bool p_can_continue_color, bool p_can_continue
 	RD::get_singleton()->draw_list_end();
 }
 
-void RasterizerSceneRD::_setup_sky(RID p_environment, RID p_render_buffers, const CameraMatrix &p_projection, const Transform &p_transform, const Size2i p_screen_size) {
+void RendererSceneRenderRD::_setup_sky(RID p_environment, RID p_render_buffers, const CameraMatrix &p_projection, const Transform &p_transform, const Size2i p_screen_size) {
 	ERR_FAIL_COND(!is_environment(p_environment));
 
 	SkyMaterialData *material = nullptr;
@@ -2185,7 +2191,7 @@ void RasterizerSceneRD::_setup_sky(RID p_environment, RID p_render_buffers, cons
 		sky_material = sky_get_material(environment_get_sky(p_environment));
 
 		if (sky_material.is_valid()) {
-			material = (SkyMaterialData *)storage->material_get_data(sky_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+			material = (SkyMaterialData *)storage->material_get_data(sky_material, RendererStorageRD::SHADER_TYPE_SKY);
 			if (!material || !material->shader_data->valid) {
 				material = nullptr;
 			}
@@ -2193,7 +2199,7 @@ void RasterizerSceneRD::_setup_sky(RID p_environment, RID p_render_buffers, cons
 
 		if (!material) {
 			sky_material = sky_shader.default_material;
-			material = (SkyMaterialData *)storage->material_get_data(sky_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+			material = (SkyMaterialData *)storage->material_get_data(sky_material, RendererStorageRD::SHADER_TYPE_SKY);
 		}
 
 		ERR_FAIL_COND(!material);
@@ -2236,7 +2242,7 @@ void RasterizerSceneRD::_setup_sky(RID p_environment, RID p_render_buffers, cons
 		if (shader_data->uses_time && time - sky->prev_time > 0.00001) {
 			sky->prev_time = time;
 			sky->reflection.dirty = true;
-			RenderingServerRaster::redraw_request();
+			RenderingServerDefault::redraw_request();
 		}
 
 		if (material != sky->prev_material) {
@@ -2284,7 +2290,7 @@ void RasterizerSceneRD::_setup_sky(RID p_environment, RID p_render_buffers, cons
 			if (light_data_dirty) {
 				RD::get_singleton()->buffer_update(sky_scene_state.directional_light_buffer, 0, sizeof(SkyDirectionalLightData) * sky_scene_state.max_directional_lights, sky_scene_state.directional_lights, true);
 
-				RasterizerSceneRD::SkyDirectionalLightData *temp = sky_scene_state.last_frame_directional_lights;
+				RendererSceneRenderRD::SkyDirectionalLightData *temp = sky_scene_state.last_frame_directional_lights;
 				sky_scene_state.last_frame_directional_lights = sky_scene_state.directional_lights;
 				sky_scene_state.directional_lights = temp;
 				sky_scene_state.last_frame_directional_light_count = sky_scene_state.ubo.directional_light_count;
@@ -2337,7 +2343,7 @@ void RasterizerSceneRD::_setup_sky(RID p_environment, RID p_render_buffers, cons
 	RD::get_singleton()->buffer_update(sky_scene_state.uniform_buffer, 0, sizeof(SkySceneState::UBO), &sky_scene_state.ubo, true);
 }
 
-void RasterizerSceneRD::_update_sky(RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform) {
+void RendererSceneRenderRD::_update_sky(RID p_environment, const CameraMatrix &p_projection, const Transform &p_transform) {
 	ERR_FAIL_COND(!is_environment(p_environment));
 
 	Sky *sky = sky_owner.getornull(environment_get_sky(p_environment));
@@ -2348,7 +2354,7 @@ void RasterizerSceneRD::_update_sky(RID p_environment, const CameraMatrix &p_pro
 	SkyMaterialData *material = nullptr;
 
 	if (sky_material.is_valid()) {
-		material = (SkyMaterialData *)storage->material_get_data(sky_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+		material = (SkyMaterialData *)storage->material_get_data(sky_material, RendererStorageRD::SHADER_TYPE_SKY);
 		if (!material || !material->shader_data->valid) {
 			material = nullptr;
 		}
@@ -2356,7 +2362,7 @@ void RasterizerSceneRD::_update_sky(RID p_environment, const CameraMatrix &p_pro
 
 	if (!material) {
 		sky_material = sky_shader.default_material;
-		material = (SkyMaterialData *)storage->material_get_data(sky_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+		material = (SkyMaterialData *)storage->material_get_data(sky_material, RendererStorageRD::SHADER_TYPE_SKY);
 	}
 
 	ERR_FAIL_COND(!material);
@@ -2417,7 +2423,7 @@ void RasterizerSceneRD::_update_sky(RID p_environment, const CameraMatrix &p_pro
 		cm = correction * cm;
 
 		if (shader_data->uses_quarter_res) {
-			RenderPipelineVertexFormatCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_CUBEMAP_QUARTER_RES];
+			PipelineCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_CUBEMAP_QUARTER_RES];
 
 			Vector<Color> clear_colors;
 			clear_colors.push_back(Color(0.0, 0.0, 0.0));
@@ -2435,7 +2441,7 @@ void RasterizerSceneRD::_update_sky(RID p_environment, const CameraMatrix &p_pro
 		}
 
 		if (shader_data->uses_half_res) {
-			RenderPipelineVertexFormatCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_CUBEMAP_HALF_RES];
+			PipelineCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_CUBEMAP_HALF_RES];
 
 			Vector<Color> clear_colors;
 			clear_colors.push_back(Color(0.0, 0.0, 0.0));
@@ -2453,7 +2459,7 @@ void RasterizerSceneRD::_update_sky(RID p_environment, const CameraMatrix &p_pro
 		}
 
 		RD::DrawListID cubemap_draw_list;
-		RenderPipelineVertexFormatCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_CUBEMAP];
+		PipelineCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_CUBEMAP];
 
 		for (int i = 0; i < 6; i++) {
 			Transform local_view;
@@ -2504,7 +2510,7 @@ void RasterizerSceneRD::_update_sky(RID p_environment, const CameraMatrix &p_pro
 
 /* SKY SHADER */
 
-void RasterizerSceneRD::SkyShaderData::set_code(const String &p_code) {
+void RendererSceneRenderRD::SkyShaderData::set_code(const String &p_code) {
 	//compile
 
 	code = p_code;
@@ -2553,7 +2559,7 @@ void RasterizerSceneRD::SkyShaderData::set_code(const String &p_code) {
 
 	actions.uniforms = &uniforms;
 
-	RasterizerSceneRD *scene_singleton = (RasterizerSceneRD *)RasterizerSceneRD::singleton;
+	RendererSceneRenderRD *scene_singleton = (RendererSceneRenderRD *)RendererSceneRenderRD::singleton;
 
 	Error err = scene_singleton->sky_shader.compiler.compile(RS::SHADER_SKY, code, &actions, path, gen_code);
 
@@ -2598,7 +2604,7 @@ void RasterizerSceneRD::SkyShaderData::set_code(const String &p_code) {
 	valid = true;
 }
 
-void RasterizerSceneRD::SkyShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
+void RendererSceneRenderRD::SkyShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
 	if (!p_texture.is_valid()) {
 		default_texture_params.erase(p_name);
 	} else {
@@ -2606,7 +2612,7 @@ void RasterizerSceneRD::SkyShaderData::set_default_texture_param(const StringNam
 	}
 }
 
-void RasterizerSceneRD::SkyShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
+void RendererSceneRenderRD::SkyShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
 	Map<int, StringName> order;
 
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
@@ -2628,13 +2634,13 @@ void RasterizerSceneRD::SkyShaderData::get_param_list(List<PropertyInfo> *p_para
 	}
 }
 
-void RasterizerSceneRD::SkyShaderData::get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const {
+void RendererSceneRenderRD::SkyShaderData::get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const {
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
 		if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
 			continue;
 		}
 
-		RasterizerStorage::InstanceShaderParam p;
+		RendererStorage::InstanceShaderParam p;
 		p.info = ShaderLanguage::uniform_to_property_info(E->get());
 		p.info.name = E->key(); //supply name
 		p.index = E->get().instance_index;
@@ -2643,7 +2649,7 @@ void RasterizerSceneRD::SkyShaderData::get_instance_param_list(List<RasterizerSt
 	}
 }
 
-bool RasterizerSceneRD::SkyShaderData::is_param_texture(const StringName &p_param) const {
+bool RendererSceneRenderRD::SkyShaderData::is_param_texture(const StringName &p_param) const {
 	if (!uniforms.has(p_param)) {
 		return false;
 	}
@@ -2651,15 +2657,15 @@ bool RasterizerSceneRD::SkyShaderData::is_param_texture(const StringName &p_para
 	return uniforms[p_param].texture_order >= 0;
 }
 
-bool RasterizerSceneRD::SkyShaderData::is_animated() const {
+bool RendererSceneRenderRD::SkyShaderData::is_animated() const {
 	return false;
 }
 
-bool RasterizerSceneRD::SkyShaderData::casts_shadows() const {
+bool RendererSceneRenderRD::SkyShaderData::casts_shadows() const {
 	return false;
 }
 
-Variant RasterizerSceneRD::SkyShaderData::get_default_parameter(const StringName &p_parameter) const {
+Variant RendererSceneRenderRD::SkyShaderData::get_default_parameter(const StringName &p_parameter) const {
 	if (uniforms.has(p_parameter)) {
 		ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
 		Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
@@ -2668,12 +2674,12 @@ Variant RasterizerSceneRD::SkyShaderData::get_default_parameter(const StringName
 	return Variant();
 }
 
-RasterizerSceneRD::SkyShaderData::SkyShaderData() {
+RendererSceneRenderRD::SkyShaderData::SkyShaderData() {
 	valid = false;
 }
 
-RasterizerSceneRD::SkyShaderData::~SkyShaderData() {
-	RasterizerSceneRD *scene_singleton = (RasterizerSceneRD *)RasterizerSceneRD::singleton;
+RendererSceneRenderRD::SkyShaderData::~SkyShaderData() {
+	RendererSceneRenderRD *scene_singleton = (RendererSceneRenderRD *)RendererSceneRenderRD::singleton;
 	ERR_FAIL_COND(!scene_singleton);
 	//pipeline variants will clear themselves if shader is gone
 	if (version.is_valid()) {
@@ -2681,13 +2687,13 @@ RasterizerSceneRD::SkyShaderData::~SkyShaderData() {
 	}
 }
 
-RasterizerStorageRD::ShaderData *RasterizerSceneRD::_create_sky_shader_func() {
+RendererStorageRD::ShaderData *RendererSceneRenderRD::_create_sky_shader_func() {
 	SkyShaderData *shader_data = memnew(SkyShaderData);
 	return shader_data;
 }
 
-void RasterizerSceneRD::SkyMaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
-	RasterizerSceneRD *scene_singleton = (RasterizerSceneRD *)RasterizerSceneRD::singleton;
+void RendererSceneRenderRD::SkyMaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
+	RendererSceneRenderRD *scene_singleton = (RendererSceneRenderRD *)RendererSceneRenderRD::singleton;
 
 	uniform_set_updated = true;
 
@@ -2749,7 +2755,7 @@ void RasterizerSceneRD::SkyMaterialData::update_parameters(const Map<StringName,
 	{
 		if (shader_data->ubo_size) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(uniform_buffer);
 			uniforms.push_back(u);
@@ -2758,7 +2764,7 @@ void RasterizerSceneRD::SkyMaterialData::update_parameters(const Map<StringName,
 		const RID *textures = texture_cache.ptrw();
 		for (uint32_t i = 0; i < tex_uniform_count; i++) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1 + i;
 			u.ids.push_back(textures[i]);
 			uniforms.push_back(u);
@@ -2768,7 +2774,7 @@ void RasterizerSceneRD::SkyMaterialData::update_parameters(const Map<StringName,
 	uniform_set = RD::get_singleton()->uniform_set_create(uniforms, scene_singleton->sky_shader.shader.version_get_shader(shader_data->version, 0), SKY_SET_MATERIAL);
 }
 
-RasterizerSceneRD::SkyMaterialData::~SkyMaterialData() {
+RendererSceneRenderRD::SkyMaterialData::~SkyMaterialData() {
 	if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
 		RD::get_singleton()->free(uniform_set);
 	}
@@ -2778,7 +2784,7 @@ RasterizerSceneRD::SkyMaterialData::~SkyMaterialData() {
 	}
 }
 
-RasterizerStorageRD::MaterialData *RasterizerSceneRD::_create_sky_material_func(SkyShaderData *p_shader) {
+RendererStorageRD::MaterialData *RendererSceneRenderRD::_create_sky_material_func(SkyShaderData *p_shader) {
 	SkyMaterialData *material_data = memnew(SkyMaterialData);
 	material_data->shader_data = p_shader;
 	material_data->last_frame = false;
@@ -2786,53 +2792,53 @@ RasterizerStorageRD::MaterialData *RasterizerSceneRD::_create_sky_material_func(
 	return material_data;
 }
 
-RID RasterizerSceneRD::environment_create() {
+RID RendererSceneRenderRD::environment_create() {
 	return environment_owner.make_rid(Environment());
 }
 
-void RasterizerSceneRD::environment_set_background(RID p_env, RS::EnvironmentBG p_bg) {
+void RendererSceneRenderRD::environment_set_background(RID p_env, RS::EnvironmentBG p_bg) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->background = p_bg;
 }
 
-void RasterizerSceneRD::environment_set_sky(RID p_env, RID p_sky) {
+void RendererSceneRenderRD::environment_set_sky(RID p_env, RID p_sky) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->sky = p_sky;
 }
 
-void RasterizerSceneRD::environment_set_sky_custom_fov(RID p_env, float p_scale) {
+void RendererSceneRenderRD::environment_set_sky_custom_fov(RID p_env, float p_scale) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->sky_custom_fov = p_scale;
 }
 
-void RasterizerSceneRD::environment_set_sky_orientation(RID p_env, const Basis &p_orientation) {
+void RendererSceneRenderRD::environment_set_sky_orientation(RID p_env, const Basis &p_orientation) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->sky_orientation = p_orientation;
 }
 
-void RasterizerSceneRD::environment_set_bg_color(RID p_env, const Color &p_color) {
+void RendererSceneRenderRD::environment_set_bg_color(RID p_env, const Color &p_color) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->bg_color = p_color;
 }
 
-void RasterizerSceneRD::environment_set_bg_energy(RID p_env, float p_energy) {
+void RendererSceneRenderRD::environment_set_bg_energy(RID p_env, float p_energy) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->bg_energy = p_energy;
 }
 
-void RasterizerSceneRD::environment_set_canvas_max_layer(RID p_env, int p_max_layer) {
+void RendererSceneRenderRD::environment_set_canvas_max_layer(RID p_env, int p_max_layer) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->canvas_max_layer = p_max_layer;
 }
 
-void RasterizerSceneRD::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, const Color &p_ao_color) {
+void RendererSceneRenderRD::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, const Color &p_ao_color) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->ambient_light = p_color;
@@ -2843,85 +2849,85 @@ void RasterizerSceneRD::environment_set_ambient_light(RID p_env, const Color &p_
 	env->ao_color = p_ao_color;
 }
 
-RS::EnvironmentBG RasterizerSceneRD::environment_get_background(RID p_env) const {
+RS::EnvironmentBG RendererSceneRenderRD::environment_get_background(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, RS::ENV_BG_MAX);
 	return env->background;
 }
 
-RID RasterizerSceneRD::environment_get_sky(RID p_env) const {
+RID RendererSceneRenderRD::environment_get_sky(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, RID());
 	return env->sky;
 }
 
-float RasterizerSceneRD::environment_get_sky_custom_fov(RID p_env) const {
+float RendererSceneRenderRD::environment_get_sky_custom_fov(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->sky_custom_fov;
 }
 
-Basis RasterizerSceneRD::environment_get_sky_orientation(RID p_env) const {
+Basis RendererSceneRenderRD::environment_get_sky_orientation(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, Basis());
 	return env->sky_orientation;
 }
 
-Color RasterizerSceneRD::environment_get_bg_color(RID p_env) const {
+Color RendererSceneRenderRD::environment_get_bg_color(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->bg_color;
 }
 
-float RasterizerSceneRD::environment_get_bg_energy(RID p_env) const {
+float RendererSceneRenderRD::environment_get_bg_energy(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->bg_energy;
 }
 
-int RasterizerSceneRD::environment_get_canvas_max_layer(RID p_env) const {
+int RendererSceneRenderRD::environment_get_canvas_max_layer(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->canvas_max_layer;
 }
 
-Color RasterizerSceneRD::environment_get_ambient_light_color(RID p_env) const {
+Color RendererSceneRenderRD::environment_get_ambient_light_color(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->ambient_light;
 }
 
-RS::EnvironmentAmbientSource RasterizerSceneRD::environment_get_ambient_source(RID p_env) const {
+RS::EnvironmentAmbientSource RendererSceneRenderRD::environment_get_ambient_source(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, RS::ENV_AMBIENT_SOURCE_BG);
 	return env->ambient_source;
 }
 
-float RasterizerSceneRD::environment_get_ambient_light_energy(RID p_env) const {
+float RendererSceneRenderRD::environment_get_ambient_light_energy(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->ambient_light_energy;
 }
 
-float RasterizerSceneRD::environment_get_ambient_sky_contribution(RID p_env) const {
+float RendererSceneRenderRD::environment_get_ambient_sky_contribution(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->ambient_sky_contribution;
 }
 
-RS::EnvironmentReflectionSource RasterizerSceneRD::environment_get_reflection_source(RID p_env) const {
+RS::EnvironmentReflectionSource RendererSceneRenderRD::environment_get_reflection_source(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, RS::ENV_REFLECTION_SOURCE_DISABLED);
 	return env->reflection_source;
 }
 
-Color RasterizerSceneRD::environment_get_ao_color(RID p_env) const {
+Color RendererSceneRenderRD::environment_get_ao_color(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->ao_color;
 }
 
-void RasterizerSceneRD::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) {
+void RendererSceneRenderRD::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.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	env->exposure = p_exposure;
@@ -2937,7 +2943,7 @@ void RasterizerSceneRD::environment_set_tonemap(RID p_env, RS::EnvironmentToneMa
 	env->auto_exp_scale = p_auto_exp_scale;
 }
 
-void RasterizerSceneRD::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) {
+void RendererSceneRenderRD::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) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 	ERR_FAIL_COND_MSG(p_levels.size() != 7, "Size of array of glow levels must be 7");
@@ -2953,18 +2959,22 @@ void RasterizerSceneRD::environment_set_glow(RID p_env, bool p_enable, Vector<fl
 	env->glow_hdr_luminance_cap = p_hdr_luminance_cap;
 }
 
-void RasterizerSceneRD::environment_glow_set_use_bicubic_upscale(bool p_enable) {
+void RendererSceneRenderRD::environment_glow_set_use_bicubic_upscale(bool p_enable) {
 	glow_bicubic_upscale = p_enable;
 }
 
-void RasterizerSceneRD::environment_glow_set_use_high_quality(bool p_enable) {
+void RendererSceneRenderRD::environment_glow_set_use_high_quality(bool p_enable) {
 	glow_high_quality = p_enable;
 }
 
-void RasterizerSceneRD::environment_set_sdfgi(RID p_env, bool p_enable, RS::EnvironmentSDFGICascades p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, bool p_use_multibounce, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) {
+void RendererSceneRenderRD::environment_set_sdfgi(RID p_env, bool p_enable, RS::EnvironmentSDFGICascades p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, bool p_use_multibounce, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 
+	if (low_end) {
+		return;
+	}
+
 	env->sdfgi_enabled = p_enable;
 	env->sdfgi_cascades = p_cascades;
 	env->sdfgi_min_cell_size = p_min_cell_size;
@@ -2977,7 +2987,7 @@ void RasterizerSceneRD::environment_set_sdfgi(RID p_env, bool p_enable, RS::Envi
 	env->sdfgi_y_scale = p_y_scale;
 }
 
-void RasterizerSceneRD::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_fog_aerial_perspective) {
+void RendererSceneRenderRD::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_fog_aerial_perspective) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 
@@ -2991,54 +3001,58 @@ void RasterizerSceneRD::environment_set_fog(RID p_env, bool p_enable, const Colo
 	env->fog_aerial_perspective = p_fog_aerial_perspective;
 }
 
-bool RasterizerSceneRD::environment_is_fog_enabled(RID p_env) const {
+bool RendererSceneRenderRD::environment_is_fog_enabled(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, false);
 
 	return env->fog_enabled;
 }
-Color RasterizerSceneRD::environment_get_fog_light_color(RID p_env) const {
+Color RendererSceneRenderRD::environment_get_fog_light_color(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, Color());
 	return env->fog_light_color;
 }
-float RasterizerSceneRD::environment_get_fog_light_energy(RID p_env) const {
+float RendererSceneRenderRD::environment_get_fog_light_energy(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_light_energy;
 }
-float RasterizerSceneRD::environment_get_fog_sun_scatter(RID p_env) const {
+float RendererSceneRenderRD::environment_get_fog_sun_scatter(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_sun_scatter;
 }
-float RasterizerSceneRD::environment_get_fog_density(RID p_env) const {
+float RendererSceneRenderRD::environment_get_fog_density(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_density;
 }
-float RasterizerSceneRD::environment_get_fog_height(RID p_env) const {
+float RendererSceneRenderRD::environment_get_fog_height(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 
 	return env->fog_height;
 }
-float RasterizerSceneRD::environment_get_fog_height_density(RID p_env) const {
+float RendererSceneRenderRD::environment_get_fog_height_density(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_height_density;
 }
 
-float RasterizerSceneRD::environment_get_fog_aerial_perspective(RID p_env) const {
+float RendererSceneRenderRD::environment_get_fog_aerial_perspective(RID p_env) const {
 	const Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, 0);
 	return env->fog_aerial_perspective;
 }
 
-void RasterizerSceneRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, RenderingServer::EnvVolumetricFogShadowFilter p_shadow_filter) {
+void RendererSceneRenderRD::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, RenderingServer::EnvVolumetricFogShadowFilter p_shadow_filter) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 
+	if (low_end) {
+		return;
+	}
+
 	env->volumetric_fog_enabled = p_enable;
 	env->volumetric_fog_density = p_density;
 	env->volumetric_fog_light = p_light;
@@ -3049,15 +3063,15 @@ void RasterizerSceneRD::environment_set_volumetric_fog(RID p_env, bool p_enable,
 	env->volumetric_fog_gi_inject = p_gi_inject;
 }
 
-void RasterizerSceneRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
+void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
 	volumetric_fog_size = p_size;
 	volumetric_fog_depth = p_depth;
 }
 
-void RasterizerSceneRD::environment_set_volumetric_fog_filter_active(bool p_enable) {
+void RendererSceneRenderRD::environment_set_volumetric_fog_filter_active(bool p_enable) {
 	volumetric_fog_filter_active = p_enable;
 }
-void RasterizerSceneRD::environment_set_volumetric_fog_directional_shadow_shrink_size(int p_shrink_size) {
+void RendererSceneRenderRD::environment_set_volumetric_fog_directional_shadow_shrink_size(int p_shrink_size) {
 	p_shrink_size = nearest_power_of_2_templated(p_shrink_size);
 	if (volumetric_fog_directional_shadow_shrink == (uint32_t)p_shrink_size) {
 		return;
@@ -3065,7 +3079,7 @@ void RasterizerSceneRD::environment_set_volumetric_fog_directional_shadow_shrink
 
 	_clear_shadow_shrink_stages(directional_shadow.shrink_stages);
 }
-void RasterizerSceneRD::environment_set_volumetric_fog_positional_shadow_shrink_size(int p_shrink_size) {
+void RendererSceneRenderRD::environment_set_volumetric_fog_positional_shadow_shrink_size(int p_shrink_size) {
 	p_shrink_size = nearest_power_of_2_templated(p_shrink_size);
 	if (volumetric_fog_positional_shadow_shrink == (uint32_t)p_shrink_size) {
 		return;
@@ -3077,18 +3091,22 @@ void RasterizerSceneRD::environment_set_volumetric_fog_positional_shadow_shrink_
 	}
 }
 
-void RasterizerSceneRD::environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) {
+void RendererSceneRenderRD::environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) {
 	sdfgi_ray_count = p_ray_count;
 }
 
-void RasterizerSceneRD::environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) {
+void RendererSceneRenderRD::environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) {
 	sdfgi_frames_to_converge = p_frames;
 }
 
-void RasterizerSceneRD::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) {
+void RendererSceneRenderRD::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.getornull(p_env);
 	ERR_FAIL_COND(!env);
 
+	if (low_end) {
+		return;
+	}
+
 	env->ssr_enabled = p_enable;
 	env->ssr_max_steps = p_max_steps;
 	env->ssr_fade_in = p_fade_int;
@@ -3096,18 +3114,22 @@ void RasterizerSceneRD::environment_set_ssr(RID p_env, bool p_enable, int p_max_
 	env->ssr_depth_tolerance = p_depth_tolerance;
 }
 
-void RasterizerSceneRD::environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) {
+void RendererSceneRenderRD::environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) {
 	ssr_roughness_quality = p_quality;
 }
 
-RS::EnvironmentSSRRoughnessQuality RasterizerSceneRD::environment_get_ssr_roughness_quality() const {
+RS::EnvironmentSSRRoughnessQuality RendererSceneRenderRD::environment_get_ssr_roughness_quality() const {
 	return ssr_roughness_quality;
 }
 
-void RasterizerSceneRD::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_bias, float p_light_affect, float p_ao_channel_affect, RS::EnvironmentSSAOBlur p_blur, float p_bilateral_sharpness) {
+void RendererSceneRenderRD::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_bias, float p_light_affect, float p_ao_channel_affect, RS::EnvironmentSSAOBlur p_blur, float p_bilateral_sharpness) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND(!env);
 
+	if (low_end) {
+		return;
+	}
+
 	env->ssao_enabled = p_enable;
 	env->ssao_radius = p_radius;
 	env->ssao_intensity = p_intensity;
@@ -3117,45 +3139,45 @@ void RasterizerSceneRD::environment_set_ssao(RID p_env, bool p_enable, float p_r
 	env->ssao_blur = p_blur;
 }
 
-void RasterizerSceneRD::environment_set_ssao_quality(RS::EnvironmentSSAOQuality p_quality, bool p_half_size) {
+void RendererSceneRenderRD::environment_set_ssao_quality(RS::EnvironmentSSAOQuality p_quality, bool p_half_size) {
 	ssao_quality = p_quality;
 	ssao_half_size = p_half_size;
 }
 
-bool RasterizerSceneRD::environment_is_ssao_enabled(RID p_env) const {
+bool RendererSceneRenderRD::environment_is_ssao_enabled(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, false);
 	return env->ssao_enabled;
 }
 
-float RasterizerSceneRD::environment_get_ssao_ao_affect(RID p_env) const {
+float RendererSceneRenderRD::environment_get_ssao_ao_affect(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
-	ERR_FAIL_COND_V(!env, false);
+	ERR_FAIL_COND_V(!env, 0.0);
 	return env->ssao_ao_channel_affect;
 }
 
-float RasterizerSceneRD::environment_get_ssao_light_affect(RID p_env) const {
+float RendererSceneRenderRD::environment_get_ssao_light_affect(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
-	ERR_FAIL_COND_V(!env, false);
+	ERR_FAIL_COND_V(!env, 0.0);
 	return env->ssao_direct_light_affect;
 }
 
-bool RasterizerSceneRD::environment_is_ssr_enabled(RID p_env) const {
+bool RendererSceneRenderRD::environment_is_ssr_enabled(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, false);
 	return env->ssr_enabled;
 }
-bool RasterizerSceneRD::environment_is_sdfgi_enabled(RID p_env) const {
+bool RendererSceneRenderRD::environment_is_sdfgi_enabled(RID p_env) const {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, false);
 	return env->sdfgi_enabled;
 }
 
-bool RasterizerSceneRD::is_environment(RID p_env) const {
+bool RendererSceneRenderRD::is_environment(RID p_env) const {
 	return environment_owner.owns(p_env);
 }
 
-Ref<Image> RasterizerSceneRD::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) {
+Ref<Image> RendererSceneRenderRD::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) {
 	Environment *env = environment_owner.getornull(p_env);
 	ERR_FAIL_COND_V(!env, Ref<Image>());
 
@@ -3194,7 +3216,7 @@ Ref<Image> RasterizerSceneRD::environment_bake_panorama(RID p_env, bool p_bake_i
 
 ////////////////////////////////////////////////////////////
 
-RID RasterizerSceneRD::reflection_atlas_create() {
+RID RendererSceneRenderRD::reflection_atlas_create() {
 	ReflectionAtlas ra;
 	ra.count = GLOBAL_GET("rendering/quality/reflection_atlas/reflection_count");
 	ra.size = GLOBAL_GET("rendering/quality/reflection_atlas/reflection_size");
@@ -3202,7 +3224,7 @@ RID RasterizerSceneRD::reflection_atlas_create() {
 	return reflection_atlas_owner.make_rid(ra);
 }
 
-void RasterizerSceneRD::reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count) {
+void RendererSceneRenderRD::reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count) {
 	ReflectionAtlas *ra = reflection_atlas_owner.getornull(p_ref_atlas);
 	ERR_FAIL_COND(!ra);
 
@@ -3233,14 +3255,21 @@ void RasterizerSceneRD::reflection_atlas_set_size(RID p_ref_atlas, int p_reflect
 	}
 }
 
+int RendererSceneRenderRD::reflection_atlas_get_size(RID p_ref_atlas) const {
+	ReflectionAtlas *ra = reflection_atlas_owner.getornull(p_ref_atlas);
+	ERR_FAIL_COND_V(!ra, 0);
+
+	return ra->size;
+}
+
 ////////////////////////
-RID RasterizerSceneRD::reflection_probe_instance_create(RID p_probe) {
+RID RendererSceneRenderRD::reflection_probe_instance_create(RID p_probe) {
 	ReflectionProbeInstance rpi;
 	rpi.probe = p_probe;
 	return reflection_probe_instance_owner.make_rid(rpi);
 }
 
-void RasterizerSceneRD::reflection_probe_instance_set_transform(RID p_instance, const Transform &p_transform) {
+void RendererSceneRenderRD::reflection_probe_instance_set_transform(RID p_instance, const Transform &p_transform) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!rpi);
 
@@ -3248,7 +3277,7 @@ void RasterizerSceneRD::reflection_probe_instance_set_transform(RID p_instance,
 	rpi->dirty = true;
 }
 
-void RasterizerSceneRD::reflection_probe_release_atlas_index(RID p_instance) {
+void RendererSceneRenderRD::reflection_probe_release_atlas_index(RID p_instance) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!rpi);
 
@@ -3263,7 +3292,7 @@ void RasterizerSceneRD::reflection_probe_release_atlas_index(RID p_instance) {
 	rpi->atlas = RID();
 }
 
-bool RasterizerSceneRD::reflection_probe_instance_needs_redraw(RID p_instance) {
+bool RendererSceneRenderRD::reflection_probe_instance_needs_redraw(RID p_instance) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!rpi, false);
 
@@ -3282,14 +3311,14 @@ bool RasterizerSceneRD::reflection_probe_instance_needs_redraw(RID p_instance) {
 	return rpi->atlas_index == -1;
 }
 
-bool RasterizerSceneRD::reflection_probe_instance_has_reflection(RID p_instance) {
+bool RendererSceneRenderRD::reflection_probe_instance_has_reflection(RID p_instance) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!rpi, false);
 
 	return rpi->atlas.is_valid();
 }
 
-bool RasterizerSceneRD::reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) {
+bool RendererSceneRenderRD::reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) {
 	ReflectionAtlas *atlas = reflection_atlas_owner.getornull(p_reflection_atlas);
 
 	ERR_FAIL_COND_V(!atlas, false);
@@ -3325,7 +3354,7 @@ bool RasterizerSceneRD::reflection_probe_instance_begin_render(RID p_instance, R
 			RD::TextureFormat tf;
 			tf.array_layers = 6 * atlas->count;
 			tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
-			tf.type = RD::TEXTURE_TYPE_CUBE_ARRAY;
+			tf.texture_type = RD::TEXTURE_TYPE_CUBE_ARRAY;
 			tf.mipmaps = mipmaps;
 			tf.width = atlas->size;
 			tf.height = atlas->size;
@@ -3388,7 +3417,7 @@ bool RasterizerSceneRD::reflection_probe_instance_begin_render(RID p_instance, R
 	return true;
 }
 
-bool RasterizerSceneRD::reflection_probe_instance_postprocess_step(RID p_instance) {
+bool RendererSceneRenderRD::reflection_probe_instance_postprocess_step(RID p_instance) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!rpi, false);
 	ERR_FAIL_COND_V(!rpi->rendering, false);
@@ -3434,7 +3463,7 @@ bool RasterizerSceneRD::reflection_probe_instance_postprocess_step(RID p_instanc
 	return false;
 }
 
-uint32_t RasterizerSceneRD::reflection_probe_instance_get_resolution(RID p_instance) {
+uint32_t RendererSceneRenderRD::reflection_probe_instance_get_resolution(RID p_instance) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!rpi, 0);
 
@@ -3443,7 +3472,7 @@ uint32_t RasterizerSceneRD::reflection_probe_instance_get_resolution(RID p_insta
 	return atlas->size;
 }
 
-RID RasterizerSceneRD::reflection_probe_instance_get_framebuffer(RID p_instance, int p_index) {
+RID RendererSceneRenderRD::reflection_probe_instance_get_framebuffer(RID p_instance, int p_index) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!rpi, RID());
 	ERR_FAIL_INDEX_V(p_index, 6, RID());
@@ -3453,7 +3482,7 @@ RID RasterizerSceneRD::reflection_probe_instance_get_framebuffer(RID p_instance,
 	return atlas->reflections[rpi->atlas_index].fbs[p_index];
 }
 
-RID RasterizerSceneRD::reflection_probe_instance_get_depth_framebuffer(RID p_instance, int p_index) {
+RID RendererSceneRenderRD::reflection_probe_instance_get_depth_framebuffer(RID p_instance, int p_index) {
 	ReflectionProbeInstance *rpi = reflection_probe_instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!rpi, RID());
 	ERR_FAIL_INDEX_V(p_index, 6, RID());
@@ -3465,11 +3494,11 @@ RID RasterizerSceneRD::reflection_probe_instance_get_depth_framebuffer(RID p_ins
 
 ///////////////////////////////////////////////////////////
 
-RID RasterizerSceneRD::shadow_atlas_create() {
+RID RendererSceneRenderRD::shadow_atlas_create() {
 	return shadow_atlas_owner.make_rid(ShadowAtlas());
 }
 
-void RasterizerSceneRD::shadow_atlas_set_size(RID p_atlas, int p_size) {
+void RendererSceneRenderRD::shadow_atlas_set_size(RID p_atlas, int p_size) {
 	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
 	ERR_FAIL_COND(!shadow_atlas);
 	ERR_FAIL_COND(p_size < 0);
@@ -3514,7 +3543,7 @@ void RasterizerSceneRD::shadow_atlas_set_size(RID p_atlas, int p_size) {
 	}
 }
 
-void RasterizerSceneRD::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) {
+void RendererSceneRenderRD::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) {
 	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
 	ERR_FAIL_COND(!shadow_atlas);
 	ERR_FAIL_INDEX(p_quadrant, 4);
@@ -3576,7 +3605,7 @@ void RasterizerSceneRD::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p
 	} while (swaps > 0);
 }
 
-bool RasterizerSceneRD::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow) {
+bool RendererSceneRenderRD::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int *p_in_quadrants, int p_quadrant_count, int p_current_subdiv, uint64_t p_tick, int &r_quadrant, int &r_shadow) {
 	for (int i = p_quadrant_count - 1; i >= 0; i--) {
 		int qidx = p_in_quadrants[i];
 
@@ -3631,7 +3660,7 @@ bool RasterizerSceneRD::_shadow_atlas_find_shadow(ShadowAtlas *shadow_atlas, int
 	return false;
 }
 
-bool RasterizerSceneRD::shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version) {
+bool RendererSceneRenderRD::shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version) {
 	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_atlas);
 	ERR_FAIL_COND_V(!shadow_atlas, false);
 
@@ -3766,7 +3795,7 @@ bool RasterizerSceneRD::shadow_atlas_update_light(RID p_atlas, RID p_light_intan
 	return false;
 }
 
-void RasterizerSceneRD::directional_shadow_atlas_set_size(int p_size) {
+void RendererSceneRenderRD::directional_shadow_atlas_set_size(int p_size) {
 	p_size = nearest_power_of_2_templated(p_size);
 
 	if (directional_shadow.size == p_size) {
@@ -3794,7 +3823,7 @@ void RasterizerSceneRD::directional_shadow_atlas_set_size(int p_size) {
 	_base_uniforms_changed();
 }
 
-void RasterizerSceneRD::set_directional_shadow_count(int p_count) {
+void RendererSceneRenderRD::set_directional_shadow_count(int p_count) {
 	directional_shadow.light_count = p_count;
 	directional_shadow.current_light = 0;
 }
@@ -3821,7 +3850,7 @@ static Rect2i _get_directional_shadow_rect(int p_size, int p_shadow_count, int p
 	return rect;
 }
 
-int RasterizerSceneRD::get_directional_light_shadow_size(RID p_light_intance) {
+int RendererSceneRenderRD::get_directional_light_shadow_size(RID p_light_intance) {
 	ERR_FAIL_COND_V(directional_shadow.light_count == 0, 0);
 
 	Rect2i r = _get_directional_shadow_rect(directional_shadow.size, directional_shadow.light_count, 0);
@@ -3845,20 +3874,20 @@ int RasterizerSceneRD::get_directional_light_shadow_size(RID p_light_intance) {
 
 //////////////////////////////////////////////////
 
-RID RasterizerSceneRD::camera_effects_create() {
+RID RendererSceneRenderRD::camera_effects_create() {
 	return camera_effects_owner.make_rid(CameraEffects());
 }
 
-void RasterizerSceneRD::camera_effects_set_dof_blur_quality(RS::DOFBlurQuality p_quality, bool p_use_jitter) {
+void RendererSceneRenderRD::camera_effects_set_dof_blur_quality(RS::DOFBlurQuality p_quality, bool p_use_jitter) {
 	dof_blur_quality = p_quality;
 	dof_blur_use_jitter = p_use_jitter;
 }
 
-void RasterizerSceneRD::camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape p_shape) {
+void RendererSceneRenderRD::camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape p_shape) {
 	dof_blur_bokeh_shape = p_shape;
 }
 
-void RasterizerSceneRD::camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) {
+void RendererSceneRenderRD::camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) {
 	CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
 	ERR_FAIL_COND(!camfx);
 
@@ -3873,7 +3902,7 @@ void RasterizerSceneRD::camera_effects_set_dof_blur(RID p_camera_effects, bool p
 	camfx->dof_blur_amount = p_amount;
 }
 
-void RasterizerSceneRD::camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) {
+void RendererSceneRenderRD::camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) {
 	CameraEffects *camfx = camera_effects_owner.getornull(p_camera_effects);
 	ERR_FAIL_COND(!camfx);
 
@@ -3881,7 +3910,7 @@ void RasterizerSceneRD::camera_effects_set_custom_exposure(RID p_camera_effects,
 	camfx->override_exposure = p_exposure;
 }
 
-RID RasterizerSceneRD::light_instance_create(RID p_light) {
+RID RendererSceneRenderRD::light_instance_create(RID p_light) {
 	RID li = light_instance_owner.make_rid(LightInstance());
 
 	LightInstance *light_instance = light_instance_owner.getornull(li);
@@ -3893,21 +3922,21 @@ RID RasterizerSceneRD::light_instance_create(RID p_light) {
 	return li;
 }
 
-void RasterizerSceneRD::light_instance_set_transform(RID p_light_instance, const Transform &p_transform) {
+void RendererSceneRenderRD::light_instance_set_transform(RID p_light_instance, const Transform &p_transform) {
 	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
 	light_instance->transform = p_transform;
 }
 
-void RasterizerSceneRD::light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb) {
+void RendererSceneRenderRD::light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb) {
 	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
 	light_instance->aabb = p_aabb;
 }
 
-void RasterizerSceneRD::light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale, float p_range_begin, const Vector2 &p_uv_scale) {
+void RendererSceneRenderRD::light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale, float p_range_begin, const Vector2 &p_uv_scale) {
 	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
@@ -3927,14 +3956,14 @@ void RasterizerSceneRD::light_instance_set_shadow_transform(RID p_light_instance
 	light_instance->shadow_transform[p_pass].uv_scale = p_uv_scale;
 }
 
-void RasterizerSceneRD::light_instance_mark_visible(RID p_light_instance) {
+void RendererSceneRenderRD::light_instance_mark_visible(RID p_light_instance) {
 	LightInstance *light_instance = light_instance_owner.getornull(p_light_instance);
 	ERR_FAIL_COND(!light_instance);
 
 	light_instance->last_scene_pass = scene_pass;
 }
 
-RasterizerSceneRD::ShadowCubemap *RasterizerSceneRD::_get_shadow_cubemap(int p_size) {
+RendererSceneRenderRD::ShadowCubemap *RendererSceneRenderRD::_get_shadow_cubemap(int p_size) {
 	if (!shadow_cubemaps.has(p_size)) {
 		ShadowCubemap sc;
 		{
@@ -3942,7 +3971,7 @@ RasterizerSceneRD::ShadowCubemap *RasterizerSceneRD::_get_shadow_cubemap(int p_s
 			tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D32_SFLOAT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D32_SFLOAT : RD::DATA_FORMAT_X8_D24_UNORM_PACK32;
 			tf.width = p_size;
 			tf.height = p_size;
-			tf.type = RD::TEXTURE_TYPE_CUBE;
+			tf.texture_type = RD::TEXTURE_TYPE_CUBE;
 			tf.array_layers = 6;
 			tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
 			sc.cubemap = RD::get_singleton()->texture_create(tf, RD::TextureView());
@@ -3961,7 +3990,7 @@ RasterizerSceneRD::ShadowCubemap *RasterizerSceneRD::_get_shadow_cubemap(int p_s
 	return &shadow_cubemaps[p_size];
 }
 
-RasterizerSceneRD::ShadowMap *RasterizerSceneRD::_get_shadow_map(const Size2i &p_size) {
+RendererSceneRenderRD::ShadowMap *RendererSceneRenderRD::_get_shadow_map(const Size2i &p_size) {
 	if (!shadow_maps.has(p_size)) {
 		ShadowMap sm;
 		{
@@ -3986,13 +4015,13 @@ RasterizerSceneRD::ShadowMap *RasterizerSceneRD::_get_shadow_map(const Size2i &p
 
 //////////////////////////
 
-RID RasterizerSceneRD::decal_instance_create(RID p_decal) {
+RID RendererSceneRenderRD::decal_instance_create(RID p_decal) {
 	DecalInstance di;
 	di.decal = p_decal;
 	return decal_instance_owner.make_rid(di);
 }
 
-void RasterizerSceneRD::decal_instance_set_transform(RID p_decal, const Transform &p_transform) {
+void RendererSceneRenderRD::decal_instance_set_transform(RID p_decal, const Transform &p_transform) {
 	DecalInstance *di = decal_instance_owner.getornull(p_decal);
 	ERR_FAIL_COND(!di);
 	di->transform = p_transform;
@@ -4000,32 +4029,40 @@ void RasterizerSceneRD::decal_instance_set_transform(RID p_decal, const Transfor
 
 /////////////////////////////////
 
-RID RasterizerSceneRD::gi_probe_instance_create(RID p_base) {
+RID RendererSceneRenderRD::gi_probe_instance_create(RID p_base) {
 	GIProbeInstance gi_probe;
 	gi_probe.probe = p_base;
 	RID rid = gi_probe_instance_owner.make_rid(gi_probe);
 	return rid;
 }
 
-void RasterizerSceneRD::gi_probe_instance_set_transform_to_data(RID p_probe, const Transform &p_xform) {
+void RendererSceneRenderRD::gi_probe_instance_set_transform_to_data(RID p_probe, const Transform &p_xform) {
 	GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->transform = p_xform;
 }
 
-bool RasterizerSceneRD::gi_probe_needs_update(RID p_probe) const {
+bool RendererSceneRenderRD::gi_probe_needs_update(RID p_probe) const {
 	GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!gi_probe, false);
 
+	if (low_end) {
+		return false;
+	}
+
 	//return true;
 	return gi_probe->last_probe_version != storage->gi_probe_get_version(gi_probe->probe);
 }
 
-void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, int p_dynamic_object_count, InstanceBase **p_dynamic_objects) {
+void RendererSceneRenderRD::gi_probe_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, int p_dynamic_object_count, InstanceBase **p_dynamic_objects) {
 	GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_probe);
 	ERR_FAIL_COND(!gi_probe);
 
+	if (low_end) {
+		return;
+	}
+
 	uint32_t data_version = storage->gi_probe_get_data_version(gi_probe->probe);
 
 	// (RE)CREATE IF NEEDED
@@ -4056,7 +4093,7 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 			tf.width = octree_size.x;
 			tf.height = octree_size.y;
 			tf.depth = octree_size.z;
-			tf.type = RD::TEXTURE_TYPE_3D;
+			tf.texture_type = RD::TEXTURE_TYPE_3D;
 			tf.mipmaps = levels.size();
 
 			tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
@@ -4087,14 +4124,14 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 				Vector<RD::Uniform> uniforms;
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+					u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 					u.binding = 1;
 					u.ids.push_back(storage->gi_probe_get_octree_buffer(gi_probe->probe));
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+					u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 					u.binding = 2;
 					u.ids.push_back(storage->gi_probe_get_data_buffer(gi_probe->probe));
 					uniforms.push_back(u);
@@ -4102,21 +4139,21 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+					u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 					u.binding = 4;
 					u.ids.push_back(gi_probe->write_buffer);
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_TEXTURE;
+					u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 					u.binding = 9;
 					u.ids.push_back(storage->gi_probe_get_sdf_texture(gi_probe->probe));
 					uniforms.push_back(u);
 				}
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_SAMPLER;
+					u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 					u.binding = 10;
 					u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 					uniforms.push_back(u);
@@ -4127,7 +4164,7 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 					if (i == 0) {
 						{
 							RD::Uniform u;
-							u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+							u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 							u.binding = 3;
 							u.ids.push_back(gi_probe_lights_uniform);
 							copy_uniforms.push_back(u);
@@ -4139,7 +4176,7 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 
 						{
 							RD::Uniform u;
-							u.type = RD::UNIFORM_TYPE_TEXTURE;
+							u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 							u.binding = 5;
 							u.ids.push_back(gi_probe->texture);
 							copy_uniforms.push_back(u);
@@ -4152,7 +4189,7 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 
 				{
 					RD::Uniform u;
-					u.type = RD::UNIFORM_TYPE_IMAGE;
+					u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 					u.binding = 5;
 					u.ids.push_back(mipmap.texture);
 					uniforms.push_back(u);
@@ -4226,7 +4263,7 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 							Vector<RD::Uniform> uniforms;
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+								u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 								u.binding = 3;
 								u.ids.push_back(gi_probe_lights_uniform);
 								uniforms.push_back(u);
@@ -4234,56 +4271,56 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 5;
 								u.ids.push_back(dmap.albedo);
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 6;
 								u.ids.push_back(dmap.normal);
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 7;
 								u.ids.push_back(dmap.orm);
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_TEXTURE;
+								u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 								u.binding = 8;
 								u.ids.push_back(dmap.fb_depth);
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_TEXTURE;
+								u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 								u.binding = 9;
 								u.ids.push_back(storage->gi_probe_get_sdf_texture(gi_probe->probe));
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_SAMPLER;
+								u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 								u.binding = 10;
 								u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 11;
 								u.ids.push_back(dmap.texture);
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 12;
 								u.ids.push_back(dmap.depth);
 								uniforms.push_back(u);
@@ -4299,14 +4336,14 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 
 						{
 							RD::Uniform u;
-							u.type = RD::UNIFORM_TYPE_IMAGE;
+							u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 							u.binding = 5;
 							u.ids.push_back(gi_probe->dynamic_maps[gi_probe->dynamic_maps.size() - 1].texture);
 							uniforms.push_back(u);
 						}
 						{
 							RD::Uniform u;
-							u.type = RD::UNIFORM_TYPE_IMAGE;
+							u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 							u.binding = 6;
 							u.ids.push_back(gi_probe->dynamic_maps[gi_probe->dynamic_maps.size() - 1].depth);
 							uniforms.push_back(u);
@@ -4315,14 +4352,14 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 						if (write) {
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 7;
 								u.ids.push_back(dmap.texture);
 								uniforms.push_back(u);
 							}
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 8;
 								u.ids.push_back(dmap.depth);
 								uniforms.push_back(u);
@@ -4331,14 +4368,14 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 
 						{
 							RD::Uniform u;
-							u.type = RD::UNIFORM_TYPE_TEXTURE;
+							u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 							u.binding = 9;
 							u.ids.push_back(storage->gi_probe_get_sdf_texture(gi_probe->probe));
 							uniforms.push_back(u);
 						}
 						{
 							RD::Uniform u;
-							u.type = RD::UNIFORM_TYPE_SAMPLER;
+							u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 							u.binding = 10;
 							u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 							uniforms.push_back(u);
@@ -4347,7 +4384,7 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 						if (plot) {
 							{
 								RD::Uniform u;
-								u.type = RD::UNIFORM_TYPE_IMAGE;
+								u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 								u.binding = 11;
 								u.ids.push_back(gi_probe->mipmaps[dmap.mipmap].texture);
 								uniforms.push_back(u);
@@ -4391,6 +4428,11 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 				RID light = light_instance_get_base_light(light_instance);
 
 				l.type = storage->light_get_type(light);
+				if (l.type == RS::LIGHT_DIRECTIONAL && storage->light_directional_is_sky_only(light)) {
+					light_count--;
+					continue;
+				}
+
 				l.attenuation = storage->light_get_param(light, RS::LIGHT_PARAM_ATTENUATION);
 				l.energy = storage->light_get_param(light, RS::LIGHT_PARAM_ENERGY) * storage->light_get_param(light, RS::LIGHT_PARAM_INDIRECT_ENERGY);
 				l.radius = to_cell.basis.xform(Vector3(storage->light_get_param(light, RS::LIGHT_PARAM_RANGE), 0, 0)).length();
@@ -4717,7 +4759,7 @@ void RasterizerSceneRD::gi_probe_update(RID p_probe, bool p_update_light_instanc
 	gi_probe->last_probe_version = storage->gi_probe_get_version(gi_probe->probe);
 }
 
-void RasterizerSceneRD::_debug_giprobe(RID p_gi_probe, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform, bool p_lighting, bool p_emission, float p_alpha) {
+void RendererSceneRenderRD::_debug_giprobe(RID p_gi_probe, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform, bool p_lighting, bool p_emission, float p_alpha) {
 	GIProbeInstance *gi_probe = gi_probe_instance_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
@@ -4753,21 +4795,21 @@ void RasterizerSceneRD::_debug_giprobe(RID p_gi_probe, RD::DrawListID p_draw_lis
 	Vector<RD::Uniform> uniforms;
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+		u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 		u.binding = 1;
 		u.ids.push_back(storage->gi_probe_get_data_buffer(gi_probe->probe));
 		uniforms.push_back(u);
 	}
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_TEXTURE;
+		u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 		u.binding = 2;
 		u.ids.push_back(gi_probe->texture);
 		uniforms.push_back(u);
 	}
 	{
 		RD::Uniform u;
-		u.type = RD::UNIFORM_TYPE_SAMPLER;
+		u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 		u.binding = 3;
 		u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 		uniforms.push_back(u);
@@ -4787,7 +4829,7 @@ void RasterizerSceneRD::_debug_giprobe(RID p_gi_probe, RD::DrawListID p_draw_lis
 	RD::get_singleton()->draw_list_draw(p_draw_list, false, cell_count, 36);
 }
 
-void RasterizerSceneRD::_debug_sdfgi_probes(RID p_render_buffers, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform) {
+void RendererSceneRenderRD::_debug_sdfgi_probes(RID p_render_buffers, RD::DrawListID p_draw_list, RID p_framebuffer, const CameraMatrix &p_camera_with_transform) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
@@ -4826,28 +4868,28 @@ void RasterizerSceneRD::_debug_sdfgi_probes(RID p_render_buffers, RD::DrawListID
 		{
 			RD::Uniform u;
 			u.binding = 1;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.ids.push_back(rb->sdfgi->cascades_ubo);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 2;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.ids.push_back(rb->sdfgi->lightprobe_texture);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 3;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 4;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.ids.push_back(rb->sdfgi->occlusion_texture);
 			uniforms.push_back(u);
 		}
@@ -4924,13 +4966,13 @@ void RasterizerSceneRD::_debug_sdfgi_probes(RID p_render_buffers, RD::DrawListID
 }
 
 ////////////////////////////////
-RID RasterizerSceneRD::render_buffers_create() {
+RID RendererSceneRenderRD::render_buffers_create() {
 	RenderBuffers rb;
 	rb.data = _create_render_buffer_data();
 	return render_buffers_owner.make_rid(rb);
 }
 
-void RasterizerSceneRD::_allocate_blur_textures(RenderBuffers *rb) {
+void RendererSceneRenderRD::_allocate_blur_textures(RenderBuffers *rb) {
 	ERR_FAIL_COND(!rb->blur[0].texture.is_null());
 
 	uint32_t mipmaps_required = Image::get_image_required_mipmaps(rb->width, rb->height, Image::FORMAT_RGBAH);
@@ -4939,7 +4981,7 @@ void RasterizerSceneRD::_allocate_blur_textures(RenderBuffers *rb) {
 	tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
 	tf.width = rb->width;
 	tf.height = rb->height;
-	tf.type = RD::TEXTURE_TYPE_2D;
+	tf.texture_type = RD::TEXTURE_TYPE_2D;
 	tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
 	tf.mipmaps = mipmaps_required;
 
@@ -4973,7 +5015,7 @@ void RasterizerSceneRD::_allocate_blur_textures(RenderBuffers *rb) {
 	}
 }
 
-void RasterizerSceneRD::_allocate_luminance_textures(RenderBuffers *rb) {
+void RendererSceneRenderRD::_allocate_luminance_textures(RenderBuffers *rb) {
 	ERR_FAIL_COND(!rb->luminance.current.is_null());
 
 	int w = rb->width;
@@ -5006,7 +5048,7 @@ void RasterizerSceneRD::_allocate_luminance_textures(RenderBuffers *rb) {
 	}
 }
 
-void RasterizerSceneRD::_free_render_buffer_data(RenderBuffers *rb) {
+void RendererSceneRenderRD::_free_render_buffer_data(RenderBuffers *rb) {
 	if (rb->texture.is_valid()) {
 		RD::get_singleton()->free(rb->texture);
 		rb->texture = RID();
@@ -5071,7 +5113,7 @@ void RasterizerSceneRD::_free_render_buffer_data(RenderBuffers *rb) {
 	}
 }
 
-void RasterizerSceneRD::_process_sss(RID p_render_buffers, const CameraMatrix &p_camera) {
+void RendererSceneRenderRD::_process_sss(RID p_render_buffers, const CameraMatrix &p_camera) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
@@ -5090,7 +5132,7 @@ void RasterizerSceneRD::_process_sss(RID p_render_buffers, const CameraMatrix &p
 	storage->get_effects()->sub_surface_scattering(rb->texture, rb->blur[0].mipmaps[0].texture, rb->depth_texture, p_camera, Size2i(rb->width, rb->height), sss_scale, sss_depth_scale, sss_quality);
 }
 
-void RasterizerSceneRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffer, RID p_normal_buffer, RID p_specular_buffer, RID p_metallic, const Color &p_metallic_mask, RID p_environment, const CameraMatrix &p_projection, bool p_use_additive) {
+void RendererSceneRenderRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffer, RID p_normal_buffer, RID p_specular_buffer, RID p_metallic, const Color &p_metallic_mask, RID p_environment, const CameraMatrix &p_projection, bool p_use_additive) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
@@ -5112,7 +5154,7 @@ void RasterizerSceneRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffe
 		tf.format = RD::DATA_FORMAT_R32_SFLOAT;
 		tf.width = rb->width / 2;
 		tf.height = rb->height / 2;
-		tf.type = RD::TEXTURE_TYPE_2D;
+		tf.texture_type = RD::TEXTURE_TYPE_2D;
 		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
 
 		rb->ssr.depth_scaled = RD::get_singleton()->texture_create(tf, RD::TextureView());
@@ -5127,7 +5169,7 @@ void RasterizerSceneRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffe
 		tf.format = RD::DATA_FORMAT_R8_UNORM;
 		tf.width = rb->width / 2;
 		tf.height = rb->height / 2;
-		tf.type = RD::TEXTURE_TYPE_2D;
+		tf.texture_type = RD::TEXTURE_TYPE_2D;
 		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;
 
 		rb->ssr.blur_radius[0] = RD::get_singleton()->texture_create(tf, RD::TextureView());
@@ -5143,7 +5185,7 @@ void RasterizerSceneRD::_process_ssr(RID p_render_buffers, RID p_dest_framebuffe
 	storage->get_effects()->merge_specular(p_dest_framebuffer, p_specular_buffer, p_use_additive ? RID() : rb->texture, rb->blur[0].mipmaps[1].texture);
 }
 
-void RasterizerSceneRD::_process_ssao(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const CameraMatrix &p_projection) {
+void RendererSceneRenderRD::_process_ssao(RID p_render_buffers, RID p_environment, RID p_normal_buffer, const CameraMatrix &p_projection) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
@@ -5212,7 +5254,7 @@ void RasterizerSceneRD::_process_ssao(RID p_render_buffers, RID p_environment, R
 	storage->get_effects()->generate_ssao(rb->depth_texture, p_normal_buffer, Size2i(rb->width, rb->height), rb->ssao.depth, rb->ssao.depth_slices, rb->ssao.ao[0], rb->ssao.ao_full.is_valid(), rb->ssao.ao[1], rb->ssao.ao_full, env->ssao_intensity, env->ssao_radius, env->ssao_bias, p_projection, ssao_quality, env->ssao_blur, env->ssao_blur_edge_sharpness);
 }
 
-void RasterizerSceneRD::_render_buffers_post_process_and_tonemap(RID p_render_buffers, RID p_environment, RID p_camera_effects, const CameraMatrix &p_projection) {
+void RendererSceneRenderRD::_render_buffers_post_process_and_tonemap(RID p_render_buffers, RID p_environment, RID p_camera_effects, const CameraMatrix &p_projection) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
@@ -5246,7 +5288,7 @@ void RasterizerSceneRD::_render_buffers_post_process_and_tonemap(RID p_render_bu
 
 		//swap final reduce with prev luminance
 		SWAP(rb->luminance.current, rb->luminance.reduce.write[rb->luminance.reduce.size() - 1]);
-		RenderingServerRaster::redraw_request(); //redraw all the time if auto exposure rendering is on
+		RenderingServerDefault::redraw_request(); //redraw all the time if auto exposure rendering is on
 	}
 
 	int max_glow_level = -1;
@@ -5287,21 +5329,19 @@ void RasterizerSceneRD::_render_buffers_post_process_and_tonemap(RID p_render_bu
 
 	{
 		//tonemap
-		RasterizerEffectsRD::TonemapSettings tonemap;
-
-		tonemap.color_correction_texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+		EffectsRD::TonemapSettings tonemap;
 
 		if (can_use_effects && env && env->auto_exposure && rb->luminance.current.is_valid()) {
 			tonemap.use_auto_exposure = true;
 			tonemap.exposure_texture = rb->luminance.current;
 			tonemap.auto_exposure_grey = env->auto_exp_scale;
 		} else {
-			tonemap.exposure_texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE);
+			tonemap.exposure_texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE);
 		}
 
 		if (can_use_effects && env && env->glow_enabled) {
 			tonemap.use_glow = true;
-			tonemap.glow_mode = RasterizerEffectsRD::TonemapSettings::GlowMode(env->glow_blend_mode);
+			tonemap.glow_mode = EffectsRD::TonemapSettings::GlowMode(env->glow_blend_mode);
 			tonemap.glow_intensity = env->glow_blend_mode == RS::ENV_GLOW_BLEND_MODE_MIX ? env->glow_mix : env->glow_intensity;
 			for (int i = 0; i < RS::MAX_GLOW_LEVELS; i++) {
 				tonemap.glow_levels[i] = env->glow_levels[i];
@@ -5311,7 +5351,7 @@ void RasterizerSceneRD::_render_buffers_post_process_and_tonemap(RID p_render_bu
 			tonemap.glow_use_bicubic_upscale = glow_bicubic_upscale;
 			tonemap.glow_texture = rb->blur[1].texture;
 		} else {
-			tonemap.glow_texture = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK);
+			tonemap.glow_texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK);
 		}
 
 		if (rb->screen_space_aa == RS::VIEWPORT_SCREEN_SPACE_AA_FXAA) {
@@ -5327,14 +5367,30 @@ void RasterizerSceneRD::_render_buffers_post_process_and_tonemap(RID p_render_bu
 			tonemap.exposure = env->exposure;
 		}
 
+		tonemap.use_color_correction = false;
+		tonemap.use_1d_color_correction = false;
+		tonemap.color_correction_texture = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+
+		if (can_use_effects && env) {
+			tonemap.use_bcs = env->adjustments_enabled;
+			tonemap.brightness = env->adjustments_brightness;
+			tonemap.contrast = env->adjustments_contrast;
+			tonemap.saturation = env->adjustments_saturation;
+			if (env->adjustments_enabled && env->color_correction.is_valid()) {
+				tonemap.use_color_correction = true;
+				tonemap.use_1d_color_correction = env->use_1d_color_correction;
+				tonemap.color_correction_texture = storage->texture_get_rd_texture(env->color_correction);
+			}
+		}
+
 		storage->get_effects()->tonemapper(rb->texture, storage->render_target_get_rd_framebuffer(rb->render_target), tonemap);
 	}
 
 	storage->render_target_disable_clear_request(rb->render_target);
 }
 
-void RasterizerSceneRD::_render_buffers_debug_draw(RID p_render_buffers, RID p_shadow_atlas) {
-	RasterizerEffectsRD *effects = storage->get_effects();
+void RendererSceneRenderRD::_render_buffers_debug_draw(RID p_render_buffers, RID p_shadow_atlas) {
+	EffectsRD *effects = storage->get_effects();
 
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
@@ -5394,7 +5450,19 @@ void RasterizerSceneRD::_render_buffers_debug_draw(RID p_render_buffers, RID p_s
 	}
 }
 
-void RasterizerSceneRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatrix &p_projection, const Transform &p_transform) {
+void RendererSceneRenderRD::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.getornull(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 RendererSceneRenderRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatrix &p_projection, const Transform &p_transform) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 
@@ -5407,12 +5475,12 @@ void RasterizerSceneRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatr
 		{
 			RD::Uniform u;
 			u.binding = 1;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t i = 0; i < SDFGI::MAX_CASCADES; i++) {
 				if (i < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[i].sdf_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
@@ -5420,12 +5488,12 @@ void RasterizerSceneRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatr
 		{
 			RD::Uniform u;
 			u.binding = 2;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t i = 0; i < SDFGI::MAX_CASCADES; i++) {
 				if (i < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[i].light_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
@@ -5433,12 +5501,12 @@ void RasterizerSceneRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatr
 		{
 			RD::Uniform u;
 			u.binding = 3;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t i = 0; i < SDFGI::MAX_CASCADES; i++) {
 				if (i < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[i].light_aniso_0_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
@@ -5446,12 +5514,12 @@ void RasterizerSceneRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatr
 		{
 			RD::Uniform u;
 			u.binding = 4;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			for (uint32_t i = 0; i < SDFGI::MAX_CASCADES; i++) {
 				if (i < rb->sdfgi->cascades.size()) {
 					u.ids.push_back(rb->sdfgi->cascades[i].light_aniso_1_tex);
 				} else {
-					u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
 				}
 			}
 			uniforms.push_back(u);
@@ -5459,35 +5527,35 @@ void RasterizerSceneRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatr
 		{
 			RD::Uniform u;
 			u.binding = 5;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.ids.push_back(rb->sdfgi->occlusion_texture);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 8;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 9;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.ids.push_back(rb->sdfgi->cascades_ubo);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 10;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 			u.ids.push_back(rb->texture);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
 			u.binding = 11;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.ids.push_back(rb->sdfgi->lightprobe_texture);
 			uniforms.push_back(u);
 		}
@@ -5540,7 +5608,7 @@ void RasterizerSceneRD::_sdfgi_debug_draw(RID p_render_buffers, const CameraMatr
 	storage->get_effects()->copy_to_fb_rect(rb->texture, storage->render_target_get_rd_framebuffer(rb->render_target), Rect2(Vector2(), rtsize), true);
 }
 
-RID RasterizerSceneRD::render_buffers_get_back_buffer_texture(RID p_render_buffers) {
+RID RendererSceneRenderRD::render_buffers_get_back_buffer_texture(RID p_render_buffers) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	if (!rb->blur[0].texture.is_valid()) {
@@ -5549,14 +5617,14 @@ RID RasterizerSceneRD::render_buffers_get_back_buffer_texture(RID p_render_buffe
 	return rb->blur[0].texture;
 }
 
-RID RasterizerSceneRD::render_buffers_get_ao_texture(RID p_render_buffers) {
+RID RendererSceneRenderRD::render_buffers_get_ao_texture(RID p_render_buffers) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 
 	return rb->ssao.ao_full.is_valid() ? rb->ssao.ao_full : rb->ssao.ao[0];
 }
 
-RID RasterizerSceneRD::render_buffers_get_gi_probe_buffer(RID p_render_buffers) {
+RID RendererSceneRenderRD::render_buffers_get_gi_probe_buffer(RID p_render_buffers) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	if (rb->giprobe_buffer.is_null()) {
@@ -5565,24 +5633,24 @@ RID RasterizerSceneRD::render_buffers_get_gi_probe_buffer(RID p_render_buffers)
 	return rb->giprobe_buffer;
 }
 
-RID RasterizerSceneRD::render_buffers_get_default_gi_probe_buffer() {
+RID RendererSceneRenderRD::render_buffers_get_default_gi_probe_buffer() {
 	return default_giprobe_buffer;
 }
 
-uint32_t RasterizerSceneRD::render_buffers_get_sdfgi_cascade_count(RID p_render_buffers) const {
+uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_count(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
 
 	return rb->sdfgi->cascades.size();
 }
-bool RasterizerSceneRD::render_buffers_is_sdfgi_enabled(RID p_render_buffers) const {
+bool RendererSceneRenderRD::render_buffers_is_sdfgi_enabled(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, false);
 
 	return rb->sdfgi != nullptr;
 }
-RID RasterizerSceneRD::render_buffers_get_sdfgi_irradiance_probes(RID p_render_buffers) const {
+RID RendererSceneRenderRD::render_buffers_get_sdfgi_irradiance_probes(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	ERR_FAIL_COND_V(!rb->sdfgi, RID());
@@ -5590,7 +5658,7 @@ RID RasterizerSceneRD::render_buffers_get_sdfgi_irradiance_probes(RID p_render_b
 	return rb->sdfgi->lightprobe_texture;
 }
 
-Vector3 RasterizerSceneRD::render_buffers_get_sdfgi_cascade_offset(RID p_render_buffers, uint32_t p_cascade) const {
+Vector3 RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_offset(RID p_render_buffers, uint32_t p_cascade) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, Vector3());
 	ERR_FAIL_COND_V(!rb->sdfgi, Vector3());
@@ -5599,7 +5667,7 @@ Vector3 RasterizerSceneRD::render_buffers_get_sdfgi_cascade_offset(RID p_render_
 	return Vector3((Vector3i(1, 1, 1) * -int32_t(rb->sdfgi->cascade_size >> 1) + rb->sdfgi->cascades[p_cascade].position)) * rb->sdfgi->cascades[p_cascade].cell_size;
 }
 
-Vector3i RasterizerSceneRD::render_buffers_get_sdfgi_cascade_probe_offset(RID p_render_buffers, uint32_t p_cascade) const {
+Vector3i RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_offset(RID p_render_buffers, uint32_t p_cascade) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, Vector3i());
 	ERR_FAIL_COND_V(!rb->sdfgi, Vector3i());
@@ -5609,14 +5677,14 @@ Vector3i RasterizerSceneRD::render_buffers_get_sdfgi_cascade_probe_offset(RID p_
 	return rb->sdfgi->cascades[p_cascade].position / probe_divisor;
 }
 
-float RasterizerSceneRD::render_buffers_get_sdfgi_normal_bias(RID p_render_buffers) const {
+float RendererSceneRenderRD::render_buffers_get_sdfgi_normal_bias(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
 
 	return rb->sdfgi->normal_bias;
 }
-float RasterizerSceneRD::render_buffers_get_sdfgi_cascade_probe_size(RID p_render_buffers, uint32_t p_cascade) const {
+float RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_size(RID p_render_buffers, uint32_t p_cascade) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
@@ -5624,7 +5692,7 @@ float RasterizerSceneRD::render_buffers_get_sdfgi_cascade_probe_size(RID p_rende
 
 	return float(rb->sdfgi->cascade_size) * rb->sdfgi->cascades[p_cascade].cell_size / float(rb->sdfgi->probe_axis_count - 1);
 }
-uint32_t RasterizerSceneRD::render_buffers_get_sdfgi_cascade_probe_count(RID p_render_buffers) const {
+uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_probe_count(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
@@ -5632,7 +5700,7 @@ uint32_t RasterizerSceneRD::render_buffers_get_sdfgi_cascade_probe_count(RID p_r
 	return rb->sdfgi->probe_axis_count;
 }
 
-uint32_t RasterizerSceneRD::render_buffers_get_sdfgi_cascade_size(RID p_render_buffers) const {
+uint32_t RendererSceneRenderRD::render_buffers_get_sdfgi_cascade_size(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, 0);
 	ERR_FAIL_COND_V(!rb->sdfgi, 0);
@@ -5640,7 +5708,7 @@ uint32_t RasterizerSceneRD::render_buffers_get_sdfgi_cascade_size(RID p_render_b
 	return rb->sdfgi->cascade_size;
 }
 
-bool RasterizerSceneRD::render_buffers_is_sdfgi_using_occlusion(RID p_render_buffers) const {
+bool RendererSceneRenderRD::render_buffers_is_sdfgi_using_occlusion(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, false);
 	ERR_FAIL_COND_V(!rb->sdfgi, false);
@@ -5648,14 +5716,14 @@ bool RasterizerSceneRD::render_buffers_is_sdfgi_using_occlusion(RID p_render_buf
 	return rb->sdfgi->uses_occlusion;
 }
 
-float RasterizerSceneRD::render_buffers_get_sdfgi_energy(RID p_render_buffers) const {
+float RendererSceneRenderRD::render_buffers_get_sdfgi_energy(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
-	ERR_FAIL_COND_V(!rb, 0);
-	ERR_FAIL_COND_V(!rb->sdfgi, false);
+	ERR_FAIL_COND_V(!rb, 0.0);
+	ERR_FAIL_COND_V(!rb->sdfgi, 0.0);
 
 	return rb->sdfgi->energy;
 }
-RID RasterizerSceneRD::render_buffers_get_sdfgi_occlusion_texture(RID p_render_buffers) const {
+RID RendererSceneRenderRD::render_buffers_get_sdfgi_occlusion_texture(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 	ERR_FAIL_COND_V(!rb->sdfgi, RID());
@@ -5663,20 +5731,20 @@ RID RasterizerSceneRD::render_buffers_get_sdfgi_occlusion_texture(RID p_render_b
 	return rb->sdfgi->occlusion_texture;
 }
 
-bool RasterizerSceneRD::render_buffers_has_volumetric_fog(RID p_render_buffers) const {
+bool RendererSceneRenderRD::render_buffers_has_volumetric_fog(RID p_render_buffers) const {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, false);
 
 	return rb->volumetric_fog != nullptr;
 }
-RID RasterizerSceneRD::render_buffers_get_volumetric_fog_texture(RID p_render_buffers) {
+RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_texture(RID p_render_buffers) {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, RID());
 
 	return rb->volumetric_fog->fog_map;
 }
 
-RID RasterizerSceneRD::render_buffers_get_volumetric_fog_sky_uniform_set(RID p_render_buffers) {
+RID RendererSceneRenderRD::render_buffers_get_volumetric_fog_sky_uniform_set(RID p_render_buffers) {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, RID());
 
@@ -5687,18 +5755,18 @@ RID RasterizerSceneRD::render_buffers_get_volumetric_fog_sky_uniform_set(RID p_r
 	return rb->volumetric_fog->sky_uniform_set;
 }
 
-float RasterizerSceneRD::render_buffers_get_volumetric_fog_end(RID p_render_buffers) {
+float RendererSceneRenderRD::render_buffers_get_volumetric_fog_end(RID p_render_buffers) {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, 0);
 	return rb->volumetric_fog->length;
 }
-float RasterizerSceneRD::render_buffers_get_volumetric_fog_detail_spread(RID p_render_buffers) {
+float RendererSceneRenderRD::render_buffers_get_volumetric_fog_detail_spread(RID p_render_buffers) {
 	const RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb || !rb->volumetric_fog, 0);
 	return rb->volumetric_fog->spread;
 }
 
-void RasterizerSceneRD::render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, RS::ViewportMSAA p_msaa, RenderingServer::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_debanding) {
+void RendererSceneRenderRD::render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, RS::ViewportMSAA p_msaa, RenderingServer::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_debanding) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	rb->width = p_width;
 	rb->height = p_height;
@@ -5748,20 +5816,20 @@ void RasterizerSceneRD::render_buffers_configure(RID p_render_buffers, RID p_ren
 	_render_buffers_uniform_set_changed(p_render_buffers);
 }
 
-void RasterizerSceneRD::sub_surface_scattering_set_quality(RS::SubSurfaceScatteringQuality p_quality) {
+void RendererSceneRenderRD::sub_surface_scattering_set_quality(RS::SubSurfaceScatteringQuality p_quality) {
 	sss_quality = p_quality;
 }
 
-RS::SubSurfaceScatteringQuality RasterizerSceneRD::sub_surface_scattering_get_quality() const {
+RS::SubSurfaceScatteringQuality RendererSceneRenderRD::sub_surface_scattering_get_quality() const {
 	return sss_quality;
 }
 
-void RasterizerSceneRD::sub_surface_scattering_set_scale(float p_scale, float p_depth_scale) {
+void RendererSceneRenderRD::sub_surface_scattering_set_scale(float p_scale, float p_depth_scale) {
 	sss_scale = p_scale;
 	sss_depth_scale = p_depth_scale;
 }
 
-void RasterizerSceneRD::shadows_quality_set(RS::ShadowQuality p_quality) {
+void RendererSceneRenderRD::shadows_quality_set(RS::ShadowQuality p_quality) {
 	ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
 
 	if (shadows_quality != p_quality) {
@@ -5801,7 +5869,7 @@ void RasterizerSceneRD::shadows_quality_set(RS::ShadowQuality p_quality) {
 	}
 }
 
-void RasterizerSceneRD::directional_shadow_quality_set(RS::ShadowQuality p_quality) {
+void RendererSceneRenderRD::directional_shadow_quality_set(RS::ShadowQuality p_quality) {
 	ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
 
 	if (directional_shadow_quality != p_quality) {
@@ -5841,21 +5909,21 @@ void RasterizerSceneRD::directional_shadow_quality_set(RS::ShadowQuality p_quali
 	}
 }
 
-int RasterizerSceneRD::get_roughness_layers() const {
+int RendererSceneRenderRD::get_roughness_layers() const {
 	return roughness_layers;
 }
 
-bool RasterizerSceneRD::is_using_radiance_cubemap_array() const {
+bool RendererSceneRenderRD::is_using_radiance_cubemap_array() const {
 	return sky_use_cubemap_array;
 }
 
-RasterizerSceneRD::RenderBufferData *RasterizerSceneRD::render_buffers_get_data(RID p_render_buffers) {
+RendererSceneRenderRD::RenderBufferData *RendererSceneRenderRD::render_buffers_get_data(RID p_render_buffers) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND_V(!rb, nullptr);
 	return rb->data;
 }
 
-void RasterizerSceneRD::_setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, RID p_environment) {
+void RendererSceneRenderRD::_setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, RID p_environment) {
 	for (int i = 0; i < p_reflection_probe_cull_count; i++) {
 		RID rpi = p_reflection_probe_cull_result[i];
 
@@ -5903,7 +5971,7 @@ void RasterizerSceneRD::_setup_reflections(RID *p_reflection_probe_cull_result,
 
 		Transform transform = reflection_probe_instance_get_transform(rpi);
 		Transform proj = (p_camera_inverse_transform * transform).inverse();
-		RasterizerStorageRD::store_transform(proj, reflection_ubo.local_matrix);
+		RendererStorageRD::store_transform(proj, reflection_ubo.local_matrix);
 
 		cluster.builder.add_reflection_probe(transform, extents);
 
@@ -5915,7 +5983,7 @@ void RasterizerSceneRD::_setup_reflections(RID *p_reflection_probe_cull_result,
 	}
 }
 
-void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, RID p_shadow_atlas, bool p_using_shadows, uint32_t &r_directional_light_count, uint32_t &r_positional_light_count) {
+void RendererSceneRenderRD::_setup_lights(RID *p_light_cull_result, int p_light_cull_count, const Transform &p_camera_inverse_transform, RID p_shadow_atlas, bool p_using_shadows, uint32_t &r_directional_light_count, uint32_t &r_positional_light_count) {
 	uint32_t light_count = 0;
 	r_directional_light_count = 0;
 	r_positional_light_count = 0;
@@ -5930,7 +5998,40 @@ void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull
 		RS::LightType type = storage->light_get_type(base);
 		switch (type) {
 			case RS::LIGHT_DIRECTIONAL: {
-				if (r_directional_light_count >= cluster.max_directional_lights) {
+				//	Copy to SkyDirectionalLightData
+				if (r_directional_light_count < sky_scene_state.max_directional_lights) {
+					SkyDirectionalLightData &sky_light_data = sky_scene_state.directional_lights[r_directional_light_count];
+					Transform light_transform = light_instance_get_base_transform(li);
+					Vector3 world_direction = light_transform.basis.xform(Vector3(0, 0, 1)).normalized();
+
+					sky_light_data.direction[0] = world_direction.x;
+					sky_light_data.direction[1] = world_direction.y;
+					sky_light_data.direction[2] = -world_direction.z;
+
+					float sign = storage->light_is_negative(base) ? -1 : 1;
+					sky_light_data.energy = sign * storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY);
+
+					Color linear_col = storage->light_get_color(base).to_linear();
+					sky_light_data.color[0] = linear_col.r;
+					sky_light_data.color[1] = linear_col.g;
+					sky_light_data.color[2] = linear_col.b;
+
+					sky_light_data.enabled = true;
+
+					float angular_diameter = storage->light_get_param(base, RS::LIGHT_PARAM_SIZE);
+					if (angular_diameter > 0.0) {
+						// I know tan(0) is 0, but let's not risk it with numerical precision.
+						// technically this will keep expanding until reaching the sun, but all we care
+						// is expand until we reach the radius of the near plane (there can't be more occluders than that)
+						angular_diameter = Math::tan(Math::deg2rad(angular_diameter));
+					} else {
+						angular_diameter = 0.0;
+					}
+					sky_light_data.size = angular_diameter;
+					sky_scene_state.ubo.directional_light_count++;
+				}
+
+				if (r_directional_light_count >= cluster.max_directional_lights || storage->light_directional_is_sky_only(base)) {
 					continue;
 				}
 
@@ -6036,7 +6137,7 @@ void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull
 						light_data.shadow_transmittance_bias[j] = storage->light_get_transmittance_bias(base) * bias_scale;
 						light_data.shadow_z_range[j] = light_instance_get_shadow_range(li, j);
 						light_data.shadow_range_begin[j] = light_instance_get_shadow_range_begin(li, j);
-						RasterizerStorageRD::store_camera(shadow_mtx, light_data.shadow_matrices[j]);
+						RendererStorageRD::store_camera(shadow_mtx, light_data.shadow_matrices[j]);
 
 						Vector2 uv_scale = light_instance_get_shadow_uv_scale(li, j);
 						uv_scale *= atlas_rect.size; //adapt to atlas size
@@ -6073,27 +6174,6 @@ void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull
 					}
 				}
 
-				//	Copy to SkyDirectionalLightData
-				if (r_directional_light_count < sky_scene_state.max_directional_lights) {
-					SkyDirectionalLightData &sky_light_data = sky_scene_state.directional_lights[r_directional_light_count];
-
-					Vector3 world_direction = light_transform.basis.xform(Vector3(0, 0, 1)).normalized();
-
-					sky_light_data.direction[0] = world_direction.x;
-					sky_light_data.direction[1] = world_direction.y;
-					sky_light_data.direction[2] = -world_direction.z;
-
-					sky_light_data.energy = light_data.energy / Math_PI;
-
-					sky_light_data.color[0] = light_data.color[0];
-					sky_light_data.color[1] = light_data.color[1];
-					sky_light_data.color[2] = light_data.color[2];
-
-					sky_light_data.enabled = true;
-					sky_light_data.size = angular_diameter;
-					sky_scene_state.ubo.directional_light_count++;
-				}
-
 				r_directional_light_count++;
 			} break;
 			case RS::LIGHT_SPOT:
@@ -6210,7 +6290,7 @@ void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull
 						light_data.atlas_rect[3] *= 0.5; //one paraboloid on top of another
 						Transform proj = (p_camera_inverse_transform * light_transform).inverse();
 
-						RasterizerStorageRD::store_transform(proj, light_data.shadow_matrix);
+						RendererStorageRD::store_transform(proj, light_data.shadow_matrix);
 
 						if (size > 0.0) {
 							light_data.soft_shadow_size = size;
@@ -6225,7 +6305,7 @@ void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull
 						bias.set_light_bias();
 
 						CameraMatrix shadow_mtx = bias * light_instance_get_shadow_camera(li, 0) * modelview;
-						RasterizerStorageRD::store_camera(shadow_mtx, light_data.shadow_matrix);
+						RendererStorageRD::store_camera(shadow_mtx, light_data.shadow_matrix);
 
 						if (size > 0.0) {
 							CameraMatrix cm = light_instance_get_shadow_camera(li, 0);
@@ -6263,7 +6343,7 @@ void RasterizerSceneRD::_setup_lights(RID *p_light_cull_result, int p_light_cull
 	}
 }
 
-void RasterizerSceneRD::_setup_decals(const RID *p_decal_instances, int p_decal_count, const Transform &p_camera_inverse_xform) {
+void RendererSceneRenderRD::_setup_decals(const RID *p_decal_instances, int p_decal_count, const Transform &p_camera_inverse_xform) {
 	Transform uv_xform;
 	uv_xform.basis.scale(Vector3(2.0, 1.0, 2.0));
 	uv_xform.origin = Vector3(-1.0, 0.0, -1.0);
@@ -6299,7 +6379,7 @@ void RasterizerSceneRD::_setup_decals(const RID *p_decal_instances, int p_decal_
 		Transform scale_xform;
 		scale_xform.basis.scale(Vector3(decal_extents.x, decal_extents.y, decal_extents.z));
 		Transform to_decal_xform = (p_camera_inverse_xform * decal_instance_get_transform(di) * scale_xform * uv_xform).affine_inverse();
-		RasterizerStorageRD::store_transform(to_decal_xform, dd.xform);
+		RendererStorageRD::store_transform(to_decal_xform, dd.xform);
 
 		Vector3 normal = xform.basis.get_axis(Vector3::AXIS_Y).normalized();
 		normal = p_camera_inverse_xform.basis.xform(normal); //camera is normalized, so fine
@@ -6337,7 +6417,7 @@ void RasterizerSceneRD::_setup_decals(const RID *p_decal_instances, int p_decal_
 			dd.normal_rect[3] = rect.size.y;
 
 			Basis normal_xform = p_camera_inverse_xform.basis * xform.basis.orthonormalized();
-			RasterizerStorageRD::store_basis_3x4(normal_xform, dd.normal_xform);
+			RendererStorageRD::store_basis_3x4(normal_xform, dd.normal_xform);
 		} else {
 			dd.normal_rect[0] = 0;
 			dd.normal_rect[1] = 0;
@@ -6393,7 +6473,7 @@ void RasterizerSceneRD::_setup_decals(const RID *p_decal_instances, int p_decal_
 	}
 }
 
-void RasterizerSceneRD::_volumetric_fog_erase(RenderBuffers *rb) {
+void RendererSceneRenderRD::_volumetric_fog_erase(RenderBuffers *rb) {
 	ERR_FAIL_COND(!rb->volumetric_fog);
 
 	RD::get_singleton()->free(rb->volumetric_fog->light_density_map);
@@ -6417,7 +6497,7 @@ void RasterizerSceneRD::_volumetric_fog_erase(RenderBuffers *rb) {
 	rb->volumetric_fog = nullptr;
 }
 
-void RasterizerSceneRD::_allocate_shadow_shrink_stages(RID p_base, int p_base_size, Vector<ShadowShrinkStage> &shrink_stages, uint32_t p_target_size) {
+void RendererSceneRenderRD::_allocate_shadow_shrink_stages(RID p_base, int p_base_size, Vector<ShadowShrinkStage> &shrink_stages, uint32_t p_target_size) {
 	//create fog mipmaps
 	uint32_t fog_texture_size = p_target_size;
 	uint32_t base_texture_size = p_base_size;
@@ -6450,7 +6530,7 @@ void RasterizerSceneRD::_allocate_shadow_shrink_stages(RID p_base, int p_base_si
 	}
 }
 
-void RasterizerSceneRD::_clear_shadow_shrink_stages(Vector<ShadowShrinkStage> &shrink_stages) {
+void RendererSceneRenderRD::_clear_shadow_shrink_stages(Vector<ShadowShrinkStage> &shrink_stages) {
 	for (int i = 1; i < shrink_stages.size(); i++) {
 		RD::get_singleton()->free(shrink_stages[i].texture);
 		if (shrink_stages[i].filter_texture.is_valid()) {
@@ -6460,7 +6540,7 @@ void RasterizerSceneRD::_clear_shadow_shrink_stages(Vector<ShadowShrinkStage> &s
 	shrink_stages.clear();
 }
 
-void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_shadow_atlas, int p_directional_light_count, bool p_use_directional_shadows, int p_positional_light_count, int p_gi_probe_count) {
+void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_environment, const CameraMatrix &p_cam_projection, const Transform &p_cam_transform, RID p_shadow_atlas, int p_directional_light_count, bool p_use_directional_shadows, int p_positional_light_count, int p_gi_probe_count) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 	Environment *env = environment_owner.getornull(p_environment);
@@ -6494,7 +6574,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 		tf.width = target_width;
 		tf.height = target_height;
 		tf.depth = volumetric_fog_depth;
-		tf.type = RD::TEXTURE_TYPE_3D;
+		tf.texture_type = RD::TEXTURE_TYPE_3D;
 		tf.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
 
 		rb->volumetric_fog->light_density_map = RD::get_singleton()->texture_create(tf, RD::TextureView());
@@ -6508,7 +6588,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 		{
 			RD::Uniform u;
 			u.binding = 0;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.ids.push_back(rb->volumetric_fog->fog_map);
 			uniforms.push_back(u);
 		}
@@ -6681,10 +6761,10 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1;
 			if (shadow_atlas == nullptr || shadow_atlas->shrink_stages.size() == 0) {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK));
 			} else {
 				u.ids.push_back(shadow_atlas->shrink_stages[shadow_atlas->shrink_stages.size() - 1].texture);
 			}
@@ -6694,10 +6774,10 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 2;
 			if (directional_shadow.shrink_stages.size() == 0) {
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_BLACK));
+				u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_BLACK));
 			} else {
 				u.ids.push_back(directional_shadow.shrink_stages[directional_shadow.shrink_stages.size() - 1].texture);
 			}
@@ -6706,7 +6786,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 3;
 			u.ids.push_back(get_positional_light_buffer());
 			uniforms.push_back(u);
@@ -6714,7 +6794,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 4;
 			u.ids.push_back(get_directional_light_buffer());
 			uniforms.push_back(u);
@@ -6722,7 +6802,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 5;
 			u.ids.push_back(get_cluster_builder_texture());
 			uniforms.push_back(u);
@@ -6730,7 +6810,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 6;
 			u.ids.push_back(get_cluster_builder_indices_buffer());
 			uniforms.push_back(u);
@@ -6738,7 +6818,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 7;
 			u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 			uniforms.push_back(u);
@@ -6746,7 +6826,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 			u.binding = 8;
 			u.ids.push_back(rb->volumetric_fog->light_density_map);
 			uniforms.push_back(u);
@@ -6754,7 +6834,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_IMAGE;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 			u.binding = 9;
 			u.ids.push_back(rb->volumetric_fog->fog_map);
 			uniforms.push_back(u);
@@ -6762,7 +6842,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 10;
 			u.ids.push_back(shadow_sampler);
 			uniforms.push_back(u);
@@ -6770,7 +6850,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 11;
 			u.ids.push_back(render_buffers_get_gi_probe_buffer(p_render_buffers));
 			uniforms.push_back(u);
@@ -6778,7 +6858,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 12;
 			for (int i = 0; i < RenderBuffers::MAX_GIPROBES; i++) {
 				u.ids.push_back(rb->giprobe_textures[i]);
@@ -6787,7 +6867,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 13;
 			u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
 			uniforms.push_back(u);
@@ -6808,7 +6888,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 				u.binding = 0;
 				u.ids.push_back(gi.sdfgi_ubo);
 				uniforms.push_back(u);
@@ -6816,7 +6896,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				u.binding = 1;
 				u.ids.push_back(rb->sdfgi->ambient_texture);
 				uniforms.push_back(u);
@@ -6824,7 +6904,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				u.binding = 2;
 				u.ids.push_back(rb->sdfgi->occlusion_texture);
 				uniforms.push_back(u);
@@ -6939,7 +7019,7 @@ void RasterizerSceneRD::_update_volumetric_fog(RID p_render_buffers, RID p_envir
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerSceneRD::render_scene(RID p_render_buffers, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass) {
+void RendererSceneRenderRD::render_scene(RID p_render_buffers, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold) {
 	Color clear_color;
 	if (p_render_buffers.is_valid()) {
 		RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
@@ -6996,7 +7076,7 @@ void RasterizerSceneRD::render_scene(RID p_render_buffers, const Transform &p_ca
 		_update_volumetric_fog(p_render_buffers, p_environment, p_cam_projection, p_cam_transform, p_shadow_atlas, directional_light_count, directional_shadows, positional_light_count, gi_probe_count);
 	}
 
-	_render_scene(p_render_buffers, p_cam_transform, p_cam_projection, p_cam_ortogonal, p_cull_result, p_cull_count, directional_light_count, p_gi_probe_cull_result, p_gi_probe_cull_count, p_lightmap_cull_result, p_lightmap_cull_count, p_environment, p_camera_effects, p_shadow_atlas, p_reflection_atlas, p_reflection_probe, p_reflection_probe_pass, clear_color);
+	_render_scene(p_render_buffers, p_cam_transform, p_cam_projection, p_cam_ortogonal, p_cull_result, p_cull_count, directional_light_count, p_gi_probe_cull_result, p_gi_probe_cull_count, p_lightmap_cull_result, p_lightmap_cull_count, p_environment, p_camera_effects, p_shadow_atlas, p_reflection_atlas, p_reflection_probe, p_reflection_probe_pass, clear_color, p_screen_lod_threshold);
 
 	if (p_render_buffers.is_valid()) {
 		RENDER_TIMESTAMP("Tonemap");
@@ -7009,7 +7089,7 @@ void RasterizerSceneRD::render_scene(RID p_render_buffers, const Transform &p_ca
 	}
 }
 
-void RasterizerSceneRD::render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count) {
+void RendererSceneRenderRD::render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count, const Plane &p_camera_plane, float p_lod_distance_multiplier, float p_screen_lod_threshold) {
 	LightInstance *light_instance = light_instance_owner.getornull(p_light);
 	ERR_FAIL_COND(!light_instance);
 
@@ -7160,7 +7240,7 @@ void RasterizerSceneRD::render_shadow(RID p_light, RID p_shadow_atlas, int p_pas
 
 	if (render_cubemap) {
 		//rendering to cubemap
-		_render_shadow(render_fb, p_cull_result, p_cull_count, light_projection, light_transform, zfar, 0, 0, false, false, use_pancake);
+		_render_shadow(render_fb, p_cull_result, p_cull_count, light_projection, light_transform, zfar, 0, 0, false, false, use_pancake, p_camera_plane, p_lod_distance_multiplier, p_screen_lod_threshold);
 		if (finalize_cubemap) {
 			//reblit
 			atlas_rect.size.height /= 2;
@@ -7171,7 +7251,7 @@ void RasterizerSceneRD::render_shadow(RID p_light, RID p_shadow_atlas, int p_pas
 	} else {
 		//render shadow
 
-		_render_shadow(render_fb, p_cull_result, p_cull_count, light_projection, light_transform, zfar, bias, normal_bias, using_dual_paraboloid, using_dual_paraboloid_flip, use_pancake);
+		_render_shadow(render_fb, p_cull_result, p_cull_count, light_projection, light_transform, zfar, bias, normal_bias, using_dual_paraboloid, using_dual_paraboloid_flip, use_pancake, p_camera_plane, p_lod_distance_multiplier, p_screen_lod_threshold);
 
 		//copy to atlas
 		if (use_linear_depth) {
@@ -7185,11 +7265,11 @@ void RasterizerSceneRD::render_shadow(RID p_light, RID p_shadow_atlas, int p_pas
 	}
 }
 
-void RasterizerSceneRD::render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
+void RendererSceneRenderRD::render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) {
 	_render_material(p_cam_transform, p_cam_projection, p_cam_ortogonal, p_cull_result, p_cull_count, p_framebuffer, p_region);
 }
 
-void RasterizerSceneRD::render_sdfgi(RID p_render_buffers, int p_region, InstanceBase **p_cull_result, int p_cull_count) {
+void RendererSceneRenderRD::render_sdfgi(RID p_render_buffers, int p_region, InstanceBase **p_cull_result, int p_cull_count) {
 	//print_line("rendering region " + itos(p_region));
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
@@ -7288,7 +7368,6 @@ void RasterizerSceneRD::render_sdfgi(RID p_render_buffers, int p_region, Instanc
 
 				ipush_constant.image_size[0] = rb->sdfgi->probe_axis_count * rb->sdfgi->probe_axis_count;
 				ipush_constant.image_size[1] = rb->sdfgi->probe_axis_count;
-				ipush_constant.image_size[1] = rb->sdfgi->probe_axis_count;
 
 				int32_t probe_divisor = rb->sdfgi->cascade_size / SDFGI::PROBE_DIVISOR;
 				ipush_constant.cascade = cascade;
@@ -7527,7 +7606,7 @@ void RasterizerSceneRD::render_sdfgi(RID p_render_buffers, int p_region, Instanc
 	}
 }
 
-void RasterizerSceneRD::render_particle_collider_heightfield(RID p_collider, const Transform &p_transform, InstanceBase **p_cull_result, int p_cull_count) {
+void RendererSceneRenderRD::render_particle_collider_heightfield(RID p_collider, const Transform &p_transform, InstanceBase **p_cull_result, int p_cull_count) {
 	ERR_FAIL_COND(!storage->particles_collision_is_heightfield(p_collider));
 	Vector3 extents = storage->particles_collision_get_extents(p_collider) * p_transform.basis.get_scale();
 	CameraMatrix cm;
@@ -7544,7 +7623,7 @@ void RasterizerSceneRD::render_particle_collider_heightfield(RID p_collider, con
 	_render_particle_collider_heightfield(fb, cam_xform, cm, p_cull_result, p_cull_count);
 }
 
-void RasterizerSceneRD::render_sdfgi_static_lights(RID p_render_buffers, uint32_t p_cascade_count, const uint32_t *p_cascade_indices, const RID **p_positional_light_cull_result, const uint32_t *p_positional_light_cull_count) {
+void RendererSceneRenderRD::render_sdfgi_static_lights(RID p_render_buffers, uint32_t p_cascade_count, const uint32_t *p_cascade_indices, const RID **p_positional_light_cull_result, const uint32_t *p_positional_light_cull_count) {
 	RenderBuffers *rb = render_buffers_owner.getornull(p_render_buffers);
 	ERR_FAIL_COND(!rb);
 	ERR_FAIL_COND(!rb->sdfgi);
@@ -7651,7 +7730,7 @@ void RasterizerSceneRD::render_sdfgi_static_lights(RID p_render_buffers, uint32_
 	RD::get_singleton()->compute_list_end();
 }
 
-bool RasterizerSceneRD::free(RID p_rid) {
+bool RendererSceneRenderRD::free(RID p_rid) {
 	if (render_buffers_owner.owns(p_rid)) {
 		RenderBuffers *rb = render_buffers_owner.getornull(p_rid);
 		_free_render_buffer_data(rb);
@@ -7750,38 +7829,38 @@ bool RasterizerSceneRD::free(RID p_rid) {
 	return true;
 }
 
-void RasterizerSceneRD::set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) {
+void RendererSceneRenderRD::set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) {
 	debug_draw = p_debug_draw;
 }
 
-void RasterizerSceneRD::update() {
+void RendererSceneRenderRD::update() {
 	_update_dirty_skys();
 }
 
-void RasterizerSceneRD::set_time(double p_time, double p_step) {
+void RendererSceneRenderRD::set_time(double p_time, double p_step) {
 	time = p_time;
 	time_step = p_step;
 }
 
-void RasterizerSceneRD::screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) {
+void RendererSceneRenderRD::screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) {
 	screen_space_roughness_limiter = p_enable;
 	screen_space_roughness_limiter_amount = p_amount;
 	screen_space_roughness_limiter_limit = p_limit;
 }
 
-bool RasterizerSceneRD::screen_space_roughness_limiter_is_active() const {
+bool RendererSceneRenderRD::screen_space_roughness_limiter_is_active() const {
 	return screen_space_roughness_limiter;
 }
 
-float RasterizerSceneRD::screen_space_roughness_limiter_get_amount() const {
+float RendererSceneRenderRD::screen_space_roughness_limiter_get_amount() const {
 	return screen_space_roughness_limiter_amount;
 }
 
-float RasterizerSceneRD::screen_space_roughness_limiter_get_limit() const {
+float RendererSceneRenderRD::screen_space_roughness_limiter_get_limit() const {
 	return screen_space_roughness_limiter_limit;
 }
 
-TypedArray<Image> RasterizerSceneRD::bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) {
+TypedArray<Image> RendererSceneRenderRD::bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) {
 	RD::TextureFormat tf;
 	tf.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
 	tf.width = p_image_size.width; // Always 64x64
@@ -7872,38 +7951,42 @@ TypedArray<Image> RasterizerSceneRD::bake_render_uv2(RID p_base, const Vector<RI
 	return ret;
 }
 
-void RasterizerSceneRD::sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) {
+void RendererSceneRenderRD::sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) {
 	sdfgi_debug_probe_pos = p_position;
 	sdfgi_debug_probe_dir = p_dir;
 }
 
-RasterizerSceneRD *RasterizerSceneRD::singleton = nullptr;
+RendererSceneRenderRD *RendererSceneRenderRD::singleton = nullptr;
 
-RID RasterizerSceneRD::get_cluster_builder_texture() {
+RID RendererSceneRenderRD::get_cluster_builder_texture() {
 	return cluster.builder.get_cluster_texture();
 }
 
-RID RasterizerSceneRD::get_cluster_builder_indices_buffer() {
+RID RendererSceneRenderRD::get_cluster_builder_indices_buffer() {
 	return cluster.builder.get_cluster_indices_buffer();
 }
 
-RID RasterizerSceneRD::get_reflection_probe_buffer() {
+RID RendererSceneRenderRD::get_reflection_probe_buffer() {
 	return cluster.reflection_buffer;
 }
-RID RasterizerSceneRD::get_positional_light_buffer() {
+RID RendererSceneRenderRD::get_positional_light_buffer() {
 	return cluster.light_buffer;
 }
-RID RasterizerSceneRD::get_directional_light_buffer() {
+RID RendererSceneRenderRD::get_directional_light_buffer() {
 	return cluster.directional_light_buffer;
 }
-RID RasterizerSceneRD::get_decal_buffer() {
+RID RendererSceneRenderRD::get_decal_buffer() {
 	return cluster.decal_buffer;
 }
-int RasterizerSceneRD::get_max_directional_lights() const {
+int RendererSceneRenderRD::get_max_directional_lights() const {
 	return cluster.max_directional_lights;
 }
 
-RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
+bool RendererSceneRenderRD::is_low_end() const {
+	return low_end;
+}
+
+RendererSceneRenderRD::RendererSceneRenderRD(RendererStorageRD *p_storage) {
 	storage = p_storage;
 	singleton = this;
 
@@ -7912,9 +7995,15 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 	sky_use_cubemap_array = GLOBAL_GET("rendering/quality/reflections/texture_array_reflections");
 	//	sky_use_cubemap_array = false;
 
-	//uint32_t textures_per_stage = RD::get_singleton()->limit_get(RD::LIMIT_MAX_TEXTURES_PER_SHADER_STAGE);
+	uint32_t textures_per_stage = RD::get_singleton()->limit_get(RD::LIMIT_MAX_TEXTURES_PER_SHADER_STAGE);
 
-	{
+	low_end = GLOBAL_GET("rendering/quality/rd_renderer/use_low_end_renderer");
+
+	if (textures_per_stage < 48) {
+		low_end = true;
+	}
+
+	if (!low_end) {
 		//kinda complicated to compute the amount of slots, we try to use as many as we can
 
 		gi_probe_max_lights = 32;
@@ -7943,7 +8032,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 		}
 	}
 
-	{
+	if (!low_end) {
 		String defines;
 		Vector<String> versions;
 		versions.push_back("\n#define MODE_DEBUG_COLOR\n");
@@ -7992,8 +8081,8 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 	}
 
 	// register our shader funds
-	storage->shader_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_SKY, _create_sky_shader_funcs);
-	storage->material_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_SKY, _create_sky_material_funcs);
+	storage->shader_set_data_request_function(RendererStorageRD::SHADER_TYPE_SKY, _create_sky_shader_funcs);
+	storage->material_set_data_request_function(RendererStorageRD::SHADER_TYPE_SKY, _create_sky_material_funcs);
 
 	{
 		ShaderCompilerRD::DefaultIdentifierActions actions;
@@ -8057,7 +8146,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 		sky_shader.default_material = storage->material_create();
 		storage->material_set_shader(sky_shader.default_material, sky_shader.default_shader);
 
-		SkyMaterialData *md = (SkyMaterialData *)storage->material_get_data(sky_shader.default_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+		SkyMaterialData *md = (SkyMaterialData *)storage->material_get_data(sky_shader.default_material, RendererStorageRD::SHADER_TYPE_SKY);
 		sky_shader.default_shader_rd = sky_shader.shader.version_get_shader(md->shader_data->version, SKY_VERSION_BACKGROUND);
 
 		sky_scene_state.uniform_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(SkySceneState::UBO));
@@ -8066,7 +8155,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 0;
 			u.ids.resize(12);
 			RID *ids_ptr = u.ids.ptrw();
@@ -8087,7 +8176,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 1;
 			u.ids.push_back(storage->global_variables_get_storage_buffer());
 			uniforms.push_back(u);
@@ -8096,7 +8185,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 		{
 			RD::Uniform u;
 			u.binding = 2;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.ids.push_back(sky_scene_state.uniform_buffer);
 			uniforms.push_back(u);
 		}
@@ -8104,7 +8193,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 		{
 			RD::Uniform u;
 			u.binding = 3;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.ids.push_back(sky_scene_state.directional_light_buffer);
 			uniforms.push_back(u);
 		}
@@ -8117,8 +8206,8 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 		{
 			RD::Uniform u;
 			u.binding = 0;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
-			RID vfog = storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+			RID vfog = storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE);
 			u.ids.push_back(vfog);
 			uniforms.push_back(u);
 		}
@@ -8136,144 +8225,148 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 		Vector<RD::Uniform> uniforms;
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 0;
-			u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
+			u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_BLACK));
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1;
-			u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE));
+			u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE));
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 2;
-			u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_WHITE));
+			u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_WHITE));
 			uniforms.push_back(u);
 		}
 
 		sky_scene_state.fog_only_texture_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, sky_shader.default_shader_rd, SKY_SET_TEXTURES);
 	}
 
-	{
-		Vector<String> preprocess_modes;
-		preprocess_modes.push_back("\n#define MODE_SCROLL\n");
-		preprocess_modes.push_back("\n#define MODE_SCROLL_OCCLUSION\n");
-		preprocess_modes.push_back("\n#define MODE_INITIALIZE_JUMP_FLOOD\n");
-		preprocess_modes.push_back("\n#define MODE_INITIALIZE_JUMP_FLOOD_HALF\n");
-		preprocess_modes.push_back("\n#define MODE_JUMPFLOOD\n");
-		preprocess_modes.push_back("\n#define MODE_JUMPFLOOD_OPTIMIZED\n");
-		preprocess_modes.push_back("\n#define MODE_UPSCALE_JUMP_FLOOD\n");
-		preprocess_modes.push_back("\n#define MODE_OCCLUSION\n");
-		preprocess_modes.push_back("\n#define MODE_STORE\n");
-		String defines = "\n#define OCCLUSION_SIZE " + itos(SDFGI::CASCADE_SIZE / SDFGI::PROBE_DIVISOR) + "\n";
-		sdfgi_shader.preprocess.initialize(preprocess_modes, defines);
-		sdfgi_shader.preprocess_shader = sdfgi_shader.preprocess.version_create();
-		for (int i = 0; i < SDGIShader::PRE_PROCESS_MAX; i++) {
-			sdfgi_shader.preprocess_pipeline[i] = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.preprocess.version_get_shader(sdfgi_shader.preprocess_shader, i));
+	if (!low_end) {
+		//SDFGI
+		{
+			Vector<String> preprocess_modes;
+			preprocess_modes.push_back("\n#define MODE_SCROLL\n");
+			preprocess_modes.push_back("\n#define MODE_SCROLL_OCCLUSION\n");
+			preprocess_modes.push_back("\n#define MODE_INITIALIZE_JUMP_FLOOD\n");
+			preprocess_modes.push_back("\n#define MODE_INITIALIZE_JUMP_FLOOD_HALF\n");
+			preprocess_modes.push_back("\n#define MODE_JUMPFLOOD\n");
+			preprocess_modes.push_back("\n#define MODE_JUMPFLOOD_OPTIMIZED\n");
+			preprocess_modes.push_back("\n#define MODE_UPSCALE_JUMP_FLOOD\n");
+			preprocess_modes.push_back("\n#define MODE_OCCLUSION\n");
+			preprocess_modes.push_back("\n#define MODE_STORE\n");
+			String defines = "\n#define OCCLUSION_SIZE " + itos(SDFGI::CASCADE_SIZE / SDFGI::PROBE_DIVISOR) + "\n";
+			sdfgi_shader.preprocess.initialize(preprocess_modes, defines);
+			sdfgi_shader.preprocess_shader = sdfgi_shader.preprocess.version_create();
+			for (int i = 0; i < SDGIShader::PRE_PROCESS_MAX; i++) {
+				sdfgi_shader.preprocess_pipeline[i] = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.preprocess.version_get_shader(sdfgi_shader.preprocess_shader, i));
+			}
 		}
-	}
 
-	{
-		//calculate tables
-		String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
+		{
+			//calculate tables
+			String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
 
-		Vector<String> direct_light_modes;
-		direct_light_modes.push_back("\n#define MODE_PROCESS_STATIC\n");
-		direct_light_modes.push_back("\n#define MODE_PROCESS_DYNAMIC\n");
-		sdfgi_shader.direct_light.initialize(direct_light_modes, defines);
-		sdfgi_shader.direct_light_shader = sdfgi_shader.direct_light.version_create();
-		for (int i = 0; i < SDGIShader::DIRECT_LIGHT_MODE_MAX; i++) {
-			sdfgi_shader.direct_light_pipeline[i] = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.direct_light.version_get_shader(sdfgi_shader.direct_light_shader, i));
+			Vector<String> direct_light_modes;
+			direct_light_modes.push_back("\n#define MODE_PROCESS_STATIC\n");
+			direct_light_modes.push_back("\n#define MODE_PROCESS_DYNAMIC\n");
+			sdfgi_shader.direct_light.initialize(direct_light_modes, defines);
+			sdfgi_shader.direct_light_shader = sdfgi_shader.direct_light.version_create();
+			for (int i = 0; i < SDGIShader::DIRECT_LIGHT_MODE_MAX; i++) {
+				sdfgi_shader.direct_light_pipeline[i] = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.direct_light.version_get_shader(sdfgi_shader.direct_light_shader, i));
+			}
 		}
-	}
 
-	{
-		//calculate tables
-		String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
-		defines += "\n#define SH_SIZE " + itos(SDFGI::SH_SIZE) + "\n";
-
-		Vector<String> integrate_modes;
-		integrate_modes.push_back("\n#define MODE_PROCESS\n");
-		integrate_modes.push_back("\n#define MODE_STORE\n");
-		integrate_modes.push_back("\n#define MODE_SCROLL\n");
-		integrate_modes.push_back("\n#define MODE_SCROLL_STORE\n");
-		sdfgi_shader.integrate.initialize(integrate_modes, defines);
-		sdfgi_shader.integrate_shader = sdfgi_shader.integrate.version_create();
+		{
+			//calculate tables
+			String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
+			defines += "\n#define SH_SIZE " + itos(SDFGI::SH_SIZE) + "\n";
 
-		for (int i = 0; i < SDGIShader::INTEGRATE_MODE_MAX; i++) {
-			sdfgi_shader.integrate_pipeline[i] = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.integrate.version_get_shader(sdfgi_shader.integrate_shader, i));
-		}
+			Vector<String> integrate_modes;
+			integrate_modes.push_back("\n#define MODE_PROCESS\n");
+			integrate_modes.push_back("\n#define MODE_STORE\n");
+			integrate_modes.push_back("\n#define MODE_SCROLL\n");
+			integrate_modes.push_back("\n#define MODE_SCROLL_STORE\n");
+			sdfgi_shader.integrate.initialize(integrate_modes, defines);
+			sdfgi_shader.integrate_shader = sdfgi_shader.integrate.version_create();
 
-		{
-			Vector<RD::Uniform> uniforms;
+			for (int i = 0; i < SDGIShader::INTEGRATE_MODE_MAX; i++) {
+				sdfgi_shader.integrate_pipeline[i] = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.integrate.version_get_shader(sdfgi_shader.integrate_shader, i));
+			}
 
 			{
-				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
-				u.binding = 0;
-				u.ids.push_back(storage->texture_rd_get_default(RasterizerStorageRD::DEFAULT_RD_TEXTURE_3D_WHITE));
-				uniforms.push_back(u);
+				Vector<RD::Uniform> uniforms;
+
+				{
+					RD::Uniform u;
+					u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
+					u.binding = 0;
+					u.ids.push_back(storage->texture_rd_get_default(RendererStorageRD::DEFAULT_RD_TEXTURE_CUBEMAP_WHITE));
+					uniforms.push_back(u);
+				}
+				{
+					RD::Uniform u;
+					u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
+					u.binding = 1;
+					u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
+					uniforms.push_back(u);
+				}
+
+				sdfgi_shader.integrate_default_sky_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, sdfgi_shader.integrate.version_get_shader(sdfgi_shader.integrate_shader, 0), 1);
 			}
-			{
-				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_SAMPLER;
-				u.binding = 1;
-				u.ids.push_back(storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED));
-				uniforms.push_back(u);
+		}
+		{
+			//calculate tables
+			String defines = "\n#define SDFGI_OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
+			Vector<String> gi_modes;
+			gi_modes.push_back("");
+			gi.shader.initialize(gi_modes, defines);
+			gi.shader_version = gi.shader.version_create();
+			for (int i = 0; i < GI::MODE_MAX; i++) {
+				gi.pipelines[i] = RD::get_singleton()->compute_pipeline_create(gi.shader.version_get_shader(gi.shader_version, i));
 			}
 
-			sdfgi_shader.integrate_default_sky_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, sdfgi_shader.integrate.version_get_shader(sdfgi_shader.integrate_shader, 0), 1);
+			gi.sdfgi_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(GI::SDFGIData));
 		}
-	}
-	{
-		//calculate tables
-		String defines = "\n#define SDFGI_OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
-		Vector<String> gi_modes;
-		gi_modes.push_back("");
-		gi.shader.initialize(gi_modes, defines);
-		gi.shader_version = gi.shader.version_create();
-		for (int i = 0; i < GI::MODE_MAX; i++) {
-			gi.pipelines[i] = RD::get_singleton()->compute_pipeline_create(gi.shader.version_get_shader(gi.shader_version, i));
+		{
+			String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
+			Vector<String> debug_modes;
+			debug_modes.push_back("");
+			sdfgi_shader.debug.initialize(debug_modes, defines);
+			sdfgi_shader.debug_shader = sdfgi_shader.debug.version_create();
+			sdfgi_shader.debug_shader_version = sdfgi_shader.debug.version_get_shader(sdfgi_shader.debug_shader, 0);
+			sdfgi_shader.debug_pipeline = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.debug_shader_version);
 		}
+		{
+			String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
 
-		gi.sdfgi_ubo = RD::get_singleton()->uniform_buffer_create(sizeof(GI::SDFGIData));
-	}
-	{
-		String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
-		Vector<String> debug_modes;
-		debug_modes.push_back("");
-		sdfgi_shader.debug.initialize(debug_modes, defines);
-		sdfgi_shader.debug_shader = sdfgi_shader.debug.version_create();
-		sdfgi_shader.debug_shader_version = sdfgi_shader.debug.version_get_shader(sdfgi_shader.debug_shader, 0);
-		sdfgi_shader.debug_pipeline = RD::get_singleton()->compute_pipeline_create(sdfgi_shader.debug_shader_version);
-	}
-	{
-		String defines = "\n#define OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";
-
-		Vector<String> versions;
-		versions.push_back("\n#define MODE_PROBES\n");
-		versions.push_back("\n#define MODE_VISIBILITY\n");
+			Vector<String> versions;
+			versions.push_back("\n#define MODE_PROBES\n");
+			versions.push_back("\n#define MODE_VISIBILITY\n");
 
-		sdfgi_shader.debug_probes.initialize(versions, defines);
-		sdfgi_shader.debug_probes_shader = sdfgi_shader.debug_probes.version_create();
+			sdfgi_shader.debug_probes.initialize(versions, defines);
+			sdfgi_shader.debug_probes_shader = sdfgi_shader.debug_probes.version_create();
 
-		{
-			RD::PipelineRasterizationState rs;
-			rs.cull_mode = RD::POLYGON_CULL_DISABLED;
-			RD::PipelineDepthStencilState ds;
-			ds.enable_depth_test = true;
-			ds.enable_depth_write = true;
-			ds.depth_compare_operator = RD::COMPARE_OP_LESS_OR_EQUAL;
-			for (int i = 0; i < SDGIShader::PROBE_DEBUG_MAX; i++) {
-				RID debug_probes_shader_version = sdfgi_shader.debug_probes.version_get_shader(sdfgi_shader.debug_probes_shader, i);
-				sdfgi_shader.debug_probes_pipeline[i].setup(debug_probes_shader_version, RD::RENDER_PRIMITIVE_TRIANGLE_STRIPS, rs, RD::PipelineMultisampleState(), ds, RD::PipelineColorBlendState::create_disabled(), 0);
+			{
+				RD::PipelineRasterizationState rs;
+				rs.cull_mode = RD::POLYGON_CULL_DISABLED;
+				RD::PipelineDepthStencilState ds;
+				ds.enable_depth_test = true;
+				ds.enable_depth_write = true;
+				ds.depth_compare_operator = RD::COMPARE_OP_LESS_OR_EQUAL;
+				for (int i = 0; i < SDGIShader::PROBE_DEBUG_MAX; i++) {
+					RID debug_probes_shader_version = sdfgi_shader.debug_probes.version_get_shader(sdfgi_shader.debug_probes_shader, i);
+					sdfgi_shader.debug_probes_pipeline[i].setup(debug_probes_shader_version, RD::RENDER_PRIMITIVE_TRIANGLE_STRIPS, rs, RD::PipelineMultisampleState(), ds, RD::PipelineColorBlendState::create_disabled(), 0);
+				}
 			}
 		}
+		default_giprobe_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(GI::GIProbeData) * RenderBuffers::MAX_GIPROBES);
 	}
 
 	//cluster setup
@@ -8317,7 +8410,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 
 	cluster.builder.setup(16, 8, 24);
 
-	{
+	if (!low_end) {
 		String defines = "\n#define MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS " + itos(cluster.max_directional_lights) + "\n";
 		Vector<String> volumetric_fog_modes;
 		volumetric_fog_modes.push_back("\n#define MODE_DENSITY\n");
@@ -8330,7 +8423,6 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 			volumetric_fog.pipelines[i] = RD::get_singleton()->compute_pipeline_create(volumetric_fog.shader.version_get_shader(volumetric_fog.shader_version, i));
 		}
 	}
-	default_giprobe_buffer = RD::get_singleton()->uniform_buffer_create(sizeof(GI::GIProbeData) * RenderBuffers::MAX_GIPROBES);
 
 	{
 		RD::SamplerState sampler;
@@ -8366,7 +8458,7 @@ RasterizerSceneRD::RasterizerSceneRD(RasterizerStorageRD *p_storage) {
 	environment_set_volumetric_fog_positional_shadow_shrink_size(GLOBAL_GET("rendering/volumetric_fog/positional_shadow_shrink"));
 }
 
-RasterizerSceneRD::~RasterizerSceneRD() {
+RendererSceneRenderRD::~RendererSceneRenderRD() {
 	for (Map<Vector2i, ShadowMap>::Element *E = shadow_maps.front(); E; E = E->next()) {
 		RD::get_singleton()->free(E->get().depth);
 	}
@@ -8378,23 +8470,26 @@ RasterizerSceneRD::~RasterizerSceneRD() {
 		RD::get_singleton()->free(sky_scene_state.uniform_set);
 	}
 
-	RD::get_singleton()->free(default_giprobe_buffer);
-	RD::get_singleton()->free(gi_probe_lights_uniform);
-	RD::get_singleton()->free(gi.sdfgi_ubo);
+	if (!low_end) {
+		RD::get_singleton()->free(default_giprobe_buffer);
+		RD::get_singleton()->free(gi_probe_lights_uniform);
+		RD::get_singleton()->free(gi.sdfgi_ubo);
 
-	giprobe_debug_shader.version_free(giprobe_debug_shader_version);
-	giprobe_shader.version_free(giprobe_lighting_shader_version);
-	gi.shader.version_free(gi.shader_version);
-	sdfgi_shader.debug_probes.version_free(sdfgi_shader.debug_probes_shader);
-	sdfgi_shader.debug.version_free(sdfgi_shader.debug_shader);
-	sdfgi_shader.direct_light.version_free(sdfgi_shader.direct_light_shader);
-	sdfgi_shader.integrate.version_free(sdfgi_shader.integrate_shader);
-	sdfgi_shader.preprocess.version_free(sdfgi_shader.preprocess_shader);
+		giprobe_debug_shader.version_free(giprobe_debug_shader_version);
+		giprobe_shader.version_free(giprobe_lighting_shader_version);
+		gi.shader.version_free(gi.shader_version);
+		sdfgi_shader.debug_probes.version_free(sdfgi_shader.debug_probes_shader);
+		sdfgi_shader.debug.version_free(sdfgi_shader.debug_shader);
+		sdfgi_shader.direct_light.version_free(sdfgi_shader.direct_light_shader);
+		sdfgi_shader.integrate.version_free(sdfgi_shader.integrate_shader);
+		sdfgi_shader.preprocess.version_free(sdfgi_shader.preprocess_shader);
 
-	volumetric_fog.shader.version_free(volumetric_fog.shader_version);
+		volumetric_fog.shader.version_free(volumetric_fog.shader_version);
+
+		memdelete_arr(gi_probe_lights);
+	}
 
-	memdelete_arr(gi_probe_lights);
-	SkyMaterialData *md = (SkyMaterialData *)storage->material_get_data(sky_shader.default_material, RasterizerStorageRD::SHADER_TYPE_SKY);
+	SkyMaterialData *md = (SkyMaterialData *)storage->material_get_data(sky_shader.default_material, RendererStorageRD::SHADER_TYPE_SKY);
 	sky_shader.shader.version_free(md->shader_data->version);
 	RD::get_singleton()->free(sky_scene_state.directional_light_buffer);
 	RD::get_singleton()->free(sky_scene_state.uniform_buffer);
diff --git a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h b/servers/rendering/renderer_rd/renderer_scene_render_rd.h
index 3d5310bb7e..3afe6e3f4a 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_scene_rd.h
+++ b/servers/rendering/renderer_rd/renderer_scene_render_rd.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_scene_rd.h                                                */
+/*  renderer_scene_render_rd.h                                           */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,27 +28,28 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RASTERIZER_SCENE_RD_H
-#define RASTERIZER_SCENE_RD_H
+#ifndef RENDERING_SERVER_SCENE_RENDER_RD_H
+#define RENDERING_SERVER_SCENE_RENDER_RD_H
 
 #include "core/templates/local_vector.h"
 #include "core/templates/rid_owner.h"
-#include "servers/rendering/rasterizer.h"
-#include "servers/rendering/rasterizer_rd/light_cluster_builder.h"
-#include "servers/rendering/rasterizer_rd/rasterizer_storage_rd.h"
-#include "servers/rendering/rasterizer_rd/shaders/gi.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/giprobe.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/sdfgi_debug.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/sdfgi_debug_probes.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/sdfgi_direct_light.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/sdfgi_integrate.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/sdfgi_preprocess.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/sky.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/volumetric_fog.glsl.gen.h"
+#include "servers/rendering/renderer_compositor.h"
+#include "servers/rendering/renderer_rd/light_cluster_builder.h"
+#include "servers/rendering/renderer_rd/renderer_storage_rd.h"
+#include "servers/rendering/renderer_rd/shaders/gi.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/giprobe.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/giprobe_debug.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/sdfgi_debug.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/sdfgi_debug_probes.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/sdfgi_direct_light.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/sdfgi_integrate.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/sdfgi_preprocess.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/sky.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/volumetric_fog.glsl.gen.h"
+#include "servers/rendering/renderer_scene_render.h"
 #include "servers/rendering/rendering_device.h"
 
-class RasterizerSceneRD : public RasterizerScene {
+class RendererSceneRenderRD : public RendererSceneRender {
 protected:
 	double time;
 
@@ -108,8 +109,8 @@ protected:
 	void _setup_reflections(RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, const Transform &p_camera_inverse_transform, RID p_environment);
 	void _setup_giprobes(RID p_render_buffers, const Transform &p_transform, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, uint32_t &r_gi_probes_used);
 
-	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_color) = 0;
-	virtual void _render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool use_dp_flip, bool p_use_pancake) = 0;
+	virtual void _render_scene(RID p_render_buffer, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, int p_directional_light_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, const Color &p_default_color, float p_screen_lod_threshold) = 0;
+	virtual void _render_shadow(RID p_framebuffer, InstanceBase **p_cull_result, int p_cull_count, const CameraMatrix &p_projection, const Transform &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool use_dp_flip, bool p_use_pancake, const Plane &p_camera_plane = Plane(), float p_lod_distance_multiplier = 0.0, float p_screen_lod_threshold = 0.0) = 0;
 	virtual void _render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) = 0;
 	virtual void _render_uv2(InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) = 0;
 	virtual void _render_sdfgi(RID p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, InstanceBase **p_cull_result, int p_cull_count, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture) = 0;
@@ -138,11 +139,11 @@ protected:
 private:
 	RS::ViewportDebugDraw debug_draw = RS::VIEWPORT_DEBUG_DRAW_DISABLED;
 	double time_step = 0;
-	static RasterizerSceneRD *singleton;
+	static RendererSceneRenderRD *singleton;
 
 	int roughness_layers;
 
-	RasterizerStorageRD *storage;
+	RendererStorageRD *storage;
 
 	struct ReflectionData {
 		struct Layer {
@@ -200,11 +201,11 @@ private:
 		RID default_shader_rd;
 	} sky_shader;
 
-	struct SkyShaderData : public RasterizerStorageRD::ShaderData {
+	struct SkyShaderData : public RendererStorageRD::ShaderData {
 		bool valid;
 		RID version;
 
-		RenderPipelineVertexFormatCacheRD pipelines[SKY_VERSION_MAX];
+		PipelineCacheRD pipelines[SKY_VERSION_MAX];
 		Map<StringName, ShaderLanguage::ShaderNode::Uniform> uniforms;
 		Vector<ShaderCompilerRD::GeneratedCode::Texture> texture_uniforms;
 
@@ -224,7 +225,7 @@ private:
 		virtual void set_code(const String &p_Code);
 		virtual void set_default_texture_param(const StringName &p_name, RID p_texture);
 		virtual void get_param_list(List<PropertyInfo> *p_param_list) const;
-		virtual void get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const;
+		virtual void get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const;
 		virtual bool is_param_texture(const StringName &p_param) const;
 		virtual bool is_animated() const;
 		virtual bool casts_shadows() const;
@@ -233,12 +234,12 @@ private:
 		virtual ~SkyShaderData();
 	};
 
-	RasterizerStorageRD::ShaderData *_create_sky_shader_func();
-	static RasterizerStorageRD::ShaderData *_create_sky_shader_funcs() {
-		return static_cast<RasterizerSceneRD *>(singleton)->_create_sky_shader_func();
+	RendererStorageRD::ShaderData *_create_sky_shader_func();
+	static RendererStorageRD::ShaderData *_create_sky_shader_funcs() {
+		return static_cast<RendererSceneRenderRD *>(singleton)->_create_sky_shader_func();
 	};
 
-	struct SkyMaterialData : public RasterizerStorageRD::MaterialData {
+	struct SkyMaterialData : public RendererStorageRD::MaterialData {
 		uint64_t last_frame;
 		SkyShaderData *shader_data;
 		RID uniform_buffer;
@@ -253,9 +254,9 @@ private:
 		virtual ~SkyMaterialData();
 	};
 
-	RasterizerStorageRD::MaterialData *_create_sky_material_func(SkyShaderData *p_shader);
-	static RasterizerStorageRD::MaterialData *_create_sky_material_funcs(RasterizerStorageRD::ShaderData *p_shader) {
-		return static_cast<RasterizerSceneRD *>(singleton)->_create_sky_material_func(static_cast<SkyShaderData *>(p_shader));
+	RendererStorageRD::MaterialData *_create_sky_material_func(SkyShaderData *p_shader);
+	static RendererStorageRD::MaterialData *_create_sky_material_funcs(RendererStorageRD::ShaderData *p_shader) {
+		return static_cast<RendererSceneRenderRD *>(singleton)->_create_sky_material_func(static_cast<SkyShaderData *>(p_shader));
 	};
 
 	enum SkyTextureSetVersion {
@@ -338,7 +339,7 @@ private:
 		Vector<Reflection> reflections;
 	};
 
-	RID_Owner<ReflectionAtlas> reflection_atlas_owner;
+	mutable RID_Owner<ReflectionAtlas> reflection_atlas_owner;
 
 	/* REFLECTION PROBE INSTANCE */
 
@@ -512,7 +513,7 @@ private:
 	GiprobeDebugShaderRD giprobe_debug_shader;
 	RID giprobe_debug_shader_version;
 	RID giprobe_debug_shader_version_shaders[GI_PROBE_DEBUG_MAX];
-	RenderPipelineVertexFormatCacheRD giprobe_debug_shader_version_pipelines[GI_PROBE_DEBUG_MAX];
+	PipelineCacheRD giprobe_debug_shader_version_pipelines[GI_PROBE_DEBUG_MAX];
 	RID giprobe_debug_uniform_set;
 
 	/* SHADOW ATLAS */
@@ -763,6 +764,15 @@ private:
 		float sdfgi_normal_bias = 1.1;
 		float sdfgi_probe_bias = 1.1;
 		RS::EnvironmentSDFGIYScale sdfgi_y_scale = RS::ENV_SDFGI_Y_SCALE_DISABLED;
+
+		/// Adjustments
+
+		bool adjustments_enabled = false;
+		float adjustments_brightness = 1.0f;
+		float adjustments_contrast = 1.0f;
+		float adjustments_saturation = 1.0f;
+		bool use_1d_color_correction = false;
+		RID color_correction = RID();
 	};
 
 	RS::EnvironmentSSAOQuality ssao_quality = RS::ENV_SSAO_QUALITY_MEDIUM;
@@ -1068,7 +1078,7 @@ private:
 		RID debug_probes_shader;
 		RID debug_probes_shader_version;
 
-		RenderPipelineVertexFormatCacheRD debug_probes_pipeline[PROBE_DEBUG_MAX];
+		PipelineCacheRD debug_probes_pipeline[PROBE_DEBUG_MAX];
 
 		struct Light {
 			float color[3];
@@ -1446,6 +1456,8 @@ private:
 		float weight;
 	};
 
+	bool low_end = false;
+
 public:
 	/* SHADOW ATLAS API */
 
@@ -1571,7 +1583,7 @@ public:
 	RS::EnvironmentSSRRoughnessQuality environment_get_ssr_roughness_quality() const;
 
 	void 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);
-	void environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, RID p_ramp) {}
+	void 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);
 
 	virtual Ref<Image> environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size);
 
@@ -1716,6 +1728,8 @@ public:
 
 	virtual RID reflection_atlas_create();
 	virtual void reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count);
+	virtual int reflection_atlas_get_size(RID p_ref_atlas) const;
+
 	_FORCE_INLINE_ RID reflection_atlas_get_texture(RID p_ref_atlas) {
 		ReflectionAtlas *atlas = reflection_atlas_owner.getornull(p_ref_atlas);
 		ERR_FAIL_COND_V(!atlas, RID());
@@ -1872,9 +1886,9 @@ public:
 	float render_buffers_get_volumetric_fog_end(RID p_render_buffers);
 	float render_buffers_get_volumetric_fog_detail_spread(RID p_render_buffers);
 
-	void render_scene(RID p_render_buffers, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_shadow_atlas, RID p_camera_effects, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass);
+	void render_scene(RID p_render_buffers, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_shadow_atlas, RID p_camera_effects, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold);
 
-	void render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count);
+	void render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count, const Plane &p_camera_plane = Plane(), float p_lod_distance_multiplier = 0, float p_screen_lod_threshold = 0.0);
 
 	void render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region);
 
@@ -1942,8 +1956,10 @@ public:
 
 	void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir);
 
-	RasterizerSceneRD(RasterizerStorageRD *p_storage);
-	~RasterizerSceneRD();
+	bool is_low_end() const;
+
+	RendererSceneRenderRD(RendererStorageRD *p_storage);
+	~RendererSceneRenderRD();
 };
 
 #endif // RASTERIZER_SCENE_RD_H
diff --git a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp b/servers/rendering/renderer_rd/renderer_storage_rd.cpp
index 8bd4362637..60c0bd1603 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.cpp
+++ b/servers/rendering/renderer_rd/renderer_storage_rd.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_storage_rd.cpp                                            */
+/*  renderer_storage_rd.cpp                                              */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,15 +28,15 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rasterizer_storage_rd.h"
+#include "renderer_storage_rd.h"
 
 #include "core/config/engine.h"
 #include "core/config/project_settings.h"
 #include "core/io/resource_loader.h"
-#include "rasterizer_rd.h"
+#include "renderer_compositor_rd.h"
 #include "servers/rendering/shader_language.h"
 
-Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_image, TextureToRDFormat &r_format) {
+Ref<Image> RendererStorageRD::_validate_texture_format(const Ref<Image> &p_image, TextureToRDFormat &r_format) {
 	Ref<Image> image = p_image->duplicate();
 
 	switch (p_image->get_format()) {
@@ -318,7 +318,7 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 			r_format.swizzle_b = RD::TEXTURE_SWIZZLE_B;
 			r_format.swizzle_a = RD::TEXTURE_SWIZZLE_ONE;
 		} break; //unsigned float bc6hu
-		case Image::FORMAT_PVRTC2: {
+		case Image::FORMAT_PVRTC1_2: {
 			//this is not properly supported by MoltekVK it seems, so best to use ETC2
 			if (RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT)) {
 				r_format.format = RD::DATA_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
@@ -336,7 +336,7 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 			r_format.swizzle_a = RD::TEXTURE_SWIZZLE_ONE;
 
 		} break; //pvrtc
-		case Image::FORMAT_PVRTC2A: {
+		case Image::FORMAT_PVRTC1_2A: {
 			//this is not properly supported by MoltekVK it seems, so best to use ETC2
 			if (RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT)) {
 				r_format.format = RD::DATA_FORMAT_PVRTC1_2BPP_UNORM_BLOCK_IMG;
@@ -353,7 +353,7 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 			r_format.swizzle_b = RD::TEXTURE_SWIZZLE_B;
 			r_format.swizzle_a = RD::TEXTURE_SWIZZLE_A;
 		} break;
-		case Image::FORMAT_PVRTC4: {
+		case Image::FORMAT_PVRTC1_4: {
 			//this is not properly supported by MoltekVK it seems, so best to use ETC2
 			if (RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT)) {
 				r_format.format = RD::DATA_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
@@ -370,7 +370,7 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 			r_format.swizzle_b = RD::TEXTURE_SWIZZLE_B;
 			r_format.swizzle_a = RD::TEXTURE_SWIZZLE_ONE;
 		} break;
-		case Image::FORMAT_PVRTC4A: {
+		case Image::FORMAT_PVRTC1_4A: {
 			//this is not properly supported by MoltekVK it seems, so best to use ETC2
 			if (RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG, RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT)) {
 				r_format.format = RD::DATA_FORMAT_PVRTC1_4BPP_UNORM_BLOCK_IMG;
@@ -535,7 +535,7 @@ Ref<Image> RasterizerStorageRD::_validate_texture_format(const Ref<Image> &p_ima
 	return image;
 }
 
-RID RasterizerStorageRD::texture_2d_create(const Ref<Image> &p_image) {
+RID RendererStorageRD::texture_2d_create(const Ref<Image> &p_image) {
 	ERR_FAIL_COND_V(p_image.is_null(), RID());
 	ERR_FAIL_COND_V(p_image->empty(), RID());
 
@@ -567,7 +567,7 @@ RID RasterizerStorageRD::texture_2d_create(const Ref<Image> &p_image) {
 		rd_format.depth = 1;
 		rd_format.array_layers = 1;
 		rd_format.mipmaps = texture.mipmaps;
-		rd_format.type = texture.rd_type;
+		rd_format.texture_type = texture.rd_type;
 		rd_format.samples = RD::TEXTURE_SAMPLES_1;
 		rd_format.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
 		if (texture.rd_format_srgb != RD::DATA_FORMAT_MAX) {
@@ -605,7 +605,7 @@ RID RasterizerStorageRD::texture_2d_create(const Ref<Image> &p_image) {
 	return texture_owner.make_rid(texture);
 }
 
-RID RasterizerStorageRD::texture_2d_layered_create(const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) {
+RID RendererStorageRD::texture_2d_layered_create(const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) {
 	ERR_FAIL_COND_V(p_layers.size() == 0, RID());
 
 	ERR_FAIL_COND_V(p_layered_type == RS::TEXTURE_LAYERED_CUBEMAP && p_layers.size() != 6, RID());
@@ -675,7 +675,7 @@ RID RasterizerStorageRD::texture_2d_layered_create(const Vector<Ref<Image>> &p_l
 		rd_format.depth = 1;
 		rd_format.array_layers = texture.layers;
 		rd_format.mipmaps = texture.mipmaps;
-		rd_format.type = texture.rd_type;
+		rd_format.texture_type = texture.rd_type;
 		rd_format.samples = RD::TEXTURE_SAMPLES_1;
 		rd_format.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
 		if (texture.rd_format_srgb != RD::DATA_FORMAT_MAX) {
@@ -715,7 +715,7 @@ RID RasterizerStorageRD::texture_2d_layered_create(const Vector<Ref<Image>> &p_l
 	return texture_owner.make_rid(texture);
 }
 
-RID RasterizerStorageRD::texture_3d_create(Image::Format p_format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) {
+RID RendererStorageRD::texture_3d_create(Image::Format p_format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) {
 	ERR_FAIL_COND_V(p_data.size() == 0, RID());
 	Image::Image3DValidateError verr = Image::validate_3d_image(p_format, p_width, p_height, p_depth, p_mipmaps, p_data);
 	if (verr != Image::VALIDATE_3D_OK) {
@@ -793,7 +793,7 @@ RID RasterizerStorageRD::texture_3d_create(Image::Format p_format, int p_width,
 		rd_format.depth = texture.depth;
 		rd_format.array_layers = 1;
 		rd_format.mipmaps = texture.mipmaps;
-		rd_format.type = texture.rd_type;
+		rd_format.texture_type = texture.rd_type;
 		rd_format.samples = RD::TEXTURE_SAMPLES_1;
 		rd_format.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
 		if (texture.rd_format_srgb != RD::DATA_FORMAT_MAX) {
@@ -831,7 +831,7 @@ RID RasterizerStorageRD::texture_3d_create(Image::Format p_format, int p_width,
 	return texture_owner.make_rid(texture);
 }
 
-RID RasterizerStorageRD::texture_proxy_create(RID p_base) {
+RID RendererStorageRD::texture_proxy_create(RID p_base) {
 	Texture *tex = texture_owner.getornull(p_base);
 	ERR_FAIL_COND_V(!tex, RID());
 	Texture proxy_tex = *tex;
@@ -854,7 +854,7 @@ RID RasterizerStorageRD::texture_proxy_create(RID p_base) {
 	return rid;
 }
 
-void RasterizerStorageRD::_texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer, bool p_immediate) {
+void RendererStorageRD::_texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer, bool p_immediate) {
 	ERR_FAIL_COND(p_image.is_null() || p_image->empty());
 
 	Texture *tex = texture_owner.getornull(p_texture);
@@ -876,15 +876,15 @@ void RasterizerStorageRD::_texture_2d_update(RID p_texture, const Ref<Image> &p_
 	RD::get_singleton()->texture_update(tex->rd_texture, p_layer, validated->get_data(), !p_immediate);
 }
 
-void RasterizerStorageRD::texture_2d_update_immediate(RID p_texture, const Ref<Image> &p_image, int p_layer) {
+void RendererStorageRD::texture_2d_update_immediate(RID p_texture, const Ref<Image> &p_image, int p_layer) {
 	_texture_2d_update(p_texture, p_image, p_layer, true);
 }
 
-void RasterizerStorageRD::texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer) {
+void RendererStorageRD::texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer) {
 	_texture_2d_update(p_texture, p_image, p_layer, false);
 }
 
-void RasterizerStorageRD::texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) {
+void RendererStorageRD::texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->type != Texture::TYPE_3D);
@@ -921,7 +921,7 @@ void RasterizerStorageRD::texture_3d_update(RID p_texture, const Vector<Ref<Imag
 	RD::get_singleton()->texture_update(tex->rd_texture, 0, all_data, true);
 }
 
-void RasterizerStorageRD::texture_proxy_update(RID p_texture, RID p_proxy_to) {
+void RendererStorageRD::texture_proxy_update(RID p_texture, RID p_proxy_to) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(!tex->is_proxy);
@@ -961,7 +961,7 @@ void RasterizerStorageRD::texture_proxy_update(RID p_texture, RID p_proxy_to) {
 }
 
 //these two APIs can be used together or in combination with the others.
-RID RasterizerStorageRD::texture_2d_placeholder_create() {
+RID RendererStorageRD::texture_2d_placeholder_create() {
 	//this could be better optimized to reuse an existing image , done this way
 	//for now to get it working
 	Ref<Image> image;
@@ -977,7 +977,7 @@ RID RasterizerStorageRD::texture_2d_placeholder_create() {
 	return texture_2d_create(image);
 }
 
-RID RasterizerStorageRD::texture_2d_layered_placeholder_create(RS::TextureLayeredType p_layered_type) {
+RID RendererStorageRD::texture_2d_layered_placeholder_create(RS::TextureLayeredType p_layered_type) {
 	//this could be better optimized to reuse an existing image , done this way
 	//for now to get it working
 	Ref<Image> image;
@@ -1003,7 +1003,7 @@ RID RasterizerStorageRD::texture_2d_layered_placeholder_create(RS::TextureLayere
 	return texture_2d_layered_create(images, p_layered_type);
 }
 
-RID RasterizerStorageRD::texture_3d_placeholder_create() {
+RID RendererStorageRD::texture_3d_placeholder_create() {
 	//this could be better optimized to reuse an existing image , done this way
 	//for now to get it working
 	Ref<Image> image;
@@ -1025,7 +1025,7 @@ RID RasterizerStorageRD::texture_3d_placeholder_create() {
 	return texture_3d_create(Image::FORMAT_RGBA8, 4, 4, 4, false, images);
 }
 
-Ref<Image> RasterizerStorageRD::texture_2d_get(RID p_texture) const {
+Ref<Image> RendererStorageRD::texture_2d_get(RID p_texture) const {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND_V(!tex, Ref<Image>());
 
@@ -1053,7 +1053,7 @@ Ref<Image> RasterizerStorageRD::texture_2d_get(RID p_texture) const {
 	return image;
 }
 
-Ref<Image> RasterizerStorageRD::texture_2d_layer_get(RID p_texture, int p_layer) const {
+Ref<Image> RendererStorageRD::texture_2d_layer_get(RID p_texture, int p_layer) const {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND_V(!tex, Ref<Image>());
 
@@ -1070,7 +1070,7 @@ Ref<Image> RasterizerStorageRD::texture_2d_layer_get(RID p_texture, int p_layer)
 	return image;
 }
 
-Vector<Ref<Image>> RasterizerStorageRD::texture_3d_get(RID p_texture) const {
+Vector<Ref<Image>> RendererStorageRD::texture_3d_get(RID p_texture) const {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND_V(!tex, Vector<Ref<Image>>());
 	ERR_FAIL_COND_V(tex->type != Texture::TYPE_3D, Vector<Ref<Image>>());
@@ -1101,7 +1101,7 @@ Vector<Ref<Image>> RasterizerStorageRD::texture_3d_get(RID p_texture) const {
 	return ret;
 }
 
-void RasterizerStorageRD::texture_replace(RID p_texture, RID p_by_texture) {
+void RendererStorageRD::texture_replace(RID p_texture, RID p_by_texture) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->proxy_to.is_valid()); //can't replace proxy
@@ -1150,7 +1150,7 @@ void RasterizerStorageRD::texture_replace(RID p_texture, RID p_by_texture) {
 	}
 }
 
-void RasterizerStorageRD::texture_set_size_override(RID p_texture, int p_width, int p_height) {
+void RendererStorageRD::texture_set_size_override(RID p_texture, int p_width, int p_height) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	ERR_FAIL_COND(tex->type != Texture::TYPE_2D);
@@ -1158,53 +1158,53 @@ void RasterizerStorageRD::texture_set_size_override(RID p_texture, int p_width,
 	tex->height_2d = p_height;
 }
 
-void RasterizerStorageRD::texture_set_path(RID p_texture, const String &p_path) {
+void RendererStorageRD::texture_set_path(RID p_texture, const String &p_path) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->path = p_path;
 }
 
-String RasterizerStorageRD::texture_get_path(RID p_texture) const {
+String RendererStorageRD::texture_get_path(RID p_texture) const {
 	return String();
 }
 
-void RasterizerStorageRD::texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
+void RendererStorageRD::texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->detect_3d_callback_ud = p_userdata;
 	tex->detect_3d_callback = p_callback;
 }
 
-void RasterizerStorageRD::texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
+void RendererStorageRD::texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->detect_normal_callback_ud = p_userdata;
 	tex->detect_normal_callback = p_callback;
 }
 
-void RasterizerStorageRD::texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) {
+void RendererStorageRD::texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) {
 	Texture *tex = texture_owner.getornull(p_texture);
 	ERR_FAIL_COND(!tex);
 	tex->detect_roughness_callback_ud = p_userdata;
 	tex->detect_roughness_callback = p_callback;
 }
 
-void RasterizerStorageRD::texture_debug_usage(List<RS::TextureInfo> *r_info) {
+void RendererStorageRD::texture_debug_usage(List<RS::TextureInfo> *r_info) {
 }
 
-void RasterizerStorageRD::texture_set_proxy(RID p_proxy, RID p_base) {
+void RendererStorageRD::texture_set_proxy(RID p_proxy, RID p_base) {
 }
 
-void RasterizerStorageRD::texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) {
+void RendererStorageRD::texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) {
 }
 
-Size2 RasterizerStorageRD::texture_size_with_proxy(RID p_proxy) {
+Size2 RendererStorageRD::texture_size_with_proxy(RID p_proxy) {
 	return texture_2d_get_size(p_proxy);
 }
 
 /* CANVAS TEXTURE */
 
-void RasterizerStorageRD::CanvasTexture::clear_sets() {
+void RendererStorageRD::CanvasTexture::clear_sets() {
 	if (cleared_cache) {
 		return;
 	}
@@ -1219,15 +1219,15 @@ void RasterizerStorageRD::CanvasTexture::clear_sets() {
 	cleared_cache = true;
 }
 
-RasterizerStorageRD::CanvasTexture::~CanvasTexture() {
+RendererStorageRD::CanvasTexture::~CanvasTexture() {
 	clear_sets();
 }
 
-RID RasterizerStorageRD::canvas_texture_create() {
+RID RendererStorageRD::canvas_texture_create() {
 	return canvas_texture_owner.make_rid(memnew(CanvasTexture));
 }
 
-void RasterizerStorageRD::canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) {
+void RendererStorageRD::canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) {
 	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
 	switch (p_channel) {
 		case RS::CANVAS_TEXTURE_CHANNEL_DIFFUSE: {
@@ -1244,7 +1244,7 @@ void RasterizerStorageRD::canvas_texture_set_channel(RID p_canvas_texture, RS::C
 	ct->clear_sets();
 }
 
-void RasterizerStorageRD::canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_specular_color, float p_shininess) {
+void RendererStorageRD::canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_specular_color, float p_shininess) {
 	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
 	ct->specular_color.r = p_specular_color.r;
 	ct->specular_color.g = p_specular_color.g;
@@ -1253,19 +1253,19 @@ void RasterizerStorageRD::canvas_texture_set_shading_parameters(RID p_canvas_tex
 	ct->clear_sets();
 }
 
-void RasterizerStorageRD::canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) {
+void RendererStorageRD::canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) {
 	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
 	ct->texture_filter = p_filter;
 	ct->clear_sets();
 }
 
-void RasterizerStorageRD::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {
+void RendererStorageRD::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {
 	CanvasTexture *ct = canvas_texture_owner.getornull(p_canvas_texture);
 	ct->texture_repeat = p_repeat;
 	ct->clear_sets();
 }
 
-bool RasterizerStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID p_base_shader, int p_base_set, RID &r_uniform_set, Size2i &r_size, Color &r_specular_shininess, bool &r_use_normal, bool &r_use_specular) {
+bool RendererStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID p_base_shader, int p_base_set, RID &r_uniform_set, Size2i &r_size, Color &r_specular_shininess, bool &r_use_normal, bool &r_use_specular) {
 	CanvasTexture *ct = nullptr;
 
 	Texture *t = texture_owner.getornull(p_texture);
@@ -1298,7 +1298,7 @@ bool RasterizerStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canv
 		Vector<RD::Uniform> uniforms;
 		{ //diffuse
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 0;
 
 			t = texture_owner.getornull(ct->diffuse);
@@ -1313,7 +1313,7 @@ bool RasterizerStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canv
 		}
 		{ //normal
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1;
 
 			t = texture_owner.getornull(ct->normalmap);
@@ -1328,7 +1328,7 @@ bool RasterizerStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canv
 		}
 		{ //specular
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 2;
 
 			t = texture_owner.getornull(ct->specular);
@@ -1343,7 +1343,7 @@ bool RasterizerStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canv
 		}
 		{ //sampler
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 3;
 			u.ids.push_back(sampler_rd_get_default(filter, repeat));
 			uniforms.push_back(u);
@@ -1365,7 +1365,7 @@ bool RasterizerStorageRD::canvas_texture_get_uniform_set(RID p_texture, RS::Canv
 
 /* SHADER API */
 
-RID RasterizerStorageRD::shader_create() {
+RID RendererStorageRD::shader_create() {
 	Shader shader;
 	shader.data = nullptr;
 	shader.type = SHADER_TYPE_MAX;
@@ -1373,7 +1373,7 @@ RID RasterizerStorageRD::shader_create() {
 	return shader_owner.make_rid(shader);
 }
 
-void RasterizerStorageRD::shader_set_code(RID p_shader, const String &p_code) {
+void RendererStorageRD::shader_set_code(RID p_shader, const String &p_code) {
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND(!shader);
 
@@ -1443,13 +1443,13 @@ void RasterizerStorageRD::shader_set_code(RID p_shader, const String &p_code) {
 	}
 }
 
-String RasterizerStorageRD::shader_get_code(RID p_shader) const {
+String RendererStorageRD::shader_get_code(RID p_shader) const {
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND_V(!shader, String());
 	return shader->code;
 }
 
-void RasterizerStorageRD::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
+void RendererStorageRD::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND(!shader);
 	if (shader->data) {
@@ -1457,7 +1457,7 @@ void RasterizerStorageRD::shader_get_param_list(RID p_shader, List<PropertyInfo>
 	}
 }
 
-void RasterizerStorageRD::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
+void RendererStorageRD::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) {
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND(!shader);
 
@@ -1475,7 +1475,7 @@ void RasterizerStorageRD::shader_set_default_texture_param(RID p_shader, const S
 	}
 }
 
-RID RasterizerStorageRD::shader_get_default_texture_param(RID p_shader, const StringName &p_name) const {
+RID RendererStorageRD::shader_get_default_texture_param(RID p_shader, const StringName &p_name) const {
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND_V(!shader, RID());
 	if (shader->default_texture_parameter.has(p_name)) {
@@ -1485,7 +1485,7 @@ RID RasterizerStorageRD::shader_get_default_texture_param(RID p_shader, const St
 	return RID();
 }
 
-Variant RasterizerStorageRD::shader_get_param_default(RID p_shader, const StringName &p_param) const {
+Variant RendererStorageRD::shader_get_param_default(RID p_shader, const StringName &p_param) const {
 	Shader *shader = shader_owner.getornull(p_shader);
 	ERR_FAIL_COND_V(!shader, Variant());
 	if (shader->data) {
@@ -1494,14 +1494,14 @@ Variant RasterizerStorageRD::shader_get_param_default(RID p_shader, const String
 	return Variant();
 }
 
-void RasterizerStorageRD::shader_set_data_request_function(ShaderType p_shader_type, ShaderDataRequestFunction p_function) {
+void RendererStorageRD::shader_set_data_request_function(ShaderType p_shader_type, ShaderDataRequestFunction p_function) {
 	ERR_FAIL_INDEX(p_shader_type, SHADER_TYPE_MAX);
 	shader_data_request_func[p_shader_type] = p_function;
 }
 
 /* COMMON MATERIAL API */
 
-RID RasterizerStorageRD::material_create() {
+RID RendererStorageRD::material_create() {
 	Material material;
 	material.data = nullptr;
 	material.shader = nullptr;
@@ -1519,7 +1519,7 @@ RID RasterizerStorageRD::material_create() {
 	return id;
 }
 
-void RasterizerStorageRD::_material_queue_update(Material *material, bool p_uniform, bool p_texture) {
+void RendererStorageRD::_material_queue_update(Material *material, bool p_uniform, bool p_texture) {
 	if (material->update_requested) {
 		return;
 	}
@@ -1531,7 +1531,7 @@ void RasterizerStorageRD::_material_queue_update(Material *material, bool p_unif
 	material->texture_dirty = material->texture_dirty || p_texture;
 }
 
-void RasterizerStorageRD::material_set_shader(RID p_material, RID p_shader) {
+void RendererStorageRD::material_set_shader(RID p_material, RID p_shader) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 
@@ -1572,7 +1572,7 @@ void RasterizerStorageRD::material_set_shader(RID p_material, RID p_shader) {
 	_material_queue_update(material, true, true);
 }
 
-void RasterizerStorageRD::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
+void RendererStorageRD::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 
@@ -1590,7 +1590,7 @@ void RasterizerStorageRD::material_set_param(RID p_material, const StringName &p
 	}
 }
 
-Variant RasterizerStorageRD::material_get_param(RID p_material, const StringName &p_param) const {
+Variant RendererStorageRD::material_get_param(RID p_material, const StringName &p_param) const {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND_V(!material, Variant());
 	if (material->params.has(p_param)) {
@@ -1600,7 +1600,7 @@ Variant RasterizerStorageRD::material_get_param(RID p_material, const StringName
 	}
 }
 
-void RasterizerStorageRD::material_set_next_pass(RID p_material, RID p_next_material) {
+void RendererStorageRD::material_set_next_pass(RID p_material, RID p_next_material) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 
@@ -1616,7 +1616,7 @@ void RasterizerStorageRD::material_set_next_pass(RID p_material, RID p_next_mate
 	material->instance_dependency.instance_notify_changed(false, true);
 }
 
-void RasterizerStorageRD::material_set_render_priority(RID p_material, int priority) {
+void RendererStorageRD::material_set_render_priority(RID p_material, int priority) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 	material->priority = priority;
@@ -1625,7 +1625,7 @@ void RasterizerStorageRD::material_set_render_priority(RID p_material, int prior
 	}
 }
 
-bool RasterizerStorageRD::material_is_animated(RID p_material) {
+bool RendererStorageRD::material_is_animated(RID p_material) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND_V(!material, false);
 	if (material->shader && material->shader->data) {
@@ -1638,7 +1638,7 @@ bool RasterizerStorageRD::material_is_animated(RID p_material) {
 	return false; //by default nothing is animated
 }
 
-bool RasterizerStorageRD::material_casts_shadows(RID p_material) {
+bool RendererStorageRD::material_casts_shadows(RID p_material) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND_V(!material, true);
 	if (material->shader && material->shader->data) {
@@ -1651,7 +1651,7 @@ bool RasterizerStorageRD::material_casts_shadows(RID p_material) {
 	return true; //by default everything casts shadows
 }
 
-void RasterizerStorageRD::material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) {
+void RendererStorageRD::material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 	if (material->shader && material->shader->data) {
@@ -1663,7 +1663,7 @@ void RasterizerStorageRD::material_get_instance_shader_parameters(RID p_material
 	}
 }
 
-void RasterizerStorageRD::material_update_dependency(RID p_material, RasterizerScene::InstanceBase *p_instance) {
+void RendererStorageRD::material_update_dependency(RID p_material, InstanceBaseDependency *p_instance) {
 	Material *material = material_owner.getornull(p_material);
 	ERR_FAIL_COND(!material);
 	p_instance->update_dependency(&material->instance_dependency);
@@ -1672,7 +1672,7 @@ void RasterizerStorageRD::material_update_dependency(RID p_material, RasterizerS
 	}
 }
 
-void RasterizerStorageRD::material_set_data_request_function(ShaderType p_shader_type, MaterialDataRequestFunction p_function) {
+void RendererStorageRD::material_set_data_request_function(ShaderType p_shader_type, MaterialDataRequestFunction p_function) {
 	ERR_FAIL_INDEX(p_shader_type, SHADER_TYPE_MAX);
 	material_data_request_func[p_shader_type] = p_function;
 }
@@ -2119,7 +2119,7 @@ _FORCE_INLINE_ static void _fill_std140_ubo_empty(ShaderLanguage::DataType type,
 	}
 }
 
-void RasterizerStorageRD::MaterialData::update_uniform_buffer(const Map<StringName, ShaderLanguage::ShaderNode::Uniform> &p_uniforms, const uint32_t *p_uniform_offsets, const Map<StringName, Variant> &p_parameters, uint8_t *p_buffer, uint32_t p_buffer_size, bool p_use_linear_color) {
+void RendererStorageRD::MaterialData::update_uniform_buffer(const Map<StringName, ShaderLanguage::ShaderNode::Uniform> &p_uniforms, const uint32_t *p_uniform_offsets, const Map<StringName, Variant> &p_parameters, uint8_t *p_buffer, uint32_t p_buffer_size, bool p_use_linear_color) {
 	bool uses_global_buffer = false;
 
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = p_uniforms.front(); E; E = E->next()) {
@@ -2133,7 +2133,7 @@ void RasterizerStorageRD::MaterialData::update_uniform_buffer(const Map<StringNa
 
 		if (E->get().scope == ShaderLanguage::ShaderNode::Uniform::SCOPE_GLOBAL) {
 			//this is a global variable, get the index to it
-			RasterizerStorageRD *rs = base_singleton;
+			RendererStorageRD *rs = base_singleton;
 
 			GlobalVariables::Variable *gv = rs->global_variables.variables.getptr(E->key());
 			uint32_t index = 0;
@@ -2180,7 +2180,7 @@ void RasterizerStorageRD::MaterialData::update_uniform_buffer(const Map<StringNa
 	}
 
 	if (uses_global_buffer != (global_buffer_E != nullptr)) {
-		RasterizerStorageRD *rs = base_singleton;
+		RendererStorageRD *rs = base_singleton;
 		if (uses_global_buffer) {
 			global_buffer_E = rs->global_variables.materials_using_buffer.push_back(self);
 		} else {
@@ -2190,16 +2190,16 @@ void RasterizerStorageRD::MaterialData::update_uniform_buffer(const Map<StringNa
 	}
 }
 
-RasterizerStorageRD::MaterialData::~MaterialData() {
+RendererStorageRD::MaterialData::~MaterialData() {
 	if (global_buffer_E) {
 		//unregister global buffers
-		RasterizerStorageRD *rs = base_singleton;
+		RendererStorageRD *rs = base_singleton;
 		rs->global_variables.materials_using_buffer.erase(global_buffer_E);
 	}
 
 	if (global_texture_E) {
 		//unregister global textures
-		RasterizerStorageRD *rs = base_singleton;
+		RendererStorageRD *rs = base_singleton;
 
 		for (Map<StringName, uint64_t>::Element *E = used_global_textures.front(); E; E = E->next()) {
 			GlobalVariables::Variable *v = rs->global_variables.variables.getptr(E->key());
@@ -2212,8 +2212,8 @@ RasterizerStorageRD::MaterialData::~MaterialData() {
 	}
 }
 
-void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Variant> &p_parameters, const Map<StringName, RID> &p_default_textures, const Vector<ShaderCompilerRD::GeneratedCode::Texture> &p_texture_uniforms, RID *p_textures, bool p_use_linear_color) {
-	RasterizerStorageRD *singleton = (RasterizerStorageRD *)RasterizerStorage::base_singleton;
+void RendererStorageRD::MaterialData::update_textures(const Map<StringName, Variant> &p_parameters, const Map<StringName, RID> &p_default_textures, const Vector<ShaderCompilerRD::GeneratedCode::Texture> &p_texture_uniforms, RID *p_textures, bool p_use_linear_color) {
+	RendererStorageRD *singleton = (RendererStorageRD *)RendererStorage::base_singleton;
 #ifdef TOOLS_ENABLED
 	Texture *roughness_detect_texture = nullptr;
 	RS::TextureDetectRoughnessChannel roughness_channel = RS::TEXTURE_DETECT_ROUGNHESS_R;
@@ -2229,7 +2229,7 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 		RID texture;
 
 		if (p_texture_uniforms[i].global) {
-			RasterizerStorageRD *rs = base_singleton;
+			RendererStorageRD *rs = base_singleton;
 
 			uses_global_textures = true;
 
@@ -2330,7 +2330,7 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 	{
 		//for textures no longer used, unregister them
 		List<Map<StringName, uint64_t>::Element *> to_delete;
-		RasterizerStorageRD *rs = base_singleton;
+		RendererStorageRD *rs = base_singleton;
 
 		for (Map<StringName, uint64_t>::Element *E = used_global_textures.front(); E; E = E->next()) {
 			if (E->get() != global_textures_pass) {
@@ -2359,7 +2359,7 @@ void RasterizerStorageRD::MaterialData::update_textures(const Map<StringName, Va
 	}
 }
 
-void RasterizerStorageRD::material_force_update_textures(RID p_material, ShaderType p_shader_type) {
+void RendererStorageRD::material_force_update_textures(RID p_material, ShaderType p_shader_type) {
 	Material *material = material_owner.getornull(p_material);
 	if (material->shader_type != p_shader_type) {
 		return;
@@ -2369,7 +2369,7 @@ void RasterizerStorageRD::material_force_update_textures(RID p_material, ShaderT
 	}
 }
 
-void RasterizerStorageRD::_update_queued_materials() {
+void RendererStorageRD::_update_queued_materials() {
 	Material *material = material_update_list;
 	while (material) {
 		Material *next = material->update_next;
@@ -2388,23 +2388,35 @@ void RasterizerStorageRD::_update_queued_materials() {
 
 /* MESH API */
 
-RID RasterizerStorageRD::mesh_create() {
+RID RendererStorageRD::mesh_create() {
 	return mesh_owner.make_rid(Mesh());
 }
 
+void RendererStorageRD::mesh_set_blend_shape_count(RID p_mesh, int p_blend_shape_count) {
+	ERR_FAIL_COND(p_blend_shape_count < 0);
+
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND(!mesh);
+
+	ERR_FAIL_COND(mesh->surface_count > 0); //surfaces already exist
+
+	mesh->blend_shape_count = p_blend_shape_count;
+}
+
 /// Returns stride
-void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) {
+void RendererStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 
 	//ensure blend shape consistency
-	ERR_FAIL_COND(mesh->blend_shape_count && p_surface.blend_shapes.size() != (int)mesh->blend_shape_count);
 	ERR_FAIL_COND(mesh->blend_shape_count && p_surface.bone_aabbs.size() != mesh->bone_aabbs.size());
 
 #ifdef DEBUG_ENABLED
 	//do a validation, to catch errors first
 	{
 		uint32_t stride = 0;
+		uint32_t attrib_stride = 0;
+		uint32_t skin_stride = 0;
 
 		for (int i = 0; i < RS::ARRAY_WEIGHTS; i++) {
 			if ((p_surface.format & (1 << i))) {
@@ -2418,59 +2430,59 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 
 					} break;
 					case RS::ARRAY_NORMAL: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_NORMAL) {
-							stride += sizeof(int8_t) * 4;
-						} else {
-							stride += sizeof(float) * 4;
-						}
+						stride += sizeof(int32_t);
 
 					} break;
 					case RS::ARRAY_TANGENT: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_TANGENT) {
-							stride += sizeof(int8_t) * 4;
-						} else {
-							stride += sizeof(float) * 4;
-						}
+						stride += sizeof(int32_t);
 
 					} break;
 					case RS::ARRAY_COLOR: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_COLOR) {
-							stride += sizeof(int8_t) * 4;
-						} else {
-							stride += sizeof(float) * 4;
-						}
-
+						attrib_stride += sizeof(int16_t) * 4;
 					} break;
 					case RS::ARRAY_TEX_UV: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_TEX_UV) {
-							stride += sizeof(int16_t) * 2;
-						} else {
-							stride += sizeof(float) * 2;
-						}
+						attrib_stride += sizeof(float) * 2;
 
 					} break;
 					case RS::ARRAY_TEX_UV2: {
-						if (p_surface.format & RS::ARRAY_COMPRESS_TEX_UV2) {
-							stride += sizeof(int16_t) * 2;
-						} else {
-							stride += sizeof(float) * 2;
-						}
+						attrib_stride += sizeof(float) * 2;
 
 					} break;
-					case RS::ARRAY_BONES: {
-						//assumed weights too
-
-						//unique format, internally 16 bits, exposed as single array for 32
-
-						stride += sizeof(int32_t) * 4;
+					case RS::ARRAY_CUSTOM0:
+					case RS::ARRAY_CUSTOM1:
+					case RS::ARRAY_CUSTOM2:
+					case RS::ARRAY_CUSTOM3: {
+						int idx = i - RS::ARRAY_CUSTOM0;
+						uint32_t fmt_shift[RS::ARRAY_CUSTOM_COUNT] = { RS::ARRAY_FORMAT_CUSTOM0_SHIFT, RS::ARRAY_FORMAT_CUSTOM1_SHIFT, RS::ARRAY_FORMAT_CUSTOM2_SHIFT, RS::ARRAY_FORMAT_CUSTOM3_SHIFT };
+						uint32_t fmt = (p_surface.format >> fmt_shift[idx]) & RS::ARRAY_FORMAT_CUSTOM_MASK;
+						uint32_t fmtsize[RS::ARRAY_CUSTOM_MAX] = { 4, 4, 4, 8, 4, 8, 12, 16 };
+						attrib_stride += fmtsize[fmt];
 
 					} break;
+					case RS::ARRAY_WEIGHTS:
+					case RS::ARRAY_BONES: {
+						//uses a separate array
+						bool use_8 = p_surface.format & RS::ARRAY_FLAG_USE_8_BONE_WEIGHTS;
+						skin_stride += sizeof(int16_t) * (use_8 ? 16 : 8);
+					} break;
 				}
 			}
 		}
 
 		int expected_size = stride * p_surface.vertex_count;
-		ERR_FAIL_COND_MSG(expected_size != p_surface.vertex_data.size(), "Size of data provided (" + itos(p_surface.vertex_data.size()) + ") does not match expected (" + itos(expected_size) + ")");
+		ERR_FAIL_COND_MSG(expected_size != p_surface.vertex_data.size(), "Size of vertex data provided (" + itos(p_surface.vertex_data.size()) + ") does not match expected (" + itos(expected_size) + ")");
+
+		int bs_expected_size = expected_size * mesh->blend_shape_count;
+
+		ERR_FAIL_COND_MSG(bs_expected_size != p_surface.blend_shape_data.size(), "Size of blend shape data provided (" + itos(p_surface.blend_shape_data.size()) + ") does not match expected (" + itos(bs_expected_size) + ")");
+
+		int expected_attrib_size = attrib_stride * p_surface.vertex_count;
+		ERR_FAIL_COND_MSG(expected_attrib_size != p_surface.attribute_data.size(), "Size of attribute data provided (" + itos(p_surface.attribute_data.size()) + ") does not match expected (" + itos(expected_attrib_size) + ")");
+
+		if ((p_surface.format & RS::ARRAY_FORMAT_WEIGHTS) && (p_surface.format & RS::ARRAY_FORMAT_BONES)) {
+			expected_size = skin_stride * p_surface.vertex_count;
+			ERR_FAIL_COND_MSG(expected_size != p_surface.skin_data.size(), "Size of skin data provided (" + itos(p_surface.skin_data.size()) + ") does not match expected (" + itos(expected_size) + ")");
+		}
 	}
 
 #endif
@@ -2480,9 +2492,25 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 	s->format = p_surface.format;
 	s->primitive = p_surface.primitive;
 
-	s->vertex_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.vertex_data.size(), p_surface.vertex_data);
+	bool use_as_storage = (p_surface.skin_data.size() || mesh->blend_shape_count > 0);
+
+	s->vertex_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.vertex_data.size(), p_surface.vertex_data, use_as_storage);
+	s->vertex_buffer_size = p_surface.vertex_data.size();
+
+	if (p_surface.attribute_data.size()) {
+		s->attribute_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.attribute_data.size(), p_surface.attribute_data);
+	}
+	if (p_surface.skin_data.size()) {
+		s->skin_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.skin_data.size(), p_surface.skin_data, use_as_storage);
+		s->skin_buffer_size = p_surface.skin_data.size();
+	}
+
 	s->vertex_count = p_surface.vertex_count;
 
+	if (p_surface.format & RS::ARRAY_FORMAT_BONES) {
+		mesh->has_bone_weights = true;
+	}
+
 	if (p_surface.index_count) {
 		bool is_index_16 = p_surface.vertex_count <= 65536;
 
@@ -2505,16 +2533,44 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 	s->aabb = p_surface.aabb;
 	s->bone_aabbs = p_surface.bone_aabbs; //only really useful for returning them.
 
-	for (int i = 0; i < p_surface.blend_shapes.size(); i++) {
-		if (p_surface.blend_shapes[i].size() != p_surface.vertex_data.size()) {
-			memdelete(s);
-			ERR_FAIL_COND(p_surface.blend_shapes[i].size() != p_surface.vertex_data.size());
-		}
-		RID vertex_buffer = RD::get_singleton()->vertex_buffer_create(p_surface.blend_shapes[i].size(), p_surface.blend_shapes[i]);
-		s->blend_shapes.push_back(vertex_buffer);
+	if (mesh->blend_shape_count > 0) {
+		s->blend_shape_buffer = RD::get_singleton()->storage_buffer_create(p_surface.blend_shape_data.size(), p_surface.blend_shape_data);
 	}
 
-	mesh->blend_shape_count = p_surface.blend_shapes.size();
+	if (use_as_storage) {
+		Vector<RD::Uniform> uniforms;
+		{
+			RD::Uniform u;
+			u.binding = 0;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.ids.push_back(s->vertex_buffer);
+			uniforms.push_back(u);
+		}
+		{
+			RD::Uniform u;
+			u.binding = 1;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			if (s->skin_buffer.is_valid()) {
+				u.ids.push_back(s->skin_buffer);
+			} else {
+				u.ids.push_back(default_rd_storage_buffer);
+			}
+			uniforms.push_back(u);
+		}
+		{
+			RD::Uniform u;
+			u.binding = 2;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			if (s->blend_shape_buffer.is_valid()) {
+				u.ids.push_back(s->blend_shape_buffer);
+			} else {
+				u.ids.push_back(default_rd_storage_buffer);
+			}
+			uniforms.push_back(u);
+		}
+
+		s->uniform_set = RD::get_singleton()->uniform_set_create(uniforms, skeleton_shader.version_shader[0], SkeletonShader::UNIFORM_SET_SURFACE);
+	}
 
 	if (mesh->surface_count == 0) {
 		mesh->bone_aabbs = p_surface.bone_aabbs;
@@ -2532,18 +2588,24 @@ void RasterizerStorageRD::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_
 	mesh->surfaces[mesh->surface_count] = s;
 	mesh->surface_count++;
 
+	for (List<MeshInstance *>::Element *E = mesh->instances.front(); E; E = E->next()) {
+		//update instances
+		MeshInstance *mi = E->get();
+		_mesh_instance_add_surface(mi, mesh, mesh->surface_count - 1);
+	}
+
 	mesh->instance_dependency.instance_notify_changed(true, true);
 
 	mesh->material_cache.clear();
 }
 
-int RasterizerStorageRD::mesh_get_blend_shape_count(RID p_mesh) const {
+int RendererStorageRD::mesh_get_blend_shape_count(RID p_mesh) const {
 	const Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, -1);
 	return mesh->blend_shape_count;
 }
 
-void RasterizerStorageRD::mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode p_mode) {
+void RendererStorageRD::mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode p_mode) {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_INDEX((int)p_mode, 2);
@@ -2551,13 +2613,13 @@ void RasterizerStorageRD::mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMo
 	mesh->blend_shape_mode = p_mode;
 }
 
-RS::BlendShapeMode RasterizerStorageRD::mesh_get_blend_shape_mode(RID p_mesh) const {
+RS::BlendShapeMode RendererStorageRD::mesh_get_blend_shape_mode(RID p_mesh) const {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, RS::BLEND_SHAPE_MODE_NORMALIZED);
 	return mesh->blend_shape_mode;
 }
 
-void RasterizerStorageRD::mesh_surface_update_region(RID p_mesh, int p_surface, int p_offset, const Vector<uint8_t> &p_data) {
+void RendererStorageRD::mesh_surface_update_region(RID p_mesh, int p_surface, int p_offset, const Vector<uint8_t> &p_data) {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count);
@@ -2568,7 +2630,7 @@ void RasterizerStorageRD::mesh_surface_update_region(RID p_mesh, int p_surface,
 	RD::get_singleton()->buffer_update(mesh->surfaces[p_surface]->vertex_buffer, p_offset, data_size, r);
 }
 
-void RasterizerStorageRD::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material) {
+void RendererStorageRD::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material) {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count);
@@ -2578,7 +2640,7 @@ void RasterizerStorageRD::mesh_surface_set_material(RID p_mesh, int p_surface, R
 	mesh->material_cache.clear();
 }
 
-RID RasterizerStorageRD::mesh_surface_get_material(RID p_mesh, int p_surface) const {
+RID RendererStorageRD::mesh_surface_get_material(RID p_mesh, int p_surface) const {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, RID());
 	ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RID());
@@ -2586,7 +2648,7 @@ RID RasterizerStorageRD::mesh_surface_get_material(RID p_mesh, int p_surface) co
 	return mesh->surfaces[p_surface]->material;
 }
 
-RS::SurfaceData RasterizerStorageRD::mesh_get_surface(RID p_mesh, int p_surface) const {
+RS::SurfaceData RendererStorageRD::mesh_get_surface(RID p_mesh, int p_surface) const {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, RS::SurfaceData());
 	ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RS::SurfaceData());
@@ -2596,6 +2658,12 @@ RS::SurfaceData RasterizerStorageRD::mesh_get_surface(RID p_mesh, int p_surface)
 	RS::SurfaceData sd;
 	sd.format = s.format;
 	sd.vertex_data = RD::get_singleton()->buffer_get_data(s.vertex_buffer);
+	if (s.attribute_buffer.is_valid()) {
+		sd.attribute_data = RD::get_singleton()->buffer_get_data(s.attribute_buffer);
+	}
+	if (s.skin_buffer.is_valid()) {
+		sd.skin_data = RD::get_singleton()->buffer_get_data(s.skin_buffer);
+	}
 	sd.vertex_count = s.vertex_count;
 	sd.index_count = s.index_count;
 	sd.primitive = s.primitive;
@@ -2613,33 +2681,32 @@ RS::SurfaceData RasterizerStorageRD::mesh_get_surface(RID p_mesh, int p_surface)
 
 	sd.bone_aabbs = s.bone_aabbs;
 
-	for (int i = 0; i < s.blend_shapes.size(); i++) {
-		Vector<uint8_t> bs = RD::get_singleton()->buffer_get_data(s.blend_shapes[i]);
-		sd.blend_shapes.push_back(bs);
+	if (s.blend_shape_buffer.is_valid()) {
+		sd.blend_shape_data = RD::get_singleton()->buffer_get_data(s.blend_shape_buffer);
 	}
 
 	return sd;
 }
 
-int RasterizerStorageRD::mesh_get_surface_count(RID p_mesh) const {
+int RendererStorageRD::mesh_get_surface_count(RID p_mesh) const {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, 0);
 	return mesh->surface_count;
 }
 
-void RasterizerStorageRD::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) {
+void RendererStorageRD::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	mesh->custom_aabb = p_aabb;
 }
 
-AABB RasterizerStorageRD::mesh_get_custom_aabb(RID p_mesh) const {
+AABB RendererStorageRD::mesh_get_custom_aabb(RID p_mesh) const {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, AABB());
 	return mesh->custom_aabb;
 }
 
-AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
+AABB RendererStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND_V(!mesh, AABB());
 
@@ -2744,12 +2811,18 @@ AABB RasterizerStorageRD::mesh_get_aabb(RID p_mesh, RID p_skeleton) {
 	return aabb;
 }
 
-void RasterizerStorageRD::mesh_clear(RID p_mesh) {
+void RendererStorageRD::mesh_clear(RID p_mesh) {
 	Mesh *mesh = mesh_owner.getornull(p_mesh);
 	ERR_FAIL_COND(!mesh);
 	for (uint32_t i = 0; i < mesh->surface_count; i++) {
 		Mesh::Surface &s = *mesh->surfaces[i];
 		RD::get_singleton()->free(s.vertex_buffer); //clears arrays as dependency automatically, including all versions
+		if (s.attribute_buffer.is_valid()) {
+			RD::get_singleton()->free(s.attribute_buffer);
+		}
+		if (s.skin_buffer.is_valid()) {
+			RD::get_singleton()->free(s.skin_buffer);
+		}
 		if (s.versions) {
 			memfree(s.versions); //reallocs, so free with memfree.
 		}
@@ -2765,12 +2838,8 @@ void RasterizerStorageRD::mesh_clear(RID p_mesh) {
 			memdelete_arr(s.lods);
 		}
 
-		for (int32_t j = 0; j < s.blend_shapes.size(); j++) {
-			RD::get_singleton()->free(s.blend_shapes[j]);
-		}
-
-		if (s.blend_shape_base_buffer.is_valid()) {
-			RD::get_singleton()->free(s.blend_shape_base_buffer);
+		if (s.blend_shape_buffer.is_valid()) {
+			RD::get_singleton()->free(s.blend_shape_buffer);
 		}
 
 		memdelete(mesh->surfaces[i]);
@@ -2782,22 +2851,231 @@ void RasterizerStorageRD::mesh_clear(RID p_mesh) {
 	mesh->surfaces = nullptr;
 	mesh->surface_count = 0;
 	mesh->material_cache.clear();
+	//clear instance data
+	for (List<MeshInstance *>::Element *E = mesh->instances.front(); E; E = E->next()) {
+		MeshInstance *mi = E->get();
+		_mesh_instance_clear(mi);
+	}
 	mesh->instance_dependency.instance_notify_changed(true, true);
+	mesh->has_bone_weights = false;
+}
+
+bool RendererStorageRD::mesh_needs_instance(RID p_mesh, bool p_has_skeleton) {
+	Mesh *mesh = mesh_owner.getornull(p_mesh);
+	ERR_FAIL_COND_V(!mesh, false);
+
+	return mesh->blend_shape_count > 0 || (mesh->has_bone_weights && p_has_skeleton);
+}
+
+/* MESH INSTANCE */
+
+RID RendererStorageRD::mesh_instance_create(RID p_base) {
+	Mesh *mesh = mesh_owner.getornull(p_base);
+	ERR_FAIL_COND_V(!mesh, RID());
+
+	MeshInstance *mi = memnew(MeshInstance);
+
+	mi->mesh = mesh;
+
+	for (uint32_t i = 0; i < mesh->surface_count; i++) {
+		_mesh_instance_add_surface(mi, mesh, i);
+	}
+
+	mi->I = mesh->instances.push_back(mi);
+
+	mi->dirty = true;
+
+	return mesh_instance_owner.make_rid(mi);
+}
+void RendererStorageRD::mesh_instance_set_skeleton(RID p_mesh_instance, RID p_skeleton) {
+	MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+	if (mi->skeleton == p_skeleton) {
+		return;
+	}
+	mi->skeleton = p_skeleton;
+	mi->skeleton_version = 0;
+	mi->dirty = true;
+}
+
+void RendererStorageRD::mesh_instance_set_blend_shape_weight(RID p_mesh_instance, int p_shape, float p_weight) {
+	MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+	ERR_FAIL_COND(!mi);
+	ERR_FAIL_INDEX(p_shape, (int)mi->blend_weights.size());
+	mi->blend_weights[p_shape] = p_weight;
+	mi->weights_dirty = true;
+	//will be eventually updated
 }
 
-void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Surface *s, uint32_t p_input_mask) {
-	uint32_t version = s->version_count;
-	s->version_count++;
-	s->versions = (Mesh::Surface::Version *)memrealloc(s->versions, sizeof(Mesh::Surface::Version) * s->version_count);
+void RendererStorageRD::_mesh_instance_clear(MeshInstance *mi) {
+	for (uint32_t i = 0; i < mi->surfaces.size(); i++) {
+		if (mi->surfaces[i].vertex_buffer.is_valid()) {
+			RD::get_singleton()->free(mi->surfaces[i].vertex_buffer);
+		}
+		if (mi->surfaces[i].versions) {
+			for (uint32_t j = 0; j < mi->surfaces[i].version_count; j++) {
+				RD::get_singleton()->free(mi->surfaces[i].versions[j].vertex_array);
+			}
+			memfree(mi->surfaces[i].versions);
+		}
+	}
+	mi->surfaces.clear();
 
-	Mesh::Surface::Version &v = s->versions[version];
+	if (mi->blend_weights_buffer.is_valid()) {
+		RD::get_singleton()->free(mi->blend_weights_buffer);
+	}
+	mi->blend_weights.clear();
+	mi->weights_dirty = false;
+	mi->skeleton_version = 0;
+}
 
+void RendererStorageRD::_mesh_instance_add_surface(MeshInstance *mi, Mesh *mesh, uint32_t p_surface) {
+	if (mesh->blend_shape_count > 0 && mi->blend_weights_buffer.is_null()) {
+		mi->blend_weights.resize(mesh->blend_shape_count);
+		for (uint32_t i = 0; i < mi->blend_weights.size(); i++) {
+			mi->blend_weights[i] = 0;
+		}
+		mi->blend_weights_buffer = RD::get_singleton()->storage_buffer_create(sizeof(float) * mi->blend_weights.size(), mi->blend_weights.to_byte_array());
+		mi->weights_dirty = true;
+	}
+
+	MeshInstance::Surface s;
+	if (mesh->blend_shape_count > 0 || (mesh->surfaces[p_surface]->format & RS::ARRAY_FORMAT_BONES)) {
+		//surface warrants transform
+		s.vertex_buffer = RD::get_singleton()->vertex_buffer_create(mesh->surfaces[p_surface]->vertex_buffer_size, Vector<uint8_t>(), true);
+
+		Vector<RD::Uniform> uniforms;
+		{
+			RD::Uniform u;
+			u.binding = 1;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.ids.push_back(s.vertex_buffer);
+			uniforms.push_back(u);
+		}
+		{
+			RD::Uniform u;
+			u.binding = 2;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			if (mi->blend_weights_buffer.is_valid()) {
+				u.ids.push_back(mi->blend_weights_buffer);
+			} else {
+				u.ids.push_back(default_rd_storage_buffer);
+			}
+			uniforms.push_back(u);
+		}
+		s.uniform_set = RD::get_singleton()->uniform_set_create(uniforms, skeleton_shader.version_shader[0], SkeletonShader::UNIFORM_SET_INSTANCE);
+	}
+
+	mi->surfaces.push_back(s);
+	mi->dirty = true;
+}
+
+void RendererStorageRD::mesh_instance_check_for_update(RID p_mesh_instance) {
+	MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+
+	bool needs_update = mi->dirty;
+
+	if (mi->weights_dirty && !mi->weight_update_list.in_list()) {
+		dirty_mesh_instance_weights.add(&mi->weight_update_list);
+		needs_update = true;
+	}
+
+	if (mi->array_update_list.in_list()) {
+		return;
+	}
+
+	if (!needs_update && mi->skeleton.is_valid()) {
+		Skeleton *sk = skeleton_owner.getornull(mi->skeleton);
+		if (sk && sk->version != mi->skeleton_version) {
+			needs_update = true;
+		}
+	}
+
+	if (needs_update) {
+		dirty_mesh_instance_arrays.add(&mi->array_update_list);
+	}
+}
+
+void RendererStorageRD::update_mesh_instances() {
+	while (dirty_mesh_instance_weights.first()) {
+		MeshInstance *mi = dirty_mesh_instance_weights.first()->self();
+
+		if (mi->blend_weights_buffer.is_valid()) {
+			RD::get_singleton()->buffer_update(mi->blend_weights_buffer, 0, mi->blend_weights.size() * sizeof(float), mi->blend_weights.ptr(), true);
+		}
+		dirty_mesh_instance_weights.remove(&mi->weight_update_list);
+		mi->weights_dirty = false;
+	}
+	if (dirty_mesh_instance_arrays.first() == nullptr) {
+		return; //nothing to do
+	}
+
+	//process skeletons and blend shapes
+	RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
+
+	while (dirty_mesh_instance_arrays.first()) {
+		MeshInstance *mi = dirty_mesh_instance_arrays.first()->self();
+
+		Skeleton *sk = skeleton_owner.getornull(mi->skeleton);
+
+		for (uint32_t i = 0; i < mi->surfaces.size(); i++) {
+			if (mi->surfaces[i].uniform_set == RID() || mi->mesh->surfaces[i]->uniform_set == RID()) {
+				continue;
+			}
+
+			bool array_is_2d = mi->mesh->surfaces[i]->format & RS::ARRAY_FLAG_USE_2D_VERTICES;
+
+			RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, skeleton_shader.pipeline[array_is_2d ? SkeletonShader::SHADER_MODE_2D : SkeletonShader::SHADER_MODE_3D]);
+
+			RD::get_singleton()->compute_list_bind_uniform_set(compute_list, mi->surfaces[i].uniform_set, SkeletonShader::UNIFORM_SET_INSTANCE);
+			RD::get_singleton()->compute_list_bind_uniform_set(compute_list, mi->mesh->surfaces[i]->uniform_set, SkeletonShader::UNIFORM_SET_SURFACE);
+			if (sk && sk->uniform_set_mi.is_valid()) {
+				RD::get_singleton()->compute_list_bind_uniform_set(compute_list, sk->uniform_set_mi, SkeletonShader::UNIFORM_SET_SKELETON);
+			} else {
+				RD::get_singleton()->compute_list_bind_uniform_set(compute_list, skeleton_shader.default_skeleton_uniform_set, SkeletonShader::UNIFORM_SET_SKELETON);
+			}
+
+			SkeletonShader::PushConstant push_constant;
+
+			push_constant.has_normal = mi->mesh->surfaces[i]->format & RS::ARRAY_FORMAT_NORMAL;
+			push_constant.has_tangent = mi->mesh->surfaces[i]->format & RS::ARRAY_FORMAT_TANGENT;
+			push_constant.has_skeleton = sk != nullptr && sk->use_2d == array_is_2d && (mi->mesh->surfaces[i]->format & RS::ARRAY_FORMAT_BONES);
+			push_constant.has_blend_shape = mi->mesh->blend_shape_count > 0;
+
+			push_constant.vertex_count = mi->mesh->surfaces[i]->vertex_count;
+			push_constant.vertex_stride = (mi->mesh->surfaces[i]->vertex_buffer_size / mi->mesh->surfaces[i]->vertex_count) / 4;
+			push_constant.skin_stride = (mi->mesh->surfaces[i]->skin_buffer_size / mi->mesh->surfaces[i]->vertex_count) / 4;
+			push_constant.skin_weight_offset = (mi->mesh->surfaces[i]->format & RS::ARRAY_FLAG_USE_8_BONE_WEIGHTS) ? 4 : 2;
+
+			push_constant.blend_shape_count = mi->mesh->blend_shape_count;
+			push_constant.normalized_blend_shapes = mi->mesh->blend_shape_mode == RS::BLEND_SHAPE_MODE_NORMALIZED;
+			push_constant.pad0 = 0;
+			push_constant.pad1 = 0;
+
+			RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(SkeletonShader::PushConstant));
+
+			//dispatch without barrier, so all is done at the same time
+			RD::get_singleton()->compute_list_dispatch_threads(compute_list, push_constant.vertex_count, 1, 1, 64, 1, 1);
+		}
+
+		mi->dirty = false;
+		if (sk) {
+			mi->skeleton_version = sk->version;
+		}
+		dirty_mesh_instance_arrays.remove(&mi->array_update_list);
+	}
+
+	RD::get_singleton()->compute_list_end();
+}
+
+void RendererStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Surface::Version &v, Mesh::Surface *s, uint32_t p_input_mask, MeshInstance::Surface *mis) {
 	Vector<RD::VertexAttribute> attributes;
 	Vector<RID> buffers;
 
 	uint32_t stride = 0;
+	uint32_t attribute_stride = 0;
+	uint32_t skin_stride = 0;
 
-	for (int i = 0; i < RS::ARRAY_WEIGHTS; i++) {
+	for (int i = 0; i < RS::ARRAY_INDEX; i++) {
 		RD::VertexAttribute vd;
 		RID buffer;
 		vd.location = i;
@@ -2805,6 +3083,7 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 		if (!(s->format & (1 << i))) {
 			// Not supplied by surface, use default value
 			buffer = mesh_default_rd_buffers[i];
+			vd.stride = 0;
 			switch (i) {
 				case RS::ARRAY_VERTEX: {
 					vd.format = RD::DATA_FORMAT_R32G32B32_SFLOAT;
@@ -2827,20 +3106,31 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 				case RS::ARRAY_TEX_UV2: {
 					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
 				} break;
+				case RS::ARRAY_CUSTOM0:
+				case RS::ARRAY_CUSTOM1:
+				case RS::ARRAY_CUSTOM2:
+				case RS::ARRAY_CUSTOM3: {
+					//assumed weights too
+					vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
+				} break;
 				case RS::ARRAY_BONES: {
 					//assumed weights too
 					vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
 				} break;
+				case RS::ARRAY_WEIGHTS: {
+					//assumed weights too
+					vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
+				} break;
 			}
 		} else {
 			//Supplied, use it
 
-			vd.offset = stride;
-			vd.stride = 1; //mark that it needs a stride set
-			buffer = s->vertex_buffer;
+			vd.stride = 1; //mark that it needs a stride set (default uses 0)
 
 			switch (i) {
 				case RS::ARRAY_VERTEX: {
+					vd.offset = stride;
+
 					if (s->format & RS::ARRAY_FLAG_USE_2D_VERTICES) {
 						vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
 						stride += sizeof(float) * 2;
@@ -2849,71 +3139,92 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 						stride += sizeof(float) * 3;
 					}
 
+					if (mis) {
+						buffer = mis->vertex_buffer;
+					} else {
+						buffer = s->vertex_buffer;
+					}
+
 				} break;
 				case RS::ARRAY_NORMAL: {
-					if (s->format & RS::ARRAY_COMPRESS_NORMAL) {
-						vd.format = RD::DATA_FORMAT_R8G8B8A8_SNORM;
-						stride += sizeof(int8_t) * 4;
+					vd.offset = stride;
+
+					vd.format = RD::DATA_FORMAT_A2B10G10R10_UNORM_PACK32;
+
+					stride += sizeof(uint32_t);
+					if (mis) {
+						buffer = mis->vertex_buffer;
 					} else {
-						vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
-						stride += sizeof(float) * 4;
+						buffer = s->vertex_buffer;
 					}
-
 				} break;
 				case RS::ARRAY_TANGENT: {
-					if (s->format & RS::ARRAY_COMPRESS_TANGENT) {
-						vd.format = RD::DATA_FORMAT_R8G8B8A8_SNORM;
-						stride += sizeof(int8_t) * 4;
+					vd.offset = stride;
+
+					vd.format = RD::DATA_FORMAT_A2B10G10R10_UNORM_PACK32;
+					stride += sizeof(uint32_t);
+					if (mis) {
+						buffer = mis->vertex_buffer;
 					} else {
-						vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
-						stride += sizeof(float) * 4;
+						buffer = s->vertex_buffer;
 					}
-
 				} break;
 				case RS::ARRAY_COLOR: {
-					if (s->format & RS::ARRAY_COMPRESS_COLOR) {
-						vd.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
-						stride += sizeof(int8_t) * 4;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32B32A32_SFLOAT;
-						stride += sizeof(float) * 4;
-					}
+					vd.offset = attribute_stride;
 
+					vd.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
+					attribute_stride += sizeof(int16_t) * 4;
+					buffer = s->attribute_buffer;
 				} break;
 				case RS::ARRAY_TEX_UV: {
-					if (s->format & RS::ARRAY_COMPRESS_TEX_UV) {
-						vd.format = RD::DATA_FORMAT_R16G16_SFLOAT;
-						stride += sizeof(int16_t) * 2;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
-						stride += sizeof(float) * 2;
-					}
+					vd.offset = attribute_stride;
+
+					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
+					attribute_stride += sizeof(float) * 2;
+					buffer = s->attribute_buffer;
 
 				} break;
 				case RS::ARRAY_TEX_UV2: {
-					if (s->format & RS::ARRAY_COMPRESS_TEX_UV2) {
-						vd.format = RD::DATA_FORMAT_R16G16_SFLOAT;
-						stride += sizeof(int16_t) * 2;
-					} else {
-						vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
-						stride += sizeof(float) * 2;
-					}
+					vd.offset = attribute_stride;
 
+					vd.format = RD::DATA_FORMAT_R32G32_SFLOAT;
+					attribute_stride += sizeof(float) * 2;
+					buffer = s->attribute_buffer;
+				} break;
+				case RS::ARRAY_CUSTOM0:
+				case RS::ARRAY_CUSTOM1:
+				case RS::ARRAY_CUSTOM2:
+				case RS::ARRAY_CUSTOM3: {
+					vd.offset = attribute_stride;
+
+					int idx = i - RS::ARRAY_CUSTOM0;
+					uint32_t fmt_shift[RS::ARRAY_CUSTOM_COUNT] = { RS::ARRAY_FORMAT_CUSTOM0_SHIFT, RS::ARRAY_FORMAT_CUSTOM1_SHIFT, RS::ARRAY_FORMAT_CUSTOM2_SHIFT, RS::ARRAY_FORMAT_CUSTOM3_SHIFT };
+					uint32_t fmt = (s->format >> fmt_shift[idx]) & RS::ARRAY_FORMAT_CUSTOM_MASK;
+					uint32_t fmtsize[RS::ARRAY_CUSTOM_MAX] = { 4, 4, 4, 8, 4, 8, 12, 16 };
+					RD::DataFormat fmtrd[RS::ARRAY_CUSTOM_MAX] = { RD::DATA_FORMAT_R8G8B8A8_UNORM, RD::DATA_FORMAT_R8G8B8A8_SNORM, RD::DATA_FORMAT_R16G16_SFLOAT, RD::DATA_FORMAT_R16G16B16A16_SFLOAT, RD::DATA_FORMAT_R32_SFLOAT, RD::DATA_FORMAT_R32G32_SFLOAT, RD::DATA_FORMAT_R32G32B32_SFLOAT, RD::DATA_FORMAT_R32G32B32A32_SFLOAT };
+					vd.format = fmtrd[fmt];
+					attribute_stride += fmtsize[fmt];
+					buffer = s->attribute_buffer;
 				} break;
 				case RS::ARRAY_BONES: {
-					//assumed weights too
-
-					//unique format, internally 16 bits, exposed as single array for 32
+					vd.offset = skin_stride;
 
-					vd.format = RD::DATA_FORMAT_R32G32B32A32_UINT;
-					stride += sizeof(int32_t) * 4;
+					vd.format = RD::DATA_FORMAT_R16G16B16A16_UINT;
+					skin_stride += sizeof(int16_t) * 4;
+					buffer = s->skin_buffer;
+				} break;
+				case RS::ARRAY_WEIGHTS: {
+					vd.offset = skin_stride;
 
+					vd.format = RD::DATA_FORMAT_R16G16B16A16_UNORM;
+					skin_stride += sizeof(int16_t) * 4;
+					buffer = s->skin_buffer;
 				} break;
 			}
 		}
 
 		if (!(p_input_mask & (1 << i))) {
-			continue; // Shader does not need this, skip it
+			continue; // Shader does not need this, skip it (but computing stride was important anyway)
 		}
 
 		attributes.push_back(vd);
@@ -2922,8 +3233,17 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 	//update final stride
 	for (int i = 0; i < attributes.size(); i++) {
-		if (attributes[i].stride == 1) {
+		if (attributes[i].stride == 0) {
+			continue; //default location
+		}
+		int loc = attributes[i].location;
+
+		if (loc < RS::ARRAY_COLOR) {
 			attributes.write[i].stride = stride;
+		} else if (loc < RS::ARRAY_BONES) {
+			attributes.write[i].stride = attribute_stride;
+		} else {
+			attributes.write[i].stride = skin_stride;
 		}
 	}
 
@@ -2934,11 +3254,11 @@ void RasterizerStorageRD::_mesh_surface_generate_version_for_input_mask(Mesh::Su
 
 ////////////////// MULTIMESH
 
-RID RasterizerStorageRD::multimesh_create() {
+RID RendererStorageRD::multimesh_create() {
 	return multimesh_owner.make_rid(MultiMesh());
 }
 
-void RasterizerStorageRD::multimesh_allocate(RID p_multimesh, int p_instances, RS::MultimeshTransformFormat p_transform_format, bool p_use_colors, bool p_use_custom_data) {
+void RendererStorageRD::multimesh_allocate(RID p_multimesh, int p_instances, RS::MultimeshTransformFormat p_transform_format, bool p_use_colors, bool p_use_custom_data) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 
@@ -2978,13 +3298,13 @@ void RasterizerStorageRD::multimesh_allocate(RID p_multimesh, int p_instances, R
 	}
 }
 
-int RasterizerStorageRD::multimesh_get_instance_count(RID p_multimesh) const {
+int RendererStorageRD::multimesh_get_instance_count(RID p_multimesh) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, 0);
 	return multimesh->instances;
 }
 
-void RasterizerStorageRD::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
+void RendererStorageRD::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	if (multimesh->mesh == p_mesh) {
@@ -3014,7 +3334,7 @@ void RasterizerStorageRD::multimesh_set_mesh(RID p_multimesh, RID p_mesh) {
 
 #define MULTIMESH_DIRTY_REGION_SIZE 512
 
-void RasterizerStorageRD::_multimesh_make_local(MultiMesh *multimesh) const {
+void RendererStorageRD::_multimesh_make_local(MultiMesh *multimesh) const {
 	if (multimesh->data_cache.size() > 0) {
 		return; //already local
 	}
@@ -3043,7 +3363,7 @@ void RasterizerStorageRD::_multimesh_make_local(MultiMesh *multimesh) const {
 	multimesh->data_cache_used_dirty_regions = 0;
 }
 
-void RasterizerStorageRD::_multimesh_mark_dirty(MultiMesh *multimesh, int p_index, bool p_aabb) {
+void RendererStorageRD::_multimesh_mark_dirty(MultiMesh *multimesh, int p_index, bool p_aabb) {
 	uint32_t region_index = p_index / MULTIMESH_DIRTY_REGION_SIZE;
 #ifdef DEBUG_ENABLED
 	uint32_t data_cache_dirty_region_count = (multimesh->instances - 1) / MULTIMESH_DIRTY_REGION_SIZE + 1;
@@ -3065,7 +3385,7 @@ void RasterizerStorageRD::_multimesh_mark_dirty(MultiMesh *multimesh, int p_inde
 	}
 }
 
-void RasterizerStorageRD::_multimesh_mark_all_dirty(MultiMesh *multimesh, bool p_data, bool p_aabb) {
+void RendererStorageRD::_multimesh_mark_all_dirty(MultiMesh *multimesh, bool p_data, bool p_aabb) {
 	if (p_data) {
 		uint32_t data_cache_dirty_region_count = (multimesh->instances - 1) / MULTIMESH_DIRTY_REGION_SIZE + 1;
 
@@ -3088,7 +3408,7 @@ void RasterizerStorageRD::_multimesh_mark_all_dirty(MultiMesh *multimesh, bool p
 	}
 }
 
-void RasterizerStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const float *p_data, int p_instances) {
+void RendererStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const float *p_data, int p_instances) {
 	ERR_FAIL_COND(multimesh->mesh.is_null());
 	AABB aabb;
 	AABB mesh_aabb = mesh_get_aabb(multimesh->mesh);
@@ -3130,7 +3450,7 @@ void RasterizerStorageRD::_multimesh_re_create_aabb(MultiMesh *multimesh, const
 	multimesh->aabb = aabb;
 }
 
-void RasterizerStorageRD::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) {
+void RendererStorageRD::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
@@ -3160,7 +3480,7 @@ void RasterizerStorageRD::multimesh_instance_set_transform(RID p_multimesh, int
 	_multimesh_mark_dirty(multimesh, p_index, true);
 }
 
-void RasterizerStorageRD::multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) {
+void RendererStorageRD::multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
@@ -3186,7 +3506,7 @@ void RasterizerStorageRD::multimesh_instance_set_transform_2d(RID p_multimesh, i
 	_multimesh_mark_dirty(multimesh, p_index, true);
 }
 
-void RasterizerStorageRD::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
+void RendererStorageRD::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
@@ -3208,7 +3528,7 @@ void RasterizerStorageRD::multimesh_instance_set_color(RID p_multimesh, int p_in
 	_multimesh_mark_dirty(multimesh, p_index, false);
 }
 
-void RasterizerStorageRD::multimesh_instance_set_custom_data(RID p_multimesh, int p_index, const Color &p_color) {
+void RendererStorageRD::multimesh_instance_set_custom_data(RID p_multimesh, int p_index, const Color &p_color) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_INDEX(p_index, multimesh->instances);
@@ -3230,14 +3550,14 @@ void RasterizerStorageRD::multimesh_instance_set_custom_data(RID p_multimesh, in
 	_multimesh_mark_dirty(multimesh, p_index, false);
 }
 
-RID RasterizerStorageRD::multimesh_get_mesh(RID p_multimesh) const {
+RID RendererStorageRD::multimesh_get_mesh(RID p_multimesh) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, RID());
 
 	return multimesh->mesh;
 }
 
-Transform RasterizerStorageRD::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
+Transform RendererStorageRD::multimesh_instance_get_transform(RID p_multimesh, int p_index) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Transform());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform());
@@ -3268,7 +3588,7 @@ Transform RasterizerStorageRD::multimesh_instance_get_transform(RID p_multimesh,
 	return t;
 }
 
-Transform2D RasterizerStorageRD::multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const {
+Transform2D RendererStorageRD::multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Transform2D());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform2D());
@@ -3293,7 +3613,7 @@ Transform2D RasterizerStorageRD::multimesh_instance_get_transform_2d(RID p_multi
 	return t;
 }
 
-Color RasterizerStorageRD::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
+Color RendererStorageRD::multimesh_instance_get_color(RID p_multimesh, int p_index) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Color());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color());
@@ -3316,7 +3636,7 @@ Color RasterizerStorageRD::multimesh_instance_get_color(RID p_multimesh, int p_i
 	return c;
 }
 
-Color RasterizerStorageRD::multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const {
+Color RendererStorageRD::multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Color());
 	ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color());
@@ -3339,7 +3659,7 @@ Color RasterizerStorageRD::multimesh_instance_get_custom_data(RID p_multimesh, i
 	return c;
 }
 
-void RasterizerStorageRD::multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) {
+void RendererStorageRD::multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_COND(p_buffer.size() != (multimesh->instances * (int)multimesh->stride_cache));
@@ -3372,7 +3692,7 @@ void RasterizerStorageRD::multimesh_set_buffer(RID p_multimesh, const Vector<flo
 	}
 }
 
-Vector<float> RasterizerStorageRD::multimesh_get_buffer(RID p_multimesh) const {
+Vector<float> RendererStorageRD::multimesh_get_buffer(RID p_multimesh) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, Vector<float>());
 	if (multimesh->buffer.is_null()) {
@@ -3395,7 +3715,7 @@ Vector<float> RasterizerStorageRD::multimesh_get_buffer(RID p_multimesh) const {
 	}
 }
 
-void RasterizerStorageRD::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
+void RendererStorageRD::multimesh_set_visible_instances(RID p_multimesh, int p_visible) {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND(!multimesh);
 	ERR_FAIL_COND(p_visible < -1 || p_visible > multimesh->instances);
@@ -3411,22 +3731,22 @@ void RasterizerStorageRD::multimesh_set_visible_instances(RID p_multimesh, int p
 	multimesh->visible_instances = p_visible;
 }
 
-int RasterizerStorageRD::multimesh_get_visible_instances(RID p_multimesh) const {
+int RendererStorageRD::multimesh_get_visible_instances(RID p_multimesh) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, 0);
 	return multimesh->visible_instances;
 }
 
-AABB RasterizerStorageRD::multimesh_get_aabb(RID p_multimesh) const {
+AABB RendererStorageRD::multimesh_get_aabb(RID p_multimesh) const {
 	MultiMesh *multimesh = multimesh_owner.getornull(p_multimesh);
 	ERR_FAIL_COND_V(!multimesh, AABB());
 	if (multimesh->aabb_dirty) {
-		const_cast<RasterizerStorageRD *>(this)->_update_dirty_multimeshes();
+		const_cast<RendererStorageRD *>(this)->_update_dirty_multimeshes();
 	}
 	return multimesh->aabb;
 }
 
-void RasterizerStorageRD::_update_dirty_multimeshes() {
+void RendererStorageRD::_update_dirty_multimeshes() {
 	while (multimesh_dirty_list) {
 		MultiMesh *multimesh = multimesh_dirty_list;
 
@@ -3481,25 +3801,25 @@ void RasterizerStorageRD::_update_dirty_multimeshes() {
 
 /* PARTICLES */
 
-RID RasterizerStorageRD::particles_create() {
+RID RendererStorageRD::particles_create() {
 	return particles_owner.make_rid(Particles());
 }
 
-void RasterizerStorageRD::particles_set_emitting(RID p_particles, bool p_emitting) {
+void RendererStorageRD::particles_set_emitting(RID p_particles, bool p_emitting) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->emitting = p_emitting;
 }
 
-bool RasterizerStorageRD::particles_get_emitting(RID p_particles) {
+bool RendererStorageRD::particles_get_emitting(RID p_particles) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND_V(!particles, false);
 
 	return particles->emitting;
 }
 
-void RasterizerStorageRD::_particles_free_data(Particles *particles) {
+void RendererStorageRD::_particles_free_data(Particles *particles) {
 	if (!particles->particle_buffer.is_valid()) {
 		return;
 	}
@@ -3526,7 +3846,7 @@ void RasterizerStorageRD::_particles_free_data(Particles *particles) {
 	}
 }
 
-void RasterizerStorageRD::particles_set_amount(RID p_particles, int p_amount) {
+void RendererStorageRD::particles_set_amount(RID p_particles, int p_amount) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
@@ -3549,14 +3869,14 @@ void RasterizerStorageRD::particles_set_amount(RID p_particles, int p_amount) {
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.binding = 1;
 				u.ids.push_back(particles->particle_buffer);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.binding = 2;
 				u.ids.push_back(particles->particle_instance_buffer);
 				uniforms.push_back(u);
@@ -3572,111 +3892,111 @@ void RasterizerStorageRD::particles_set_amount(RID p_particles, int p_amount) {
 	particles->clear = true;
 }
 
-void RasterizerStorageRD::particles_set_lifetime(RID p_particles, float p_lifetime) {
+void RendererStorageRD::particles_set_lifetime(RID p_particles, float p_lifetime) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->lifetime = p_lifetime;
 }
 
-void RasterizerStorageRD::particles_set_one_shot(RID p_particles, bool p_one_shot) {
+void RendererStorageRD::particles_set_one_shot(RID p_particles, bool p_one_shot) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->one_shot = p_one_shot;
 }
 
-void RasterizerStorageRD::particles_set_pre_process_time(RID p_particles, float p_time) {
+void RendererStorageRD::particles_set_pre_process_time(RID p_particles, float p_time) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->pre_process_time = p_time;
 }
-void RasterizerStorageRD::particles_set_explosiveness_ratio(RID p_particles, float p_ratio) {
+void RendererStorageRD::particles_set_explosiveness_ratio(RID p_particles, float p_ratio) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->explosiveness = p_ratio;
 }
-void RasterizerStorageRD::particles_set_randomness_ratio(RID p_particles, float p_ratio) {
+void RendererStorageRD::particles_set_randomness_ratio(RID p_particles, float p_ratio) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->randomness = p_ratio;
 }
 
-void RasterizerStorageRD::particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) {
+void RendererStorageRD::particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	particles->custom_aabb = p_aabb;
 	particles->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::particles_set_speed_scale(RID p_particles, float p_scale) {
+void RendererStorageRD::particles_set_speed_scale(RID p_particles, float p_scale) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->speed_scale = p_scale;
 }
-void RasterizerStorageRD::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
+void RendererStorageRD::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->use_local_coords = p_enable;
 }
 
-void RasterizerStorageRD::particles_set_fixed_fps(RID p_particles, int p_fps) {
+void RendererStorageRD::particles_set_fixed_fps(RID p_particles, int p_fps) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->fixed_fps = p_fps;
 }
 
-void RasterizerStorageRD::particles_set_fractional_delta(RID p_particles, bool p_enable) {
+void RendererStorageRD::particles_set_fractional_delta(RID p_particles, bool p_enable) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->fractional_delta = p_enable;
 }
 
-void RasterizerStorageRD::particles_set_collision_base_size(RID p_particles, float p_size) {
+void RendererStorageRD::particles_set_collision_base_size(RID p_particles, float p_size) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->collision_base_size = p_size;
 }
 
-void RasterizerStorageRD::particles_set_process_material(RID p_particles, RID p_material) {
+void RendererStorageRD::particles_set_process_material(RID p_particles, RID p_material) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->process_material = p_material;
 }
 
-void RasterizerStorageRD::particles_set_draw_order(RID p_particles, RS::ParticlesDrawOrder p_order) {
+void RendererStorageRD::particles_set_draw_order(RID p_particles, RS::ParticlesDrawOrder p_order) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->draw_order = p_order;
 }
 
-void RasterizerStorageRD::particles_set_draw_passes(RID p_particles, int p_passes) {
+void RendererStorageRD::particles_set_draw_passes(RID p_particles, int p_passes) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->draw_passes.resize(p_passes);
 }
 
-void RasterizerStorageRD::particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) {
+void RendererStorageRD::particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	ERR_FAIL_INDEX(p_pass, particles->draw_passes.size());
 	particles->draw_passes.write[p_pass] = p_mesh;
 }
 
-void RasterizerStorageRD::particles_restart(RID p_particles) {
+void RendererStorageRD::particles_restart(RID p_particles) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->restart_request = true;
 }
 
-void RasterizerStorageRD::_particles_allocate_emission_buffer(Particles *particles) {
+void RendererStorageRD::_particles_allocate_emission_buffer(Particles *particles) {
 	ERR_FAIL_COND(particles->emission_buffer != nullptr);
 
 	particles->emission_buffer_data.resize(sizeof(ParticleEmissionBuffer::Data) * particles->amount + sizeof(uint32_t) * 4);
@@ -3693,7 +4013,7 @@ void RasterizerStorageRD::_particles_allocate_emission_buffer(Particles *particl
 	}
 }
 
-void RasterizerStorageRD::particles_set_subemitter(RID p_particles, RID p_subemitter_particles) {
+void RendererStorageRD::particles_set_subemitter(RID p_particles, RID p_subemitter_particles) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	ERR_FAIL_COND(p_particles == p_subemitter_particles);
@@ -3706,7 +4026,7 @@ void RasterizerStorageRD::particles_set_subemitter(RID p_particles, RID p_subemi
 	}
 }
 
-void RasterizerStorageRD::particles_emit(RID p_particles, const Transform &p_transform, const Vector3 &p_velocity, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) {
+void RendererStorageRD::particles_emit(RID p_particles, const Transform &p_transform, const Vector3 &p_velocity, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 	ERR_FAIL_COND(particles->amount == 0);
@@ -3749,7 +4069,7 @@ void RasterizerStorageRD::particles_emit(RID p_particles, const Transform &p_tra
 	}
 }
 
-void RasterizerStorageRD::particles_request_process(RID p_particles) {
+void RendererStorageRD::particles_request_process(RID p_particles) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
@@ -3760,7 +4080,7 @@ void RasterizerStorageRD::particles_request_process(RID p_particles) {
 	}
 }
 
-AABB RasterizerStorageRD::particles_get_current_aabb(RID p_particles) {
+AABB RendererStorageRD::particles_get_current_aabb(RID p_particles) {
 	const Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND_V(!particles, AABB());
 
@@ -3804,28 +4124,28 @@ AABB RasterizerStorageRD::particles_get_current_aabb(RID p_particles) {
 	return aabb;
 }
 
-AABB RasterizerStorageRD::particles_get_aabb(RID p_particles) const {
+AABB RendererStorageRD::particles_get_aabb(RID p_particles) const {
 	const Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND_V(!particles, AABB());
 
 	return particles->custom_aabb;
 }
 
-void RasterizerStorageRD::particles_set_emission_transform(RID p_particles, const Transform &p_transform) {
+void RendererStorageRD::particles_set_emission_transform(RID p_particles, const Transform &p_transform) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
 	particles->emission_transform = p_transform;
 }
 
-int RasterizerStorageRD::particles_get_draw_passes(RID p_particles) const {
+int RendererStorageRD::particles_get_draw_passes(RID p_particles) const {
 	const Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND_V(!particles, 0);
 
 	return particles->draw_passes.size();
 }
 
-RID RasterizerStorageRD::particles_get_draw_pass_mesh(RID p_particles, int p_pass) const {
+RID RendererStorageRD::particles_get_draw_pass_mesh(RID p_particles, int p_pass) const {
 	const Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND_V(!particles, RID());
 	ERR_FAIL_INDEX_V(p_pass, particles->draw_passes.size(), RID());
@@ -3833,36 +4153,40 @@ RID RasterizerStorageRD::particles_get_draw_pass_mesh(RID p_particles, int p_pas
 	return particles->draw_passes[p_pass];
 }
 
-void RasterizerStorageRD::particles_add_collision(RID p_particles, RasterizerScene::InstanceBase *p_instance) {
+void RendererStorageRD::particles_add_collision(RID p_particles, InstanceBaseDependency *p_instance) {
+	RendererSceneRender::InstanceBase *instance = static_cast<RendererSceneRender::InstanceBase *>(p_instance);
+
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
-	ERR_FAIL_COND(p_instance->base_type != RS::INSTANCE_PARTICLES_COLLISION);
+	ERR_FAIL_COND(instance->base_type != RS::INSTANCE_PARTICLES_COLLISION);
 
-	particles->collisions.insert(p_instance);
+	particles->collisions.insert(instance);
 }
 
-void RasterizerStorageRD::particles_remove_collision(RID p_particles, RasterizerScene::InstanceBase *p_instance) {
+void RendererStorageRD::particles_remove_collision(RID p_particles, InstanceBaseDependency *p_instance) {
+	RendererSceneRender::InstanceBase *instance = static_cast<RendererSceneRender::InstanceBase *>(p_instance);
+
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
-	particles->collisions.erase(p_instance);
+	particles->collisions.erase(instance);
 }
 
-void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_delta) {
+void RendererStorageRD::_particles_process(Particles *p_particles, float p_delta) {
 	if (p_particles->particles_material_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(p_particles->particles_material_uniform_set)) {
 		Vector<RD::Uniform> uniforms;
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(p_particles->frame_params_buffer);
 			uniforms.push_back(u);
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 1;
 			u.ids.push_back(p_particles->particle_buffer);
 			uniforms.push_back(u);
@@ -3870,7 +4194,7 @@ void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_del
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 2;
 			if (p_particles->emission_storage_buffer.is_valid()) {
 				u.ids.push_back(p_particles->emission_storage_buffer);
@@ -3881,7 +4205,7 @@ void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_del
 		}
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 3;
 			Particles *sub_emitter = particles_owner.getornull(p_particles->sub_emitter);
 			if (sub_emitter) {
@@ -3918,7 +4242,7 @@ void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_del
 
 	p_particles->phase = new_phase;
 
-	frame_params.time = RasterizerRD::singleton->get_total_time();
+	frame_params.time = RendererCompositorRD::singleton->get_total_time();
 	frame_params.delta = p_delta * p_particles->speed_scale;
 	frame_params.random_seed = p_particles->random_seed;
 	frame_params.explosiveness = p_particles->explosiveness;
@@ -3946,7 +4270,7 @@ void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_del
 			to_particles = p_particles->emission_transform.affine_inverse();
 		}
 		uint32_t collision_3d_textures_used = 0;
-		for (const Set<RasterizerScene::InstanceBase *>::Element *E = p_particles->collisions.front(); E; E = E->next()) {
+		for (const Set<RendererSceneRender::InstanceBase *>::Element *E = p_particles->collisions.front(); E; E = E->next()) {
 			ParticlesCollision *pc = particles_collision_owner.getornull(E->get()->base);
 			Transform to_collider = E->get()->transform;
 			if (p_particles->use_local_coords) {
@@ -4088,7 +4412,7 @@ void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_del
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				u.binding = 0;
 				for (uint32_t i = 0; i < ParticlesFrameParams::MAX_3D_TEXTURES; i++) {
 					RID rd_tex;
@@ -4108,7 +4432,7 @@ void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_del
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_TEXTURE;
+				u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 				u.binding = 1;
 				if (collision_heightmap_texture.is_valid()) {
 					u.ids.push_back(collision_heightmap_texture);
@@ -4188,7 +4512,7 @@ void RasterizerStorageRD::_particles_process(Particles *p_particles, float p_del
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerStorageRD::particles_set_view_axis(RID p_particles, const Vector3 &p_axis) {
+void RendererStorageRD::particles_set_view_axis(RID p_particles, const Vector3 &p_axis) {
 	Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND(!particles);
 
@@ -4209,7 +4533,7 @@ void RasterizerStorageRD::particles_set_view_axis(RID p_particles, const Vector3
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.binding = 0;
 				u.ids.push_back(particles->particles_sort_buffer);
 				uniforms.push_back(u);
@@ -4254,7 +4578,7 @@ void RasterizerStorageRD::particles_set_view_axis(RID p_particles, const Vector3
 	RD::get_singleton()->compute_list_end();
 }
 
-void RasterizerStorageRD::update_particles() {
+void RendererStorageRD::update_particles() {
 	while (particle_update_list) {
 		//use transform feedback to process particles
 
@@ -4289,7 +4613,7 @@ void RasterizerStorageRD::update_particles() {
 			particles->inactive = false;
 			particles->inactive_time = 0;
 		} else {
-			particles->inactive_time += particles->speed_scale * RasterizerRD::singleton->get_frame_delta_time();
+			particles->inactive_time += particles->speed_scale * RendererCompositorRD::singleton->get_frame_delta_time();
 			if (particles->inactive_time > particles->lifetime * 1.2) {
 				particles->inactive = true;
 				continue;
@@ -4323,7 +4647,7 @@ void RasterizerStorageRD::update_particles() {
 				frame_time = 1.0 / particles->fixed_fps;
 				decr = frame_time;
 			}
-			float delta = RasterizerRD::singleton->get_frame_delta_time();
+			float delta = RendererCompositorRD::singleton->get_frame_delta_time();
 			if (delta > 0.1) { //avoid recursive stalls if fps goes below 10
 				delta = 0.1;
 			} else if (delta <= 0.0) { //unlikely but..
@@ -4342,7 +4666,7 @@ void RasterizerStorageRD::update_particles() {
 			if (zero_time_scale)
 				_particles_process(particles, 0.0);
 			else
-				_particles_process(particles, RasterizerRD::singleton->get_frame_delta_time());
+				_particles_process(particles, RendererCompositorRD::singleton->get_frame_delta_time());
 		}
 
 		//copy particles to instance buffer
@@ -4365,7 +4689,7 @@ void RasterizerStorageRD::update_particles() {
 	}
 }
 
-bool RasterizerStorageRD::particles_is_inactive(RID p_particles) const {
+bool RendererStorageRD::particles_is_inactive(RID p_particles) const {
 	const Particles *particles = particles_owner.getornull(p_particles);
 	ERR_FAIL_COND_V(!particles, false);
 	return !particles->emitting && particles->inactive;
@@ -4373,7 +4697,7 @@ bool RasterizerStorageRD::particles_is_inactive(RID p_particles) const {
 
 /* SKY SHADER */
 
-void RasterizerStorageRD::ParticlesShaderData::set_code(const String &p_code) {
+void RendererStorageRD::ParticlesShaderData::set_code(const String &p_code) {
 	//compile
 
 	code = p_code;
@@ -4421,7 +4745,7 @@ void RasterizerStorageRD::ParticlesShaderData::set_code(const String &p_code) {
 	valid = true;
 }
 
-void RasterizerStorageRD::ParticlesShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
+void RendererStorageRD::ParticlesShaderData::set_default_texture_param(const StringName &p_name, RID p_texture) {
 	if (!p_texture.is_valid()) {
 		default_texture_params.erase(p_name);
 	} else {
@@ -4429,7 +4753,7 @@ void RasterizerStorageRD::ParticlesShaderData::set_default_texture_param(const S
 	}
 }
 
-void RasterizerStorageRD::ParticlesShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
+void RendererStorageRD::ParticlesShaderData::get_param_list(List<PropertyInfo> *p_param_list) const {
 	Map<int, StringName> order;
 
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
@@ -4451,13 +4775,13 @@ void RasterizerStorageRD::ParticlesShaderData::get_param_list(List<PropertyInfo>
 	}
 }
 
-void RasterizerStorageRD::ParticlesShaderData::get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const {
+void RendererStorageRD::ParticlesShaderData::get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const {
 	for (Map<StringName, ShaderLanguage::ShaderNode::Uniform>::Element *E = uniforms.front(); E; E = E->next()) {
 		if (E->get().scope != ShaderLanguage::ShaderNode::Uniform::SCOPE_INSTANCE) {
 			continue;
 		}
 
-		RasterizerStorage::InstanceShaderParam p;
+		RendererStorage::InstanceShaderParam p;
 		p.info = ShaderLanguage::uniform_to_property_info(E->get());
 		p.info.name = E->key(); //supply name
 		p.index = E->get().instance_index;
@@ -4466,7 +4790,7 @@ void RasterizerStorageRD::ParticlesShaderData::get_instance_param_list(List<Rast
 	}
 }
 
-bool RasterizerStorageRD::ParticlesShaderData::is_param_texture(const StringName &p_param) const {
+bool RendererStorageRD::ParticlesShaderData::is_param_texture(const StringName &p_param) const {
 	if (!uniforms.has(p_param)) {
 		return false;
 	}
@@ -4474,15 +4798,15 @@ bool RasterizerStorageRD::ParticlesShaderData::is_param_texture(const StringName
 	return uniforms[p_param].texture_order >= 0;
 }
 
-bool RasterizerStorageRD::ParticlesShaderData::is_animated() const {
+bool RendererStorageRD::ParticlesShaderData::is_animated() const {
 	return false;
 }
 
-bool RasterizerStorageRD::ParticlesShaderData::casts_shadows() const {
+bool RendererStorageRD::ParticlesShaderData::casts_shadows() const {
 	return false;
 }
 
-Variant RasterizerStorageRD::ParticlesShaderData::get_default_parameter(const StringName &p_parameter) const {
+Variant RendererStorageRD::ParticlesShaderData::get_default_parameter(const StringName &p_parameter) const {
 	if (uniforms.has(p_parameter)) {
 		ShaderLanguage::ShaderNode::Uniform uniform = uniforms[p_parameter];
 		Vector<ShaderLanguage::ConstantNode::Value> default_value = uniform.default_value;
@@ -4491,23 +4815,23 @@ Variant RasterizerStorageRD::ParticlesShaderData::get_default_parameter(const St
 	return Variant();
 }
 
-RasterizerStorageRD::ParticlesShaderData::ParticlesShaderData() {
+RendererStorageRD::ParticlesShaderData::ParticlesShaderData() {
 	valid = false;
 }
 
-RasterizerStorageRD::ParticlesShaderData::~ParticlesShaderData() {
+RendererStorageRD::ParticlesShaderData::~ParticlesShaderData() {
 	//pipeline variants will clear themselves if shader is gone
 	if (version.is_valid()) {
 		base_singleton->particles_shader.shader.version_free(version);
 	}
 }
 
-RasterizerStorageRD::ShaderData *RasterizerStorageRD::_create_particles_shader_func() {
+RendererStorageRD::ShaderData *RendererStorageRD::_create_particles_shader_func() {
 	ParticlesShaderData *shader_data = memnew(ParticlesShaderData);
 	return shader_data;
 }
 
-void RasterizerStorageRD::ParticlesMaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
+void RendererStorageRD::ParticlesMaterialData::update_parameters(const Map<StringName, Variant> &p_parameters, bool p_uniform_dirty, bool p_textures_dirty) {
 	uniform_set_updated = true;
 
 	if ((uint32_t)ubo_data.size() != shader_data->ubo_size) {
@@ -4568,7 +4892,7 @@ void RasterizerStorageRD::ParticlesMaterialData::update_parameters(const Map<Str
 	{
 		if (shader_data->ubo_size) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_UNIFORM_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(uniform_buffer);
 			uniforms.push_back(u);
@@ -4577,7 +4901,7 @@ void RasterizerStorageRD::ParticlesMaterialData::update_parameters(const Map<Str
 		const RID *textures = texture_cache.ptrw();
 		for (uint32_t i = 0; i < tex_uniform_count; i++) {
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_TEXTURE;
+			u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;
 			u.binding = 1 + i;
 			u.ids.push_back(textures[i]);
 			uniforms.push_back(u);
@@ -4587,7 +4911,7 @@ void RasterizerStorageRD::ParticlesMaterialData::update_parameters(const Map<Str
 	uniform_set = RD::get_singleton()->uniform_set_create(uniforms, base_singleton->particles_shader.shader.version_get_shader(shader_data->version, 0), 3);
 }
 
-RasterizerStorageRD::ParticlesMaterialData::~ParticlesMaterialData() {
+RendererStorageRD::ParticlesMaterialData::~ParticlesMaterialData() {
 	if (uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(uniform_set)) {
 		RD::get_singleton()->free(uniform_set);
 	}
@@ -4597,7 +4921,7 @@ RasterizerStorageRD::ParticlesMaterialData::~ParticlesMaterialData() {
 	}
 }
 
-RasterizerStorageRD::MaterialData *RasterizerStorageRD::_create_particles_material_func(ParticlesShaderData *p_shader) {
+RendererStorageRD::MaterialData *RendererStorageRD::_create_particles_material_func(ParticlesShaderData *p_shader) {
 	ParticlesMaterialData *material_data = memnew(ParticlesMaterialData);
 	material_data->shader_data = p_shader;
 	material_data->last_frame = false;
@@ -4608,11 +4932,11 @@ RasterizerStorageRD::MaterialData *RasterizerStorageRD::_create_particles_materi
 
 /* PARTICLES COLLISION API */
 
-RID RasterizerStorageRD::particles_collision_create() {
+RID RendererStorageRD::particles_collision_create() {
 	return particles_collision_owner.make_rid(ParticlesCollision());
 }
 
-RID RasterizerStorageRD::particles_collision_get_heightfield_framebuffer(RID p_particles_collision) const {
+RID RendererStorageRD::particles_collision_get_heightfield_framebuffer(RID p_particles_collision) const {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, RID());
 	ERR_FAIL_COND_V(particles_collision->type != RS::PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE, RID());
@@ -4633,7 +4957,7 @@ RID RasterizerStorageRD::particles_collision_get_heightfield_framebuffer(RID p_p
 		tf.format = RD::DATA_FORMAT_D32_SFLOAT;
 		tf.width = size.x;
 		tf.height = size.y;
-		tf.type = RD::TEXTURE_TYPE_2D;
+		tf.texture_type = RD::TEXTURE_TYPE_2D;
 		tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
 
 		particles_collision->heightfield_texture = RD::get_singleton()->texture_create(tf, RD::TextureView());
@@ -4647,7 +4971,7 @@ RID RasterizerStorageRD::particles_collision_get_heightfield_framebuffer(RID p_p
 	return particles_collision->heightfield_fb;
 }
 
-void RasterizerStorageRD::particles_collision_set_collision_type(RID p_particles_collision, RS::ParticlesCollisionType p_type) {
+void RendererStorageRD::particles_collision_set_collision_type(RID p_particles_collision, RS::ParticlesCollisionType p_type) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
@@ -4663,13 +4987,13 @@ void RasterizerStorageRD::particles_collision_set_collision_type(RID p_particles
 	particles_collision->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::particles_collision_set_cull_mask(RID p_particles_collision, uint32_t p_cull_mask) {
+void RendererStorageRD::particles_collision_set_cull_mask(RID p_particles_collision, uint32_t p_cull_mask) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 	particles_collision->cull_mask = p_cull_mask;
 }
 
-void RasterizerStorageRD::particles_collision_set_sphere_radius(RID p_particles_collision, float p_radius) {
+void RendererStorageRD::particles_collision_set_sphere_radius(RID p_particles_collision, float p_radius) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
@@ -4677,7 +5001,7 @@ void RasterizerStorageRD::particles_collision_set_sphere_radius(RID p_particles_
 	particles_collision->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::particles_collision_set_box_extents(RID p_particles_collision, const Vector3 &p_extents) {
+void RendererStorageRD::particles_collision_set_box_extents(RID p_particles_collision, const Vector3 &p_extents) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
@@ -4685,41 +5009,41 @@ void RasterizerStorageRD::particles_collision_set_box_extents(RID p_particles_co
 	particles_collision->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::particles_collision_set_attractor_strength(RID p_particles_collision, float p_strength) {
+void RendererStorageRD::particles_collision_set_attractor_strength(RID p_particles_collision, float p_strength) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->attractor_strength = p_strength;
 }
 
-void RasterizerStorageRD::particles_collision_set_attractor_directionality(RID p_particles_collision, float p_directionality) {
+void RendererStorageRD::particles_collision_set_attractor_directionality(RID p_particles_collision, float p_directionality) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->attractor_directionality = p_directionality;
 }
 
-void RasterizerStorageRD::particles_collision_set_attractor_attenuation(RID p_particles_collision, float p_curve) {
+void RendererStorageRD::particles_collision_set_attractor_attenuation(RID p_particles_collision, float p_curve) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->attractor_attenuation = p_curve;
 }
 
-void RasterizerStorageRD::particles_collision_set_field_texture(RID p_particles_collision, RID p_texture) {
+void RendererStorageRD::particles_collision_set_field_texture(RID p_particles_collision, RID p_texture) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
 	particles_collision->field_texture = p_texture;
 }
 
-void RasterizerStorageRD::particles_collision_height_field_update(RID p_particles_collision) {
+void RendererStorageRD::particles_collision_height_field_update(RID p_particles_collision) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 	particles_collision->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::particles_collision_set_height_field_resolution(RID p_particles_collision, RS::ParticlesCollisionHeightfieldResolution p_resolution) {
+void RendererStorageRD::particles_collision_set_height_field_resolution(RID p_particles_collision, RS::ParticlesCollisionHeightfieldResolution p_resolution) {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND(!particles_collision);
 
@@ -4735,7 +5059,7 @@ void RasterizerStorageRD::particles_collision_set_height_field_resolution(RID p_
 	}
 }
 
-AABB RasterizerStorageRD::particles_collision_get_aabb(RID p_particles_collision) const {
+AABB RendererStorageRD::particles_collision_get_aabb(RID p_particles_collision) const {
 	ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, AABB());
 
@@ -4758,13 +5082,13 @@ AABB RasterizerStorageRD::particles_collision_get_aabb(RID p_particles_collision
 	return AABB();
 }
 
-Vector3 RasterizerStorageRD::particles_collision_get_extents(RID p_particles_collision) const {
+Vector3 RendererStorageRD::particles_collision_get_extents(RID p_particles_collision) const {
 	const ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, Vector3());
 	return particles_collision->extents;
 }
 
-bool RasterizerStorageRD::particles_collision_is_heightfield(RID p_particles_collision) const {
+bool RendererStorageRD::particles_collision_is_heightfield(RID p_particles_collision) const {
 	const ParticlesCollision *particles_collision = particles_collision_owner.getornull(p_particles_collision);
 	ERR_FAIL_COND_V(!particles_collision, false);
 	return particles_collision->type == RS::PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE;
@@ -4772,11 +5096,11 @@ bool RasterizerStorageRD::particles_collision_is_heightfield(RID p_particles_col
 
 /* SKELETON API */
 
-RID RasterizerStorageRD::skeleton_create() {
+RID RendererStorageRD::skeleton_create() {
 	return skeleton_owner.make_rid(Skeleton());
 }
 
-void RasterizerStorageRD::_skeleton_make_dirty(Skeleton *skeleton) {
+void RendererStorageRD::_skeleton_make_dirty(Skeleton *skeleton) {
 	if (!skeleton->dirty) {
 		skeleton->dirty = true;
 		skeleton->dirty_list = skeleton_dirty_list;
@@ -4784,7 +5108,7 @@ void RasterizerStorageRD::_skeleton_make_dirty(Skeleton *skeleton) {
 	}
 }
 
-void RasterizerStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton) {
+void RendererStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton) {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
 	ERR_FAIL_COND(p_bones < 0);
@@ -4801,6 +5125,7 @@ void RasterizerStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_
 		RD::get_singleton()->free(skeleton->buffer);
 		skeleton->buffer = RID();
 		skeleton->data.resize(0);
+		skeleton->uniform_set_mi = RID();
 	}
 
 	if (skeleton->size) {
@@ -4809,17 +5134,29 @@ void RasterizerStorageRD::skeleton_allocate(RID p_skeleton, int p_bones, bool p_
 		zeromem(skeleton->data.ptrw(), skeleton->data.size() * sizeof(float));
 
 		_skeleton_make_dirty(skeleton);
+
+		{
+			Vector<RD::Uniform> uniforms;
+			{
+				RD::Uniform u;
+				u.binding = 0;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.ids.push_back(skeleton->buffer);
+				uniforms.push_back(u);
+			}
+			skeleton->uniform_set_mi = RD::get_singleton()->uniform_set_create(uniforms, skeleton_shader.version_shader[0], SkeletonShader::UNIFORM_SET_SKELETON);
+		}
 	}
 }
 
-int RasterizerStorageRD::skeleton_get_bone_count(RID p_skeleton) const {
+int RendererStorageRD::skeleton_get_bone_count(RID p_skeleton) const {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 	ERR_FAIL_COND_V(!skeleton, 0);
 
 	return skeleton->size;
 }
 
-void RasterizerStorageRD::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) {
+void RendererStorageRD::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton);
@@ -4844,7 +5181,7 @@ void RasterizerStorageRD::skeleton_bone_set_transform(RID p_skeleton, int p_bone
 	_skeleton_make_dirty(skeleton);
 }
 
-Transform RasterizerStorageRD::skeleton_bone_get_transform(RID p_skeleton, int p_bone) const {
+Transform RendererStorageRD::skeleton_bone_get_transform(RID p_skeleton, int p_bone) const {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND_V(!skeleton, Transform());
@@ -4871,7 +5208,7 @@ Transform RasterizerStorageRD::skeleton_bone_get_transform(RID p_skeleton, int p
 	return t;
 }
 
-void RasterizerStorageRD::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) {
+void RendererStorageRD::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton);
@@ -4892,7 +5229,7 @@ void RasterizerStorageRD::skeleton_bone_set_transform_2d(RID p_skeleton, int p_b
 	_skeleton_make_dirty(skeleton);
 }
 
-Transform2D RasterizerStorageRD::skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const {
+Transform2D RendererStorageRD::skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND_V(!skeleton, Transform2D());
@@ -4912,7 +5249,7 @@ Transform2D RasterizerStorageRD::skeleton_bone_get_transform_2d(RID p_skeleton,
 	return t;
 }
 
-void RasterizerStorageRD::skeleton_set_base_transform_2d(RID p_skeleton, const Transform2D &p_base_transform) {
+void RendererStorageRD::skeleton_set_base_transform_2d(RID p_skeleton, const Transform2D &p_base_transform) {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 
 	ERR_FAIL_COND(!skeleton->use_2d);
@@ -4920,7 +5257,7 @@ void RasterizerStorageRD::skeleton_set_base_transform_2d(RID p_skeleton, const T
 	skeleton->base_transform_2d = p_base_transform;
 }
 
-void RasterizerStorageRD::_update_dirty_skeletons() {
+void RendererStorageRD::_update_dirty_skeletons() {
 	while (skeleton_dirty_list) {
 		Skeleton *skeleton = skeleton_dirty_list;
 
@@ -4931,6 +5268,7 @@ void RasterizerStorageRD::_update_dirty_skeletons() {
 		skeleton_dirty_list = skeleton->dirty_list;
 
 		skeleton->instance_dependency.instance_notify_changed(true, false);
+		skeleton->version++;
 
 		skeleton->dirty = false;
 		skeleton->dirty_list = nullptr;
@@ -4941,7 +5279,7 @@ void RasterizerStorageRD::_update_dirty_skeletons() {
 
 /* LIGHT */
 
-RID RasterizerStorageRD::light_create(RS::LightType p_type) {
+RID RendererStorageRD::light_create(RS::LightType p_type) {
 	Light light;
 	light.type = p_type;
 
@@ -4965,14 +5303,14 @@ RID RasterizerStorageRD::light_create(RS::LightType p_type) {
 	return light_owner.make_rid(light);
 }
 
-void RasterizerStorageRD::light_set_color(RID p_light, const Color &p_color) {
+void RendererStorageRD::light_set_color(RID p_light, const Color &p_color) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->color = p_color;
 }
 
-void RasterizerStorageRD::light_set_param(RID p_light, RS::LightParam p_param, float p_value) {
+void RendererStorageRD::light_set_param(RID p_light, RS::LightParam p_param, float p_value) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 	ERR_FAIL_INDEX(p_param, RS::LIGHT_PARAM_MAX);
@@ -4997,7 +5335,7 @@ void RasterizerStorageRD::light_set_param(RID p_light, RS::LightParam p_param, f
 	light->param[p_param] = p_value;
 }
 
-void RasterizerStorageRD::light_set_shadow(RID p_light, bool p_enabled) {
+void RendererStorageRD::light_set_shadow(RID p_light, bool p_enabled) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 	light->shadow = p_enabled;
@@ -5006,13 +5344,13 @@ void RasterizerStorageRD::light_set_shadow(RID p_light, bool p_enabled) {
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::light_set_shadow_color(RID p_light, const Color &p_color) {
+void RendererStorageRD::light_set_shadow_color(RID p_light, const Color &p_color) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 	light->shadow_color = p_color;
 }
 
-void RasterizerStorageRD::light_set_projector(RID p_light, RID p_texture) {
+void RendererStorageRD::light_set_projector(RID p_light, RID p_texture) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5031,14 +5369,14 @@ void RasterizerStorageRD::light_set_projector(RID p_light, RID p_texture) {
 	}
 }
 
-void RasterizerStorageRD::light_set_negative(RID p_light, bool p_enable) {
+void RendererStorageRD::light_set_negative(RID p_light, bool p_enable) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->negative = p_enable;
 }
 
-void RasterizerStorageRD::light_set_cull_mask(RID p_light, uint32_t p_mask) {
+void RendererStorageRD::light_set_cull_mask(RID p_light, uint32_t p_mask) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5048,7 +5386,7 @@ void RasterizerStorageRD::light_set_cull_mask(RID p_light, uint32_t p_mask) {
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) {
+void RendererStorageRD::light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5058,7 +5396,7 @@ void RasterizerStorageRD::light_set_reverse_cull_face_mode(RID p_light, bool p_e
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::light_set_bake_mode(RID p_light, RS::LightBakeMode p_bake_mode) {
+void RendererStorageRD::light_set_bake_mode(RID p_light, RS::LightBakeMode p_bake_mode) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5068,7 +5406,7 @@ void RasterizerStorageRD::light_set_bake_mode(RID p_light, RS::LightBakeMode p_b
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::light_set_max_sdfgi_cascade(RID p_light, uint32_t p_cascade) {
+void RendererStorageRD::light_set_max_sdfgi_cascade(RID p_light, uint32_t p_cascade) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5078,7 +5416,7 @@ void RasterizerStorageRD::light_set_max_sdfgi_cascade(RID p_light, uint32_t p_ca
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMode p_mode) {
+void RendererStorageRD::light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMode p_mode) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5088,14 +5426,14 @@ void RasterizerStorageRD::light_omni_set_shadow_mode(RID p_light, RS::LightOmniS
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-RS::LightOmniShadowMode RasterizerStorageRD::light_omni_get_shadow_mode(RID p_light) {
+RS::LightOmniShadowMode RendererStorageRD::light_omni_get_shadow_mode(RID p_light) {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_OMNI_SHADOW_CUBE);
 
 	return light->omni_shadow_mode;
 }
 
-void RasterizerStorageRD::light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode) {
+void RendererStorageRD::light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5104,7 +5442,7 @@ void RasterizerStorageRD::light_directional_set_shadow_mode(RID p_light, RS::Lig
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::light_directional_set_blend_splits(RID p_light, bool p_enable) {
+void RendererStorageRD::light_directional_set_blend_splits(RID p_light, bool p_enable) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
@@ -5113,56 +5451,70 @@ void RasterizerStorageRD::light_directional_set_blend_splits(RID p_light, bool p
 	light->instance_dependency.instance_notify_changed(true, false);
 }
 
-bool RasterizerStorageRD::light_directional_get_blend_splits(RID p_light) const {
+bool RendererStorageRD::light_directional_get_blend_splits(RID p_light) const {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, false);
 
 	return light->directional_blend_splits;
 }
 
-RS::LightDirectionalShadowMode RasterizerStorageRD::light_directional_get_shadow_mode(RID p_light) {
+void RendererStorageRD::light_directional_set_sky_only(RID p_light, bool p_sky_only) {
+	Light *light = light_owner.getornull(p_light);
+	ERR_FAIL_COND(!light);
+
+	light->directional_sky_only = p_sky_only;
+}
+
+bool RendererStorageRD::light_directional_is_sky_only(RID p_light) const {
+	const Light *light = light_owner.getornull(p_light);
+	ERR_FAIL_COND_V(!light, false);
+
+	return light->directional_sky_only;
+}
+
+RS::LightDirectionalShadowMode RendererStorageRD::light_directional_get_shadow_mode(RID p_light) {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL);
 
 	return light->directional_shadow_mode;
 }
 
-void RasterizerStorageRD::light_directional_set_shadow_depth_range_mode(RID p_light, RS::LightDirectionalShadowDepthRangeMode p_range_mode) {
+void RendererStorageRD::light_directional_set_shadow_depth_range_mode(RID p_light, RS::LightDirectionalShadowDepthRangeMode p_range_mode) {
 	Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND(!light);
 
 	light->directional_range_mode = p_range_mode;
 }
 
-RS::LightDirectionalShadowDepthRangeMode RasterizerStorageRD::light_directional_get_shadow_depth_range_mode(RID p_light) const {
+RS::LightDirectionalShadowDepthRangeMode RendererStorageRD::light_directional_get_shadow_depth_range_mode(RID p_light) const {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE);
 
 	return light->directional_range_mode;
 }
 
-uint32_t RasterizerStorageRD::light_get_max_sdfgi_cascade(RID p_light) {
+uint32_t RendererStorageRD::light_get_max_sdfgi_cascade(RID p_light) {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, 0);
 
 	return light->max_sdfgi_cascade;
 }
 
-RS::LightBakeMode RasterizerStorageRD::light_get_bake_mode(RID p_light) {
+RS::LightBakeMode RendererStorageRD::light_get_bake_mode(RID p_light) {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, RS::LIGHT_BAKE_DISABLED);
 
 	return light->bake_mode;
 }
 
-uint64_t RasterizerStorageRD::light_get_version(RID p_light) const {
+uint64_t RendererStorageRD::light_get_version(RID p_light) const {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, 0);
 
 	return light->version;
 }
 
-AABB RasterizerStorageRD::light_get_aabb(RID p_light) const {
+AABB RendererStorageRD::light_get_aabb(RID p_light) const {
 	const Light *light = light_owner.getornull(p_light);
 	ERR_FAIL_COND_V(!light, AABB());
 
@@ -5186,11 +5538,11 @@ AABB RasterizerStorageRD::light_get_aabb(RID p_light) const {
 
 /* REFLECTION PROBE */
 
-RID RasterizerStorageRD::reflection_probe_create() {
+RID RendererStorageRD::reflection_probe_create() {
 	return reflection_probe_owner.make_rid(ReflectionProbe());
 }
 
-void RasterizerStorageRD::reflection_probe_set_update_mode(RID p_probe, RS::ReflectionProbeUpdateMode p_mode) {
+void RendererStorageRD::reflection_probe_set_update_mode(RID p_probe, RS::ReflectionProbeUpdateMode p_mode) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -5198,35 +5550,35 @@ void RasterizerStorageRD::reflection_probe_set_update_mode(RID p_probe, RS::Refl
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::reflection_probe_set_intensity(RID p_probe, float p_intensity) {
+void RendererStorageRD::reflection_probe_set_intensity(RID p_probe, float p_intensity) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->intensity = p_intensity;
 }
 
-void RasterizerStorageRD::reflection_probe_set_ambient_mode(RID p_probe, RS::ReflectionProbeAmbientMode p_mode) {
+void RendererStorageRD::reflection_probe_set_ambient_mode(RID p_probe, RS::ReflectionProbeAmbientMode p_mode) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->ambient_mode = p_mode;
 }
 
-void RasterizerStorageRD::reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) {
+void RendererStorageRD::reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->ambient_color = p_color;
 }
 
-void RasterizerStorageRD::reflection_probe_set_ambient_energy(RID p_probe, float p_energy) {
+void RendererStorageRD::reflection_probe_set_ambient_energy(RID p_probe, float p_energy) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->ambient_color_energy = p_energy;
 }
 
-void RasterizerStorageRD::reflection_probe_set_max_distance(RID p_probe, float p_distance) {
+void RendererStorageRD::reflection_probe_set_max_distance(RID p_probe, float p_distance) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -5235,7 +5587,7 @@ void RasterizerStorageRD::reflection_probe_set_max_distance(RID p_probe, float p
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {
+void RendererStorageRD::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -5246,7 +5598,7 @@ void RasterizerStorageRD::reflection_probe_set_extents(RID p_probe, const Vector
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) {
+void RendererStorageRD::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -5254,7 +5606,7 @@ void RasterizerStorageRD::reflection_probe_set_origin_offset(RID p_probe, const
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::reflection_probe_set_as_interior(RID p_probe, bool p_enable) {
+void RendererStorageRD::reflection_probe_set_as_interior(RID p_probe, bool p_enable) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -5262,14 +5614,14 @@ void RasterizerStorageRD::reflection_probe_set_as_interior(RID p_probe, bool p_e
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) {
+void RendererStorageRD::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
 	reflection_probe->box_projection = p_enable;
 }
 
-void RasterizerStorageRD::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) {
+void RendererStorageRD::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -5277,7 +5629,7 @@ void RasterizerStorageRD::reflection_probe_set_enable_shadows(RID p_probe, bool
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) {
+void RendererStorageRD::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 
@@ -5285,7 +5637,7 @@ void RasterizerStorageRD::reflection_probe_set_cull_mask(RID p_probe, uint32_t p
 	reflection_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::reflection_probe_set_resolution(RID p_probe, int p_resolution) {
+void RendererStorageRD::reflection_probe_set_resolution(RID p_probe, int p_resolution) {
 	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND(!reflection_probe);
 	ERR_FAIL_COND(p_resolution < 32);
@@ -5293,7 +5645,16 @@ void RasterizerStorageRD::reflection_probe_set_resolution(RID p_probe, int p_res
 	reflection_probe->resolution = p_resolution;
 }
 
-AABB RasterizerStorageRD::reflection_probe_get_aabb(RID p_probe) const {
+void RendererStorageRD::reflection_probe_set_lod_threshold(RID p_probe, float p_ratio) {
+	ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND(!reflection_probe);
+
+	reflection_probe->lod_threshold = p_ratio;
+
+	reflection_probe->instance_dependency.instance_notify_changed(true, false);
+}
+
+AABB RendererStorageRD::reflection_probe_get_aabb(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, AABB());
 
@@ -5304,107 +5665,114 @@ AABB RasterizerStorageRD::reflection_probe_get_aabb(RID p_probe) const {
 	return aabb;
 }
 
-RS::ReflectionProbeUpdateMode RasterizerStorageRD::reflection_probe_get_update_mode(RID p_probe) const {
+RS::ReflectionProbeUpdateMode RendererStorageRD::reflection_probe_get_update_mode(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, RS::REFLECTION_PROBE_UPDATE_ALWAYS);
 
 	return reflection_probe->update_mode;
 }
 
-uint32_t RasterizerStorageRD::reflection_probe_get_cull_mask(RID p_probe) const {
+uint32_t RendererStorageRD::reflection_probe_get_cull_mask(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->cull_mask;
 }
 
-Vector3 RasterizerStorageRD::reflection_probe_get_extents(RID p_probe) const {
+Vector3 RendererStorageRD::reflection_probe_get_extents(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Vector3());
 
 	return reflection_probe->extents;
 }
 
-Vector3 RasterizerStorageRD::reflection_probe_get_origin_offset(RID p_probe) const {
+Vector3 RendererStorageRD::reflection_probe_get_origin_offset(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Vector3());
 
 	return reflection_probe->origin_offset;
 }
 
-bool RasterizerStorageRD::reflection_probe_renders_shadows(RID p_probe) const {
+bool RendererStorageRD::reflection_probe_renders_shadows(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
 	return reflection_probe->enable_shadows;
 }
 
-float RasterizerStorageRD::reflection_probe_get_origin_max_distance(RID p_probe) const {
+float RendererStorageRD::reflection_probe_get_origin_max_distance(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->max_distance;
 }
 
-int RasterizerStorageRD::reflection_probe_get_resolution(RID p_probe) const {
+float RendererStorageRD::reflection_probe_get_lod_threshold(RID p_probe) const {
+	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
+	ERR_FAIL_COND_V(!reflection_probe, 0);
+
+	return reflection_probe->lod_threshold;
+}
+
+int RendererStorageRD::reflection_probe_get_resolution(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->resolution;
 }
 
-float RasterizerStorageRD::reflection_probe_get_intensity(RID p_probe) const {
+float RendererStorageRD::reflection_probe_get_intensity(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->intensity;
 }
 
-bool RasterizerStorageRD::reflection_probe_is_interior(RID p_probe) const {
+bool RendererStorageRD::reflection_probe_is_interior(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
 	return reflection_probe->interior;
 }
 
-bool RasterizerStorageRD::reflection_probe_is_box_projection(RID p_probe) const {
+bool RendererStorageRD::reflection_probe_is_box_projection(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, false);
 
 	return reflection_probe->box_projection;
 }
 
-RS::ReflectionProbeAmbientMode RasterizerStorageRD::reflection_probe_get_ambient_mode(RID p_probe) const {
+RS::ReflectionProbeAmbientMode RendererStorageRD::reflection_probe_get_ambient_mode(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, RS::REFLECTION_PROBE_AMBIENT_DISABLED);
 	return reflection_probe->ambient_mode;
 }
 
-Color RasterizerStorageRD::reflection_probe_get_ambient_color(RID p_probe) const {
+Color RendererStorageRD::reflection_probe_get_ambient_color(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, Color());
 
 	return reflection_probe->ambient_color;
 }
-float RasterizerStorageRD::reflection_probe_get_ambient_color_energy(RID p_probe) const {
+float RendererStorageRD::reflection_probe_get_ambient_color_energy(RID p_probe) const {
 	const ReflectionProbe *reflection_probe = reflection_probe_owner.getornull(p_probe);
 	ERR_FAIL_COND_V(!reflection_probe, 0);
 
 	return reflection_probe->ambient_color_energy;
 }
 
-RID RasterizerStorageRD::decal_create() {
+RID RendererStorageRD::decal_create() {
 	return decal_owner.make_rid(Decal());
 }
 
-void RasterizerStorageRD::decal_set_extents(RID p_decal, const Vector3 &p_extents) {
+void RendererStorageRD::decal_set_extents(RID p_decal, const Vector3 &p_extents) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->extents = p_extents;
 	decal->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) {
+void RendererStorageRD::decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	ERR_FAIL_INDEX(p_type, RS::DECAL_TEXTURE_MAX);
@@ -5428,32 +5796,32 @@ void RasterizerStorageRD::decal_set_texture(RID p_decal, RS::DecalTexture p_type
 	decal->instance_dependency.instance_notify_changed(false, true);
 }
 
-void RasterizerStorageRD::decal_set_emission_energy(RID p_decal, float p_energy) {
+void RendererStorageRD::decal_set_emission_energy(RID p_decal, float p_energy) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->emission_energy = p_energy;
 }
 
-void RasterizerStorageRD::decal_set_albedo_mix(RID p_decal, float p_mix) {
+void RendererStorageRD::decal_set_albedo_mix(RID p_decal, float p_mix) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->albedo_mix = p_mix;
 }
 
-void RasterizerStorageRD::decal_set_modulate(RID p_decal, const Color &p_modulate) {
+void RendererStorageRD::decal_set_modulate(RID p_decal, const Color &p_modulate) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->modulate = p_modulate;
 }
 
-void RasterizerStorageRD::decal_set_cull_mask(RID p_decal, uint32_t p_layers) {
+void RendererStorageRD::decal_set_cull_mask(RID p_decal, uint32_t p_layers) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->cull_mask = p_layers;
 	decal->instance_dependency.instance_notify_changed(true, false);
 }
 
-void RasterizerStorageRD::decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) {
+void RendererStorageRD::decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->distance_fade = p_enabled;
@@ -5461,31 +5829,31 @@ void RasterizerStorageRD::decal_set_distance_fade(RID p_decal, bool p_enabled, f
 	decal->distance_fade_length = p_length;
 }
 
-void RasterizerStorageRD::decal_set_fade(RID p_decal, float p_above, float p_below) {
+void RendererStorageRD::decal_set_fade(RID p_decal, float p_above, float p_below) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->upper_fade = p_above;
 	decal->lower_fade = p_below;
 }
 
-void RasterizerStorageRD::decal_set_normal_fade(RID p_decal, float p_fade) {
+void RendererStorageRD::decal_set_normal_fade(RID p_decal, float p_fade) {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND(!decal);
 	decal->normal_fade = p_fade;
 }
 
-AABB RasterizerStorageRD::decal_get_aabb(RID p_decal) const {
+AABB RendererStorageRD::decal_get_aabb(RID p_decal) const {
 	Decal *decal = decal_owner.getornull(p_decal);
 	ERR_FAIL_COND_V(!decal, AABB());
 
 	return AABB(-decal->extents, decal->extents * 2.0);
 }
 
-RID RasterizerStorageRD::gi_probe_create() {
+RID RendererStorageRD::gi_probe_create() {
 	return gi_probe_owner.make_rid(GIProbe());
 }
 
-void RasterizerStorageRD::gi_probe_allocate(RID p_gi_probe, const Transform &p_to_cell_xform, const AABB &p_aabb, const Vector3i &p_octree_size, const Vector<uint8_t> &p_octree_cells, const Vector<uint8_t> &p_data_cells, const Vector<uint8_t> &p_distance_field, const Vector<int> &p_level_counts) {
+void RendererStorageRD::gi_probe_allocate(RID p_gi_probe, const Transform &p_to_cell_xform, const AABB &p_aabb, const Vector3i &p_octree_size, const Vector<uint8_t> &p_octree_cells, const Vector<uint8_t> &p_data_cells, const Vector<uint8_t> &p_distance_field, const Vector<int> &p_level_counts) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
@@ -5528,7 +5896,7 @@ void RasterizerStorageRD::gi_probe_allocate(RID p_gi_probe, const Transform &p_t
 			tf.width = gi_probe->octree_size.x;
 			tf.height = gi_probe->octree_size.y;
 			tf.depth = gi_probe->octree_size.z;
-			tf.type = RD::TEXTURE_TYPE_3D;
+			tf.texture_type = RD::TEXTURE_TYPE_3D;
 			tf.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
 			Vector<Vector<uint8_t>> s;
 			s.push_back(p_distance_field);
@@ -5549,7 +5917,6 @@ void RasterizerStorageRD::gi_probe_allocate(RID p_gi_probe, const Transform &p_t
 			}
 			RID shared_tex;
 			{
-
 				RD::TextureView tv;
 				tv.format_override = RD::DATA_FORMAT_R8_UINT;
 				shared_tex = RD::get_singleton()->texture_create_shared(tv, gi_probe->sdf_texture);
@@ -5558,21 +5925,21 @@ void RasterizerStorageRD::gi_probe_allocate(RID p_gi_probe, const Transform &p_t
 			Vector<RD::Uniform> uniforms;
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.binding = 1;
 				u.ids.push_back(gi_probe->octree_buffer);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.binding = 2;
 				u.ids.push_back(gi_probe->data_buffer);
 				uniforms.push_back(u);
 			}
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_IMAGE;
+				u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
 				u.binding = 3;
 				u.ids.push_back(shared_tex);
 				uniforms.push_back(u);
@@ -5611,20 +5978,20 @@ void RasterizerStorageRD::gi_probe_allocate(RID p_gi_probe, const Transform &p_t
 	gi_probe->instance_dependency.instance_notify_changed(true, false);
 }
 
-AABB RasterizerStorageRD::gi_probe_get_bounds(RID p_gi_probe) const {
+AABB RendererStorageRD::gi_probe_get_bounds(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, AABB());
 
 	return gi_probe->bounds;
 }
 
-Vector3i RasterizerStorageRD::gi_probe_get_octree_size(RID p_gi_probe) const {
+Vector3i RendererStorageRD::gi_probe_get_octree_size(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, Vector3i());
 	return gi_probe->octree_size;
 }
 
-Vector<uint8_t> RasterizerStorageRD::gi_probe_get_octree_cells(RID p_gi_probe) const {
+Vector<uint8_t> RendererStorageRD::gi_probe_get_octree_cells(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, Vector<uint8_t>());
 
@@ -5634,7 +6001,7 @@ Vector<uint8_t> RasterizerStorageRD::gi_probe_get_octree_cells(RID p_gi_probe) c
 	return Vector<uint8_t>();
 }
 
-Vector<uint8_t> RasterizerStorageRD::gi_probe_get_data_cells(RID p_gi_probe) const {
+Vector<uint8_t> RendererStorageRD::gi_probe_get_data_cells(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, Vector<uint8_t>());
 
@@ -5644,7 +6011,7 @@ Vector<uint8_t> RasterizerStorageRD::gi_probe_get_data_cells(RID p_gi_probe) con
 	return Vector<uint8_t>();
 }
 
-Vector<uint8_t> RasterizerStorageRD::gi_probe_get_distance_field(RID p_gi_probe) const {
+Vector<uint8_t> RendererStorageRD::gi_probe_get_distance_field(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, Vector<uint8_t>());
 
@@ -5654,21 +6021,21 @@ Vector<uint8_t> RasterizerStorageRD::gi_probe_get_distance_field(RID p_gi_probe)
 	return Vector<uint8_t>();
 }
 
-Vector<int> RasterizerStorageRD::gi_probe_get_level_counts(RID p_gi_probe) const {
+Vector<int> RendererStorageRD::gi_probe_get_level_counts(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, Vector<int>());
 
 	return gi_probe->level_counts;
 }
 
-Transform RasterizerStorageRD::gi_probe_get_to_cell_xform(RID p_gi_probe) const {
+Transform RendererStorageRD::gi_probe_get_to_cell_xform(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, Transform());
 
 	return gi_probe->to_cell_xform;
 }
 
-void RasterizerStorageRD::gi_probe_set_dynamic_range(RID p_gi_probe, float p_range) {
+void RendererStorageRD::gi_probe_set_dynamic_range(RID p_gi_probe, float p_range) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
@@ -5676,14 +6043,14 @@ void RasterizerStorageRD::gi_probe_set_dynamic_range(RID p_gi_probe, float p_ran
 	gi_probe->version++;
 }
 
-float RasterizerStorageRD::gi_probe_get_dynamic_range(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_dynamic_range(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 
 	return gi_probe->dynamic_range;
 }
 
-void RasterizerStorageRD::gi_probe_set_propagation(RID p_gi_probe, float p_range) {
+void RendererStorageRD::gi_probe_set_propagation(RID p_gi_probe, float p_range) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
@@ -5691,98 +6058,98 @@ void RasterizerStorageRD::gi_probe_set_propagation(RID p_gi_probe, float p_range
 	gi_probe->version++;
 }
 
-float RasterizerStorageRD::gi_probe_get_propagation(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_propagation(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->propagation;
 }
 
-void RasterizerStorageRD::gi_probe_set_energy(RID p_gi_probe, float p_energy) {
+void RendererStorageRD::gi_probe_set_energy(RID p_gi_probe, float p_energy) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->energy = p_energy;
 }
 
-float RasterizerStorageRD::gi_probe_get_energy(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_energy(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->energy;
 }
 
-void RasterizerStorageRD::gi_probe_set_ao(RID p_gi_probe, float p_ao) {
+void RendererStorageRD::gi_probe_set_ao(RID p_gi_probe, float p_ao) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->ao = p_ao;
 }
 
-float RasterizerStorageRD::gi_probe_get_ao(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_ao(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->ao;
 }
 
-void RasterizerStorageRD::gi_probe_set_ao_size(RID p_gi_probe, float p_strength) {
+void RendererStorageRD::gi_probe_set_ao_size(RID p_gi_probe, float p_strength) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->ao_size = p_strength;
 }
 
-float RasterizerStorageRD::gi_probe_get_ao_size(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_ao_size(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->ao_size;
 }
 
-void RasterizerStorageRD::gi_probe_set_bias(RID p_gi_probe, float p_bias) {
+void RendererStorageRD::gi_probe_set_bias(RID p_gi_probe, float p_bias) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->bias = p_bias;
 }
 
-float RasterizerStorageRD::gi_probe_get_bias(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_bias(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->bias;
 }
 
-void RasterizerStorageRD::gi_probe_set_normal_bias(RID p_gi_probe, float p_normal_bias) {
+void RendererStorageRD::gi_probe_set_normal_bias(RID p_gi_probe, float p_normal_bias) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->normal_bias = p_normal_bias;
 }
 
-float RasterizerStorageRD::gi_probe_get_normal_bias(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_normal_bias(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->normal_bias;
 }
 
-void RasterizerStorageRD::gi_probe_set_anisotropy_strength(RID p_gi_probe, float p_strength) {
+void RendererStorageRD::gi_probe_set_anisotropy_strength(RID p_gi_probe, float p_strength) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->anisotropy_strength = p_strength;
 }
 
-float RasterizerStorageRD::gi_probe_get_anisotropy_strength(RID p_gi_probe) const {
+float RendererStorageRD::gi_probe_get_anisotropy_strength(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->anisotropy_strength;
 }
 
-void RasterizerStorageRD::gi_probe_set_interior(RID p_gi_probe, bool p_enable) {
+void RendererStorageRD::gi_probe_set_interior(RID p_gi_probe, bool p_enable) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
 	gi_probe->interior = p_enable;
 }
 
-void RasterizerStorageRD::gi_probe_set_use_two_bounces(RID p_gi_probe, bool p_enable) {
+void RendererStorageRD::gi_probe_set_use_two_bounces(RID p_gi_probe, bool p_enable) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND(!gi_probe);
 
@@ -5790,43 +6157,43 @@ void RasterizerStorageRD::gi_probe_set_use_two_bounces(RID p_gi_probe, bool p_en
 	gi_probe->version++;
 }
 
-bool RasterizerStorageRD::gi_probe_is_using_two_bounces(RID p_gi_probe) const {
+bool RendererStorageRD::gi_probe_is_using_two_bounces(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, false);
 	return gi_probe->use_two_bounces;
 }
 
-bool RasterizerStorageRD::gi_probe_is_interior(RID p_gi_probe) const {
+bool RendererStorageRD::gi_probe_is_interior(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->interior;
 }
 
-uint32_t RasterizerStorageRD::gi_probe_get_version(RID p_gi_probe) {
+uint32_t RendererStorageRD::gi_probe_get_version(RID p_gi_probe) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->version;
 }
 
-uint32_t RasterizerStorageRD::gi_probe_get_data_version(RID p_gi_probe) {
+uint32_t RendererStorageRD::gi_probe_get_data_version(RID p_gi_probe) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, 0);
 	return gi_probe->data_version;
 }
 
-RID RasterizerStorageRD::gi_probe_get_octree_buffer(RID p_gi_probe) const {
+RID RendererStorageRD::gi_probe_get_octree_buffer(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, RID());
 	return gi_probe->octree_buffer;
 }
 
-RID RasterizerStorageRD::gi_probe_get_data_buffer(RID p_gi_probe) const {
+RID RendererStorageRD::gi_probe_get_data_buffer(RID p_gi_probe) const {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, RID());
 	return gi_probe->data_buffer;
 }
 
-RID RasterizerStorageRD::gi_probe_get_sdf_texture(RID p_gi_probe) {
+RID RendererStorageRD::gi_probe_get_sdf_texture(RID p_gi_probe) {
 	GIProbe *gi_probe = gi_probe_owner.getornull(p_gi_probe);
 	ERR_FAIL_COND_V(!gi_probe, RID());
 
@@ -5835,11 +6202,11 @@ RID RasterizerStorageRD::gi_probe_get_sdf_texture(RID p_gi_probe) {
 
 /* LIGHTMAP API */
 
-RID RasterizerStorageRD::lightmap_create() {
+RID RendererStorageRD::lightmap_create() {
 	return lightmap_owner.make_rid(Lightmap());
 }
 
-void RasterizerStorageRD::lightmap_set_textures(RID p_lightmap, RID p_light, bool p_uses_spherical_haromics) {
+void RendererStorageRD::lightmap_set_textures(RID p_lightmap, RID p_light, bool p_uses_spherical_haromics) {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
@@ -5887,19 +6254,19 @@ void RasterizerStorageRD::lightmap_set_textures(RID p_lightmap, RID p_light, boo
 	}
 }
 
-void RasterizerStorageRD::lightmap_set_probe_bounds(RID p_lightmap, const AABB &p_bounds) {
+void RendererStorageRD::lightmap_set_probe_bounds(RID p_lightmap, const AABB &p_bounds) {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 	lm->bounds = p_bounds;
 }
 
-void RasterizerStorageRD::lightmap_set_probe_interior(RID p_lightmap, bool p_interior) {
+void RendererStorageRD::lightmap_set_probe_interior(RID p_lightmap, bool p_interior) {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 	lm->interior = p_interior;
 }
 
-void RasterizerStorageRD::lightmap_set_probe_capture_data(RID p_lightmap, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) {
+void RendererStorageRD::lightmap_set_probe_capture_data(RID p_lightmap, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
@@ -5915,36 +6282,36 @@ void RasterizerStorageRD::lightmap_set_probe_capture_data(RID p_lightmap, const
 	lm->tetrahedra = p_tetrahedra;
 }
 
-PackedVector3Array RasterizerStorageRD::lightmap_get_probe_capture_points(RID p_lightmap) const {
+PackedVector3Array RendererStorageRD::lightmap_get_probe_capture_points(RID p_lightmap) const {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedVector3Array());
 
 	return lm->points;
 }
 
-PackedColorArray RasterizerStorageRD::lightmap_get_probe_capture_sh(RID p_lightmap) const {
+PackedColorArray RendererStorageRD::lightmap_get_probe_capture_sh(RID p_lightmap) const {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedColorArray());
 	return lm->point_sh;
 }
 
-PackedInt32Array RasterizerStorageRD::lightmap_get_probe_capture_tetrahedra(RID p_lightmap) const {
+PackedInt32Array RendererStorageRD::lightmap_get_probe_capture_tetrahedra(RID p_lightmap) const {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedInt32Array());
 	return lm->tetrahedra;
 }
 
-PackedInt32Array RasterizerStorageRD::lightmap_get_probe_capture_bsp_tree(RID p_lightmap) const {
+PackedInt32Array RendererStorageRD::lightmap_get_probe_capture_bsp_tree(RID p_lightmap) const {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND_V(!lm, PackedInt32Array());
 	return lm->bsp_tree;
 }
 
-void RasterizerStorageRD::lightmap_set_probe_capture_update_speed(float p_speed) {
+void RendererStorageRD::lightmap_set_probe_capture_update_speed(float p_speed) {
 	lightmap_probe_capture_update_speed = p_speed;
 }
 
-void RasterizerStorageRD::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) {
+void RendererStorageRD::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) {
 	Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND(!lm);
 
@@ -5994,13 +6361,13 @@ void RasterizerStorageRD::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p
 	}
 }
 
-bool RasterizerStorageRD::lightmap_is_interior(RID p_lightmap) const {
+bool RendererStorageRD::lightmap_is_interior(RID p_lightmap) const {
 	const Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND_V(!lm, false);
 	return lm->interior;
 }
 
-AABB RasterizerStorageRD::lightmap_get_aabb(RID p_lightmap) const {
+AABB RendererStorageRD::lightmap_get_aabb(RID p_lightmap) const {
 	const Lightmap *lm = lightmap_owner.getornull(p_lightmap);
 	ERR_FAIL_COND_V(!lm, AABB());
 	return lm->bounds;
@@ -6008,7 +6375,7 @@ AABB RasterizerStorageRD::lightmap_get_aabb(RID p_lightmap) const {
 
 /* RENDER TARGET API */
 
-void RasterizerStorageRD::_clear_render_target(RenderTarget *rt) {
+void RendererStorageRD::_clear_render_target(RenderTarget *rt) {
 	//free in reverse dependency order
 	if (rt->framebuffer.is_valid()) {
 		RD::get_singleton()->free(rt->framebuffer);
@@ -6030,11 +6397,13 @@ void RasterizerStorageRD::_clear_render_target(RenderTarget *rt) {
 		rt->backbuffer_uniform_set = RID(); //chain deleted
 	}
 
+	_render_target_clear_sdf(rt);
+
 	rt->framebuffer = RID();
 	rt->color = RID();
 }
 
-void RasterizerStorageRD::_update_render_target(RenderTarget *rt) {
+void RendererStorageRD::_update_render_target(RenderTarget *rt) {
 	if (rt->texture.is_null()) {
 		//create a placeholder until updated
 		rt->texture = texture_2d_placeholder_create();
@@ -6061,7 +6430,7 @@ void RasterizerStorageRD::_update_render_target(RenderTarget *rt) {
 		rd_format.depth = 1;
 		rd_format.array_layers = 1;
 		rd_format.mipmaps = 1;
-		rd_format.type = RD::TEXTURE_TYPE_2D;
+		rd_format.texture_type = RD::TEXTURE_TYPE_2D;
 		rd_format.samples = RD::TEXTURE_SAMPLES_1;
 		rd_format.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
 		rd_format.shareable_formats.push_back(rt->color_format);
@@ -6122,7 +6491,7 @@ void RasterizerStorageRD::_update_render_target(RenderTarget *rt) {
 	}
 }
 
-void RasterizerStorageRD::_create_render_target_backbuffer(RenderTarget *rt) {
+void RendererStorageRD::_create_render_target_backbuffer(RenderTarget *rt) {
 	ERR_FAIL_COND(rt->backbuffer.is_valid());
 
 	uint32_t mipmaps_required = Image::get_image_required_mipmaps(rt->size.width, rt->size.height, Image::FORMAT_RGBA8);
@@ -6130,7 +6499,7 @@ void RasterizerStorageRD::_create_render_target_backbuffer(RenderTarget *rt) {
 	tf.format = rt->color_format;
 	tf.width = rt->size.width;
 	tf.height = rt->size.height;
-	tf.type = RD::TEXTURE_TYPE_2D;
+	tf.texture_type = RD::TEXTURE_TYPE_2D;
 	tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
 	tf.mipmaps = mipmaps_required;
 
@@ -6170,7 +6539,7 @@ void RasterizerStorageRD::_create_render_target_backbuffer(RenderTarget *rt) {
 	}
 }
 
-RID RasterizerStorageRD::render_target_create() {
+RID RendererStorageRD::render_target_create() {
 	RenderTarget render_target;
 
 	render_target.was_used = false;
@@ -6183,11 +6552,11 @@ RID RasterizerStorageRD::render_target_create() {
 	return render_target_owner.make_rid(render_target);
 }
 
-void RasterizerStorageRD::render_target_set_position(RID p_render_target, int p_x, int p_y) {
+void RendererStorageRD::render_target_set_position(RID p_render_target, int p_x, int p_y) {
 	//unused for this render target
 }
 
-void RasterizerStorageRD::render_target_set_size(RID p_render_target, int p_width, int p_height) {
+void RendererStorageRD::render_target_set_size(RID p_render_target, int p_width, int p_height) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->size.x = p_width;
@@ -6195,63 +6564,63 @@ void RasterizerStorageRD::render_target_set_size(RID p_render_target, int p_widt
 	_update_render_target(rt);
 }
 
-RID RasterizerStorageRD::render_target_get_texture(RID p_render_target) {
+RID RendererStorageRD::render_target_get_texture(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	return rt->texture;
 }
 
-void RasterizerStorageRD::render_target_set_external_texture(RID p_render_target, unsigned int p_texture_id) {
+void RendererStorageRD::render_target_set_external_texture(RID p_render_target, unsigned int p_texture_id) {
 }
 
-void RasterizerStorageRD::render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value) {
+void RendererStorageRD::render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->flags[p_flag] = p_value;
 	_update_render_target(rt);
 }
 
-bool RasterizerStorageRD::render_target_was_used(RID p_render_target) {
+bool RendererStorageRD::render_target_was_used(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 	return rt->was_used;
 }
 
-void RasterizerStorageRD::render_target_set_as_unused(RID p_render_target) {
+void RendererStorageRD::render_target_set_as_unused(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->was_used = false;
 }
 
-Size2 RasterizerStorageRD::render_target_get_size(RID p_render_target) {
+Size2 RendererStorageRD::render_target_get_size(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, Size2());
 
 	return rt->size;
 }
 
-RID RasterizerStorageRD::render_target_get_rd_framebuffer(RID p_render_target) {
+RID RendererStorageRD::render_target_get_rd_framebuffer(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	return rt->framebuffer;
 }
 
-RID RasterizerStorageRD::render_target_get_rd_texture(RID p_render_target) {
+RID RendererStorageRD::render_target_get_rd_texture(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	return rt->color;
 }
 
-RID RasterizerStorageRD::render_target_get_rd_backbuffer(RID p_render_target) {
+RID RendererStorageRD::render_target_get_rd_backbuffer(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 	return rt->backbuffer;
 }
 
-RID RasterizerStorageRD::render_target_get_rd_backbuffer_framebuffer(RID p_render_target) {
+RID RendererStorageRD::render_target_get_rd_backbuffer_framebuffer(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
@@ -6262,32 +6631,32 @@ RID RasterizerStorageRD::render_target_get_rd_backbuffer_framebuffer(RID p_rende
 	return rt->backbuffer_fb;
 }
 
-void RasterizerStorageRD::render_target_request_clear(RID p_render_target, const Color &p_clear_color) {
+void RendererStorageRD::render_target_request_clear(RID p_render_target, const Color &p_clear_color) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->clear_requested = true;
 	rt->clear_color = p_clear_color;
 }
 
-bool RasterizerStorageRD::render_target_is_clear_requested(RID p_render_target) {
+bool RendererStorageRD::render_target_is_clear_requested(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 	return rt->clear_requested;
 }
 
-Color RasterizerStorageRD::render_target_get_clear_request_color(RID p_render_target) {
+Color RendererStorageRD::render_target_get_clear_request_color(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, Color());
 	return rt->clear_color;
 }
 
-void RasterizerStorageRD::render_target_disable_clear_request(RID p_render_target) {
+void RendererStorageRD::render_target_disable_clear_request(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->clear_requested = false;
 }
 
-void RasterizerStorageRD::render_target_do_clear_request(RID p_render_target) {
+void RendererStorageRD::render_target_do_clear_request(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->clear_requested) {
@@ -6300,7 +6669,276 @@ void RasterizerStorageRD::render_target_do_clear_request(RID p_render_target) {
 	rt->clear_requested = false;
 }
 
-void RasterizerStorageRD::render_target_copy_to_back_buffer(RID p_render_target, const Rect2i &p_region, bool p_gen_mipmaps) {
+void RendererStorageRD::render_target_set_sdf_size_and_scale(RID p_render_target, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) {
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND(!rt);
+	if (rt->sdf_oversize == p_size && rt->sdf_scale == p_scale) {
+		return;
+	}
+
+	rt->sdf_oversize = p_size;
+	rt->sdf_scale = p_scale;
+
+	_render_target_clear_sdf(rt);
+}
+
+Rect2i RendererStorageRD::_render_target_get_sdf_rect(const RenderTarget *rt) const {
+	Size2i margin;
+	int scale;
+	switch (rt->sdf_oversize) {
+		case RS::VIEWPORT_SDF_OVERSIZE_100_PERCENT: {
+			scale = 100;
+		} break;
+		case RS::VIEWPORT_SDF_OVERSIZE_120_PERCENT: {
+			scale = 120;
+		} break;
+		case RS::VIEWPORT_SDF_OVERSIZE_150_PERCENT: {
+			scale = 150;
+		} break;
+		case RS::VIEWPORT_SDF_OVERSIZE_200_PERCENT: {
+			scale = 200;
+		} break;
+		default: {
+		}
+	}
+
+	margin = (rt->size * scale / 100) - rt->size;
+
+	Rect2i r(Vector2i(), rt->size);
+	r.position -= margin;
+	r.size += margin * 2;
+
+	return r;
+}
+
+Rect2i RendererStorageRD::render_target_get_sdf_rect(RID p_render_target) const {
+	const RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND_V(!rt, Rect2i());
+
+	return _render_target_get_sdf_rect(rt);
+}
+
+RID RendererStorageRD::render_target_get_sdf_texture(RID p_render_target) {
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND_V(!rt, RID());
+	if (rt->sdf_buffer_read.is_null()) {
+		// no texture, create a dummy one for the 2D uniform set
+		RD::TextureFormat tformat;
+		tformat.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
+		tformat.width = 4;
+		tformat.height = 4;
+		tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
+		tformat.texture_type = RD::TEXTURE_TYPE_2D;
+
+		Vector<uint8_t> pv;
+		pv.resize(16 * 4);
+		zeromem(pv.ptrw(), 16 * 4);
+		Vector<Vector<uint8_t>> vpv;
+
+		rt->sdf_buffer_read = RD::get_singleton()->texture_create(tformat, RD::TextureView(), vpv);
+	}
+
+	return rt->sdf_buffer_read;
+}
+
+void RendererStorageRD::_render_target_allocate_sdf(RenderTarget *rt) {
+	ERR_FAIL_COND(rt->sdf_buffer_write_fb.is_valid());
+	if (rt->sdf_buffer_read.is_valid()) {
+		RD::get_singleton()->free(rt->sdf_buffer_read);
+		rt->sdf_buffer_read = RID();
+	}
+
+	Size2i size = _render_target_get_sdf_rect(rt).size;
+
+	RD::TextureFormat tformat;
+	tformat.format = RD::DATA_FORMAT_R8_UNORM;
+	tformat.width = size.width;
+	tformat.height = size.height;
+	tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
+	tformat.texture_type = RD::TEXTURE_TYPE_2D;
+
+	rt->sdf_buffer_write = RD::get_singleton()->texture_create(tformat, RD::TextureView());
+
+	{
+		Vector<RID> write_fb;
+		write_fb.push_back(rt->sdf_buffer_write);
+		rt->sdf_buffer_write_fb = RD::get_singleton()->framebuffer_create(write_fb);
+	}
+
+	int scale;
+	switch (rt->sdf_scale) {
+		case RS::VIEWPORT_SDF_SCALE_100_PERCENT: {
+			scale = 100;
+		} break;
+		case RS::VIEWPORT_SDF_SCALE_50_PERCENT: {
+			scale = 50;
+		} break;
+		case RS::VIEWPORT_SDF_SCALE_25_PERCENT: {
+			scale = 25;
+		} break;
+		default: {
+			scale = 100;
+		} break;
+	}
+
+	rt->process_size = size * scale / 100;
+	rt->process_size.x = MAX(rt->process_size.x, 1);
+	rt->process_size.y = MAX(rt->process_size.y, 1);
+
+	tformat.format = RD::DATA_FORMAT_R16G16_UINT;
+	tformat.width = rt->process_size.width;
+	tformat.height = rt->process_size.height;
+	tformat.usage_bits = RD::TEXTURE_USAGE_STORAGE_BIT;
+
+	rt->sdf_buffer_process[0] = RD::get_singleton()->texture_create(tformat, RD::TextureView());
+	rt->sdf_buffer_process[1] = RD::get_singleton()->texture_create(tformat, RD::TextureView());
+
+	tformat.format = RD::DATA_FORMAT_R16_UNORM;
+	tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
+
+	rt->sdf_buffer_read = RD::get_singleton()->texture_create(tformat, RD::TextureView());
+
+	{
+		Vector<RD::Uniform> uniforms;
+		{
+			RD::Uniform u;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+			u.binding = 1;
+			u.ids.push_back(rt->sdf_buffer_write);
+			uniforms.push_back(u);
+		}
+		{
+			RD::Uniform u;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+			u.binding = 2;
+			u.ids.push_back(rt->sdf_buffer_read);
+			uniforms.push_back(u);
+		}
+		{
+			RD::Uniform u;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+			u.binding = 3;
+			u.ids.push_back(rt->sdf_buffer_process[0]);
+			uniforms.push_back(u);
+		}
+		{
+			RD::Uniform u;
+			u.uniform_type = RD::UNIFORM_TYPE_IMAGE;
+			u.binding = 4;
+			u.ids.push_back(rt->sdf_buffer_process[1]);
+			uniforms.push_back(u);
+		}
+
+		rt->sdf_buffer_process_uniform_sets[0] = RD::get_singleton()->uniform_set_create(uniforms, rt_sdf.shader.version_get_shader(rt_sdf.shader_version, 0), 0);
+		SWAP(uniforms.write[2].ids.write[0], uniforms.write[3].ids.write[0]);
+		rt->sdf_buffer_process_uniform_sets[1] = RD::get_singleton()->uniform_set_create(uniforms, rt_sdf.shader.version_get_shader(rt_sdf.shader_version, 0), 0);
+	}
+}
+
+void RendererStorageRD::_render_target_clear_sdf(RenderTarget *rt) {
+	if (rt->sdf_buffer_read.is_valid()) {
+		RD::get_singleton()->free(rt->sdf_buffer_read);
+		rt->sdf_buffer_read = RID();
+	}
+	if (rt->sdf_buffer_write_fb.is_valid()) {
+		RD::get_singleton()->free(rt->sdf_buffer_write);
+		RD::get_singleton()->free(rt->sdf_buffer_process[0]);
+		RD::get_singleton()->free(rt->sdf_buffer_process[1]);
+		rt->sdf_buffer_write = RID();
+		rt->sdf_buffer_write_fb = RID();
+		rt->sdf_buffer_process[0] = RID();
+		rt->sdf_buffer_process[1] = RID();
+		rt->sdf_buffer_process_uniform_sets[0] = RID();
+		rt->sdf_buffer_process_uniform_sets[1] = RID();
+	}
+}
+
+RID RendererStorageRD::render_target_get_sdf_framebuffer(RID p_render_target) {
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND_V(!rt, RID());
+
+	if (rt->sdf_buffer_write_fb.is_null()) {
+		_render_target_allocate_sdf(rt);
+	}
+
+	return rt->sdf_buffer_write_fb;
+}
+void RendererStorageRD::render_target_sdf_process(RID p_render_target) {
+	RenderTarget *rt = render_target_owner.getornull(p_render_target);
+	ERR_FAIL_COND(!rt);
+	ERR_FAIL_COND(rt->sdf_buffer_write_fb.is_null());
+
+	RenderTargetSDF::PushConstant push_constant;
+
+	Rect2i r = _render_target_get_sdf_rect(rt);
+
+	push_constant.size[0] = r.size.width;
+	push_constant.size[1] = r.size.height;
+	push_constant.stride = 0;
+	push_constant.shift = 0;
+	push_constant.base_size[0] = r.size.width;
+	push_constant.base_size[1] = r.size.height;
+
+	bool shrink = false;
+
+	switch (rt->sdf_scale) {
+		case RS::VIEWPORT_SDF_SCALE_50_PERCENT: {
+			push_constant.size[0] >>= 1;
+			push_constant.size[1] >>= 1;
+			push_constant.shift = 1;
+			shrink = true;
+		} break;
+		case RS::VIEWPORT_SDF_SCALE_25_PERCENT: {
+			push_constant.size[0] >>= 2;
+			push_constant.size[1] >>= 2;
+			push_constant.shift = 2;
+			shrink = true;
+		} break;
+		default: {
+		};
+	}
+
+	RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();
+
+	/* Load */
+
+	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, rt_sdf.pipelines[shrink ? RenderTargetSDF::SHADER_LOAD_SHRINK : RenderTargetSDF::SHADER_LOAD]);
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rt->sdf_buffer_process_uniform_sets[1], 0); //fill [0]
+	RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(RenderTargetSDF::PushConstant));
+
+	RD::get_singleton()->compute_list_dispatch_threads(compute_list, push_constant.size[0], push_constant.size[1], 1, 8, 8, 1);
+
+	/* Process */
+
+	int stride = nearest_power_of_2_templated(MAX(push_constant.size[0], push_constant.size[1]) / 2);
+
+	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, rt_sdf.pipelines[RenderTargetSDF::SHADER_PROCESS]);
+
+	RD::get_singleton()->compute_list_add_barrier(compute_list);
+	bool swap = false;
+
+	//jumpflood
+	while (stride > 0) {
+		RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rt->sdf_buffer_process_uniform_sets[swap ? 1 : 0], 0);
+		push_constant.stride = stride;
+		RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(RenderTargetSDF::PushConstant));
+		RD::get_singleton()->compute_list_dispatch_threads(compute_list, push_constant.size[0], push_constant.size[1], 1, 8, 8, 1);
+		stride /= 2;
+		swap = !swap;
+		RD::get_singleton()->compute_list_add_barrier(compute_list);
+	}
+
+	/* Store */
+
+	RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, rt_sdf.pipelines[shrink ? RenderTargetSDF::SHADER_STORE_SHRINK : RenderTargetSDF::SHADER_STORE]);
+	RD::get_singleton()->compute_list_bind_uniform_set(compute_list, rt->sdf_buffer_process_uniform_sets[swap ? 1 : 0], 0);
+	RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(RenderTargetSDF::PushConstant));
+	RD::get_singleton()->compute_list_dispatch_threads(compute_list, push_constant.size[0], push_constant.size[1], 1, 8, 8, 1);
+
+	RD::get_singleton()->compute_list_end();
+}
+
+void RendererStorageRD::render_target_copy_to_back_buffer(RID p_render_target, const Rect2i &p_region, bool p_gen_mipmaps) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->backbuffer.is_valid()) {
@@ -6311,7 +6949,7 @@ void RasterizerStorageRD::render_target_copy_to_back_buffer(RID p_render_target,
 	if (p_region == Rect2i()) {
 		region.size = rt->size;
 	} else {
-		region = Rect2i(Size2i(), rt->size).clip(p_region);
+		region = Rect2i(Size2i(), rt->size).intersection(p_region);
 		if (region.size == Size2i()) {
 			return; //nothing to do
 		}
@@ -6340,7 +6978,7 @@ void RasterizerStorageRD::render_target_copy_to_back_buffer(RID p_render_target,
 	}
 }
 
-void RasterizerStorageRD::render_target_clear_back_buffer(RID p_render_target, const Rect2i &p_region, const Color &p_color) {
+void RendererStorageRD::render_target_clear_back_buffer(RID p_render_target, const Rect2i &p_region, const Color &p_color) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->backbuffer.is_valid()) {
@@ -6351,7 +6989,7 @@ void RasterizerStorageRD::render_target_clear_back_buffer(RID p_render_target, c
 	if (p_region == Rect2i()) {
 		region.size = rt->size;
 	} else {
-		region = Rect2i(Size2i(), rt->size).clip(p_region);
+		region = Rect2i(Size2i(), rt->size).intersection(p_region);
 		if (region.size == Size2i()) {
 			return; //nothing to do
 		}
@@ -6361,7 +6999,7 @@ void RasterizerStorageRD::render_target_clear_back_buffer(RID p_render_target, c
 	effects.set_color(rt->backbuffer_mipmap0, p_color, region, true);
 }
 
-void RasterizerStorageRD::render_target_gen_back_buffer_mipmaps(RID p_render_target, const Rect2i &p_region) {
+void RendererStorageRD::render_target_gen_back_buffer_mipmaps(RID p_render_target, const Rect2i &p_region) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	if (!rt->backbuffer.is_valid()) {
@@ -6372,7 +7010,7 @@ void RasterizerStorageRD::render_target_gen_back_buffer_mipmaps(RID p_render_tar
 	if (p_region == Rect2i()) {
 		region.size = rt->size;
 	} else {
-		region = Rect2i(Size2i(), rt->size).clip(p_region);
+		region = Rect2i(Size2i(), rt->size).intersection(p_region);
 		if (region.size == Size2i()) {
 			return; //nothing to do
 		}
@@ -6393,29 +7031,29 @@ void RasterizerStorageRD::render_target_gen_back_buffer_mipmaps(RID p_render_tar
 	}
 }
 
-RID RasterizerStorageRD::render_target_get_framebuffer_uniform_set(RID p_render_target) {
+RID RendererStorageRD::render_target_get_framebuffer_uniform_set(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 	return rt->framebuffer_uniform_set;
 }
-RID RasterizerStorageRD::render_target_get_backbuffer_uniform_set(RID p_render_target) {
+RID RendererStorageRD::render_target_get_backbuffer_uniform_set(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 	return rt->backbuffer_uniform_set;
 }
 
-void RasterizerStorageRD::render_target_set_framebuffer_uniform_set(RID p_render_target, RID p_uniform_set) {
+void RendererStorageRD::render_target_set_framebuffer_uniform_set(RID p_render_target, RID p_uniform_set) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->framebuffer_uniform_set = p_uniform_set;
 }
-void RasterizerStorageRD::render_target_set_backbuffer_uniform_set(RID p_render_target, RID p_uniform_set) {
+void RendererStorageRD::render_target_set_backbuffer_uniform_set(RID p_render_target, RID p_uniform_set) {
 	RenderTarget *rt = render_target_owner.getornull(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->backbuffer_uniform_set = p_uniform_set;
 }
 
-void RasterizerStorageRD::base_update_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance) {
+void RendererStorageRD::base_update_dependency(RID p_base, InstanceBaseDependency *p_instance) {
 	if (mesh_owner.owns(p_base)) {
 		Mesh *mesh = mesh_owner.getornull(p_base);
 		p_instance->update_dependency(&mesh->instance_dependency);
@@ -6449,14 +7087,14 @@ void RasterizerStorageRD::base_update_dependency(RID p_base, RasterizerScene::In
 	}
 }
 
-void RasterizerStorageRD::skeleton_update_dependency(RID p_skeleton, RasterizerScene::InstanceBase *p_instance) {
+void RendererStorageRD::skeleton_update_dependency(RID p_skeleton, InstanceBaseDependency *p_instance) {
 	Skeleton *skeleton = skeleton_owner.getornull(p_skeleton);
 	ERR_FAIL_COND(!skeleton);
 
 	p_instance->update_dependency(&skeleton->instance_dependency);
 }
 
-RS::InstanceType RasterizerStorageRD::get_base_type(RID p_rid) const {
+RS::InstanceType RendererStorageRD::get_base_type(RID p_rid) const {
 	if (mesh_owner.owns(p_rid)) {
 		return RS::INSTANCE_MESH;
 	}
@@ -6488,7 +7126,7 @@ RS::InstanceType RasterizerStorageRD::get_base_type(RID p_rid) const {
 	return RS::INSTANCE_NONE;
 }
 
-void RasterizerStorageRD::texture_add_to_decal_atlas(RID p_texture, bool p_panorama_to_dp) {
+void RendererStorageRD::texture_add_to_decal_atlas(RID p_texture, bool p_panorama_to_dp) {
 	if (!decal_atlas.textures.has(p_texture)) {
 		DecalAtlas::Texture t;
 		t.users = 1;
@@ -6504,7 +7142,7 @@ void RasterizerStorageRD::texture_add_to_decal_atlas(RID p_texture, bool p_panor
 	}
 }
 
-void RasterizerStorageRD::texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp) {
+void RendererStorageRD::texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp) {
 	DecalAtlas::Texture *t = decal_atlas.textures.getptr(p_texture);
 	ERR_FAIL_COND(!t);
 	t->users--;
@@ -6518,15 +7156,15 @@ void RasterizerStorageRD::texture_remove_from_decal_atlas(RID p_texture, bool p_
 	}
 }
 
-RID RasterizerStorageRD::decal_atlas_get_texture() const {
+RID RendererStorageRD::decal_atlas_get_texture() const {
 	return decal_atlas.texture;
 }
 
-RID RasterizerStorageRD::decal_atlas_get_texture_srgb() const {
+RID RendererStorageRD::decal_atlas_get_texture_srgb() const {
 	return decal_atlas.texture_srgb;
 }
 
-void RasterizerStorageRD::_update_decal_atlas() {
+void RendererStorageRD::_update_decal_atlas() {
 	if (!decal_atlas.dirty) {
 		return; //nothing to do
 	}
@@ -6653,7 +7291,7 @@ void RasterizerStorageRD::_update_decal_atlas() {
 	tformat.width = decal_atlas.size.width;
 	tformat.height = decal_atlas.size.height;
 	tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
-	tformat.type = RD::TEXTURE_TYPE_2D;
+	tformat.texture_type = RD::TEXTURE_TYPE_2D;
 	tformat.mipmaps = decal_atlas.mipmaps;
 	tformat.shareable_formats.push_back(RD::DATA_FORMAT_R8G8B8A8_UNORM);
 	tformat.shareable_formats.push_back(RD::DATA_FORMAT_R8G8B8A8_SRGB);
@@ -6718,7 +7356,7 @@ void RasterizerStorageRD::_update_decal_atlas() {
 	}
 }
 
-int32_t RasterizerStorageRD::_global_variable_allocate(uint32_t p_elements) {
+int32_t RendererStorageRD::_global_variable_allocate(uint32_t p_elements) {
 	int32_t idx = 0;
 	while (idx + p_elements <= global_variables.buffer_size) {
 		if (global_variables.buffer_usage[idx].elements == 0) {
@@ -6744,7 +7382,7 @@ int32_t RasterizerStorageRD::_global_variable_allocate(uint32_t p_elements) {
 	return -1;
 }
 
-void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::GlobalVariableType p_type, const Variant &p_value) {
+void RendererStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::GlobalVariableType p_type, const Variant &p_value) {
 	switch (p_type) {
 		case RS::GLOBAL_VAR_TYPE_BOOL: {
 			GlobalVariables::Value &bv = global_variables.buffer_values[p_index];
@@ -7021,7 +7659,7 @@ void RasterizerStorageRD::_global_variable_store_in_buffer(int32_t p_index, RS::
 	}
 }
 
-void RasterizerStorageRD::_global_variable_mark_buffer_dirty(int32_t p_index, int32_t p_elements) {
+void RendererStorageRD::_global_variable_mark_buffer_dirty(int32_t p_index, int32_t p_elements) {
 	int32_t prev_chunk = -1;
 
 	for (int32_t i = 0; i < p_elements; i++) {
@@ -7037,7 +7675,7 @@ void RasterizerStorageRD::_global_variable_mark_buffer_dirty(int32_t p_index, in
 	}
 }
 
-void RasterizerStorageRD::global_variable_add(const StringName &p_name, RS::GlobalVariableType p_type, const Variant &p_value) {
+void RendererStorageRD::global_variable_add(const StringName &p_name, RS::GlobalVariableType p_type, const Variant &p_value) {
 	ERR_FAIL_COND(global_variables.variables.has(p_name));
 	GlobalVariables::Variable gv;
 	gv.type = p_type;
@@ -7075,7 +7713,7 @@ void RasterizerStorageRD::global_variable_add(const StringName &p_name, RS::Glob
 	global_variables.variables[p_name] = gv;
 }
 
-void RasterizerStorageRD::global_variable_remove(const StringName &p_name) {
+void RendererStorageRD::global_variable_remove(const StringName &p_name) {
 	if (!global_variables.variables.has(p_name)) {
 		return;
 	}
@@ -7091,7 +7729,7 @@ void RasterizerStorageRD::global_variable_remove(const StringName &p_name) {
 	global_variables.variables.erase(p_name);
 }
 
-Vector<StringName> RasterizerStorageRD::global_variable_get_list() const {
+Vector<StringName> RendererStorageRD::global_variable_get_list() const {
 	if (!Engine::get_singleton()->is_editor_hint()) {
 		ERR_FAIL_V_MSG(Vector<StringName>(), "This function should never be used outside the editor, it can severely damage performance.");
 	}
@@ -7105,7 +7743,7 @@ Vector<StringName> RasterizerStorageRD::global_variable_get_list() const {
 	return names;
 }
 
-void RasterizerStorageRD::global_variable_set(const StringName &p_name, const Variant &p_value) {
+void RendererStorageRD::global_variable_set(const StringName &p_name, const Variant &p_value) {
 	ERR_FAIL_COND(!global_variables.variables.has(p_name));
 	GlobalVariables::Variable &gv = global_variables.variables[p_name];
 	gv.value = p_value;
@@ -7125,7 +7763,7 @@ void RasterizerStorageRD::global_variable_set(const StringName &p_name, const Va
 	}
 }
 
-void RasterizerStorageRD::global_variable_set_override(const StringName &p_name, const Variant &p_value) {
+void RendererStorageRD::global_variable_set_override(const StringName &p_name, const Variant &p_value) {
 	if (!global_variables.variables.has(p_name)) {
 		return; //variable may not exist
 	}
@@ -7153,7 +7791,7 @@ void RasterizerStorageRD::global_variable_set_override(const StringName &p_name,
 	}
 }
 
-Variant RasterizerStorageRD::global_variable_get(const StringName &p_name) const {
+Variant RendererStorageRD::global_variable_get(const StringName &p_name) const {
 	if (!Engine::get_singleton()->is_editor_hint()) {
 		ERR_FAIL_V_MSG(Variant(), "This function should never be used outside the editor, it can severely damage performance.");
 	}
@@ -7165,7 +7803,7 @@ Variant RasterizerStorageRD::global_variable_get(const StringName &p_name) const
 	return global_variables.variables[p_name].value;
 }
 
-RS::GlobalVariableType RasterizerStorageRD::global_variable_get_type_internal(const StringName &p_name) const {
+RS::GlobalVariableType RendererStorageRD::global_variable_get_type_internal(const StringName &p_name) const {
 	if (!global_variables.variables.has(p_name)) {
 		return RS::GLOBAL_VAR_TYPE_MAX;
 	}
@@ -7173,7 +7811,7 @@ RS::GlobalVariableType RasterizerStorageRD::global_variable_get_type_internal(co
 	return global_variables.variables[p_name].type;
 }
 
-RS::GlobalVariableType RasterizerStorageRD::global_variable_get_type(const StringName &p_name) const {
+RS::GlobalVariableType RendererStorageRD::global_variable_get_type(const StringName &p_name) const {
 	if (!Engine::get_singleton()->is_editor_hint()) {
 		ERR_FAIL_V_MSG(RS::GLOBAL_VAR_TYPE_MAX, "This function should never be used outside the editor, it can severely damage performance.");
 	}
@@ -7181,7 +7819,7 @@ RS::GlobalVariableType RasterizerStorageRD::global_variable_get_type(const Strin
 	return global_variable_get_type_internal(p_name);
 }
 
-void RasterizerStorageRD::global_variables_load_settings(bool p_load_textures) {
+void RendererStorageRD::global_variables_load_settings(bool p_load_textures) {
 	List<PropertyInfo> settings;
 	ProjectSettings::get_singleton()->get_property_list(&settings);
 
@@ -7262,15 +7900,15 @@ void RasterizerStorageRD::global_variables_load_settings(bool p_load_textures) {
 	}
 }
 
-void RasterizerStorageRD::global_variables_clear() {
+void RendererStorageRD::global_variables_clear() {
 	global_variables.variables.clear(); //not right but for now enough
 }
 
-RID RasterizerStorageRD::global_variables_get_storage_buffer() const {
+RID RendererStorageRD::global_variables_get_storage_buffer() const {
 	return global_variables.buffer;
 }
 
-int32_t RasterizerStorageRD::global_variables_instance_allocate(RID p_instance) {
+int32_t RendererStorageRD::global_variables_instance_allocate(RID p_instance) {
 	ERR_FAIL_COND_V(global_variables.instance_buffer_pos.has(p_instance), -1);
 	int32_t pos = _global_variable_allocate(ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES);
 	global_variables.instance_buffer_pos[p_instance] = pos; //save anyway
@@ -7279,7 +7917,7 @@ int32_t RasterizerStorageRD::global_variables_instance_allocate(RID p_instance)
 	return pos;
 }
 
-void RasterizerStorageRD::global_variables_instance_free(RID p_instance) {
+void RendererStorageRD::global_variables_instance_free(RID p_instance) {
 	ERR_FAIL_COND(!global_variables.instance_buffer_pos.has(p_instance));
 	int32_t pos = global_variables.instance_buffer_pos[p_instance];
 	if (pos >= 0) {
@@ -7288,7 +7926,7 @@ void RasterizerStorageRD::global_variables_instance_free(RID p_instance) {
 	global_variables.instance_buffer_pos.erase(p_instance);
 }
 
-void RasterizerStorageRD::global_variables_instance_update(RID p_instance, int p_index, const Variant &p_value) {
+void RendererStorageRD::global_variables_instance_update(RID p_instance, int p_index, const Variant &p_value) {
 	if (!global_variables.instance_buffer_pos.has(p_instance)) {
 		return; //just not allocated, ignore
 	}
@@ -7331,7 +7969,7 @@ void RasterizerStorageRD::global_variables_instance_update(RID p_instance, int p
 	_global_variable_mark_buffer_dirty(pos, 1);
 }
 
-void RasterizerStorageRD::_update_global_variables() {
+void RendererStorageRD::_update_global_variables() {
 	if (global_variables.buffer_dirty_region_count > 0) {
 		uint32_t total_regions = global_variables.buffer_size / GlobalVariables::BUFFER_DIRTY_REGION_SIZE;
 		if (total_regions / global_variables.buffer_dirty_region_count <= 4) {
@@ -7381,7 +8019,7 @@ void RasterizerStorageRD::_update_global_variables() {
 	}
 }
 
-void RasterizerStorageRD::update_dirty_resources() {
+void RendererStorageRD::update_dirty_resources() {
 	_update_global_variables(); //must do before materials, so it can queue them for update
 	_update_queued_materials();
 	_update_dirty_multimeshes();
@@ -7389,7 +8027,7 @@ void RasterizerStorageRD::update_dirty_resources() {
 	_update_decal_atlas();
 }
 
-bool RasterizerStorageRD::has_os_feature(const String &p_feature) const {
+bool RendererStorageRD::has_os_feature(const String &p_feature) const {
 	if (p_feature == "rgtc" && RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_BC5_UNORM_BLOCK, RD::TEXTURE_USAGE_SAMPLING_BIT)) {
 		return true;
 	}
@@ -7413,7 +8051,7 @@ bool RasterizerStorageRD::has_os_feature(const String &p_feature) const {
 	return false;
 }
 
-bool RasterizerStorageRD::free(RID p_rid) {
+bool RendererStorageRD::free(RID p_rid) {
 	if (texture_owner.owns(p_rid)) {
 		Texture *t = texture_owner.getornull(p_rid);
 
@@ -7480,7 +8118,18 @@ bool RasterizerStorageRD::free(RID p_rid) {
 		mesh_clear(p_rid);
 		Mesh *mesh = mesh_owner.getornull(p_rid);
 		mesh->instance_dependency.instance_notify_deleted(p_rid);
+		if (mesh->instances.size()) {
+			ERR_PRINT("deleting mesh with active instances");
+		}
 		mesh_owner.free(p_rid);
+	} else if (mesh_instance_owner.owns(p_rid)) {
+		MeshInstance *mi = mesh_instance_owner.getornull(p_rid);
+		_mesh_instance_clear(mi);
+		mi->mesh->instances.erase(mi->I);
+		mi->I = nullptr;
+		mesh_instance_owner.free(p_rid);
+		memdelete(mi);
+
 	} else if (multimesh_owner.owns(p_rid)) {
 		_update_dirty_multimeshes();
 		multimesh_allocate(p_rid, 0, RS::MULTIMESH_TRANSFORM_2D);
@@ -7556,41 +8205,41 @@ bool RasterizerStorageRD::free(RID p_rid) {
 	return true;
 }
 
-RasterizerEffectsRD *RasterizerStorageRD::get_effects() {
+EffectsRD *RendererStorageRD::get_effects() {
 	return &effects;
 }
 
-void RasterizerStorageRD::capture_timestamps_begin() {
+void RendererStorageRD::capture_timestamps_begin() {
 	RD::get_singleton()->capture_timestamp("Frame Begin", false);
 }
 
-void RasterizerStorageRD::capture_timestamp(const String &p_name) {
+void RendererStorageRD::capture_timestamp(const String &p_name) {
 	RD::get_singleton()->capture_timestamp(p_name, true);
 }
 
-uint32_t RasterizerStorageRD::get_captured_timestamps_count() const {
+uint32_t RendererStorageRD::get_captured_timestamps_count() const {
 	return RD::get_singleton()->get_captured_timestamps_count();
 }
 
-uint64_t RasterizerStorageRD::get_captured_timestamps_frame() const {
+uint64_t RendererStorageRD::get_captured_timestamps_frame() const {
 	return RD::get_singleton()->get_captured_timestamps_frame();
 }
 
-uint64_t RasterizerStorageRD::get_captured_timestamp_gpu_time(uint32_t p_index) const {
+uint64_t RendererStorageRD::get_captured_timestamp_gpu_time(uint32_t p_index) const {
 	return RD::get_singleton()->get_captured_timestamp_gpu_time(p_index);
 }
 
-uint64_t RasterizerStorageRD::get_captured_timestamp_cpu_time(uint32_t p_index) const {
+uint64_t RendererStorageRD::get_captured_timestamp_cpu_time(uint32_t p_index) const {
 	return RD::get_singleton()->get_captured_timestamp_cpu_time(p_index);
 }
 
-String RasterizerStorageRD::get_captured_timestamp_name(uint32_t p_index) const {
+String RendererStorageRD::get_captured_timestamp_name(uint32_t p_index) const {
 	return RD::get_singleton()->get_captured_timestamp_name(p_index);
 }
 
-RasterizerStorageRD *RasterizerStorageRD::base_singleton = nullptr;
+RendererStorageRD *RendererStorageRD::base_singleton = nullptr;
 
-RasterizerStorageRD::RasterizerStorageRD() {
+RendererStorageRD::RendererStorageRD() {
 	base_singleton = this;
 
 	for (int i = 0; i < SHADER_TYPE_MAX; i++) {
@@ -7616,7 +8265,7 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		tformat.width = 4;
 		tformat.height = 4;
 		tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT;
-		tformat.type = RD::TEXTURE_TYPE_2D;
+		tformat.texture_type = RD::TEXTURE_TYPE_2D;
 
 		Vector<uint8_t> pv;
 		pv.resize(16 * 4);
@@ -7708,7 +8357,7 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		tformat.height = 4;
 		tformat.array_layers = 6;
 		tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT;
-		tformat.type = RD::TEXTURE_TYPE_CUBE_ARRAY;
+		tformat.texture_type = RD::TEXTURE_TYPE_CUBE_ARRAY;
 
 		Vector<uint8_t> pv;
 		pv.resize(16 * 4);
@@ -7736,7 +8385,7 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		tformat.height = 4;
 		tformat.array_layers = 6;
 		tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT;
-		tformat.type = RD::TEXTURE_TYPE_CUBE;
+		tformat.texture_type = RD::TEXTURE_TYPE_CUBE;
 
 		Vector<uint8_t> pv;
 		pv.resize(16 * 4);
@@ -7756,6 +8405,34 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		}
 	}
 
+	{ //create default cubemap white array
+
+		RD::TextureFormat tformat;
+		tformat.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
+		tformat.width = 4;
+		tformat.height = 4;
+		tformat.array_layers = 6;
+		tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT;
+		tformat.texture_type = RD::TEXTURE_TYPE_CUBE;
+
+		Vector<uint8_t> pv;
+		pv.resize(16 * 4);
+		for (int i = 0; i < 16; i++) {
+			pv.set(i * 4 + 0, 255);
+			pv.set(i * 4 + 1, 255);
+			pv.set(i * 4 + 2, 255);
+			pv.set(i * 4 + 3, 255);
+		}
+
+		{
+			Vector<Vector<uint8_t>> vpv;
+			for (int i = 0; i < 6; i++) {
+				vpv.push_back(pv);
+			}
+			default_rd_textures[DEFAULT_RD_TEXTURE_CUBEMAP_WHITE] = RD::get_singleton()->texture_create(tformat, RD::TextureView(), vpv);
+		}
+	}
+
 	{ //create default 3D
 
 		RD::TextureFormat tformat;
@@ -7764,7 +8441,7 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		tformat.height = 4;
 		tformat.depth = 4;
 		tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT;
-		tformat.type = RD::TEXTURE_TYPE_3D;
+		tformat.texture_type = RD::TEXTURE_TYPE_3D;
 
 		Vector<uint8_t> pv;
 		pv.resize(64 * 4);
@@ -7790,7 +8467,7 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		tformat.height = 4;
 		tformat.array_layers = 1;
 		tformat.usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_UPDATE_BIT;
-		tformat.type = RD::TEXTURE_TYPE_2D_ARRAY;
+		tformat.texture_type = RD::TEXTURE_TYPE_2D_ARRAY;
 
 		Vector<uint8_t> pv;
 		pv.resize(16 * 4);
@@ -7951,6 +8628,19 @@ RasterizerStorageRD::RasterizerStorageRD() {
 			mesh_default_rd_buffers[DEFAULT_RD_BUFFER_TEX_UV2] = RD::get_singleton()->vertex_buffer_create(buffer.size(), buffer);
 		}
 
+		for (int i = 0; i < RS::ARRAY_CUSTOM_COUNT; i++) {
+			buffer.resize(sizeof(float) * 4);
+			{
+				uint8_t *w = buffer.ptrw();
+				float *fptr = (float *)w;
+				fptr[0] = 0.0;
+				fptr[1] = 0.0;
+				fptr[2] = 0.0;
+				fptr[3] = 0.0;
+			}
+			mesh_default_rd_buffers[DEFAULT_RD_BUFFER_CUSTOM0 + i] = RD::get_singleton()->vertex_buffer_create(buffer.size(), buffer);
+		}
+
 		{ //bones
 			buffer.resize(sizeof(uint32_t) * 4);
 			{
@@ -8013,8 +8703,8 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		particles_modes.push_back("");
 		particles_shader.shader.initialize(particles_modes, String());
 	}
-	shader_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_PARTICLES, _create_particles_shader_funcs);
-	material_set_data_request_function(RasterizerStorageRD::SHADER_TYPE_PARTICLES, _create_particles_material_funcs);
+	shader_set_data_request_function(RendererStorageRD::SHADER_TYPE_PARTICLES, _create_particles_shader_funcs);
+	material_set_data_request_function(RendererStorageRD::SHADER_TYPE_PARTICLES, _create_particles_material_funcs);
 
 	{
 		ShaderCompilerRD::DefaultIdentifierActions actions;
@@ -8075,14 +8765,14 @@ RasterizerStorageRD::RasterizerStorageRD() {
 		particles_shader.default_material = material_create();
 		material_set_shader(particles_shader.default_material, particles_shader.default_shader);
 
-		ParticlesMaterialData *md = (ParticlesMaterialData *)material_get_data(particles_shader.default_material, RasterizerStorageRD::SHADER_TYPE_PARTICLES);
+		ParticlesMaterialData *md = (ParticlesMaterialData *)material_get_data(particles_shader.default_material, RendererStorageRD::SHADER_TYPE_PARTICLES);
 		particles_shader.default_shader_rd = particles_shader.shader.version_get_shader(md->shader_data->version, 0);
 
 		Vector<RD::Uniform> uniforms;
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_SAMPLER;
+			u.uniform_type = RD::UNIFORM_TYPE_SAMPLER;
 			u.binding = 1;
 			u.ids.resize(12);
 			RID *ids_ptr = u.ids.ptrw();
@@ -8103,7 +8793,7 @@ RasterizerStorageRD::RasterizerStorageRD() {
 
 		{
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 2;
 			u.ids.push_back(global_variables_get_storage_buffer());
 			uniforms.push_back(u);
@@ -8128,9 +8818,51 @@ RasterizerStorageRD::RasterizerStorageRD() {
 			particles_shader.copy_pipelines[i] = RD::get_singleton()->compute_pipeline_create(particles_shader.copy_shader.version_get_shader(particles_shader.copy_shader_version, i));
 		}
 	}
+
+	{
+		Vector<String> sdf_modes;
+		sdf_modes.push_back("\n#define MODE_LOAD\n");
+		sdf_modes.push_back("\n#define MODE_LOAD_SHRINK\n");
+		sdf_modes.push_back("\n#define MODE_PROCESS\n");
+		sdf_modes.push_back("\n#define MODE_PROCESS_OPTIMIZED\n");
+		sdf_modes.push_back("\n#define MODE_STORE\n");
+		sdf_modes.push_back("\n#define MODE_STORE_SHRINK\n");
+
+		rt_sdf.shader.initialize(sdf_modes);
+
+		rt_sdf.shader_version = rt_sdf.shader.version_create();
+
+		for (int i = 0; i < RenderTargetSDF::SHADER_MAX; i++) {
+			rt_sdf.pipelines[i] = RD::get_singleton()->compute_pipeline_create(rt_sdf.shader.version_get_shader(rt_sdf.shader_version, i));
+		}
+	}
+	{
+		Vector<String> skeleton_modes;
+		skeleton_modes.push_back("\n#define MODE_2D\n");
+		skeleton_modes.push_back("");
+
+		skeleton_shader.shader.initialize(skeleton_modes);
+		skeleton_shader.version = skeleton_shader.shader.version_create();
+		for (int i = 0; i < SkeletonShader::SHADER_MODE_MAX; i++) {
+			skeleton_shader.version_shader[i] = skeleton_shader.shader.version_get_shader(skeleton_shader.version, i);
+			skeleton_shader.pipeline[i] = RD::get_singleton()->compute_pipeline_create(skeleton_shader.version_shader[i]);
+		}
+
+		{
+			Vector<RD::Uniform> uniforms;
+			{
+				RD::Uniform u;
+				u.binding = 0;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.ids.push_back(default_rd_storage_buffer);
+				uniforms.push_back(u);
+			}
+			skeleton_shader.default_skeleton_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, skeleton_shader.version_shader[0], SkeletonShader::UNIFORM_SET_SKELETON);
+		}
+	}
 }
 
-RasterizerStorageRD::~RasterizerStorageRD() {
+RendererStorageRD::~RendererStorageRD() {
 	memdelete_arr(global_variables.buffer_values);
 	memdelete_arr(global_variables.buffer_usage);
 	memdelete_arr(global_variables.buffer_dirty_regions);
@@ -8155,6 +8887,9 @@ RasterizerStorageRD::~RasterizerStorageRD() {
 
 	giprobe_sdf_shader.version_free(giprobe_sdf_shader_version);
 	particles_shader.copy_shader.version_free(particles_shader.copy_shader_version);
+	rt_sdf.shader.version_free(rt_sdf.shader_version);
+
+	skeleton_shader.shader.version_free(skeleton_shader.version);
 
 	RenderingServer::get_singleton()->free(particles_shader.default_material);
 	RenderingServer::get_singleton()->free(particles_shader.default_shader);
diff --git a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h b/servers/rendering/renderer_rd/renderer_storage_rd.h
index 05cb1b4a73..e4199ffd12 100644
--- a/servers/rendering/rasterizer_rd/rasterizer_storage_rd.h
+++ b/servers/rendering/renderer_rd/renderer_storage_rd.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer_storage_rd.h                                              */
+/*  renderer_storage_rd.h                                                */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,19 +28,23 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RASTERIZER_STORAGE_RD_H
-#define RASTERIZER_STORAGE_RD_H
+#ifndef RENDERING_SERVER_STORAGE_RD_H
+#define RENDERING_SERVER_STORAGE_RD_H
 
+#include "core/templates/list.h"
+#include "core/templates/local_vector.h"
 #include "core/templates/rid_owner.h"
-#include "servers/rendering/rasterizer.h"
-#include "servers/rendering/rasterizer_rd/rasterizer_effects_rd.h"
-#include "servers/rendering/rasterizer_rd/shader_compiler_rd.h"
-#include "servers/rendering/rasterizer_rd/shaders/giprobe_sdf.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/particles.glsl.gen.h"
-#include "servers/rendering/rasterizer_rd/shaders/particles_copy.glsl.gen.h"
+#include "servers/rendering/renderer_compositor.h"
+#include "servers/rendering/renderer_rd/effects_rd.h"
+#include "servers/rendering/renderer_rd/shader_compiler_rd.h"
+#include "servers/rendering/renderer_rd/shaders/canvas_sdf.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/giprobe_sdf.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/particles.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/particles_copy.glsl.gen.h"
+#include "servers/rendering/renderer_rd/shaders/skeleton.glsl.gen.h"
+#include "servers/rendering/renderer_scene_render.h"
 #include "servers/rendering/rendering_device.h"
-
-class RasterizerStorageRD : public RasterizerStorage {
+class RendererStorageRD : public RendererStorage {
 public:
 	static _FORCE_INLINE_ void store_transform(const Transform &p_mtx, float *p_array) {
 		p_array[0] = p_mtx.basis.elements[0][0];
@@ -138,7 +142,7 @@ public:
 		virtual ~MaterialData();
 
 	private:
-		friend class RasterizerStorageRD;
+		friend class RendererStorageRD;
 		RID self;
 		List<RID>::Element *global_buffer_E = nullptr;
 		List<RID>::Element *global_texture_E = nullptr;
@@ -155,6 +159,7 @@ public:
 		DEFAULT_RD_TEXTURE_MULTIMESH_BUFFER,
 		DEFAULT_RD_TEXTURE_CUBEMAP_BLACK,
 		DEFAULT_RD_TEXTURE_CUBEMAP_ARRAY_BLACK,
+		DEFAULT_RD_TEXTURE_CUBEMAP_WHITE,
 		DEFAULT_RD_TEXTURE_3D_WHITE,
 		DEFAULT_RD_TEXTURE_2D_ARRAY_WHITE,
 		DEFAULT_RD_TEXTURE_2D_UINT,
@@ -168,6 +173,10 @@ public:
 		DEFAULT_RD_BUFFER_COLOR,
 		DEFAULT_RD_BUFFER_TEX_UV,
 		DEFAULT_RD_BUFFER_TEX_UV2,
+		DEFAULT_RD_BUFFER_CUSTOM0,
+		DEFAULT_RD_BUFFER_CUSTOM1,
+		DEFAULT_RD_BUFFER_CUSTOM2,
+		DEFAULT_RD_BUFFER_CUSTOM3,
 		DEFAULT_RD_BUFFER_BONES,
 		DEFAULT_RD_BUFFER_WEIGHTS,
 		DEFAULT_RD_BUFFER_MAX,
@@ -358,7 +367,7 @@ private:
 		Map<StringName, Variant> params;
 		int32_t priority;
 		RID next_pass;
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	MaterialDataRequestFunction material_data_request_func[SHADER_TYPE_MAX];
@@ -370,13 +379,19 @@ private:
 
 	/* Mesh */
 
+	struct MeshInstance;
+
 	struct Mesh {
 		struct Surface {
 			RS::PrimitiveType primitive = RS::PRIMITIVE_POINTS;
 			uint32_t format = 0;
 
 			RID vertex_buffer;
+			RID attribute_buffer;
+			RID skin_buffer;
 			uint32_t vertex_count = 0;
+			uint32_t vertex_buffer_size = 0;
+			uint32_t skin_buffer_size = 0;
 
 			// A different pipeline needs to be allocated
 			// depending on the inputs available in the
@@ -412,8 +427,7 @@ private:
 
 			Vector<AABB> bone_aabbs;
 
-			Vector<RID> blend_shapes;
-			RID blend_shape_base_buffer; //source buffer goes here when using blend shapes, and main one is uncompressed
+			RID blend_shape_buffer;
 
 			RID material;
 
@@ -425,6 +439,8 @@ private:
 
 			uint32_t particles_render_index = 0;
 			uint64_t particles_render_pass = 0;
+
+			RID uniform_set;
 		};
 
 		uint32_t blend_shape_count = 0;
@@ -435,17 +451,90 @@ private:
 
 		Vector<AABB> bone_aabbs;
 
+		bool has_bone_weights = false;
+
 		AABB aabb;
 		AABB custom_aabb;
 
 		Vector<RID> material_cache;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		List<MeshInstance *> instances;
+
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	mutable RID_Owner<Mesh> mesh_owner;
 
-	void _mesh_surface_generate_version_for_input_mask(Mesh::Surface *s, uint32_t p_input_mask);
+	struct MeshInstance {
+		Mesh *mesh;
+		RID skeleton;
+		struct Surface {
+			RID vertex_buffer;
+			RID uniform_set;
+
+			Mesh::Surface::Version *versions = nullptr; //allocated on demand
+			uint32_t version_count = 0;
+		};
+		LocalVector<Surface> surfaces;
+		LocalVector<float> blend_weights;
+
+		RID blend_weights_buffer;
+		List<MeshInstance *>::Element *I = nullptr; //used to erase itself
+		uint64_t skeleton_version = 0;
+		bool dirty = false;
+		bool weights_dirty = false;
+		SelfList<MeshInstance> weight_update_list;
+		SelfList<MeshInstance> array_update_list;
+		MeshInstance() :
+				weight_update_list(this), array_update_list(this) {}
+	};
+
+	void _mesh_instance_clear(MeshInstance *mi);
+	void _mesh_instance_add_surface(MeshInstance *mi, Mesh *mesh, uint32_t p_surface);
+
+	mutable RID_PtrOwner<MeshInstance> mesh_instance_owner;
+
+	SelfList<MeshInstance>::List dirty_mesh_instance_weights;
+	SelfList<MeshInstance>::List dirty_mesh_instance_arrays;
+
+	struct SkeletonShader {
+		struct PushConstant {
+			uint32_t has_normal;
+			uint32_t has_tangent;
+			uint32_t has_skeleton;
+			uint32_t has_blend_shape;
+
+			uint32_t vertex_count;
+			uint32_t vertex_stride;
+			uint32_t skin_stride;
+			uint32_t skin_weight_offset;
+
+			uint32_t blend_shape_count;
+			uint32_t normalized_blend_shapes;
+			uint32_t pad0;
+			uint32_t pad1;
+		};
+
+		enum {
+			UNIFORM_SET_INSTANCE = 0,
+			UNIFORM_SET_SURFACE = 1,
+			UNIFORM_SET_SKELETON = 2,
+		};
+		enum {
+			SHADER_MODE_2D,
+			SHADER_MODE_3D,
+			SHADER_MODE_MAX
+		};
+
+		SkeletonShaderRD shader;
+		RID version;
+		RID version_shader[SHADER_MODE_MAX];
+		RID pipeline[SHADER_MODE_MAX];
+
+		RID default_skeleton_uniform_set;
+	} skeleton_shader;
+
+	void _mesh_surface_generate_version_for_input_mask(Mesh::Surface::Version &v, Mesh::Surface *s, uint32_t p_input_mask, MeshInstance::Surface *mis = nullptr);
 
 	RID mesh_default_rd_buffers[DEFAULT_RD_BUFFER_MAX];
 
@@ -474,7 +563,7 @@ private:
 		bool dirty = false;
 		MultiMesh *dirty_list = nullptr;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	mutable RID_Owner<MultiMesh> multimesh_owner;
@@ -645,7 +734,7 @@ private:
 		ParticleEmissionBuffer *emission_buffer = nullptr;
 		RID emission_storage_buffer;
 
-		Set<RasterizerScene::InstanceBase *> collisions;
+		Set<RendererSceneRender::InstanceBase *> collisions;
 
 		Particles() :
 				inactive(true),
@@ -672,7 +761,7 @@ private:
 				clear(true) {
 		}
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 
 		ParticlesFrameParams frame_params;
 	};
@@ -727,7 +816,7 @@ private:
 		bool valid;
 		RID version;
 
-		//RenderPipelineVertexFormatCacheRD pipelines[SKY_VERSION_MAX];
+		//PipelineCacheRD pipelines[SKY_VERSION_MAX];
 		Map<StringName, ShaderLanguage::ShaderNode::Uniform> uniforms;
 		Vector<ShaderCompilerRD::GeneratedCode::Texture> texture_uniforms;
 
@@ -745,7 +834,7 @@ private:
 		virtual void set_code(const String &p_Code);
 		virtual void set_default_texture_param(const StringName &p_name, RID p_texture);
 		virtual void get_param_list(List<PropertyInfo> *p_param_list) const;
-		virtual void get_instance_param_list(List<RasterizerStorage::InstanceShaderParam> *p_param_list) const;
+		virtual void get_instance_param_list(List<RendererStorage::InstanceShaderParam> *p_param_list) const;
 		virtual bool is_param_texture(const StringName &p_param) const;
 		virtual bool is_animated() const;
 		virtual bool casts_shadows() const;
@@ -755,7 +844,7 @@ private:
 	};
 
 	ShaderData *_create_particles_shader_func();
-	static RasterizerStorageRD::ShaderData *_create_particles_shader_funcs() {
+	static RendererStorageRD::ShaderData *_create_particles_shader_funcs() {
 		return base_singleton->_create_particles_shader_func();
 	}
 
@@ -775,7 +864,7 @@ private:
 	};
 
 	MaterialData *_create_particles_material_func(ParticlesShaderData *p_shader);
-	static RasterizerStorageRD::MaterialData *_create_particles_material_funcs(ShaderData *p_shader) {
+	static RendererStorageRD::MaterialData *_create_particles_material_funcs(ShaderData *p_shader) {
 		return base_singleton->_create_particles_material_func(static_cast<ParticlesShaderData *>(p_shader));
 	}
 
@@ -800,7 +889,7 @@ private:
 
 		RS::ParticlesCollisionHeightfieldResolution heightfield_resolution = RS::PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_1024;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	mutable RID_Owner<ParticlesCollision> particles_collision_owner;
@@ -818,8 +907,11 @@ private:
 		Transform2D base_transform_2d;
 
 		RID uniform_set_3d;
+		RID uniform_set_mi;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		uint64_t version = 1;
+
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	mutable RID_Owner<Skeleton> skeleton_owner;
@@ -848,9 +940,10 @@ private:
 		RS::LightDirectionalShadowMode directional_shadow_mode = RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL;
 		RS::LightDirectionalShadowDepthRangeMode directional_range_mode = RS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE;
 		bool directional_blend_splits = false;
+		bool directional_sky_only = false;
 		uint64_t version = 0;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	mutable RID_Owner<Light> light_owner;
@@ -871,8 +964,9 @@ private:
 		bool box_projection = false;
 		bool enable_shadows = false;
 		uint32_t cull_mask = (1 << 20) - 1;
+		float lod_threshold = 0.01;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	mutable RID_Owner<ReflectionProbe> reflection_probe_owner;
@@ -893,7 +987,7 @@ private:
 		float distance_fade_length = 1;
 		float normal_fade = 0.0;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	mutable RID_Owner<Decal> decal_owner;
@@ -931,7 +1025,7 @@ private:
 		uint32_t version = 1;
 		uint32_t data_version = 1;
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	GiprobeSdfShaderRD giprobe_sdf_shader;
@@ -960,7 +1054,7 @@ private:
 			int32_t over = EMPTY_LEAF, under = EMPTY_LEAF;
 		};
 
-		RasterizerScene::InstanceDependency instance_dependency;
+		RendererStorage::InstanceDependency instance_dependency;
 	};
 
 	bool using_lightmap_array; //high end uses this
@@ -1002,6 +1096,15 @@ private:
 		RID framebuffer_uniform_set;
 		RID backbuffer_uniform_set;
 
+		RID sdf_buffer_write;
+		RID sdf_buffer_write_fb;
+		RID sdf_buffer_process[2];
+		RID sdf_buffer_read;
+		RID sdf_buffer_process_uniform_sets[2];
+		RS::ViewportSDFOversize sdf_oversize = RS::VIEWPORT_SDF_OVERSIZE_120_PERCENT;
+		RS::ViewportSDFScale sdf_scale = RS::VIEWPORT_SDF_SCALE_50_PERCENT;
+		Size2i process_size;
+
 		//texture generated for this owner (nor RD).
 		RID texture;
 		bool was_used;
@@ -1011,11 +1114,38 @@ private:
 		Color clear_color;
 	};
 
-	RID_Owner<RenderTarget> render_target_owner;
+	mutable RID_Owner<RenderTarget> render_target_owner;
 
 	void _clear_render_target(RenderTarget *rt);
 	void _update_render_target(RenderTarget *rt);
 	void _create_render_target_backbuffer(RenderTarget *rt);
+	void _render_target_allocate_sdf(RenderTarget *rt);
+	void _render_target_clear_sdf(RenderTarget *rt);
+	Rect2i _render_target_get_sdf_rect(const RenderTarget *rt) const;
+
+	struct RenderTargetSDF {
+		enum {
+			SHADER_LOAD,
+			SHADER_LOAD_SHRINK,
+			SHADER_PROCESS,
+			SHADER_PROCESS_OPTIMIZED,
+			SHADER_STORE,
+			SHADER_STORE_SHRINK,
+			SHADER_MAX
+		};
+
+		struct PushConstant {
+			int32_t size[2];
+			int32_t stride;
+			int32_t shift;
+			int32_t base_size[2];
+			int32_t pad[2];
+		};
+
+		CanvasSdfShaderRD shader;
+		RID shader_version;
+		RID pipelines[SHADER_MAX];
+	} rt_sdf;
 
 	/* GLOBAL SHADER VARIABLES */
 
@@ -1085,7 +1215,7 @@ private:
 	void _update_global_variables();
 	/* EFFECTS */
 
-	RasterizerEffectsRD effects;
+	EffectsRD effects;
 
 public:
 	/* TEXTURE API */
@@ -1217,7 +1347,7 @@ public:
 
 	void material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters);
 
-	void material_update_dependency(RID p_material, RasterizerScene::InstanceBase *p_instance);
+	void material_update_dependency(RID p_material, InstanceBaseDependency *p_instance);
 	void material_force_update_textures(RID p_material, ShaderType p_shader_type);
 
 	void material_set_data_request_function(ShaderType p_shader_type, MaterialDataRequestFunction p_function);
@@ -1235,6 +1365,8 @@ public:
 
 	virtual RID mesh_create();
 
+	virtual void mesh_set_blend_shape_count(RID p_mesh, int p_blend_shape_count);
+
 	/// Return stride
 	virtual void mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface);
 
@@ -1259,6 +1391,16 @@ public:
 
 	virtual void mesh_clear(RID p_mesh);
 
+	virtual bool mesh_needs_instance(RID p_mesh, bool p_has_skeleton);
+
+	/* MESH INSTANCE */
+
+	virtual RID mesh_instance_create(RID p_base);
+	virtual void mesh_instance_set_skeleton(RID p_mesh_instance, RID p_skeleton);
+	virtual void mesh_instance_set_blend_shape_weight(RID p_mesh_instance, int p_shape, float p_weight);
+	virtual void mesh_instance_check_for_update(RID p_mesh_instance);
+	virtual void update_mesh_instances();
+
 	_FORCE_INLINE_ const RID *mesh_get_surface_count_and_materials(RID p_mesh, uint32_t &r_surface_count) {
 		Mesh *mesh = mesh_owner.getornull(p_mesh);
 		ERR_FAIL_COND_V(!mesh, nullptr);
@@ -1276,22 +1418,50 @@ public:
 		return mesh->material_cache.ptr();
 	}
 
-	_FORCE_INLINE_ RS::PrimitiveType mesh_surface_get_primitive(RID p_mesh, uint32_t p_surface_index) {
+	_FORCE_INLINE_ void *mesh_get_surface(RID p_mesh, uint32_t p_surface_index) {
 		Mesh *mesh = mesh_owner.getornull(p_mesh);
-		ERR_FAIL_COND_V(!mesh, RS::PRIMITIVE_MAX);
-		ERR_FAIL_UNSIGNED_INDEX_V(p_surface_index, mesh->surface_count, RS::PRIMITIVE_MAX);
+		ERR_FAIL_COND_V(!mesh, nullptr);
+		ERR_FAIL_UNSIGNED_INDEX_V(p_surface_index, mesh->surface_count, nullptr);
 
-		return mesh->surfaces[p_surface_index]->primitive;
+		return mesh->surfaces[p_surface_index];
 	}
 
-	_FORCE_INLINE_ void mesh_surface_get_arrays_and_format(RID p_mesh, uint32_t p_surface_index, uint32_t p_input_mask, RID &r_vertex_array_rd, RID &r_index_array_rd, RD::VertexFormatID &r_vertex_format) {
-		Mesh *mesh = mesh_owner.getornull(p_mesh);
-		ERR_FAIL_COND(!mesh);
-		ERR_FAIL_UNSIGNED_INDEX(p_surface_index, mesh->surface_count);
+	_FORCE_INLINE_ RS::PrimitiveType mesh_surface_get_primitive(void *p_surface) {
+		Mesh::Surface *surface = reinterpret_cast<Mesh::Surface *>(p_surface);
+		return surface->primitive;
+	}
 
-		Mesh::Surface *s = mesh->surfaces[p_surface_index];
+	_FORCE_INLINE_ bool mesh_surface_has_lod(void *p_surface) const {
+		Mesh::Surface *s = reinterpret_cast<Mesh::Surface *>(p_surface);
+		return s->lod_count > 0;
+	}
+
+	_FORCE_INLINE_ RID mesh_surface_get_index_array(void *p_surface) const {
+		Mesh::Surface *s = reinterpret_cast<Mesh::Surface *>(p_surface);
+
+		return s->index_array;
+	}
 
-		r_index_array_rd = s->index_array;
+	_FORCE_INLINE_ RID mesh_surface_get_index_array_with_lod(void *p_surface, float p_model_scale, float p_distance_threshold, float p_lod_threshold) const {
+		Mesh::Surface *s = reinterpret_cast<Mesh::Surface *>(p_surface);
+
+		int32_t current_lod = -1;
+		for (uint32_t i = 0; i < s->lod_count; i++) {
+			float screen_size = s->lods[i].edge_length * p_model_scale / p_distance_threshold;
+			if (screen_size > p_lod_threshold) {
+				break;
+			}
+			current_lod = i;
+		}
+		if (current_lod == -1) {
+			return s->index_array;
+		} else {
+			return s->lods[current_lod].index_array;
+		}
+	}
+
+	_FORCE_INLINE_ void mesh_surface_get_vertex_arrays_and_format(void *p_surface, uint32_t p_input_mask, RID &r_vertex_array_rd, RD::VertexFormatID &r_vertex_format) {
+		Mesh::Surface *s = reinterpret_cast<Mesh::Surface *>(p_surface);
 
 		s->version_lock.lock();
 
@@ -1308,9 +1478,11 @@ public:
 			return;
 		}
 
-		uint32_t version = s->version_count; //gets added at the end
+		uint32_t version = s->version_count;
+		s->version_count++;
+		s->versions = (Mesh::Surface::Version *)memrealloc(s->versions, sizeof(Mesh::Surface::Version) * s->version_count);
 
-		_mesh_surface_generate_version_for_input_mask(s, p_input_mask);
+		_mesh_surface_generate_version_for_input_mask(s->versions[version], s, p_input_mask);
 
 		r_vertex_format = s->versions[version].vertex_format;
 		r_vertex_array_rd = s->versions[version].vertex_array;
@@ -1318,6 +1490,42 @@ public:
 		s->version_lock.unlock();
 	}
 
+	_FORCE_INLINE_ void mesh_instance_surface_get_vertex_arrays_and_format(RID p_mesh_instance, uint32_t p_surface_index, uint32_t p_input_mask, RID &r_vertex_array_rd, RD::VertexFormatID &r_vertex_format) {
+		MeshInstance *mi = mesh_instance_owner.getornull(p_mesh_instance);
+		ERR_FAIL_COND(!mi);
+		Mesh *mesh = mi->mesh;
+		ERR_FAIL_UNSIGNED_INDEX(p_surface_index, mesh->surface_count);
+
+		MeshInstance::Surface *mis = &mi->surfaces[p_surface_index];
+		Mesh::Surface *s = mesh->surfaces[p_surface_index];
+
+		s->version_lock.lock();
+
+		//there will never be more than, at much, 3 or 4 versions, so iterating is the fastest way
+
+		for (uint32_t i = 0; i < mis->version_count; i++) {
+			if (mis->versions[i].input_mask != p_input_mask) {
+				continue;
+			}
+			//we have this version, hooray
+			r_vertex_format = mis->versions[i].vertex_format;
+			r_vertex_array_rd = mis->versions[i].vertex_array;
+			s->version_lock.unlock();
+			return;
+		}
+
+		uint32_t version = mis->version_count;
+		mis->version_count++;
+		mis->versions = (Mesh::Surface::Version *)memrealloc(mis->versions, sizeof(Mesh::Surface::Version) * mis->version_count);
+
+		_mesh_surface_generate_version_for_input_mask(mis->versions[version], s, p_input_mask, mis);
+
+		r_vertex_format = mis->versions[version].vertex_format;
+		r_vertex_array_rd = mis->versions[version].vertex_array;
+
+		s->version_lock.unlock();
+	}
+
 	_FORCE_INLINE_ RID mesh_get_default_rd_buffer(DefaultRDBuffer p_buffer) {
 		ERR_FAIL_INDEX_V(p_buffer, DEFAULT_RD_BUFFER_MAX, RID());
 		return mesh_default_rd_buffers[p_buffer];
@@ -1418,7 +1626,7 @@ public:
 		if (!multimesh->uniform_set_3d.is_valid()) {
 			Vector<RD::Uniform> uniforms;
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(multimesh->buffer);
 			uniforms.push_back(u);
@@ -1466,7 +1674,7 @@ public:
 		if (!skeleton->uniform_set_3d.is_valid()) {
 			Vector<RD::Uniform> uniforms;
 			RD::Uniform u;
-			u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+			u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 			u.binding = 0;
 			u.ids.push_back(skeleton->buffer);
 			uniforms.push_back(u);
@@ -1499,6 +1707,8 @@ public:
 	void light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode);
 	void light_directional_set_blend_splits(RID p_light, bool p_enable);
 	bool light_directional_get_blend_splits(RID p_light) const;
+	void light_directional_set_sky_only(RID p_light, bool p_sky_only);
+	bool light_directional_is_sky_only(RID p_light) const;
 	void light_directional_set_shadow_depth_range_mode(RID p_light, RS::LightDirectionalShadowDepthRangeMode p_range_mode);
 	RS::LightDirectionalShadowDepthRangeMode light_directional_get_shadow_depth_range_mode(RID p_light) const;
 
@@ -1597,6 +1807,7 @@ public:
 	void reflection_probe_set_enable_shadows(RID p_probe, bool p_enable);
 	void reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers);
 	void reflection_probe_set_resolution(RID p_probe, int p_resolution);
+	void reflection_probe_set_lod_threshold(RID p_probe, float p_ratio);
 
 	AABB reflection_probe_get_aabb(RID p_probe) const;
 	RS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const;
@@ -1604,6 +1815,8 @@ public:
 	Vector3 reflection_probe_get_extents(RID p_probe) const;
 	Vector3 reflection_probe_get_origin_offset(RID p_probe) const;
 	float reflection_probe_get_origin_max_distance(RID p_probe) const;
+	float reflection_probe_get_lod_threshold(RID p_probe) const;
+
 	int reflection_probe_get_resolution(RID p_probe) const;
 	bool reflection_probe_renders_shadows(RID p_probe) const;
 
@@ -1614,8 +1827,8 @@ public:
 	Color reflection_probe_get_ambient_color(RID p_probe) const;
 	float reflection_probe_get_ambient_color_energy(RID p_probe) const;
 
-	void base_update_dependency(RID p_base, RasterizerScene::InstanceBase *p_instance);
-	void skeleton_update_dependency(RID p_skeleton, RasterizerScene::InstanceBase *p_instance);
+	void base_update_dependency(RID p_base, InstanceBaseDependency *p_instance);
+	void skeleton_update_dependency(RID p_skeleton, InstanceBaseDependency *p_instance);
 
 	/* DECAL API */
 
@@ -1853,7 +2066,7 @@ public:
 
 			{
 				RD::Uniform u;
-				u.type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
+				u.uniform_type = RD::UNIFORM_TYPE_STORAGE_BUFFER;
 				u.binding = 0;
 				u.ids.push_back(particles->particle_instance_buffer);
 				uniforms.push_back(u);
@@ -1865,8 +2078,8 @@ public:
 		return particles->particles_transforms_buffer_uniform_set;
 	}
 
-	virtual void particles_add_collision(RID p_particles, RasterizerScene::InstanceBase *p_instance);
-	virtual void particles_remove_collision(RID p_particles, RasterizerScene::InstanceBase *p_instance);
+	virtual void particles_add_collision(RID p_particles, InstanceBaseDependency *p_instance);
+	virtual void particles_remove_collision(RID p_particles, InstanceBaseDependency *p_instance);
 
 	/* PARTICLES COLLISION */
 
@@ -1929,6 +2142,12 @@ public:
 	virtual void render_target_disable_clear_request(RID p_render_target);
 	virtual void render_target_do_clear_request(RID p_render_target);
 
+	virtual void render_target_set_sdf_size_and_scale(RID p_render_target, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale);
+	RID render_target_get_sdf_texture(RID p_render_target);
+	RID render_target_get_sdf_framebuffer(RID p_render_target);
+	void render_target_sdf_process(RID p_render_target);
+	virtual Rect2i render_target_get_sdf_rect(RID p_render_target) const;
+
 	Size2 render_target_get_size(RID p_render_target);
 	RID render_target_get_rd_framebuffer(RID p_render_target);
 	RID render_target_get_rd_texture(RID p_render_target);
@@ -1969,12 +2188,12 @@ public:
 
 	RID get_default_rd_storage_buffer() { return default_rd_storage_buffer; }
 
-	static RasterizerStorageRD *base_singleton;
+	static RendererStorageRD *base_singleton;
 
-	RasterizerEffectsRD *get_effects();
+	EffectsRD *get_effects();
 
-	RasterizerStorageRD();
-	~RasterizerStorageRD();
+	RendererStorageRD();
+	~RendererStorageRD();
 };
 
 #endif // RASTERIZER_STORAGE_RD_H
diff --git a/servers/rendering/rasterizer_rd/shader_compiler_rd.cpp b/servers/rendering/renderer_rd/shader_compiler_rd.cpp
index 1a33e9a567..2c1d2a84fd 100644
--- a/servers/rendering/rasterizer_rd/shader_compiler_rd.cpp
+++ b/servers/rendering/renderer_rd/shader_compiler_rd.cpp
@@ -32,7 +32,7 @@
 
 #include "core/config/project_settings.h"
 #include "core/os/os.h"
-#include "rasterizer_storage_rd.h"
+#include "renderer_storage_rd.h"
 #include "servers/rendering_server.h"
 
 #define SL ShaderLanguage
@@ -671,7 +671,6 @@ String ShaderCompilerRD::_dump_node_code(const SL::Node *p_node, int p_level, Ge
 			}
 			/*
 			for(Map<StringName,SL::ShaderNode::Uniform>::Element *E=pnode->uniforms.front();E;E=E->next()) {
-
 				if (SL::is_sampler_type(E->get().type)) {
 					continue;
 				}
@@ -1073,6 +1072,11 @@ String ShaderCompilerRD::_dump_node_code(const SL::Node *p_node, int p_level, Ge
 					} else if (onode->op == SL::OP_CONSTRUCT) {
 						code += String(vnode->name);
 					} else {
+						if (p_actions.usage_flag_pointers.has(vnode->name) && !used_flag_pointers.has(vnode->name)) {
+							*p_actions.usage_flag_pointers[vnode->name] = true;
+							used_flag_pointers.insert(vnode->name);
+						}
+
 						if (internal_functions.has(vnode->name)) {
 							code += vnode->name;
 							is_texture_func = texture_functions.has(vnode->name);
@@ -1234,7 +1238,7 @@ String ShaderCompilerRD::_dump_node_code(const SL::Node *p_node, int p_level, Ge
 }
 
 ShaderLanguage::DataType ShaderCompilerRD::_get_variable_type(const StringName &p_type) {
-	RS::GlobalVariableType gvt = ((RasterizerStorageRD *)(RasterizerStorage::base_singleton))->global_variable_get_type_internal(p_type);
+	RS::GlobalVariableType gvt = ((RendererStorageRD *)(RendererStorage::base_singleton))->global_variable_get_type_internal(p_type);
 	return RS::global_variable_type_get_shader_datatype(gvt);
 }
 
diff --git a/servers/rendering/rasterizer_rd/shader_compiler_rd.h b/servers/rendering/renderer_rd/shader_compiler_rd.h
index 694f8fff91..694f8fff91 100644
--- a/servers/rendering/rasterizer_rd/shader_compiler_rd.h
+++ b/servers/rendering/renderer_rd/shader_compiler_rd.h
diff --git a/servers/rendering/rasterizer_rd/shader_rd.cpp b/servers/rendering/renderer_rd/shader_rd.cpp
index 865a1e1bbe..41126218ae 100644
--- a/servers/rendering/rasterizer_rd/shader_rd.cpp
+++ b/servers/rendering/renderer_rd/shader_rd.cpp
@@ -31,7 +31,7 @@
 #include "shader_rd.h"
 
 #include "core/string/string_builder.h"
-#include "rasterizer_rd.h"
+#include "renderer_compositor_rd.h"
 #include "servers/rendering/rendering_device.h"
 
 void ShaderRD::setup(const char *p_vertex_code, const char *p_fragment_code, const char *p_compute_code, const char *p_name) {
@@ -199,6 +199,10 @@ void ShaderRD::_clear_version(Version *p_version) {
 }
 
 void ShaderRD::_compile_variant(uint32_t p_variant, Version *p_version) {
+	if (!variants_enabled[p_variant]) {
+		return; //variant is disabled, return
+	}
+
 	Vector<RD::ShaderStageData> stages;
 
 	String error;
@@ -356,7 +360,7 @@ void ShaderRD::_compile_version(Version *p_version) {
 	p_version->variants = memnew_arr(RID, variant_defines.size());
 #if 1
 
-	RasterizerRD::thread_work_pool.do_work(variant_defines.size(), this, &ShaderRD::_compile_variant, p_version);
+	RendererCompositorRD::thread_work_pool.do_work(variant_defines.size(), this, &ShaderRD::_compile_variant, p_version);
 #else
 	for (int i = 0; i < variant_defines.size(); i++) {
 		_compile_variant(i, p_version);
@@ -365,6 +369,9 @@ void ShaderRD::_compile_version(Version *p_version) {
 
 	bool all_valid = true;
 	for (int i = 0; i < variant_defines.size(); i++) {
+		if (!variants_enabled[i]) {
+			continue; //disabled
+		}
 		if (p_version->variants[i].is_null()) {
 			all_valid = false;
 			break;
@@ -374,6 +381,9 @@ void ShaderRD::_compile_version(Version *p_version) {
 	if (!all_valid) {
 		//clear versions if they exist
 		for (int i = 0; i < variant_defines.size(); i++) {
+			if (!variants_enabled[i]) {
+				continue; //disabled
+			}
 			if (!p_version->variants[i].is_null()) {
 				RD::get_singleton()->free(p_version->variants[i]);
 			}
@@ -454,12 +464,26 @@ bool ShaderRD::version_free(RID p_version) {
 	return true;
 }
 
+void ShaderRD::set_variant_enabled(int p_variant, bool p_enabled) {
+	ERR_FAIL_COND(version_owner.get_rid_count() > 0); //versions exist
+	ERR_FAIL_INDEX(p_variant, variants_enabled.size());
+	variants_enabled.write[p_variant] = p_enabled;
+}
+
+bool ShaderRD::is_variant_enabled(int p_variant) const {
+	ERR_FAIL_INDEX_V(p_variant, variants_enabled.size(), false);
+	return variants_enabled[p_variant];
+}
+
 void ShaderRD::initialize(const Vector<String> &p_variant_defines, const String &p_general_defines) {
 	ERR_FAIL_COND(variant_defines.size());
 	ERR_FAIL_COND(p_variant_defines.size() == 0);
+
 	general_defines = p_general_defines.utf8();
+
 	for (int i = 0; i < p_variant_defines.size(); i++) {
 		variant_defines.push_back(p_variant_defines[i].utf8());
+		variants_enabled.push_back(true);
 	}
 }
 
diff --git a/servers/rendering/rasterizer_rd/shader_rd.h b/servers/rendering/renderer_rd/shader_rd.h
index 0c379db6f2..05e07d3cf3 100644
--- a/servers/rendering/rasterizer_rd/shader_rd.h
+++ b/servers/rendering/renderer_rd/shader_rd.h
@@ -46,6 +46,7 @@ class ShaderRD {
 	//versions
 	CharString general_defines;
 	Vector<CharString> variant_defines;
+	Vector<bool> variants_enabled;
 
 	struct Version {
 		CharString uniforms;
@@ -109,6 +110,7 @@ public:
 
 	_FORCE_INLINE_ RID version_get_shader(RID p_version, int p_variant) {
 		ERR_FAIL_INDEX_V(p_variant, variant_defines.size(), RID());
+		ERR_FAIL_COND_V(!variants_enabled[p_variant], RID());
 
 		Version *version = version_owner.getornull(p_version);
 		ERR_FAIL_COND_V(!version, RID());
@@ -128,6 +130,9 @@ public:
 
 	bool version_free(RID p_version);
 
+	void set_variant_enabled(int p_variant, bool p_enabled);
+	bool is_variant_enabled(int p_variant) const;
+
 	void initialize(const Vector<String> &p_variant_defines, const String &p_general_defines = "");
 	virtual ~ShaderRD();
 };
diff --git a/servers/rendering/rasterizer_rd/shaders/SCsub b/servers/rendering/renderer_rd/shaders/SCsub
index 9d531d63ad..cb62882deb 100644
--- a/servers/rendering/rasterizer_rd/shaders/SCsub
+++ b/servers/rendering/renderer_rd/shaders/SCsub
@@ -5,12 +5,13 @@ Import("env")
 if "RD_GLSL" in env["BUILDERS"]:
     env.RD_GLSL("canvas.glsl")
     env.RD_GLSL("canvas_occlusion.glsl")
+    env.RD_GLSL("canvas_sdf.glsl")
     env.RD_GLSL("copy.glsl")
     env.RD_GLSL("copy_to_fb.glsl")
     env.RD_GLSL("cubemap_roughness.glsl")
     env.RD_GLSL("cubemap_downsampler.glsl")
     env.RD_GLSL("cubemap_filter.glsl")
-    env.RD_GLSL("scene_high_end.glsl")
+    env.RD_GLSL("scene_forward.glsl")
     env.RD_GLSL("sky.glsl")
     env.RD_GLSL("tonemap.glsl")
     env.RD_GLSL("cube_to_dp.glsl")
@@ -40,3 +41,4 @@ if "RD_GLSL" in env["BUILDERS"]:
     env.RD_GLSL("particles.glsl")
     env.RD_GLSL("particles_copy.glsl")
     env.RD_GLSL("sort.glsl")
+    env.RD_GLSL("skeleton.glsl")
diff --git a/servers/rendering/rasterizer_rd/shaders/bokeh_dof.glsl b/servers/rendering/renderer_rd/shaders/bokeh_dof.glsl
index 63f086a83d..63f086a83d 100644
--- a/servers/rendering/rasterizer_rd/shaders/bokeh_dof.glsl
+++ b/servers/rendering/renderer_rd/shaders/bokeh_dof.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/canvas.glsl b/servers/rendering/renderer_rd/shaders/canvas.glsl
index 2a0f94e733..7808e7ed52 100644
--- a/servers/rendering/rasterizer_rd/shaders/canvas.glsl
+++ b/servers/rendering/renderer_rd/shaders/canvas.glsl
@@ -9,7 +9,8 @@ layout(location = 0) in vec2 vertex_attrib;
 layout(location = 3) in vec4 color_attrib;
 layout(location = 4) in vec2 uv_attrib;
 
-layout(location = 6) in uvec4 bones_attrib;
+layout(location = 10) in uvec4 bone_attrib;
+layout(location = 11) in vec4 weight_attrib;
 
 #endif
 
@@ -61,6 +62,7 @@ void main() {
 		color = vec4(unpackHalf2x16(draw_data.colors[4]), unpackHalf2x16(draw_data.colors[5]));
 	}
 	uvec4 bones = uvec4(0, 0, 0, 0);
+	vec4 bone_weights = vec4(0.0);
 
 #elif defined(USE_ATTRIBUTES)
 
@@ -68,7 +70,8 @@ void main() {
 	vec4 color = color_attrib;
 	vec2 uv = uv_attrib;
 
-	uvec4 bones = bones_attrib;
+	uvec4 bones = bone_attrib;
+	vec4 bone_weights = weight_attrib;
 #else
 
 	vec2 vertex_base_arr[4] = vec2[](vec2(0.0, 0.0), vec2(0.0, 1.0), vec2(1.0, 1.0), vec2(1.0, 0.0));
@@ -233,6 +236,30 @@ MATERIAL_UNIFORMS
 } material;
 #endif
 
+vec2 screen_uv_to_sdf(vec2 p_uv) {
+	return canvas_data.screen_to_sdf * p_uv;
+}
+
+float texture_sdf(vec2 p_sdf) {
+	vec2 uv = p_sdf * canvas_data.sdf_to_tex.xy + canvas_data.sdf_to_tex.zw;
+	float d = texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv).r;
+	d = d * SDF_MAX_LENGTH - 1.0;
+	return d * canvas_data.tex_to_sdf;
+}
+
+vec2 texture_sdf_normal(vec2 p_sdf) {
+	vec2 uv = p_sdf * canvas_data.sdf_to_tex.xy + canvas_data.sdf_to_tex.zw;
+
+	const float EPSILON = 0.001;
+	return normalize(vec2(
+			texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv + vec2(EPSILON, 0.0)).r - texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv - vec2(EPSILON, 0.0)).r,
+			texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv + vec2(0.0, EPSILON)).r - texture(sampler2D(sdf_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), uv - vec2(0.0, EPSILON)).r));
+}
+
+vec2 sdf_to_screen_uv(vec2 p_sdf) {
+	return p_sdf * canvas_data.sdf_to_screen;
+}
+
 /* clang-format off */
 FRAGMENT_SHADER_GLOBALS
 /* clang-format on */
@@ -500,8 +527,13 @@ FRAGMENT_SHADER_CODE
 		color = vec4(0.0); //invisible by default due to using light mask
 	}
 
+#ifdef MODE_LIGHT_ONLY
+	color = vec4(0.0);
+#else
 	color *= canvas_data.canvas_modulation;
-#ifdef USE_LIGHTING
+#endif
+
+#if defined(USE_LIGHTING) && !defined(MODE_UNSHADED)
 
 	// Directional Lights
 
diff --git a/servers/rendering/rasterizer_rd/shaders/canvas_occlusion.glsl b/servers/rendering/renderer_rd/shaders/canvas_occlusion.glsl
index 421282cd4d..5c25235c58 100644
--- a/servers/rendering/rasterizer_rd/shaders/canvas_occlusion.glsl
+++ b/servers/rendering/renderer_rd/shaders/canvas_occlusion.glsl
@@ -2,6 +2,8 @@
 
 #version 450
 
+VERSION_DEFINES
+
 layout(location = 0) in highp vec3 vertex;
 
 layout(push_constant, binding = 0, std430) uniform Constants {
@@ -13,12 +15,16 @@ layout(push_constant, binding = 0, std430) uniform Constants {
 }
 constants;
 
+#ifdef MODE_SHADOW
 layout(location = 0) out highp float depth;
+#endif
 
 void main() {
 	highp vec4 vtx = vec4(vertex, 1.0) * mat4(constants.modelview[0], constants.modelview[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0));
-	depth = dot(constants.direction, vtx.xy);
 
+#ifdef MODE_SHADOW
+	depth = dot(constants.direction, vtx.xy);
+#endif
 	gl_Position = constants.projection * vtx;
 }
 
@@ -26,6 +32,8 @@ void main() {
 
 #version 450
 
+VERSION_DEFINES
+
 layout(push_constant, binding = 0, std430) uniform Constants {
 	mat4 projection;
 	mat2x4 modelview;
@@ -35,9 +43,17 @@ layout(push_constant, binding = 0, std430) uniform Constants {
 }
 constants;
 
+#ifdef MODE_SHADOW
 layout(location = 0) in highp float depth;
 layout(location = 0) out highp float distance_buf;
+#else
+layout(location = 0) out highp float sdf_buf;
+#endif
 
 void main() {
+#ifdef MODE_SHADOW
 	distance_buf = depth / constants.z_far;
+#else
+	sdf_buf = 1.0;
+#endif
 }
diff --git a/servers/rendering/renderer_rd/shaders/canvas_sdf.glsl b/servers/rendering/renderer_rd/shaders/canvas_sdf.glsl
new file mode 100644
index 0000000000..302ad03b41
--- /dev/null
+++ b/servers/rendering/renderer_rd/shaders/canvas_sdf.glsl
@@ -0,0 +1,135 @@
+#[compute]
+
+#version 450
+
+VERSION_DEFINES
+
+layout(local_size_x = 8, local_size_y = 8, local_size_z = 1) in;
+
+layout(r8, set = 0, binding = 1) uniform restrict readonly image2D src_pixels;
+layout(r16, set = 0, binding = 2) uniform restrict writeonly image2D dst_sdf;
+
+layout(rg16i, set = 0, binding = 3) uniform restrict readonly iimage2D src_process;
+layout(rg16i, set = 0, binding = 4) uniform restrict writeonly iimage2D dst_process;
+
+layout(push_constant, binding = 0, std430) uniform Params {
+	ivec2 size;
+	int stride;
+	int shift;
+	ivec2 base_size;
+	uvec2 pad;
+}
+params;
+
+#define SDF_MAX_LENGTH 16384.0
+
+void main() {
+	ivec2 pos = ivec2(gl_GlobalInvocationID.xy);
+	if (any(greaterThanEqual(pos, params.size))) { //too large, do nothing
+		return;
+	}
+
+#ifdef MODE_LOAD
+
+	bool solid = imageLoad(src_pixels, pos).r > 0.5;
+	imageStore(dst_process, pos, solid ? ivec4(pos, 0, 0) : ivec4(ivec2(32767), 0, 0));
+#endif
+
+#ifdef MODE_LOAD_SHRINK
+
+	int s = 1 << params.shift;
+	ivec2 base = pos << params.shift;
+	ivec2 center = base + ivec2(params.shift);
+
+	ivec2 rel = ivec2(32767);
+	float d = 1e20;
+	for (int i = 0; i < s; i++) {
+		for (int j = 0; j < s; j++) {
+			ivec2 src_pos = base + ivec2(i, j);
+			if (any(greaterThanEqual(src_pos, params.base_size))) {
+				continue;
+			}
+			bool solid = imageLoad(src_pixels, src_pos).r > 0.5;
+			if (solid) {
+				float dist = length(vec2(src_pos - center));
+				if (dist < d) {
+					d = dist;
+					rel = src_pos;
+				}
+			}
+		}
+	}
+
+	imageStore(dst_process, pos, ivec4(rel, 0, 0));
+#endif
+
+#ifdef MODE_PROCESS
+
+	ivec2 base = pos << params.shift;
+	ivec2 center = base + ivec2(params.shift);
+
+	ivec2 rel = imageLoad(src_process, pos).xy;
+
+	if (center != rel) {
+		//only process if it does not point to itself
+		const int ofs_table_size = 8;
+		const ivec2 ofs_table[ofs_table_size] = ivec2[](
+				ivec2(-1, -1),
+				ivec2(0, -1),
+				ivec2(+1, -1),
+
+				ivec2(-1, 0),
+				ivec2(+1, 0),
+
+				ivec2(-1, +1),
+				ivec2(0, +1),
+				ivec2(+1, +1));
+
+		float dist = length(vec2(rel - center));
+		for (int i = 0; i < ofs_table_size; i++) {
+			ivec2 src_pos = pos + ofs_table[i] * params.stride;
+			if (any(lessThan(src_pos, ivec2(0))) || any(greaterThanEqual(src_pos, params.size))) {
+				continue;
+			}
+			ivec2 src_rel = imageLoad(src_process, src_pos).xy;
+			float src_dist = length(vec2(src_rel - center));
+			if (src_dist < dist) {
+				dist = src_dist;
+				rel = src_rel;
+			}
+		}
+	}
+
+	imageStore(dst_process, pos, ivec4(rel, 0, 0));
+#endif
+
+#ifdef MODE_STORE
+
+	ivec2 rel = imageLoad(src_process, pos).xy;
+	float d = length(vec2(rel - pos));
+	if (d > 0.01) {
+		d += 1.0; //make it signed
+	}
+	d /= SDF_MAX_LENGTH;
+	d = clamp(d, 0.0, 1.0);
+	imageStore(dst_sdf, pos, vec4(d));
+
+#endif
+
+#ifdef MODE_STORE_SHRINK
+
+	ivec2 base = pos << params.shift;
+	ivec2 center = base + ivec2(params.shift);
+
+	ivec2 rel = imageLoad(src_process, pos).xy;
+	float d = length(vec2(rel - center));
+
+	if (d > 0.01) {
+		d += 1.0; //make it signed
+	}
+	d /= SDF_MAX_LENGTH;
+	d = clamp(d, 0.0, 1.0);
+	imageStore(dst_sdf, pos, vec4(d));
+
+#endif
+}
diff --git a/servers/rendering/rasterizer_rd/shaders/canvas_uniforms_inc.glsl b/servers/rendering/renderer_rd/shaders/canvas_uniforms_inc.glsl
index bb39584cbb..cf7678ea31 100644
--- a/servers/rendering/rasterizer_rd/shaders/canvas_uniforms_inc.glsl
+++ b/servers/rendering/renderer_rd/shaders/canvas_uniforms_inc.glsl
@@ -3,6 +3,8 @@
 
 #define M_PI 3.14159265359
 
+#define SDF_MAX_LENGTH 16384.0
+
 #define FLAGS_INSTANCING_STRIDE_MASK 0xF
 #define FLAGS_INSTANCING_ENABLED (1 << 4)
 #define FLAGS_INSTANCING_HAS_COLORS (1 << 5)
@@ -24,6 +26,19 @@
 #define FLAGS_DEFAULT_NORMAL_MAP_USED (1 << 26)
 #define FLAGS_DEFAULT_SPECULAR_MAP_USED (1 << 27)
 
+#define SAMPLER_NEAREST_CLAMP 0
+#define SAMPLER_LINEAR_CLAMP 1
+#define SAMPLER_NEAREST_WITH_MIPMAPS_CLAMP 2
+#define SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP 3
+#define SAMPLER_NEAREST_WITH_MIPMAPS_ANISOTROPIC_CLAMP 4
+#define SAMPLER_LINEAR_WITH_MIPMAPS_ANISOTROPIC_CLAMP 5
+#define SAMPLER_NEAREST_REPEAT 6
+#define SAMPLER_LINEAR_REPEAT 7
+#define SAMPLER_NEAREST_WITH_MIPMAPS_REPEAT 8
+#define SAMPLER_LINEAR_WITH_MIPMAPS_REPEAT 9
+#define SAMPLER_NEAREST_WITH_MIPMAPS_ANISOTROPIC_REPEAT 10
+#define SAMPLER_LINEAR_WITH_MIPMAPS_ANISOTROPIC_REPEAT 11
+
 // Push Constant
 
 layout(push_constant, binding = 0, std430) uniform DrawData {
@@ -68,8 +83,12 @@ layout(set = 0, binding = 1, std140) uniform CanvasData {
 	float time;
 	bool use_pixel_snap;
 
+	vec4 sdf_to_tex;
+	vec2 screen_to_sdf;
+	vec2 sdf_to_screen;
+
 	uint directional_light_count;
-	uint pad0;
+	float tex_to_sdf;
 	uint pad1;
 	uint pad2;
 }
@@ -115,10 +134,11 @@ layout(set = 0, binding = 4) uniform texture2D shadow_atlas_texture;
 layout(set = 0, binding = 5) uniform sampler shadow_sampler;
 
 layout(set = 0, binding = 6) uniform texture2D screen_texture;
+layout(set = 0, binding = 7) uniform texture2D sdf_texture;
 
-layout(set = 0, binding = 7) uniform sampler material_samplers[12];
+layout(set = 0, binding = 8) uniform sampler material_samplers[12];
 
-layout(set = 0, binding = 8, std430) restrict readonly buffer GlobalVariableData {
+layout(set = 0, binding = 9, std430) restrict readonly buffer GlobalVariableData {
 	vec4 data[];
 }
 global_variables;
diff --git a/servers/rendering/rasterizer_rd/shaders/cluster_data_inc.glsl b/servers/rendering/renderer_rd/shaders/cluster_data_inc.glsl
index e723468dd8..e723468dd8 100644
--- a/servers/rendering/rasterizer_rd/shaders/cluster_data_inc.glsl
+++ b/servers/rendering/renderer_rd/shaders/cluster_data_inc.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/copy.glsl b/servers/rendering/renderer_rd/shaders/copy.glsl
index cdd35dfb3f..cdd35dfb3f 100644
--- a/servers/rendering/rasterizer_rd/shaders/copy.glsl
+++ b/servers/rendering/renderer_rd/shaders/copy.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/copy_to_fb.glsl b/servers/rendering/renderer_rd/shaders/copy_to_fb.glsl
index 9751e13b4e..9751e13b4e 100644
--- a/servers/rendering/rasterizer_rd/shaders/copy_to_fb.glsl
+++ b/servers/rendering/renderer_rd/shaders/copy_to_fb.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/cube_to_dp.glsl b/servers/rendering/renderer_rd/shaders/cube_to_dp.glsl
index 54d67db6c6..54d67db6c6 100644
--- a/servers/rendering/rasterizer_rd/shaders/cube_to_dp.glsl
+++ b/servers/rendering/renderer_rd/shaders/cube_to_dp.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/cubemap_downsampler.glsl b/servers/rendering/renderer_rd/shaders/cubemap_downsampler.glsl
index 7f269b7af3..7f269b7af3 100644
--- a/servers/rendering/rasterizer_rd/shaders/cubemap_downsampler.glsl
+++ b/servers/rendering/renderer_rd/shaders/cubemap_downsampler.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/cubemap_filter.glsl b/servers/rendering/renderer_rd/shaders/cubemap_filter.glsl
index 987545fb76..987545fb76 100644
--- a/servers/rendering/rasterizer_rd/shaders/cubemap_filter.glsl
+++ b/servers/rendering/renderer_rd/shaders/cubemap_filter.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/cubemap_roughness.glsl b/servers/rendering/renderer_rd/shaders/cubemap_roughness.glsl
index 5cbb00baa4..5cbb00baa4 100644
--- a/servers/rendering/rasterizer_rd/shaders/cubemap_roughness.glsl
+++ b/servers/rendering/renderer_rd/shaders/cubemap_roughness.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/gi.glsl b/servers/rendering/renderer_rd/shaders/gi.glsl
index 8011dadc72..8011dadc72 100644
--- a/servers/rendering/rasterizer_rd/shaders/gi.glsl
+++ b/servers/rendering/renderer_rd/shaders/gi.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/giprobe.glsl b/servers/rendering/renderer_rd/shaders/giprobe.glsl
index ea4237a45e..ea4237a45e 100644
--- a/servers/rendering/rasterizer_rd/shaders/giprobe.glsl
+++ b/servers/rendering/renderer_rd/shaders/giprobe.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl b/servers/rendering/renderer_rd/shaders/giprobe_debug.glsl
index 515cc35507..515cc35507 100644
--- a/servers/rendering/rasterizer_rd/shaders/giprobe_debug.glsl
+++ b/servers/rendering/renderer_rd/shaders/giprobe_debug.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/giprobe_sdf.glsl b/servers/rendering/renderer_rd/shaders/giprobe_sdf.glsl
index 5b3dec0ee7..5b3dec0ee7 100644
--- a/servers/rendering/rasterizer_rd/shaders/giprobe_sdf.glsl
+++ b/servers/rendering/renderer_rd/shaders/giprobe_sdf.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/giprobe_write.glsl b/servers/rendering/renderer_rd/shaders/giprobe_write.glsl
index 9c794f1bcc..9c794f1bcc 100644
--- a/servers/rendering/rasterizer_rd/shaders/giprobe_write.glsl
+++ b/servers/rendering/renderer_rd/shaders/giprobe_write.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/luminance_reduce.glsl b/servers/rendering/renderer_rd/shaders/luminance_reduce.glsl
index 8a11c35b78..8a11c35b78 100644
--- a/servers/rendering/rasterizer_rd/shaders/luminance_reduce.glsl
+++ b/servers/rendering/renderer_rd/shaders/luminance_reduce.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/particles.glsl b/servers/rendering/renderer_rd/shaders/particles.glsl
index 926c7ef9fc..926c7ef9fc 100644
--- a/servers/rendering/rasterizer_rd/shaders/particles.glsl
+++ b/servers/rendering/renderer_rd/shaders/particles.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/particles_copy.glsl b/servers/rendering/renderer_rd/shaders/particles_copy.glsl
index 6c782b6045..6c782b6045 100644
--- a/servers/rendering/rasterizer_rd/shaders/particles_copy.glsl
+++ b/servers/rendering/renderer_rd/shaders/particles_copy.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/resolve.glsl b/servers/rendering/renderer_rd/shaders/resolve.glsl
index 9429a66dc9..9429a66dc9 100644
--- a/servers/rendering/rasterizer_rd/shaders/resolve.glsl
+++ b/servers/rendering/renderer_rd/shaders/resolve.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/roughness_limiter.glsl b/servers/rendering/renderer_rd/shaders/roughness_limiter.glsl
index 464895928a..464895928a 100644
--- a/servers/rendering/rasterizer_rd/shaders/roughness_limiter.glsl
+++ b/servers/rendering/renderer_rd/shaders/roughness_limiter.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl b/servers/rendering/renderer_rd/shaders/scene_forward.glsl
index da3c60af04..a7fe86b029 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end.glsl
+++ b/servers/rendering/renderer_rd/shaders/scene_forward.glsl
@@ -4,12 +4,18 @@
 
 VERSION_DEFINES
 
-#include "scene_high_end_inc.glsl"
+#include "scene_forward_inc.glsl"
 
 /* INPUT ATTRIBS */
 
 layout(location = 0) in vec3 vertex_attrib;
+
+//only for pure render depth when normal is not used
+
+#ifdef NORMAL_USED
 layout(location = 1) in vec3 normal_attrib;
+#endif
+
 #if defined(TANGENT_USED) || defined(NORMALMAP_USED) || defined(LIGHT_ANISOTROPY_USED)
 layout(location = 2) in vec4 tangent_attrib;
 #endif
@@ -18,24 +24,53 @@ layout(location = 2) in vec4 tangent_attrib;
 layout(location = 3) in vec4 color_attrib;
 #endif
 
+#ifdef UV_USED
 layout(location = 4) in vec2 uv_attrib;
+#endif
 
 #if defined(UV2_USED) || defined(USE_LIGHTMAP) || defined(MODE_RENDER_MATERIAL)
 layout(location = 5) in vec2 uv2_attrib;
 #endif
 
-layout(location = 6) in uvec4 bone_attrib; // always bound, even if unused
+#if defined(CUSTOM0_USED)
+layout(location = 6) in vec4 custom0_attrib;
+#endif
+
+#if defined(CUSTOM1_USED)
+layout(location = 7) in vec4 custom1_attrib;
+#endif
+
+#if defined(CUSTOM2_USED)
+layout(location = 8) in vec4 custom2_attrib;
+#endif
+
+#if defined(CUSTOM3_USED)
+layout(location = 9) in vec4 custom3_attrib;
+#endif
+
+#if defined(BONES_USED)
+layout(location = 10) in uvec4 bone_attrib;
+#endif
+
+#if defined(WEIGHTS_USED)
+layout(location = 11) in vec4 weight_attrib;
+#endif
 
 /* Varyings */
 
 layout(location = 0) out vec3 vertex_interp;
+
+#ifdef NORMAL_USED
 layout(location = 1) out vec3 normal_interp;
+#endif
 
 #if defined(COLOR_USED)
 layout(location = 2) out vec4 color_interp;
 #endif
 
+#ifdef UV_USED
 layout(location = 3) out vec2 uv_interp;
+#endif
 
 #if defined(UV2_USED) || defined(USE_LIGHTMAP)
 layout(location = 4) out vec2 uv2_interp;
@@ -116,14 +151,17 @@ void main() {
 	}
 
 	vec3 vertex = vertex_attrib;
-	vec3 normal = normal_attrib;
+#ifdef NORMAL_USED
+	vec3 normal = normal_attrib * 2.0 - 1.0;
+#endif
 
 #if defined(TANGENT_USED) || defined(NORMALMAP_USED) || defined(LIGHT_ANISOTROPY_USED)
-	vec3 tangent = tangent_attrib.xyz;
-	float binormalf = tangent_attrib.a;
+	vec3 tangent = tangent_attrib.xyz * 2.0 - 1.0;
+	float binormalf = tangent_attrib.a * 2.0 - 1.0;
 	vec3 binormal = normalize(cross(normal, tangent) * binormalf);
 #endif
 
+#if 0
 	if (bool(instances.data[instance_index].flags & INSTANCE_FLAGS_SKELETON)) {
 		//multimesh, instances are for it
 
@@ -147,8 +185,11 @@ void main() {
 		binormal = (vec4(binormal, 0.0) * m).xyz;
 #endif
 	}
+#endif
 
+#ifdef UV_USED
 	uv_interp = uv_attrib;
+#endif
 
 #if defined(UV2_USED) || defined(USE_LIGHTMAP)
 	uv2_interp = uv2_attrib;
@@ -192,9 +233,12 @@ VERTEX_SHADER_CODE
 #if !defined(SKIP_TRANSFORM_USED) && !defined(VERTEX_WORLD_COORDS_USED)
 
 	vertex = (modelview * vec4(vertex, 1.0)).xyz;
+#ifdef NORMAL_USED
 	normal = modelview_normal * normal;
 #endif
 
+#endif
+
 #if defined(TANGENT_USED) || defined(NORMALMAP_USED) || defined(LIGHT_ANISOTROPY_USED)
 
 	binormal = modelview_normal * binormal;
@@ -215,7 +259,9 @@ VERTEX_SHADER_CODE
 #endif
 
 	vertex_interp = vertex;
+#ifdef NORMAL_USED
 	normal_interp = normal;
+#endif
 
 #if defined(TANGENT_USED) || defined(NORMALMAP_USED) || defined(LIGHT_ANISOTROPY_USED)
 	tangent_interp = tangent;
@@ -227,7 +273,6 @@ VERTEX_SHADER_CODE
 #ifdef MODE_DUAL_PARABOLOID
 
 	vertex_interp.z *= scene_data.dual_paraboloid_side;
-	normal_interp.z *= scene_data.dual_paraboloid_side;
 
 	dp_clip = vertex_interp.z; //this attempts to avoid noise caused by objects sent to the other parabolloid side due to bias
 
@@ -273,18 +318,23 @@ VERTEX_SHADER_CODE
 
 VERSION_DEFINES
 
-#include "scene_high_end_inc.glsl"
+#include "scene_forward_inc.glsl"
 
 /* Varyings */
 
 layout(location = 0) in vec3 vertex_interp;
+
+#ifdef NORMAL_USED
 layout(location = 1) in vec3 normal_interp;
+#endif
 
 #if defined(COLOR_USED)
 layout(location = 2) in vec4 color_interp;
 #endif
 
+#ifdef UV_USED
 layout(location = 3) in vec2 uv_interp;
+#endif
 
 #if defined(UV2_USED) || defined(USE_LIGHTMAP)
 layout(location = 4) in vec2 uv2_interp;
@@ -868,7 +918,6 @@ void light_process_omni(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 v
 		inout float alpha,
 #endif
 		inout vec3 diffuse_light, inout vec3 specular_light) {
-
 	vec3 light_rel_vec = lights.data[idx].position - vertex;
 	float light_length = length(light_rel_vec);
 	float normalized_distance = light_length * lights.data[idx].inv_radius;
@@ -1158,7 +1207,6 @@ void light_process_spot(uint idx, vec3 vertex, vec3 eye_vec, vec3 normal, vec3 v
 #endif
 		inout vec3 diffuse_light,
 		inout vec3 specular_light) {
-
 	vec3 light_rel_vec = lights.data[idx].position - vertex;
 	float light_length = length(light_rel_vec);
 	float normalized_distance = light_length * lights.data[idx].inv_radius;
@@ -1527,8 +1575,6 @@ void gi_probe_compute(uint index, vec3 position, vec3 normal, vec3 ref_vec, mat3
 	out_spec += vec4(irr_light.rgb * blend, blend);
 }
 
-#endif //USE_FORWARD_GI
-
 vec2 octahedron_wrap(vec2 v) {
 	vec2 signVal;
 	signVal.x = v.x >= 0.0 ? 1.0 : -1.0;
@@ -1662,10 +1708,14 @@ void sdfgi_process(uint cascade, vec3 cascade_pos, vec3 cam_pos, vec3 cam_normal
 	}
 }
 
+#endif //USE_FORWARD_GI
+
 #endif //!defined(MODE_RENDER_DEPTH) && !defined(MODE_UNSHADED)
 
 #ifndef MODE_RENDER_DEPTH
 
+#ifndef LOW_END_MODE
+
 vec4 volumetric_fog_process(vec2 screen_uv, float z) {
 	vec3 fog_pos = vec3(screen_uv, z * scene_data.volumetric_fog_inv_length);
 	if (fog_pos.z < 0.0) {
@@ -1676,6 +1726,7 @@ vec4 volumetric_fog_process(vec2 screen_uv, float z) {
 
 	return texture(sampler3D(volumetric_fog_texture, material_samplers[SAMPLER_LINEAR_CLAMP]), fog_pos);
 }
+#endif
 
 vec4 fog_process(vec3 vertex) {
 	vec3 fog_color = scene_data.fog_light_color;
@@ -1775,6 +1826,8 @@ void main() {
 	vec3 binormal = vec3(0.0);
 	vec3 tangent = vec3(0.0);
 #endif
+
+#ifdef NORMAL_USED
 	vec3 normal = normalize(normal_interp);
 
 #if defined(DO_SIDE_CHECK)
@@ -1783,7 +1836,11 @@ void main() {
 	}
 #endif
 
+#endif //NORMAL_USED
+
+#ifdef UV_USED
 	vec2 uv = uv_interp;
+#endif
 
 #if defined(UV2_USED) || defined(USE_LIGHTMAP)
 	vec2 uv2 = uv2_interp;
@@ -1970,6 +2027,7 @@ FRAGMENT_SHADER_CODE
 #endif //not render depth
 	/////////////////////// LIGHTING //////////////////////////////
 
+#ifdef NORMAL_USED
 	if (scene_data.roughness_limiter_enabled) {
 		//http://www.jp.square-enix.com/tech/library/pdf/ImprovedGeometricSpecularAA.pdf
 		float roughness2 = roughness * roughness;
@@ -1979,6 +2037,7 @@ FRAGMENT_SHADER_CODE
 		float filteredRoughness2 = min(1.0, roughness2 + kernelRoughness2);
 		roughness = sqrt(filteredRoughness2);
 	}
+#endif
 	//apply energy conservation
 
 	vec3 specular_light = vec3(0.0, 0.0, 0.0);
@@ -2200,30 +2259,13 @@ FRAGMENT_SHADER_CODE
 		specular_light = spec_accum.rgb;
 		ambient_light = amb_accum.rgb;
 	}
-#else
+#elif !defined(LOW_END_MODE)
+
 	if (bool(instances.data[instance_index].flags & INSTANCE_FLAGS_USE_GI_BUFFERS)) { //use GI buffers
 
 		ivec2 coord;
 
 		if (scene_data.gi_upscale_for_msaa) {
-			/*
-			//find the closest depth to upscale from, based on neighbours
-			ivec2 base_coord = ivec2(gl_FragCoord.xy);
-			float z_dist = gl_FragCoord.z;
-			ivec2 closest_coord = base_coord;
-			float closest_z_dist = abs(texelFetch(sampler2D(depth_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), base_coord,0).r-z_dist);
-
-			for(int i=0;i<4;i++) {
-				const ivec2 neighbours[4]=ivec2[](ivec2(-1,0),ivec2(1,0),ivec2(0,-1),ivec2(0,1));
-				ivec2 neighbour_coord = base_coord + neighbours[i];
-				float neighbour_z_dist = abs(texelFetch(sampler2D(depth_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), neighbour_coord,0).r-z_dist);
-				if (neighbour_z_dist < closest_z_dist) {
-					closest_z_dist = neighbour_z_dist;
-					closest_coord = neighbour_coord;
-				}
-			}
-
-*/
 			ivec2 base_coord = ivec2(gl_FragCoord.xy);
 			ivec2 closest_coord = base_coord;
 			float closest_ang = dot(normal, texelFetch(sampler2D(normal_roughness_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), base_coord, 0).xyz * 2.0 - 1.0);
@@ -2802,11 +2844,13 @@ FRAGMENT_SHADER_CODE
 //ambient occlusion
 #if defined(AO_USED)
 
+#ifndef LOW_END_MODE
 	if (scene_data.ssao_enabled && scene_data.ssao_ao_affect > 0.0) {
 		float ssao = texture(sampler2D(ao_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), screen_uv).r;
 		ao = mix(ao, min(ao, ssao), scene_data.ssao_ao_affect);
 		ao_light_affect = mix(ao_light_affect, max(ao_light_affect, scene_data.ssao_light_affect), scene_data.ssao_ao_affect);
 	}
+#endif //LOW_END_MODE
 
 	ambient_light = mix(scene_data.ao_color.rgb, ambient_light, ao);
 	ao_light_affect = mix(1.0, ao, ao_light_affect);
@@ -2814,6 +2858,7 @@ FRAGMENT_SHADER_CODE
 	diffuse_light = mix(scene_data.ao_color.rgb, diffuse_light, ao_light_affect);
 #else
 
+#ifndef LOW_END_MODE
 	if (scene_data.ssao_enabled) {
 		float ao = texture(sampler2D(ao_buffer, material_samplers[SAMPLER_LINEAR_CLAMP]), screen_uv).r;
 		ambient_light = mix(scene_data.ao_color.rgb, ambient_light, ao);
@@ -2821,6 +2866,7 @@ FRAGMENT_SHADER_CODE
 		specular_light = mix(scene_data.ao_color.rgb, specular_light, ao_light_affect);
 		diffuse_light = mix(scene_data.ao_color.rgb, diffuse_light, ao_light_affect);
 	}
+#endif //LOW_END_MODE
 
 #endif // AO_USED
 
@@ -2850,11 +2896,13 @@ FRAGMENT_SHADER_CODE
 		specular_buffer.rgb = mix(specular_buffer.rgb, vec3(0.0), fog.a);
 	}
 
+#ifndef LOW_END_MODE
 	if (scene_data.volumetric_fog_enabled) {
 		vec4 fog = volumetric_fog_process(screen_uv, -vertex.z);
 		diffuse_buffer.rgb = mix(diffuse_buffer.rgb, fog.rgb, fog.a);
 		specular_buffer.rgb = mix(specular_buffer.rgb, vec3(0.0), fog.a);
 	}
+#endif // LOW_END_MODE
 
 #if defined(CUSTOM_FOG_USED)
 	diffuse_buffer.rgb = mix(diffuse_buffer.rgb, custom_fog.rgb, custom_fog.a);
@@ -2875,11 +2923,12 @@ FRAGMENT_SHADER_CODE
 		vec4 fog = fog_process(vertex);
 		frag_color.rgb = mix(frag_color.rgb, fog.rgb, fog.a);
 	}
-
+#ifndef LOW_END_MODE
 	if (scene_data.volumetric_fog_enabled) {
 		vec4 fog = volumetric_fog_process(screen_uv, -vertex.z);
 		frag_color.rgb = mix(frag_color.rgb, fog.rgb, fog.a);
 	}
+#endif
 
 #if defined(CUSTOM_FOG_USED)
 	frag_color.rgb = mix(frag_color.rgb, custom_fog.rgb, custom_fog.a);
diff --git a/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl b/servers/rendering/renderer_rd/shaders/scene_forward_inc.glsl
index e29a490ca1..fdc9941bba 100644
--- a/servers/rendering/rasterizer_rd/shaders/scene_high_end_inc.glsl
+++ b/servers/rendering/renderer_rd/shaders/scene_forward_inc.glsl
@@ -5,6 +5,12 @@
 
 #include "cluster_data_inc.glsl"
 
+#if !defined(MODE_RENDER_DEPTH) || defined(MODE_RENDER_MATERIAL) || defined(MODE_RENDER_SDF) || defined(MODE_RENDER_NORMAL_ROUGHNESS) || defined(MODE_RENDER_GIPROBE) || defined(TANGENT_USED) || defined(NORMALMAP_USED)
+#ifndef NORMAL_USED
+#define NORMAL_USED
+#endif
+#endif
+
 layout(push_constant, binding = 0, std430) uniform DrawCall {
 	uint instance_index;
 	uint pad; //16 bits minimum size
@@ -204,6 +210,8 @@ layout(set = 0, binding = 19, std430) restrict readonly buffer GlobalVariableDat
 }
 global_variables;
 
+#ifndef LOW_END_MODE
+
 struct SDFGIProbeCascadeData {
 	vec3 position;
 	float to_probe;
@@ -239,6 +247,8 @@ layout(set = 0, binding = 20, std140) uniform SDFGI {
 }
 sdfgi;
 
+#endif //LOW_END_MODE
+
 // decal atlas
 
 /* Set 1, Radiance */
@@ -255,20 +265,22 @@ layout(set = 1, binding = 0) uniform textureCube radiance_cubemap;
 
 /* Set 2, Reflection and Shadow Atlases (view dependent) */
 
-layout(set = 2, binding = 0) uniform textureCubeArray reflection_atlas;
+layout(set = 1, binding = 1) uniform textureCubeArray reflection_atlas;
 
-layout(set = 2, binding = 1) uniform texture2D shadow_atlas;
+layout(set = 1, binding = 2) uniform texture2D shadow_atlas;
 
-layout(set = 2, binding = 2) uniform texture3D gi_probe_textures[MAX_GI_PROBES];
+#ifndef LOW_END_MODE
+layout(set = 1, binding = 3) uniform texture3D gi_probe_textures[MAX_GI_PROBES];
+#endif
 
 /* Set 3, Render Buffers */
 
 #ifdef MODE_RENDER_SDF
 
-layout(r16ui, set = 3, binding = 0) uniform restrict writeonly uimage3D albedo_volume_grid;
-layout(r32ui, set = 3, binding = 1) uniform restrict writeonly uimage3D emission_grid;
-layout(r32ui, set = 3, binding = 2) uniform restrict writeonly uimage3D emission_aniso_grid;
-layout(r32ui, set = 3, binding = 3) uniform restrict uimage3D geom_facing_grid;
+layout(r16ui, set = 1, binding = 4) uniform restrict writeonly uimage3D albedo_volume_grid;
+layout(r32ui, set = 1, binding = 5) uniform restrict writeonly uimage3D emission_grid;
+layout(r32ui, set = 1, binding = 6) uniform restrict writeonly uimage3D emission_aniso_grid;
+layout(r32ui, set = 1, binding = 7) uniform restrict uimage3D geom_facing_grid;
 
 //still need to be present for shaders that use it, so remap them to something
 #define depth_buffer shadow_atlas
@@ -277,14 +289,17 @@ layout(r32ui, set = 3, binding = 3) uniform restrict uimage3D geom_facing_grid;
 
 #else
 
-layout(set = 3, binding = 0) uniform texture2D depth_buffer;
-layout(set = 3, binding = 1) uniform texture2D color_buffer;
-layout(set = 3, binding = 2) uniform texture2D normal_roughness_buffer;
-layout(set = 3, binding = 4) uniform texture2D ao_buffer;
-layout(set = 3, binding = 5) uniform texture2D ambient_buffer;
-layout(set = 3, binding = 6) uniform texture2D reflection_buffer;
-layout(set = 3, binding = 7) uniform texture2DArray sdfgi_lightprobe_texture;
-layout(set = 3, binding = 8) uniform texture3D sdfgi_occlusion_cascades;
+layout(set = 1, binding = 4) uniform texture2D depth_buffer;
+layout(set = 1, binding = 5) uniform texture2D color_buffer;
+
+#ifndef LOW_END_MODE
+
+layout(set = 1, binding = 6) uniform texture2D normal_roughness_buffer;
+layout(set = 1, binding = 7) uniform texture2D ao_buffer;
+layout(set = 1, binding = 8) uniform texture2D ambient_buffer;
+layout(set = 1, binding = 9) uniform texture2D reflection_buffer;
+layout(set = 1, binding = 10) uniform texture2DArray sdfgi_lightprobe_texture;
+layout(set = 1, binding = 11) uniform texture3D sdfgi_occlusion_cascades;
 
 struct GIProbeData {
 	mat4 xform;
@@ -302,18 +317,20 @@ struct GIProbeData {
 	uint mipmaps;
 };
 
-layout(set = 3, binding = 9, std140) uniform GIProbes {
+layout(set = 1, binding = 12, std140) uniform GIProbes {
 	GIProbeData data[MAX_GI_PROBES];
 }
 gi_probes;
 
-layout(set = 3, binding = 10) uniform texture3D volumetric_fog_texture;
+layout(set = 1, binding = 13) uniform texture3D volumetric_fog_texture;
+
+#endif // LOW_END_MODE
 
 #endif
 
 /* Set 4 Skeleton & Instancing (Multimesh) */
 
-layout(set = 4, binding = 0, std430) restrict readonly buffer Transforms {
+layout(set = 2, binding = 0, std430) restrict readonly buffer Transforms {
 	vec4 data[];
 }
 transforms;
diff --git a/servers/rendering/rasterizer_rd/shaders/screen_space_reflection.glsl b/servers/rendering/renderer_rd/shaders/screen_space_reflection.glsl
index 06dc4b13de..06dc4b13de 100644
--- a/servers/rendering/rasterizer_rd/shaders/screen_space_reflection.glsl
+++ b/servers/rendering/renderer_rd/shaders/screen_space_reflection.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/screen_space_reflection_filter.glsl b/servers/rendering/renderer_rd/shaders/screen_space_reflection_filter.glsl
index a5afe74cb2..a5afe74cb2 100644
--- a/servers/rendering/rasterizer_rd/shaders/screen_space_reflection_filter.glsl
+++ b/servers/rendering/renderer_rd/shaders/screen_space_reflection_filter.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/screen_space_reflection_scale.glsl b/servers/rendering/renderer_rd/shaders/screen_space_reflection_scale.glsl
index 218605a962..218605a962 100644
--- a/servers/rendering/rasterizer_rd/shaders/screen_space_reflection_scale.glsl
+++ b/servers/rendering/renderer_rd/shaders/screen_space_reflection_scale.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/sdfgi_debug.glsl b/servers/rendering/renderer_rd/shaders/sdfgi_debug.glsl
index 813ea29fa1..813ea29fa1 100644
--- a/servers/rendering/rasterizer_rd/shaders/sdfgi_debug.glsl
+++ b/servers/rendering/renderer_rd/shaders/sdfgi_debug.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/sdfgi_debug_probes.glsl b/servers/rendering/renderer_rd/shaders/sdfgi_debug_probes.glsl
index 08da283dad..08da283dad 100644
--- a/servers/rendering/rasterizer_rd/shaders/sdfgi_debug_probes.glsl
+++ b/servers/rendering/renderer_rd/shaders/sdfgi_debug_probes.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/sdfgi_direct_light.glsl b/servers/rendering/renderer_rd/shaders/sdfgi_direct_light.glsl
index 61e4bf5e18..61e4bf5e18 100644
--- a/servers/rendering/rasterizer_rd/shaders/sdfgi_direct_light.glsl
+++ b/servers/rendering/renderer_rd/shaders/sdfgi_direct_light.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/sdfgi_fields.glsl b/servers/rendering/renderer_rd/shaders/sdfgi_fields.glsl
index eec0a90c0d..69d8824d8a 100644
--- a/servers/rendering/rasterizer_rd/shaders/sdfgi_fields.glsl
+++ b/servers/rendering/renderer_rd/shaders/sdfgi_fields.glsl
@@ -14,7 +14,7 @@ layout(local_size_x = OCT_RES, local_size_y = OCT_RES, local_size_z = 1) in;
 layout(rgba16f, set = 0, binding = 1) uniform restrict image2DArray irradiance_texture;
 layout(rg16f, set = 0, binding = 2) uniform restrict image2DArray depth_texture;
 
-ayout(rgba32ui, set = 0, binding = 3) uniform restrict uimage2DArray irradiance_history_texture;
+layout(rgba32ui, set = 0, binding = 3) uniform restrict uimage2DArray irradiance_history_texture;
 layout(rg32ui, set = 0, binding = 4) uniform restrict uimage2DArray depth_history_texture;
 
 struct CascadeData {
diff --git a/servers/rendering/rasterizer_rd/shaders/sdfgi_integrate.glsl b/servers/rendering/renderer_rd/shaders/sdfgi_integrate.glsl
index d516ab22c3..d516ab22c3 100644
--- a/servers/rendering/rasterizer_rd/shaders/sdfgi_integrate.glsl
+++ b/servers/rendering/renderer_rd/shaders/sdfgi_integrate.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/sdfgi_preprocess.glsl b/servers/rendering/renderer_rd/shaders/sdfgi_preprocess.glsl
index 916c60ac89..916c60ac89 100644
--- a/servers/rendering/rasterizer_rd/shaders/sdfgi_preprocess.glsl
+++ b/servers/rendering/renderer_rd/shaders/sdfgi_preprocess.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/shadow_reduce.glsl b/servers/rendering/renderer_rd/shaders/shadow_reduce.glsl
index 29443ae7db..29443ae7db 100644
--- a/servers/rendering/rasterizer_rd/shaders/shadow_reduce.glsl
+++ b/servers/rendering/renderer_rd/shaders/shadow_reduce.glsl
diff --git a/servers/rendering/renderer_rd/shaders/skeleton.glsl b/servers/rendering/renderer_rd/shaders/skeleton.glsl
new file mode 100644
index 0000000000..b19f5a9ad3
--- /dev/null
+++ b/servers/rendering/renderer_rd/shaders/skeleton.glsl
@@ -0,0 +1,199 @@
+#[compute]
+
+#version 450
+
+VERSION_DEFINES
+
+layout(local_size_x = 64, local_size_y = 1, local_size_z = 1) in;
+
+layout(set = 0, binding = 1, std430) buffer restrict writeonly DstVertexData {
+	uint data[];
+}
+dst_vertices;
+
+layout(set = 0, binding = 2, std430) buffer restrict readonly BlendShapeWeights {
+	float data[];
+}
+blend_shape_weights;
+
+layout(set = 1, binding = 0, std430) buffer restrict readonly SrcVertexData {
+	uint data[];
+}
+src_vertices;
+
+layout(set = 1, binding = 1, std430) buffer restrict readonly BoneWeightData {
+	uint data[];
+}
+src_bone_weights;
+
+layout(set = 1, binding = 2, std430) buffer restrict readonly BlendShapeData {
+	uint data[];
+}
+src_blend_shapes;
+
+layout(set = 2, binding = 0, std430) buffer restrict readonly SkeletonData {
+	vec4 data[];
+}
+bone_transforms;
+
+layout(push_constant, binding = 0, std430) uniform Params {
+	bool has_normal;
+	bool has_tangent;
+	bool has_skeleton;
+	bool has_blend_shape;
+
+	uint vertex_count;
+	uint vertex_stride;
+	uint skin_stride;
+	uint skin_weight_offset;
+
+	uint blend_shape_count;
+	bool normalized_blend_shapes;
+	uint pad0;
+	uint pad1;
+}
+params;
+
+vec4 decode_abgr_2_10_10_10(uint base) {
+	uvec4 abgr_2_10_10_10 = (uvec4(base) >> uvec4(0, 10, 20, 30)) & uvec4(0x3FF, 0x3FF, 0x3FF, 0x3);
+	return vec4(abgr_2_10_10_10) / vec4(1023.0, 1023.0, 1023.0, 3.0) * 2.0 - 1.0;
+}
+
+uint encode_abgr_2_10_10_10(vec4 base) {
+	uvec4 abgr_2_10_10_10 = uvec4(clamp(ivec4((base * 0.5 + 0.5) * vec4(1023.0, 1023.0, 1023.0, 3.0)), ivec4(0), ivec4(0x3FF, 0x3FF, 0x3FF, 0x3))) << uvec4(0, 10, 20, 30);
+	return abgr_2_10_10_10.x | abgr_2_10_10_10.y | abgr_2_10_10_10.z | abgr_2_10_10_10.w;
+}
+
+void main() {
+	uint index = gl_GlobalInvocationID.x;
+	if (index >= params.vertex_count) {
+		return;
+	}
+
+	uint src_offset = index * params.vertex_stride;
+
+#ifdef MODE_2D
+	vec2 vertex = uintBitsToFloat(uvec2(src_vertices.data[src_offset + 0], src_vertices.data[src_offset + 1]));
+#else
+	vec3 vertex;
+	vec3 normal;
+	vec4 tangent;
+
+	vertex = uintBitsToFloat(uvec3(src_vertices.data[src_offset + 0], src_vertices.data[src_offset + 1], src_vertices.data[src_offset + 2]));
+
+	src_offset += 3;
+
+	if (params.has_normal) {
+		normal = decode_abgr_2_10_10_10(src_vertices.data[src_offset]).rgb;
+		src_offset++;
+	}
+
+	if (params.has_tangent) {
+		tangent = decode_abgr_2_10_10_10(src_vertices.data[src_offset]);
+	}
+
+	if (params.has_blend_shape) {
+		float blend_total = 0.0;
+		vec3 blend_vertex = vec3(0.0);
+		vec3 blend_normal = vec3(0.0);
+		vec3 blend_tangent = vec3(0.0);
+
+		for (uint i = 0; i < params.blend_shape_count; i++) {
+			float w = blend_shape_weights.data[i];
+			if (w > 0.0001) {
+				uint base_offset = (params.vertex_count * i + index) * params.vertex_stride;
+
+				blend_vertex += uintBitsToFloat(uvec3(src_blend_shapes.data[base_offset + 0], src_blend_shapes.data[base_offset + 1], src_blend_shapes.data[base_offset + 2])) * w;
+
+				base_offset += 3;
+
+				if (params.has_normal) {
+					blend_normal += decode_abgr_2_10_10_10(src_blend_shapes.data[base_offset]).rgb * w;
+					base_offset++;
+				}
+
+				if (params.has_tangent) {
+					blend_tangent += decode_abgr_2_10_10_10(src_blend_shapes.data[base_offset]).rgb;
+				}
+
+				blend_total += w;
+			}
+		}
+
+		if (params.normalized_blend_shapes) {
+			vertex = (1.0 - blend_total) * vertex;
+			normal = (1.0 - blend_total) * normal;
+			tangent.rgb = (1.0 - blend_total) * tangent.rgb;
+		}
+
+		vertex += blend_vertex;
+		normal += normalize(normal + blend_normal);
+		tangent.rgb += normalize(tangent.rgb + blend_tangent);
+	}
+
+	if (params.has_skeleton) {
+		uint skin_offset = params.skin_stride * index;
+
+		uvec2 bones = uvec2(src_bone_weights.data[skin_offset + 0], src_bone_weights.data[skin_offset + 1]);
+		uvec2 bones_01 = uvec2(bones.x & 0xFFFF, bones.x >> 16) * 3; //pre-add xform offset
+		uvec2 bones_23 = uvec2(bones.y & 0xFFFF, bones.y >> 16) * 3;
+
+		skin_offset += params.skin_weight_offset;
+
+		uvec2 weights = uvec2(src_bone_weights.data[skin_offset + 0], src_bone_weights.data[skin_offset + 1]);
+
+		vec2 weights_01 = unpackUnorm2x16(weights.x);
+		vec2 weights_23 = unpackUnorm2x16(weights.y);
+
+		mat4 m = mat4(bone_transforms.data[bones_01.x], bone_transforms.data[bones_01.x + 1], bone_transforms.data[bones_01.x + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_01.x;
+		m += mat4(bone_transforms.data[bones_01.y], bone_transforms.data[bones_01.y + 1], bone_transforms.data[bones_01.y + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_01.y;
+		m += mat4(bone_transforms.data[bones_23.x], bone_transforms.data[bones_23.x + 1], bone_transforms.data[bones_23.x + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_23.x;
+		m += mat4(bone_transforms.data[bones_23.y], bone_transforms.data[bones_23.y + 1], bone_transforms.data[bones_23.y + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_23.y;
+
+		if (params.skin_weight_offset == 4) {
+			//using 8 bones/weights
+			skin_offset = params.skin_stride * index + 2;
+
+			bones = uvec2(src_bone_weights.data[skin_offset + 0], src_bone_weights.data[skin_offset + 1]);
+			bones_01 = uvec2(bones.x & 0xFFFF, bones.x >> 16) * 3; //pre-add xform offset
+			bones_23 = uvec2(bones.y & 0xFFFF, bones.y >> 16) * 3;
+
+			skin_offset += params.skin_weight_offset;
+
+			weights = uvec2(src_bone_weights.data[skin_offset + 0], src_bone_weights.data[skin_offset + 1]);
+
+			weights_01 = unpackUnorm2x16(weights.x);
+			weights_23 = unpackUnorm2x16(weights.y);
+
+			m += mat4(bone_transforms.data[bones_01.x], bone_transforms.data[bones_01.x + 1], bone_transforms.data[bones_01.x + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_01.x;
+			m += mat4(bone_transforms.data[bones_01.y], bone_transforms.data[bones_01.y + 1], bone_transforms.data[bones_01.y + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_01.y;
+			m += mat4(bone_transforms.data[bones_23.x], bone_transforms.data[bones_23.x + 1], bone_transforms.data[bones_23.x + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_23.x;
+			m += mat4(bone_transforms.data[bones_23.y], bone_transforms.data[bones_23.y + 1], bone_transforms.data[bones_23.y + 2], vec4(0.0, 0.0, 0.0, 1.0)) * weights_23.y;
+		}
+
+		//reverse order because its transposed
+		vertex = (vec4(vertex, 1.0) * m).xyz;
+		normal = normalize((vec4(normal, 0.0) * m).xyz);
+		tangent.xyz = normalize((vec4(tangent.xyz, 0.0) * m).xyz);
+	}
+
+	uint dst_offset = index * params.vertex_stride;
+
+	uvec3 uvertex = floatBitsToUint(vertex);
+	dst_vertices.data[dst_offset + 0] = uvertex.x;
+	dst_vertices.data[dst_offset + 1] = uvertex.y;
+	dst_vertices.data[dst_offset + 2] = uvertex.z;
+
+	dst_offset += 3;
+
+	if (params.has_normal) {
+		dst_vertices.data[dst_offset] = encode_abgr_2_10_10_10(vec4(normal, 0.0));
+		dst_offset++;
+	}
+
+	if (params.has_tangent) {
+		dst_vertices.data[dst_offset] = encode_abgr_2_10_10_10(tangent);
+	}
+
+#endif
+}
diff --git a/servers/rendering/rasterizer_rd/shaders/sky.glsl b/servers/rendering/renderer_rd/shaders/sky.glsl
index 6c985e1f5c..6c985e1f5c 100644
--- a/servers/rendering/rasterizer_rd/shaders/sky.glsl
+++ b/servers/rendering/renderer_rd/shaders/sky.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/sort.glsl b/servers/rendering/renderer_rd/shaders/sort.glsl
index e5ebb9c64b..e5ebb9c64b 100644
--- a/servers/rendering/rasterizer_rd/shaders/sort.glsl
+++ b/servers/rendering/renderer_rd/shaders/sort.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/specular_merge.glsl b/servers/rendering/renderer_rd/shaders/specular_merge.glsl
index 0b8f406213..0b8f406213 100644
--- a/servers/rendering/rasterizer_rd/shaders/specular_merge.glsl
+++ b/servers/rendering/renderer_rd/shaders/specular_merge.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/ssao.glsl b/servers/rendering/renderer_rd/shaders/ssao.glsl
index 346338181a..346338181a 100644
--- a/servers/rendering/rasterizer_rd/shaders/ssao.glsl
+++ b/servers/rendering/renderer_rd/shaders/ssao.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/ssao_blur.glsl b/servers/rendering/renderer_rd/shaders/ssao_blur.glsl
index 3e63e3cb59..3e63e3cb59 100644
--- a/servers/rendering/rasterizer_rd/shaders/ssao_blur.glsl
+++ b/servers/rendering/renderer_rd/shaders/ssao_blur.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/ssao_minify.glsl b/servers/rendering/renderer_rd/shaders/ssao_minify.glsl
index 263fca386f..263fca386f 100644
--- a/servers/rendering/rasterizer_rd/shaders/ssao_minify.glsl
+++ b/servers/rendering/renderer_rd/shaders/ssao_minify.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/subsurface_scattering.glsl b/servers/rendering/renderer_rd/shaders/subsurface_scattering.glsl
index 88a953562f..88a953562f 100644
--- a/servers/rendering/rasterizer_rd/shaders/subsurface_scattering.glsl
+++ b/servers/rendering/renderer_rd/shaders/subsurface_scattering.glsl
diff --git a/servers/rendering/rasterizer_rd/shaders/tonemap.glsl b/servers/rendering/renderer_rd/shaders/tonemap.glsl
index 4cc4fd3f64..7de91fd541 100644
--- a/servers/rendering/rasterizer_rd/shaders/tonemap.glsl
+++ b/servers/rendering/renderer_rd/shaders/tonemap.glsl
@@ -23,7 +23,11 @@ layout(location = 0) in vec2 uv_interp;
 layout(set = 0, binding = 0) uniform sampler2D source_color;
 layout(set = 1, binding = 0) uniform sampler2D source_auto_exposure;
 layout(set = 2, binding = 0) uniform sampler2D source_glow;
-layout(set = 3, binding = 0) uniform sampler3D color_correction;
+#ifdef USE_1D_LUT
+layout(set = 3, binding = 0) uniform sampler2D source_color_correction;
+#else
+layout(set = 3, binding = 0) uniform sampler3D source_color_correction;
+#endif
 
 layout(push_constant, binding = 1, std430) uniform Params {
 	vec3 bcs;
@@ -35,9 +39,9 @@ layout(push_constant, binding = 1, std430) uniform Params {
 	uint tonemapper;
 
 	uvec2 glow_texture_size;
-
 	float glow_intensity;
 	uint pad3;
+
 	uint glow_mode;
 	float glow_levels[7];
 
@@ -255,10 +259,18 @@ vec3 apply_bcs(vec3 color, vec3 bcs) {
 
 	return color;
 }
-
-vec3 apply_color_correction(vec3 color, sampler3D correction_tex) {
-	return texture(correction_tex, color).rgb;
+#ifdef USE_1D_LUT
+vec3 apply_color_correction(vec3 color) {
+	color.r = texture(source_color_correction, vec2(color.r, 0.0f)).r;
+	color.g = texture(source_color_correction, vec2(color.g, 0.0f)).g;
+	color.b = texture(source_color_correction, vec2(color.b, 0.0f)).b;
+	return color;
+}
+#else
+vec3 apply_color_correction(vec3 color) {
+	return textureLod(source_color_correction, color, 0.0).rgb;
 }
+#endif
 
 vec3 do_fxaa(vec3 color, float exposure, vec2 uv_interp) {
 	const float FXAA_REDUCE_MIN = (1.0 / 128.0);
@@ -367,7 +379,7 @@ void main() {
 	}
 
 	if (params.use_color_correction) {
-		color = apply_color_correction(color, color_correction);
+		color = apply_color_correction(color);
 	}
 
 	frag_color = vec4(color, 1.0f);
diff --git a/servers/rendering/rasterizer_rd/shaders/volumetric_fog.glsl b/servers/rendering/renderer_rd/shaders/volumetric_fog.glsl
index 13b162f0c9..13b162f0c9 100644
--- a/servers/rendering/rasterizer_rd/shaders/volumetric_fog.glsl
+++ b/servers/rendering/renderer_rd/shaders/volumetric_fog.glsl
diff --git a/servers/rendering/renderer_scene.cpp b/servers/rendering/renderer_scene.cpp
new file mode 100644
index 0000000000..1da8fc59de
--- /dev/null
+++ b/servers/rendering/renderer_scene.cpp
@@ -0,0 +1,37 @@
+/*************************************************************************/
+/*  renderer_scene.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 "renderer_scene.h"
+
+RendererScene::RendererScene() {
+}
+
+RendererScene::~RendererScene() {
+}
diff --git a/servers/rendering/renderer_scene.h b/servers/rendering/renderer_scene.h
new file mode 100644
index 0000000000..56c38beaa3
--- /dev/null
+++ b/servers/rendering/renderer_scene.h
@@ -0,0 +1,203 @@
+/*************************************************************************/
+/*  renderer_scene.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 RENDERINGSERVERSCENE_H
+#define RENDERINGSERVERSCENE_H
+
+#include "servers/rendering/renderer_compositor.h"
+#include "servers/xr/xr_interface.h"
+
+class RendererScene {
+public:
+	virtual RID camera_create() = 0;
+
+	virtual void camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) = 0;
+	virtual void camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) = 0;
+	virtual void camera_set_frustum(RID p_camera, float p_size, Vector2 p_offset, float p_z_near, float p_z_far) = 0;
+	virtual void camera_set_transform(RID p_camera, const Transform &p_transform) = 0;
+	virtual void camera_set_cull_mask(RID p_camera, uint32_t p_layers) = 0;
+	virtual void camera_set_environment(RID p_camera, RID p_env) = 0;
+	virtual void camera_set_camera_effects(RID p_camera, RID p_fx) = 0;
+	virtual void camera_set_use_vertical_aspect(RID p_camera, bool p_enable) = 0;
+	virtual bool is_camera(RID p_camera) const = 0;
+
+	virtual RID scenario_create() = 0;
+
+	virtual void scenario_set_debug(RID p_scenario, RS::ScenarioDebugMode p_debug_mode) = 0;
+	virtual void scenario_set_environment(RID p_scenario, RID p_environment) = 0;
+	virtual void scenario_set_camera_effects(RID p_scenario, RID p_fx) = 0;
+	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment) = 0;
+	virtual void scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count) = 0;
+	virtual bool is_scenario(RID p_scenario) const = 0;
+	virtual RID scenario_get_environment(RID p_scenario) = 0;
+
+	virtual RID instance_create() = 0;
+
+	virtual void instance_set_base(RID p_instance, RID p_base) = 0;
+	virtual void instance_set_scenario(RID p_instance, RID p_scenario) = 0;
+	virtual void instance_set_layer_mask(RID p_instance, uint32_t p_mask) = 0;
+	virtual void instance_set_transform(RID p_instance, const Transform &p_transform) = 0;
+	virtual void instance_attach_object_instance_id(RID p_instance, ObjectID p_id) = 0;
+	virtual void instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight) = 0;
+	virtual void instance_set_surface_material(RID p_instance, int p_surface, RID p_material) = 0;
+	virtual void instance_set_visible(RID p_instance, bool p_visible) = 0;
+
+	virtual void instance_set_custom_aabb(RID p_instance, AABB p_aabb) = 0;
+
+	virtual void instance_attach_skeleton(RID p_instance, RID p_skeleton) = 0;
+	virtual void instance_set_exterior(RID p_instance, bool p_enabled) = 0;
+
+	virtual void instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) = 0;
+
+	// don't use these in a game!
+	virtual Vector<ObjectID> instances_cull_aabb(const AABB &p_aabb, RID p_scenario = RID()) const = 0;
+	virtual Vector<ObjectID> instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario = RID()) const = 0;
+	virtual Vector<ObjectID> instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario = RID()) const = 0;
+
+	virtual void instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) = 0;
+	virtual void instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting) = 0;
+	virtual void instance_geometry_set_material_override(RID p_instance, RID p_material) = 0;
+
+	virtual void instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin) = 0;
+	virtual void instance_geometry_set_as_instance_lod(RID p_instance, RID p_as_lod_of_instance) = 0;
+	virtual void instance_geometry_set_lightmap(RID p_instance, RID p_lightmap, const Rect2 &p_lightmap_uv_scale, int p_slice_index) = 0;
+	virtual void instance_geometry_set_lod_bias(RID p_instance, float p_lod_bias) = 0;
+
+	virtual void instance_geometry_set_shader_parameter(RID p_instance, const StringName &p_parameter, const Variant &p_value) = 0;
+	virtual void instance_geometry_get_shader_parameter_list(RID p_instance, List<PropertyInfo> *p_parameters) const = 0;
+	virtual Variant instance_geometry_get_shader_parameter(RID p_instance, const StringName &p_parameter) const = 0;
+	virtual Variant instance_geometry_get_shader_parameter_default_value(RID p_instance, const StringName &p_parameter) const = 0;
+
+	virtual void directional_shadow_atlas_set_size(int p_size) = 0;
+
+	/* SKY API */
+
+	virtual RID sky_create() = 0;
+	virtual void sky_set_radiance_size(RID p_sky, int p_radiance_size) = 0;
+	virtual void sky_set_mode(RID p_sky, RS::SkyMode p_samples) = 0;
+	virtual void sky_set_material(RID p_sky, RID p_material) = 0;
+	virtual Ref<Image> sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) = 0;
+
+	/* ENVIRONMENT API */
+
+	virtual RID environment_create() = 0;
+
+	virtual void environment_set_background(RID p_env, RS::EnvironmentBG p_bg) = 0;
+	virtual void environment_set_sky(RID p_env, RID p_sky) = 0;
+	virtual void environment_set_sky_custom_fov(RID p_env, float p_scale) = 0;
+	virtual void environment_set_sky_orientation(RID p_env, const Basis &p_orientation) = 0;
+	virtual void environment_set_bg_color(RID p_env, const Color &p_color) = 0;
+	virtual void environment_set_bg_energy(RID p_env, float p_energy) = 0;
+	virtual void environment_set_canvas_max_layer(RID p_env, int p_max_layer) = 0;
+	virtual void environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient = RS::ENV_AMBIENT_SOURCE_BG, float p_energy = 1.0, float p_sky_contribution = 0.0, RS::EnvironmentReflectionSource p_reflection_source = RS::ENV_REFLECTION_SOURCE_BG, const Color &p_ao_color = Color()) = 0;
+
+	virtual void 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) = 0;
+	virtual void environment_glow_set_use_bicubic_upscale(bool p_enable) = 0;
+	virtual void environment_glow_set_use_high_quality(bool p_enable) = 0;
+
+	virtual void environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, RS::EnvVolumetricFogShadowFilter p_shadow_filter) = 0;
+
+	virtual void environment_set_volumetric_fog_volume_size(int p_size, int p_depth) = 0;
+	virtual void environment_set_volumetric_fog_filter_active(bool p_enable) = 0;
+	virtual void environment_set_volumetric_fog_directional_shadow_shrink_size(int p_shrink_size) = 0;
+	virtual void environment_set_volumetric_fog_positional_shadow_shrink_size(int p_shrink_size) = 0;
+
+	virtual void 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) = 0;
+	virtual void environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) = 0;
+
+	virtual void environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_bias, float p_light_affect, float p_ao_channel_affect, RS::EnvironmentSSAOBlur p_blur, float p_bilateral_sharpness) = 0;
+
+	virtual void environment_set_ssao_quality(RS::EnvironmentSSAOQuality p_quality, bool p_half_size) = 0;
+
+	virtual void environment_set_sdfgi(RID p_env, bool p_enable, RS::EnvironmentSDFGICascades p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, bool p_use_multibounce, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) = 0;
+
+	virtual void environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) = 0;
+	virtual void environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) = 0;
+
+	virtual void 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) = 0;
+
+	virtual void 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) = 0;
+
+	virtual void environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_aerial_perspective) = 0;
+
+	virtual Ref<Image> environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) = 0;
+
+	virtual RS::EnvironmentBG environment_get_background(RID p_Env) const = 0;
+	virtual int environment_get_canvas_max_layer(RID p_env) const = 0;
+
+	virtual bool is_environment(RID p_environment) const = 0;
+
+	virtual void screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) = 0;
+	virtual void sub_surface_scattering_set_quality(RS::SubSurfaceScatteringQuality p_quality) = 0;
+	virtual void sub_surface_scattering_set_scale(float p_scale, float p_depth_scale) = 0;
+
+	/* Camera Effects */
+
+	virtual RID camera_effects_create() = 0;
+
+	virtual void camera_effects_set_dof_blur_quality(RS::DOFBlurQuality p_quality, bool p_use_jitter) = 0;
+	virtual void camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape p_shape) = 0;
+
+	virtual void camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) = 0;
+	virtual void camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) = 0;
+
+	virtual void shadows_quality_set(RS::ShadowQuality p_quality) = 0;
+	virtual void directional_shadow_quality_set(RS::ShadowQuality p_quality) = 0;
+
+	virtual RID shadow_atlas_create() = 0;
+	virtual void shadow_atlas_set_size(RID p_atlas, int p_size) = 0;
+	virtual void shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) = 0;
+
+	/* Render Buffers */
+
+	virtual RID render_buffers_create() = 0;
+	virtual void render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, RS::ViewportMSAA p_msaa, RS::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_debanding) = 0;
+
+	virtual void set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) = 0;
+
+	virtual TypedArray<Image> bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) = 0;
+	virtual void gi_probe_set_quality(RS::GIProbeQuality) = 0;
+
+	virtual void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) = 0;
+
+	virtual void render_empty_scene(RID p_render_buffers, RID p_scenario, RID p_shadow_atlas) = 0;
+	virtual void render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, Size2 p_viewport_size, float p_lod_threshold, RID p_shadow_atlas) = 0;
+	virtual void render_camera(RID p_render_buffers, Ref<XRInterface> &p_interface, XRInterface::Eyes p_eye, RID p_camera, RID p_scenario, Size2 p_viewport_size, float p_lod_threshold, RID p_shadow_atlas) = 0;
+
+	virtual void update() = 0;
+	virtual void render_probes() = 0;
+
+	virtual bool free(RID p_rid) = 0;
+
+	RendererScene();
+	virtual ~RendererScene();
+};
+
+#endif // RENDERINGSERVERSCENE_H
diff --git a/servers/rendering/rendering_server_scene.cpp b/servers/rendering/renderer_scene_cull.cpp
index ae6786090a..88a0859a28 100644
--- a/servers/rendering/rendering_server_scene.cpp
+++ b/servers/rendering/renderer_scene_cull.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_scene.cpp                                           */
+/*  renderer_scene_cull.cpp                                              */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,22 +28,22 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rendering_server_scene.h"
+#include "renderer_scene_cull.h"
 
 #include "core/os/os.h"
+#include "rendering_server_default.h"
 #include "rendering_server_globals.h"
-#include "rendering_server_raster.h"
 
 #include <new>
 
 /* CAMERA API */
 
-RID RenderingServerScene::camera_create() {
+RID RendererSceneCull::camera_create() {
 	Camera *camera = memnew(Camera);
 	return camera_owner.make_rid(camera);
 }
 
-void RenderingServerScene::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) {
+void RendererSceneCull::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->type = Camera::PERSPECTIVE;
@@ -52,7 +52,7 @@ void RenderingServerScene::camera_set_perspective(RID p_camera, float p_fovy_deg
 	camera->zfar = p_z_far;
 }
 
-void RenderingServerScene::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) {
+void RendererSceneCull::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->type = Camera::ORTHOGONAL;
@@ -61,7 +61,7 @@ void RenderingServerScene::camera_set_orthogonal(RID p_camera, float p_size, flo
 	camera->zfar = p_z_far;
 }
 
-void RenderingServerScene::camera_set_frustum(RID p_camera, float p_size, Vector2 p_offset, float p_z_near, float p_z_far) {
+void RendererSceneCull::camera_set_frustum(RID p_camera, float p_size, Vector2 p_offset, float p_z_near, float p_z_far) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->type = Camera::FRUSTUM;
@@ -71,41 +71,45 @@ void RenderingServerScene::camera_set_frustum(RID p_camera, float p_size, Vector
 	camera->zfar = p_z_far;
 }
 
-void RenderingServerScene::camera_set_transform(RID p_camera, const Transform &p_transform) {
+void RendererSceneCull::camera_set_transform(RID p_camera, const Transform &p_transform) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->transform = p_transform.orthonormalized();
 }
 
-void RenderingServerScene::camera_set_cull_mask(RID p_camera, uint32_t p_layers) {
+void RendererSceneCull::camera_set_cull_mask(RID p_camera, uint32_t p_layers) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 
 	camera->visible_layers = p_layers;
 }
 
-void RenderingServerScene::camera_set_environment(RID p_camera, RID p_env) {
+void RendererSceneCull::camera_set_environment(RID p_camera, RID p_env) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->env = p_env;
 }
 
-void RenderingServerScene::camera_set_camera_effects(RID p_camera, RID p_fx) {
+void RendererSceneCull::camera_set_camera_effects(RID p_camera, RID p_fx) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->effects = p_fx;
 }
 
-void RenderingServerScene::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) {
+void RendererSceneCull::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) {
 	Camera *camera = camera_owner.getornull(p_camera);
 	ERR_FAIL_COND(!camera);
 	camera->vaspect = p_enable;
 }
 
+bool RendererSceneCull::is_camera(RID p_camera) const {
+	return camera_owner.owns(p_camera);
+}
+
 /* SCENARIO API */
 
-void *RenderingServerScene::_instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int) {
-	//RenderingServerScene *self = (RenderingServerScene*)p_self;
+void *RendererSceneCull::_instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int) {
+	//RendererSceneCull *self = (RendererSceneCull*)p_self;
 	Instance *A = p_A;
 	Instance *B = p_B;
 
@@ -165,7 +169,7 @@ void *RenderingServerScene::_instance_pair(void *p_self, OctreeElementID, Instan
 			pinfo.geometry = A;
 			pinfo.L = geom->lightmap_captures.push_back(B);
 			List<InstanceLightmapData::PairInfo>::Element *E = lightmap_data->geometries.push_back(pinfo);
-			((RenderingServerScene *)p_self)->_instance_queue_update(A, false, false); //need to update capture
+			((RendererSceneCull *)p_self)->_instance_queue_update(A, false, false); //need to update capture
 			return E; //this element should make freeing faster
 		} else {
 			return nullptr;
@@ -200,8 +204,8 @@ void *RenderingServerScene::_instance_pair(void *p_self, OctreeElementID, Instan
 	return nullptr;
 }
 
-void RenderingServerScene::_instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *udata) {
-	//RenderingServerScene *self = (RenderingServerScene*)p_self;
+void RendererSceneCull::_instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *udata) {
+	//RendererSceneCull *self = (RendererSceneCull*)p_self;
 	Instance *A = p_A;
 	Instance *B = p_B;
 
@@ -253,7 +257,7 @@ void RenderingServerScene::_instance_unpair(void *p_self, OctreeElementID, Insta
 
 			geom->lightmap_captures.erase(E->get().L);
 			lightmap_data->geometries.erase(E);
-			((RenderingServerScene *)p_self)->_instance_queue_update(A, false, false); //need to update capture
+			((RendererSceneCull *)p_self)->_instance_queue_update(A, false, false); //need to update capture
 		}
 
 	} else if (B->base_type == RS::INSTANCE_GI_PROBE && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) {
@@ -281,7 +285,7 @@ void RenderingServerScene::_instance_unpair(void *p_self, OctreeElementID, Insta
 	}
 }
 
-RID RenderingServerScene::scenario_create() {
+RID RendererSceneCull::scenario_create() {
 	Scenario *scenario = memnew(Scenario);
 	ERR_FAIL_COND_V(!scenario, RID());
 	RID scenario_rid = scenario_owner.make_rid(scenario);
@@ -289,49 +293,59 @@ RID RenderingServerScene::scenario_create() {
 
 	scenario->octree.set_pair_callback(_instance_pair, this);
 	scenario->octree.set_unpair_callback(_instance_unpair, this);
-	scenario->reflection_probe_shadow_atlas = RSG::scene_render->shadow_atlas_create();
-	RSG::scene_render->shadow_atlas_set_size(scenario->reflection_probe_shadow_atlas, 1024); //make enough shadows for close distance, don't bother with rest
-	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 0, 4);
-	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 1, 4);
-	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 2, 4);
-	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 3, 8);
-	scenario->reflection_atlas = RSG::scene_render->reflection_atlas_create();
+	scenario->reflection_probe_shadow_atlas = scene_render->shadow_atlas_create();
+	scene_render->shadow_atlas_set_size(scenario->reflection_probe_shadow_atlas, 1024); //make enough shadows for close distance, don't bother with rest
+	scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 0, 4);
+	scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 1, 4);
+	scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 2, 4);
+	scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 3, 8);
+	scenario->reflection_atlas = scene_render->reflection_atlas_create();
 	return scenario_rid;
 }
 
-void RenderingServerScene::scenario_set_debug(RID p_scenario, RS::ScenarioDebugMode p_debug_mode) {
+void RendererSceneCull::scenario_set_debug(RID p_scenario, RS::ScenarioDebugMode p_debug_mode) {
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scenario->debug = p_debug_mode;
 }
 
-void RenderingServerScene::scenario_set_environment(RID p_scenario, RID p_environment) {
+void RendererSceneCull::scenario_set_environment(RID p_scenario, RID p_environment) {
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scenario->environment = p_environment;
 }
 
-void RenderingServerScene::scenario_set_camera_effects(RID p_scenario, RID p_camera_effects) {
+void RendererSceneCull::scenario_set_camera_effects(RID p_scenario, RID p_camera_effects) {
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scenario->camera_effects = p_camera_effects;
 }
 
-void RenderingServerScene::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
+void RendererSceneCull::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND(!scenario);
 	scenario->fallback_environment = p_environment;
 }
 
-void RenderingServerScene::scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count) {
+void RendererSceneCull::scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count) {
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND(!scenario);
-	RSG::scene_render->reflection_atlas_set_size(scenario->reflection_atlas, p_reflection_size, p_reflection_count);
+	scene_render->reflection_atlas_set_size(scenario->reflection_atlas, p_reflection_size, p_reflection_count);
+}
+
+bool RendererSceneCull::is_scenario(RID p_scenario) const {
+	return scenario_owner.owns(p_scenario);
+}
+
+RID RendererSceneCull::scenario_get_environment(RID p_scenario) {
+	Scenario *scenario = scenario_owner.getornull(p_scenario);
+	ERR_FAIL_COND_V(!scenario, RID());
+	return scenario->environment;
 }
 
 /* INSTANCING API */
 
-void RenderingServerScene::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_dependencies) {
+void RendererSceneCull::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_dependencies) {
 	if (p_update_aabb) {
 		p_instance->update_aabb = true;
 	}
@@ -346,7 +360,7 @@ void RenderingServerScene::_instance_queue_update(Instance *p_instance, bool p_u
 	_instance_update_list.add(&p_instance->update_item);
 }
 
-RID RenderingServerScene::instance_create() {
+RID RendererSceneCull::instance_create() {
 	Instance *instance = memnew(Instance);
 	ERR_FAIL_COND_V(!instance, RID());
 
@@ -356,7 +370,23 @@ RID RenderingServerScene::instance_create() {
 	return instance_rid;
 }
 
-void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
+void RendererSceneCull::_instance_update_mesh_instance(Instance *p_instance) {
+	bool needs_instance = RSG::storage->mesh_needs_instance(p_instance->base, p_instance->skeleton.is_valid());
+	if (needs_instance != p_instance->mesh_instance.is_valid()) {
+		if (needs_instance) {
+			p_instance->mesh_instance = RSG::storage->mesh_instance_create(p_instance->base);
+		} else {
+			RSG::storage->free(p_instance->mesh_instance);
+			p_instance->mesh_instance = RID();
+		}
+	}
+
+	if (p_instance->mesh_instance.is_valid()) {
+		RSG::storage->mesh_instance_set_skeleton(p_instance->mesh_instance, p_instance->skeleton);
+	}
+}
+
+void RendererSceneCull::instance_set_base(RID p_instance, RID p_base) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -370,6 +400,11 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 			instance->octree_id = 0;
 		}
 
+		if (instance->mesh_instance.is_valid()) {
+			RSG::storage->free(instance->mesh_instance);
+			instance->mesh_instance = RID();
+		}
+
 		switch (instance->base_type) {
 			case RS::INSTANCE_LIGHT: {
 				InstanceLightData *light = static_cast<InstanceLightData *>(instance->base_data);
@@ -387,18 +422,18 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 					scenario->directional_lights.erase(light->D);
 					light->D = nullptr;
 				}
-				RSG::scene_render->free(light->instance);
+				scene_render->free(light->instance);
 			} break;
 			case RS::INSTANCE_REFLECTION_PROBE: {
 				InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(instance->base_data);
-				RSG::scene_render->free(reflection_probe->instance);
+				scene_render->free(reflection_probe->instance);
 				if (reflection_probe->update_list.in_list()) {
 					reflection_probe_render_list.remove(&reflection_probe->update_list);
 				}
 			} break;
 			case RS::INSTANCE_DECAL: {
 				InstanceDecalData *decal = static_cast<InstanceDecalData *>(instance->base_data);
-				RSG::scene_render->free(decal->instance);
+				scene_render->free(decal->instance);
 
 			} break;
 			case RS::INSTANCE_LIGHTMAP: {
@@ -424,7 +459,7 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 					gi_probe_update_list.remove(&gi_probe->update_element);
 				}
 
-				RSG::scene_render->free(gi_probe->probe_instance);
+				scene_render->free(gi_probe->probe_instance);
 
 			} break;
 			default: {
@@ -436,7 +471,6 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 			instance->base_data = nullptr;
 		}
 
-		instance->blend_values.clear();
 		instance->materials.clear();
 	}
 
@@ -455,7 +489,7 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 					light->D = scenario->directional_lights.push_back(instance);
 				}
 
-				light->instance = RSG::scene_render->light_instance_create(p_base);
+				light->instance = scene_render->light_instance_create(p_base);
 
 				instance->base_data = light;
 			} break;
@@ -465,28 +499,26 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 			case RS::INSTANCE_PARTICLES: {
 				InstanceGeometryData *geom = memnew(InstanceGeometryData);
 				instance->base_data = geom;
-				if (instance->base_type == RS::INSTANCE_MESH) {
-					instance->blend_values.resize(RSG::storage->mesh_get_blend_shape_count(p_base));
-				}
+
 			} break;
 			case RS::INSTANCE_REFLECTION_PROBE: {
 				InstanceReflectionProbeData *reflection_probe = memnew(InstanceReflectionProbeData);
 				reflection_probe->owner = instance;
 				instance->base_data = reflection_probe;
 
-				reflection_probe->instance = RSG::scene_render->reflection_probe_instance_create(p_base);
+				reflection_probe->instance = scene_render->reflection_probe_instance_create(p_base);
 			} break;
 			case RS::INSTANCE_DECAL: {
 				InstanceDecalData *decal = memnew(InstanceDecalData);
 				decal->owner = instance;
 				instance->base_data = decal;
 
-				decal->instance = RSG::scene_render->decal_instance_create(p_base);
+				decal->instance = scene_render->decal_instance_create(p_base);
 			} break;
 			case RS::INSTANCE_LIGHTMAP: {
 				InstanceLightmapData *lightmap_data = memnew(InstanceLightmapData);
 				instance->base_data = lightmap_data;
-				//lightmap_data->instance = RSG::scene_render->lightmap_data_instance_create(p_base);
+				//lightmap_data->instance = scene_render->lightmap_data_instance_create(p_base);
 			} break;
 			case RS::INSTANCE_GI_PROBE: {
 				InstanceGIProbeData *gi_probe = memnew(InstanceGIProbeData);
@@ -497,7 +529,7 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 					gi_probe_update_list.add(&gi_probe->update_element);
 				}
 
-				gi_probe->probe_instance = RSG::scene_render->gi_probe_instance_create(p_base);
+				gi_probe->probe_instance = scene_render->gi_probe_instance_create(p_base);
 
 			} break;
 			default: {
@@ -506,6 +538,10 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 
 		instance->base = p_base;
 
+		if (instance->base_type == RS::INSTANCE_MESH) {
+			_instance_update_mesh_instance(instance);
+		}
+
 		//forcefully update the dependency now, so if for some reason it gets removed, we can immediately clear it
 		RSG::storage->base_update_dependency(p_base, instance);
 	}
@@ -513,7 +549,7 @@ void RenderingServerScene::instance_set_base(RID p_instance, RID p_base) {
 	_instance_queue_update(instance, true, true);
 }
 
-void RenderingServerScene::instance_set_scenario(RID p_instance, RID p_scenario) {
+void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -540,7 +576,7 @@ void RenderingServerScene::instance_set_scenario(RID p_instance, RID p_scenario)
 			} break;
 			case RS::INSTANCE_REFLECTION_PROBE: {
 				InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(instance->base_data);
-				RSG::scene_render->reflection_probe_release_atlas_index(reflection_probe->instance);
+				scene_render->reflection_probe_release_atlas_index(reflection_probe->instance);
 
 			} break;
 			case RS::INSTANCE_PARTICLES_COLLISION: {
@@ -601,14 +637,14 @@ void RenderingServerScene::instance_set_scenario(RID p_instance, RID p_scenario)
 	}
 }
 
-void RenderingServerScene::instance_set_layer_mask(RID p_instance, uint32_t p_mask) {
+void RendererSceneCull::instance_set_layer_mask(RID p_instance, uint32_t p_mask) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->layer_mask = p_mask;
 }
 
-void RenderingServerScene::instance_set_transform(RID p_instance, const Transform &p_transform) {
+void RendererSceneCull::instance_set_transform(RID p_instance, const Transform &p_transform) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -633,14 +669,14 @@ void RenderingServerScene::instance_set_transform(RID p_instance, const Transfor
 	_instance_queue_update(instance, true);
 }
 
-void RenderingServerScene::instance_attach_object_instance_id(RID p_instance, ObjectID p_id) {
+void RendererSceneCull::instance_attach_object_instance_id(RID p_instance, ObjectID p_id) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
 	instance->object_id = p_id;
 }
 
-void RenderingServerScene::instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight) {
+void RendererSceneCull::instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -648,11 +684,12 @@ void RenderingServerScene::instance_set_blend_shape_weight(RID p_instance, int p
 		_update_dirty_instance(instance);
 	}
 
-	ERR_FAIL_INDEX(p_shape, instance->blend_values.size());
-	instance->blend_values.write[p_shape] = p_weight;
+	if (instance->mesh_instance.is_valid()) {
+		RSG::storage->mesh_instance_set_blend_shape_weight(instance->mesh_instance, p_shape, p_weight);
+	}
 }
 
-void RenderingServerScene::instance_set_surface_material(RID p_instance, int p_surface, RID p_material) {
+void RendererSceneCull::instance_set_surface_material(RID p_instance, int p_surface, RID p_material) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -668,7 +705,7 @@ void RenderingServerScene::instance_set_surface_material(RID p_instance, int p_s
 	_instance_queue_update(instance, false, true);
 }
 
-void RenderingServerScene::instance_set_visible(RID p_instance, bool p_visible) {
+void RendererSceneCull::instance_set_visible(RID p_instance, bool p_visible) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -724,7 +761,7 @@ inline bool is_geometry_instance(RenderingServer::InstanceType p_type) {
 	return p_type == RS::INSTANCE_MESH || p_type == RS::INSTANCE_MULTIMESH || p_type == RS::INSTANCE_PARTICLES || p_type == RS::INSTANCE_IMMEDIATE;
 }
 
-void RenderingServerScene::instance_set_custom_aabb(RID p_instance, AABB p_aabb) {
+void RendererSceneCull::instance_set_custom_aabb(RID p_instance, AABB p_aabb) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 	ERR_FAIL_COND(!is_geometry_instance(instance->base_type));
@@ -749,7 +786,7 @@ void RenderingServerScene::instance_set_custom_aabb(RID p_instance, AABB p_aabb)
 	}
 }
 
-void RenderingServerScene::instance_attach_skeleton(RID p_instance, RID p_skeleton) {
+void RendererSceneCull::instance_attach_skeleton(RID p_instance, RID p_skeleton) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -763,13 +800,16 @@ void RenderingServerScene::instance_attach_skeleton(RID p_instance, RID p_skelet
 		//update the dependency now, so if cleared, we remove it
 		RSG::storage->skeleton_update_dependency(p_skeleton, instance);
 	}
+
+	_instance_update_mesh_instance(instance);
+
 	_instance_queue_update(instance, true, true);
 }
 
-void RenderingServerScene::instance_set_exterior(RID p_instance, bool p_enabled) {
+void RendererSceneCull::instance_set_exterior(RID p_instance, bool p_enabled) {
 }
 
-void RenderingServerScene::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) {
+void RendererSceneCull::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -777,12 +817,12 @@ void RenderingServerScene::instance_set_extra_visibility_margin(RID p_instance,
 	_instance_queue_update(instance, true, false);
 }
 
-Vector<ObjectID> RenderingServerScene::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const {
+Vector<ObjectID> RendererSceneCull::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const {
 	Vector<ObjectID> instances;
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND_V(!scenario, instances);
 
-	const_cast<RenderingServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
+	const_cast<RendererSceneCull *>(this)->update_dirty_instances(); // check dirty instances before culling
 
 	int culled = 0;
 	Instance *cull[1024];
@@ -801,11 +841,11 @@ Vector<ObjectID> RenderingServerScene::instances_cull_aabb(const AABB &p_aabb, R
 	return instances;
 }
 
-Vector<ObjectID> RenderingServerScene::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const {
+Vector<ObjectID> RendererSceneCull::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const {
 	Vector<ObjectID> instances;
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND_V(!scenario, instances);
-	const_cast<RenderingServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
+	const_cast<RendererSceneCull *>(this)->update_dirty_instances(); // check dirty instances before culling
 
 	int culled = 0;
 	Instance *cull[1024];
@@ -824,11 +864,11 @@ Vector<ObjectID> RenderingServerScene::instances_cull_ray(const Vector3 &p_from,
 	return instances;
 }
 
-Vector<ObjectID> RenderingServerScene::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario) const {
+Vector<ObjectID> RendererSceneCull::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario) const {
 	Vector<ObjectID> instances;
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 	ERR_FAIL_COND_V(!scenario, instances);
-	const_cast<RenderingServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
+	const_cast<RendererSceneCull *>(this)->update_dirty_instances(); // check dirty instances before culling
 
 	int culled = 0;
 	Instance *cull[1024];
@@ -848,7 +888,7 @@ Vector<ObjectID> RenderingServerScene::instances_cull_convex(const Vector<Plane>
 	return instances;
 }
 
-void RenderingServerScene::instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) {
+void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -885,7 +925,7 @@ void RenderingServerScene::instance_geometry_set_flag(RID p_instance, RS::Instan
 	}
 }
 
-void RenderingServerScene::instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting) {
+void RendererSceneCull::instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -893,7 +933,7 @@ void RenderingServerScene::instance_geometry_set_cast_shadows_setting(RID p_inst
 	_instance_queue_update(instance, false, true);
 }
 
-void RenderingServerScene::instance_geometry_set_material_override(RID p_instance, RID p_material) {
+void RendererSceneCull::instance_geometry_set_material_override(RID p_instance, RID p_material) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -901,13 +941,13 @@ void RenderingServerScene::instance_geometry_set_material_override(RID p_instanc
 	_instance_queue_update(instance, false, true);
 }
 
-void RenderingServerScene::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin) {
+void RendererSceneCull::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin) {
 }
 
-void RenderingServerScene::instance_geometry_set_as_instance_lod(RID p_instance, RID p_as_lod_of_instance) {
+void RendererSceneCull::instance_geometry_set_as_instance_lod(RID p_instance, RID p_as_lod_of_instance) {
 }
 
-void RenderingServerScene::instance_geometry_set_lightmap(RID p_instance, RID p_lightmap, const Rect2 &p_lightmap_uv_scale, int p_slice_index) {
+void RendererSceneCull::instance_geometry_set_lightmap(RID p_instance, RID p_lightmap, const Rect2 &p_lightmap_uv_scale, int p_slice_index) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
@@ -929,14 +969,21 @@ void RenderingServerScene::instance_geometry_set_lightmap(RID p_instance, RID p_
 	}
 }
 
-void RenderingServerScene::instance_geometry_set_shader_parameter(RID p_instance, const StringName &p_parameter, const Variant &p_value) {
+void RendererSceneCull::instance_geometry_set_lod_bias(RID p_instance, float p_lod_bias) {
+	Instance *instance = instance_owner.getornull(p_instance);
+	ERR_FAIL_COND(!instance);
+
+	instance->lod_bias = p_lod_bias;
+}
+
+void RendererSceneCull::instance_geometry_set_shader_parameter(RID p_instance, const StringName &p_parameter, const Variant &p_value) {
 	Instance *instance = instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
-	Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter>::Element *E = instance->instance_shader_parameters.find(p_parameter);
+	Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter>::Element *E = instance->instance_shader_parameters.find(p_parameter);
 
 	if (!E) {
-		RasterizerScene::InstanceBase::InstanceShaderParameter isp;
+		RendererSceneRender::InstanceBase::InstanceShaderParameter isp;
 		isp.index = -1;
 		isp.info = PropertyInfo();
 		isp.value = p_value;
@@ -950,8 +997,8 @@ void RenderingServerScene::instance_geometry_set_shader_parameter(RID p_instance
 	}
 }
 
-Variant RenderingServerScene::instance_geometry_get_shader_parameter(RID p_instance, const StringName &p_parameter) const {
-	const Instance *instance = const_cast<RenderingServerScene *>(this)->instance_owner.getornull(p_instance);
+Variant RendererSceneCull::instance_geometry_get_shader_parameter(RID p_instance, const StringName &p_parameter) const {
+	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!instance, Variant());
 
 	if (instance->instance_shader_parameters.has(p_parameter)) {
@@ -960,8 +1007,8 @@ Variant RenderingServerScene::instance_geometry_get_shader_parameter(RID p_insta
 	return Variant();
 }
 
-Variant RenderingServerScene::instance_geometry_get_shader_parameter_default_value(RID p_instance, const StringName &p_parameter) const {
-	const Instance *instance = const_cast<RenderingServerScene *>(this)->instance_owner.getornull(p_instance);
+Variant RendererSceneCull::instance_geometry_get_shader_parameter_default_value(RID p_instance, const StringName &p_parameter) const {
+	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.getornull(p_instance);
 	ERR_FAIL_COND_V(!instance, Variant());
 
 	if (instance->instance_shader_parameters.has(p_parameter)) {
@@ -970,14 +1017,14 @@ Variant RenderingServerScene::instance_geometry_get_shader_parameter_default_val
 	return Variant();
 }
 
-void RenderingServerScene::instance_geometry_get_shader_parameter_list(RID p_instance, List<PropertyInfo> *p_parameters) const {
-	const Instance *instance = const_cast<RenderingServerScene *>(this)->instance_owner.getornull(p_instance);
+void RendererSceneCull::instance_geometry_get_shader_parameter_list(RID p_instance, List<PropertyInfo> *p_parameters) const {
+	const Instance *instance = const_cast<RendererSceneCull *>(this)->instance_owner.getornull(p_instance);
 	ERR_FAIL_COND(!instance);
 
-	const_cast<RenderingServerScene *>(this)->update_dirty_instances();
+	const_cast<RendererSceneCull *>(this)->update_dirty_instances();
 
 	Vector<StringName> names;
-	for (Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter>::Element *E = instance->instance_shader_parameters.front(); E; E = E->next()) {
+	for (Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter>::Element *E = instance->instance_shader_parameters.front(); E; E = E->next()) {
 		names.push_back(E->key());
 	}
 	names.sort_custom<StringName::AlphCompare>();
@@ -987,14 +1034,14 @@ void RenderingServerScene::instance_geometry_get_shader_parameter_list(RID p_ins
 	}
 }
 
-void RenderingServerScene::_update_instance(Instance *p_instance) {
+void RendererSceneCull::_update_instance(Instance *p_instance) {
 	p_instance->version++;
 
 	if (p_instance->base_type == RS::INSTANCE_LIGHT) {
 		InstanceLightData *light = static_cast<InstanceLightData *>(p_instance->base_data);
 
-		RSG::scene_render->light_instance_set_transform(light->instance, p_instance->transform);
-		RSG::scene_render->light_instance_set_aabb(light->instance, p_instance->transform.xform(p_instance->aabb));
+		scene_render->light_instance_set_transform(light->instance, p_instance->transform);
+		scene_render->light_instance_set_aabb(light->instance, p_instance->transform.xform(p_instance->aabb));
 		light->shadow_dirty = true;
 
 		RS::LightBakeMode bake_mode = RSG::storage->light_get_bake_mode(p_instance->base);
@@ -1019,20 +1066,20 @@ void RenderingServerScene::_update_instance(Instance *p_instance) {
 	if (p_instance->base_type == RS::INSTANCE_REFLECTION_PROBE) {
 		InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(p_instance->base_data);
 
-		RSG::scene_render->reflection_probe_instance_set_transform(reflection_probe->instance, p_instance->transform);
+		scene_render->reflection_probe_instance_set_transform(reflection_probe->instance, p_instance->transform);
 		reflection_probe->reflection_dirty = true;
 	}
 
 	if (p_instance->base_type == RS::INSTANCE_DECAL) {
 		InstanceDecalData *decal = static_cast<InstanceDecalData *>(p_instance->base_data);
 
-		RSG::scene_render->decal_instance_set_transform(decal->instance, p_instance->transform);
+		scene_render->decal_instance_set_transform(decal->instance, p_instance->transform);
 	}
 
 	if (p_instance->base_type == RS::INSTANCE_GI_PROBE) {
 		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(p_instance->base_data);
 
-		RSG::scene_render->gi_probe_instance_set_transform_to_data(gi_probe->probe_instance, p_instance->transform);
+		scene_render->gi_probe_instance_set_transform_to_data(gi_probe->probe_instance, p_instance->transform);
 	}
 
 	if (p_instance->base_type == RS::INSTANCE_PARTICLES) {
@@ -1129,7 +1176,7 @@ void RenderingServerScene::_update_instance(Instance *p_instance) {
 	}
 }
 
-void RenderingServerScene::_update_instance_aabb(Instance *p_instance) {
+void RendererSceneCull::_update_instance_aabb(Instance *p_instance) {
 	AABB new_aabb;
 
 	ERR_FAIL_COND(p_instance->base_type != RS::INSTANCE_NONE && !p_instance->base.is_valid());
@@ -1207,7 +1254,7 @@ void RenderingServerScene::_update_instance_aabb(Instance *p_instance) {
 	p_instance->aabb = new_aabb;
 }
 
-void RenderingServerScene::_update_instance_lightmap_captures(Instance *p_instance) {
+void RendererSceneCull::_update_instance_lightmap_captures(Instance *p_instance) {
 	bool first_set = p_instance->lightmap_sh.size() == 0;
 	p_instance->lightmap_sh.resize(9); //using SH
 	p_instance->lightmap_target_sh.resize(9); //using SH
@@ -1285,7 +1332,7 @@ void RenderingServerScene::_update_instance_lightmap_captures(Instance *p_instan
 	}
 }
 
-bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_shadow_atlas, Scenario *p_scenario) {
+bool RendererSceneCull::_light_instance_update_shadow(Instance *p_instance, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_shadow_atlas, Scenario *p_scenario, float p_screen_lod_threshold) {
 	InstanceLightData *light = static_cast<InstanceLightData *>(p_instance->base_data);
 
 	Transform light_transform = p_instance->transform;
@@ -1295,6 +1342,8 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 
 	switch (RSG::storage->light_get_type(p_instance->base)) {
 		case RS::LIGHT_DIRECTIONAL: {
+			Plane camera_plane(p_cam_transform.get_origin(), -p_cam_transform.basis.get_axis(Vector3::AXIS_Z));
+
 			real_t max_distance = p_cam_projection.get_z_far();
 			real_t shadow_max = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SHADOW_MAX_DISTANCE);
 			if (shadow_max > 0 && !p_cam_orthogonal) { //its impractical (and leads to unwanted behaviors) to set max distance in orthogonal camera
@@ -1372,7 +1421,7 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 
 			distances[splits] = max_distance;
 
-			real_t texture_size = RSG::scene_render->get_directional_light_shadow_size(light->instance);
+			real_t texture_size = scene_render->get_directional_light_shadow_size(light->instance);
 
 			bool overlap = RSG::storage->light_directional_get_blend_splits(p_instance->base);
 
@@ -1557,6 +1606,10 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 					if (j == 0 || max > cull_max) {
 						cull_max = max;
 					}
+
+					if (instance->mesh_instance.is_valid()) {
+						RSG::storage->mesh_instance_check_for_update(instance->mesh_instance);
+					}
 				}
 
 				if (cull_max > z_max) {
@@ -1654,17 +1707,19 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 						cull_max = dir_in_view.dot(max_in_view);
 					}
 
-					RSG::scene_render->light_instance_set_shadow_transform(light->instance, ortho_camera, ortho_transform, z_max - z_min_cam, distances[i + 1], i, radius * 2.0 / texture_size, bias_scale * aspect_bias_scale * min_distance_bias_scale, z_max, uv_scale);
+					scene_render->light_instance_set_shadow_transform(light->instance, ortho_camera, ortho_transform, z_max - z_min_cam, distances[i + 1], i, radius * 2.0 / texture_size, bias_scale * aspect_bias_scale * min_distance_bias_scale, z_max, uv_scale);
 				}
 
-				RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
+				RSG::storage->update_mesh_instances();
+
+				scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RendererSceneRender::InstanceBase **)instance_shadow_cull_result, cull_count, camera_plane, p_cam_projection.get_lod_multiplier(), p_screen_lod_threshold);
 			}
 
 		} break;
 		case RS::LIGHT_OMNI: {
 			RS::LightOmniShadowMode shadow_mode = RSG::storage->light_omni_get_shadow_mode(p_instance->base);
 
-			if (shadow_mode == RS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID || !RSG::scene_render->light_instances_can_render_shadow_cube()) {
+			if (shadow_mode == RS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID || !scene_render->light_instances_can_render_shadow_cube()) {
 				for (int i = 0; i < 2; i++) {
 					//using this one ensures that raster deferred will have it
 					RENDER_TIMESTAMP("Culling Shadow Paraboloid" + itos(i));
@@ -1697,11 +1752,17 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 
 							instance->depth = near_plane.distance_to(instance->transform.origin);
 							instance->depth_layer = 0;
+
+							if (instance->mesh_instance.is_valid()) {
+								RSG::storage->mesh_instance_check_for_update(instance->mesh_instance);
+							}
 						}
 					}
 
-					RSG::scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, i, 0);
-					RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
+					RSG::storage->update_mesh_instances();
+
+					scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, i, 0);
+					scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RendererSceneRender::InstanceBase **)instance_shadow_cull_result, cull_count);
 				}
 			} else { //shadow cube
 
@@ -1749,15 +1810,19 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 							}
 							instance->depth = near_plane.distance_to(instance->transform.origin);
 							instance->depth_layer = 0;
+							if (instance->mesh_instance.is_valid()) {
+								RSG::storage->mesh_instance_check_for_update(instance->mesh_instance);
+							}
 						}
 					}
 
-					RSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, xform, radius, 0, i, 0);
-					RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
+					RSG::storage->update_mesh_instances();
+					scene_render->light_instance_set_shadow_transform(light->instance, cm, xform, radius, 0, i, 0);
+					scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RendererSceneRender::InstanceBase **)instance_shadow_cull_result, cull_count);
 				}
 
 				//restore the regular DP matrix
-				RSG::scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, 0, 0);
+				scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, 0, 0);
 			}
 
 		} break;
@@ -1786,11 +1851,17 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 					}
 					instance->depth = near_plane.distance_to(instance->transform.origin);
 					instance->depth_layer = 0;
+
+					if (instance->mesh_instance.is_valid()) {
+						RSG::storage->mesh_instance_check_for_update(instance->mesh_instance);
+					}
 				}
 			}
 
-			RSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, light_transform, radius, 0, 0, 0);
-			RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, 0, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
+			RSG::storage->update_mesh_instances();
+
+			scene_render->light_instance_set_shadow_transform(light->instance, cm, light_transform, radius, 0, 0, 0);
+			scene_render->render_shadow(light->instance, p_shadow_atlas, 0, (RendererSceneRender::InstanceBase **)instance_shadow_cull_result, cull_count);
 
 		} break;
 	}
@@ -1798,7 +1869,7 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
 	return animated_material_found;
 }
 
-void RenderingServerScene::render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas) {
+void RendererSceneCull::render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, Size2 p_viewport_size, float p_screen_lod_threshold, RID p_shadow_atlas) {
 // render to mono camera
 #ifndef _3D_DISABLED
 
@@ -1843,12 +1914,12 @@ void RenderingServerScene::render_camera(RID p_render_buffers, RID p_camera, RID
 
 	RID environment = _render_get_environment(p_camera, p_scenario);
 
-	_prepare_scene(camera->transform, camera_matrix, ortho, camera->vaspect, p_render_buffers, environment, camera->visible_layers, p_scenario, p_shadow_atlas, RID());
-	_render_scene(p_render_buffers, camera->transform, camera_matrix, ortho, environment, camera->effects, p_scenario, p_shadow_atlas, RID(), -1);
+	_prepare_scene(camera->transform, camera_matrix, ortho, camera->vaspect, p_render_buffers, environment, camera->visible_layers, p_scenario, p_shadow_atlas, RID(), p_screen_lod_threshold);
+	_render_scene(p_render_buffers, camera->transform, camera_matrix, ortho, environment, camera->effects, p_scenario, p_shadow_atlas, RID(), -1, p_screen_lod_threshold);
 #endif
 }
 
-void RenderingServerScene::render_camera(RID p_render_buffers, Ref<XRInterface> &p_interface, XRInterface::Eyes p_eye, RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas) {
+void RendererSceneCull::render_camera(RID p_render_buffers, Ref<XRInterface> &p_interface, XRInterface::Eyes p_eye, RID p_camera, RID p_scenario, Size2 p_viewport_size, float p_screen_lod_threshold, RID p_shadow_atlas) {
 	// render for AR/VR interface
 
 	Camera *camera = camera_owner.getornull(p_camera);
@@ -1922,17 +1993,17 @@ void RenderingServerScene::render_camera(RID p_render_buffers, Ref<XRInterface>
 		mono_transform *= apply_z_shift;
 
 		// now prepare our scene with our adjusted transform projection matrix
-		_prepare_scene(mono_transform, combined_matrix, false, false, p_render_buffers, environment, camera->visible_layers, p_scenario, p_shadow_atlas, RID());
+		_prepare_scene(mono_transform, combined_matrix, false, false, p_render_buffers, environment, camera->visible_layers, p_scenario, p_shadow_atlas, RID(), p_screen_lod_threshold);
 	} else if (p_eye == XRInterface::EYE_MONO) {
 		// For mono render, prepare as per usual
-		_prepare_scene(cam_transform, camera_matrix, false, false, p_render_buffers, environment, camera->visible_layers, p_scenario, p_shadow_atlas, RID());
+		_prepare_scene(cam_transform, camera_matrix, false, false, p_render_buffers, environment, camera->visible_layers, p_scenario, p_shadow_atlas, RID(), p_screen_lod_threshold);
 	}
 
 	// And render our scene...
-	_render_scene(p_render_buffers, cam_transform, camera_matrix, false, environment, camera->effects, p_scenario, p_shadow_atlas, RID(), -1);
+	_render_scene(p_render_buffers, cam_transform, camera_matrix, false, environment, camera->effects, p_scenario, p_shadow_atlas, RID(), -1, p_screen_lod_threshold);
 };
 
-void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_render_buffers, RID p_environment, uint32_t p_visible_layers, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, bool p_using_shadows) {
+void RendererSceneCull::_prepare_scene(const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_render_buffers, RID p_environment, uint32_t p_visible_layers, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, float p_screen_lod_threshold, bool p_using_shadows) {
 	// Note, in stereo rendering:
 	// - p_cam_transform will be a transform in the middle of our two eyes
 	// - p_cam_projection is a wider frustrum that encompasses both eyes
@@ -1942,10 +2013,10 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 	render_pass++;
 	uint32_t camera_layer_mask = p_visible_layers;
 
-	RSG::scene_render->set_scene_pass(render_pass);
+	scene_render->set_scene_pass(render_pass);
 
 	if (p_render_buffers.is_valid()) {
-		RSG::scene_render->sdfgi_update(p_render_buffers, p_environment, p_cam_transform.origin); //update conditions for SDFGI (whether its used or not)
+		scene_render->sdfgi_update(p_render_buffers, p_environment, p_cam_transform.origin); //update conditions for SDFGI (whether its used or not)
 	}
 
 	RENDER_TIMESTAMP("Frustum Culling");
@@ -1998,7 +2069,7 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 					light_cull_result[light_cull_count] = ins;
 					light_instance_cull_result[light_cull_count] = light->instance;
 					if (p_shadow_atlas.is_valid() && RSG::storage->light_has_shadow(ins->base)) {
-						RSG::scene_render->light_instance_mark_visible(light->instance); //mark it visible for shadow allocation later
+						scene_render->light_instance_mark_visible(light->instance); //mark it visible for shadow allocation later
 					}
 
 					light_cull_count++;
@@ -2014,7 +2085,7 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 					if (!reflection_probe->geometries.empty()) {
 						//do not add this light if no geometry is affected by it..
 
-						if (reflection_probe->reflection_dirty || RSG::scene_render->reflection_probe_instance_needs_redraw(reflection_probe->instance)) {
+						if (reflection_probe->reflection_dirty || scene_render->reflection_probe_instance_needs_redraw(reflection_probe->instance)) {
 							if (!reflection_probe->update_list.in_list()) {
 								reflection_probe->render_step = 0;
 								reflection_probe_render_list.add_last(&reflection_probe->update_list);
@@ -2023,7 +2094,7 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 							reflection_probe->reflection_dirty = false;
 						}
 
-						if (RSG::scene_render->reflection_probe_instance_has_reflection(reflection_probe->instance)) {
+						if (scene_render->reflection_probe_instance_has_reflection(reflection_probe->instance)) {
 							reflection_probe_instance_cull_result[reflection_probe_cull_count] = reflection_probe->instance;
 							reflection_probe_cull_count++;
 						}
@@ -2063,7 +2134,7 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 			InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(ins->base_data);
 
 			if (ins->redraw_if_visible) {
-				RenderingServerRaster::redraw_request();
+				RenderingServerDefault::redraw_request();
 			}
 
 			if (ins->base_type == RS::INSTANCE_PARTICLES) {
@@ -2075,7 +2146,7 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 					RSG::storage->particles_request_process(ins->base);
 					RSG::storage->particles_set_view_axis(ins->base, -p_cam_transform.basis.get_axis(2).normalized());
 					//particles visible? request redraw
-					RenderingServerRaster::redraw_request();
+					RenderingServerDefault::redraw_request();
 				}
 			}
 
@@ -2129,6 +2200,10 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 				}
 			}
 
+			if (ins->mesh_instance.is_valid()) {
+				RSG::storage->mesh_instance_check_for_update(ins->mesh_instance);
+			}
+
 			ins->depth = near_plane.distance_to(ins->transform.origin);
 			ins->depth_layer = CLAMP(int(ins->depth * 16 / z_far), 0, 15);
 		}
@@ -2145,6 +2220,8 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 		ins->last_frame_pass = frame_number;
 	}
 
+	RSG::storage->update_mesh_instances();
+
 	/* STEP 5 - PROCESS LIGHTS */
 
 	RID *directional_light_ptr = &light_instance_cull_result[light_cull_count];
@@ -2169,7 +2246,7 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 			//check shadow..
 
 			if (light) {
-				if (p_using_shadows && p_shadow_atlas.is_valid() && RSG::storage->light_has_shadow(E->get()->base)) {
+				if (p_using_shadows && p_shadow_atlas.is_valid() && RSG::storage->light_has_shadow(E->get()->base) && !(RSG::storage->light_get_type(E->get()->base) == RS::LIGHT_DIRECTIONAL && RSG::storage->light_directional_is_sky_only(E->get()->base))) {
 					lights_with_shadow[directional_shadow_count++] = E->get();
 				}
 				//add to list
@@ -2177,12 +2254,12 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 			}
 		}
 
-		RSG::scene_render->set_directional_shadow_count(directional_shadow_count);
+		scene_render->set_directional_shadow_count(directional_shadow_count);
 
 		for (int i = 0; i < directional_shadow_count; i++) {
 			RENDER_TIMESTAMP(">Rendering Directional Light " + itos(i));
 
-			_light_instance_update_shadow(lights_with_shadow[i], p_cam_transform, p_cam_projection, p_cam_orthogonal, p_cam_vaspect, p_shadow_atlas, scenario);
+			_light_instance_update_shadow(lights_with_shadow[i], p_cam_transform, p_cam_projection, p_cam_orthogonal, p_cam_vaspect, p_shadow_atlas, scenario, p_screen_lod_threshold);
 
 			RENDER_TIMESTAMP("<Rendering Directional Light " + itos(i));
 		}
@@ -2276,12 +2353,12 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 				light->shadow_dirty = false;
 			}
 
-			bool redraw = RSG::scene_render->shadow_atlas_update_light(p_shadow_atlas, light->instance, coverage, light->last_version);
+			bool redraw = scene_render->shadow_atlas_update_light(p_shadow_atlas, light->instance, coverage, light->last_version);
 
 			if (redraw) {
 				//must redraw!
 				RENDER_TIMESTAMP(">Rendering Light " + itos(i));
-				light->shadow_dirty = _light_instance_update_shadow(ins, p_cam_transform, p_cam_projection, p_cam_orthogonal, p_cam_vaspect, p_shadow_atlas, scenario);
+				light->shadow_dirty = _light_instance_update_shadow(ins, p_cam_transform, p_cam_projection, p_cam_orthogonal, p_cam_vaspect, p_shadow_atlas, scenario, p_screen_lod_threshold);
 				RENDER_TIMESTAMP("<Rendering Light " + itos(i));
 			}
 		}
@@ -2297,9 +2374,9 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 		uint32_t sdfgi_light_cull_count = 0;
 
 		uint32_t prev_cascade = 0xFFFFFFFF;
-		for (int i = 0; i < RSG::scene_render->sdfgi_get_pending_region_count(p_render_buffers); i++) {
-			AABB region = RSG::scene_render->sdfgi_get_pending_region_bounds(p_render_buffers, i);
-			uint32_t region_cascade = RSG::scene_render->sdfgi_get_pending_region_cascade(p_render_buffers, i);
+		for (int i = 0; i < scene_render->sdfgi_get_pending_region_count(p_render_buffers); i++) {
+			AABB region = scene_render->sdfgi_get_pending_region_bounds(p_render_buffers, i);
+			uint32_t region_cascade = scene_render->sdfgi_get_pending_region_cascade(p_render_buffers, i);
 
 			if (region_cascade != prev_cascade) {
 				cascade_sizes[cascade_count] = 0;
@@ -2330,6 +2407,9 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 				} else if ((1 << ins->base_type) & RS::INSTANCE_GEOMETRY_MASK) {
 					if (ins->baked_light) {
 						keep = true;
+						if (ins->mesh_instance.is_valid()) {
+							RSG::storage->mesh_instance_check_for_update(ins->mesh_instance);
+						}
 					}
 				}
 
@@ -2341,21 +2421,23 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
 				}
 			}
 
-			RSG::scene_render->render_sdfgi(p_render_buffers, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, sdfgi_cull_count);
+			RSG::storage->update_mesh_instances();
+
+			scene_render->render_sdfgi(p_render_buffers, i, (RendererSceneRender::InstanceBase **)instance_shadow_cull_result, sdfgi_cull_count);
 			//have to save updated cascades, then update static lights.
 		}
 
 		if (sdfgi_light_cull_count) {
-			RSG::scene_render->render_sdfgi_static_lights(p_render_buffers, cascade_count, cascade_index, cascade_ptrs, cascade_sizes);
+			scene_render->render_sdfgi_static_lights(p_render_buffers, cascade_count, cascade_index, cascade_ptrs, cascade_sizes);
 		}
 
-		RSG::scene_render->sdfgi_update_probes(p_render_buffers, p_environment, directional_light_ptr, directional_light_count, scenario->dynamic_lights.ptr(), scenario->dynamic_lights.size());
+		scene_render->sdfgi_update_probes(p_render_buffers, p_environment, directional_light_ptr, directional_light_count, scenario->dynamic_lights.ptr(), scenario->dynamic_lights.size());
 	}
 }
 
-RID RenderingServerScene::_render_get_environment(RID p_camera, RID p_scenario) {
+RID RendererSceneCull::_render_get_environment(RID p_camera, RID p_scenario) {
 	Camera *camera = camera_owner.getornull(p_camera);
-	if (camera && RSG::scene_render->is_environment(camera->env)) {
+	if (camera && scene_render->is_environment(camera->env)) {
 		return camera->env;
 	}
 
@@ -2363,18 +2445,18 @@ RID RenderingServerScene::_render_get_environment(RID p_camera, RID p_scenario)
 	if (!scenario) {
 		return RID();
 	}
-	if (RSG::scene_render->is_environment(scenario->environment)) {
+	if (scene_render->is_environment(scenario->environment)) {
 		return scenario->environment;
 	}
 
-	if (RSG::scene_render->is_environment(scenario->fallback_environment)) {
+	if (scene_render->is_environment(scenario->fallback_environment)) {
 		return scenario->fallback_environment;
 	}
 
 	return RID();
 }
 
-void RenderingServerScene::_render_scene(RID p_render_buffers, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, RID p_environment, RID p_force_camera_effects, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass) {
+void RendererSceneCull::_render_scene(RID p_render_buffers, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, RID p_environment, RID p_force_camera_effects, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold) {
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
 
 	RID camera_effects;
@@ -2386,10 +2468,10 @@ void RenderingServerScene::_render_scene(RID p_render_buffers, const Transform p
 	/* PROCESS GEOMETRY AND DRAW SCENE */
 
 	RENDER_TIMESTAMP("Render Scene ");
-	RSG::scene_render->render_scene(p_render_buffers, p_cam_transform, p_cam_projection, p_cam_orthogonal, (RasterizerScene::InstanceBase **)instance_cull_result, instance_cull_count, light_instance_cull_result, light_cull_count + directional_light_count, reflection_probe_instance_cull_result, reflection_probe_cull_count, gi_probe_instance_cull_result, gi_probe_cull_count, decal_instance_cull_result, decal_cull_count, (RasterizerScene::InstanceBase **)lightmap_cull_result, lightmap_cull_count, p_environment, camera_effects, p_shadow_atlas, p_reflection_probe.is_valid() ? RID() : scenario->reflection_atlas, p_reflection_probe, p_reflection_probe_pass);
+	scene_render->render_scene(p_render_buffers, p_cam_transform, p_cam_projection, p_cam_orthogonal, (RendererSceneRender::InstanceBase **)instance_cull_result, instance_cull_count, light_instance_cull_result, light_cull_count + directional_light_count, reflection_probe_instance_cull_result, reflection_probe_cull_count, gi_probe_instance_cull_result, gi_probe_cull_count, decal_instance_cull_result, decal_cull_count, (RendererSceneRender::InstanceBase **)lightmap_cull_result, lightmap_cull_count, p_environment, camera_effects, p_shadow_atlas, p_reflection_probe.is_valid() ? RID() : scenario->reflection_atlas, p_reflection_probe, p_reflection_probe_pass, p_screen_lod_threshold);
 }
 
-void RenderingServerScene::render_empty_scene(RID p_render_buffers, RID p_scenario, RID p_shadow_atlas) {
+void RendererSceneCull::render_empty_scene(RID p_render_buffers, RID p_scenario, RID p_shadow_atlas) {
 #ifndef _3D_DISABLED
 
 	Scenario *scenario = scenario_owner.getornull(p_scenario);
@@ -2401,19 +2483,19 @@ void RenderingServerScene::render_empty_scene(RID p_render_buffers, RID p_scenar
 		environment = scenario->fallback_environment;
 	}
 	RENDER_TIMESTAMP("Render Empty Scene ");
-	RSG::scene_render->render_scene(p_render_buffers, Transform(), CameraMatrix(), true, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, environment, RID(), p_shadow_atlas, scenario->reflection_atlas, RID(), 0);
+	scene_render->render_scene(p_render_buffers, Transform(), CameraMatrix(), true, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, nullptr, 0, environment, RID(), p_shadow_atlas, scenario->reflection_atlas, RID(), 0, 0);
 #endif
 }
 
-bool RenderingServerScene::_render_reflection_probe_step(Instance *p_instance, int p_step) {
+bool RendererSceneCull::_render_reflection_probe_step(Instance *p_instance, int p_step) {
 	InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(p_instance->base_data);
 	Scenario *scenario = p_instance->scenario;
 	ERR_FAIL_COND_V(!scenario, true);
 
-	RenderingServerRaster::redraw_request(); //update, so it updates in editor
+	RenderingServerDefault::redraw_request(); //update, so it updates in editor
 
 	if (p_step == 0) {
-		if (!RSG::scene_render->reflection_probe_instance_begin_render(reflection_probe->instance, scenario->reflection_atlas)) {
+		if (!scene_render->reflection_probe_instance_begin_render(reflection_probe->instance, scenario->reflection_atlas)) {
 			return true; //all full
 		}
 	}
@@ -2439,6 +2521,8 @@ bool RenderingServerScene::_render_reflection_probe_step(Instance *p_instance, i
 		Vector3 extents = RSG::storage->reflection_probe_get_extents(p_instance->base);
 		Vector3 origin_offset = RSG::storage->reflection_probe_get_origin_offset(p_instance->base);
 		float max_distance = RSG::storage->reflection_probe_get_origin_max_distance(p_instance->base);
+		float size = scene_render->reflection_atlas_get_size(scenario->reflection_atlas);
+		float lod_threshold = RSG::storage->reflection_probe_get_lod_threshold(p_instance->base) / size;
 
 		Vector3 edge = view_normals[p_step] * extents;
 		float distance = ABS(view_normals[p_step].dot(edge) - view_normals[p_step].dot(origin_offset)); //distance from origin offset to actual view distance limit
@@ -2462,19 +2546,19 @@ bool RenderingServerScene::_render_reflection_probe_step(Instance *p_instance, i
 		}
 
 		RENDER_TIMESTAMP("Render Reflection Probe, Step " + itos(p_step));
-		_prepare_scene(xform, cm, false, false, RID(), RID(), RSG::storage->reflection_probe_get_cull_mask(p_instance->base), p_instance->scenario->self, shadow_atlas, reflection_probe->instance, use_shadows);
-		_render_scene(RID(), xform, cm, false, RID(), RID(), p_instance->scenario->self, shadow_atlas, reflection_probe->instance, p_step);
+		_prepare_scene(xform, cm, false, false, RID(), RID(), RSG::storage->reflection_probe_get_cull_mask(p_instance->base), p_instance->scenario->self, shadow_atlas, reflection_probe->instance, lod_threshold, use_shadows);
+		_render_scene(RID(), xform, cm, false, RID(), RID(), p_instance->scenario->self, shadow_atlas, reflection_probe->instance, p_step, lod_threshold);
 
 	} else {
 		//do roughness postprocess step until it believes it's done
 		RENDER_TIMESTAMP("Post-Process Reflection Probe, Step " + itos(p_step));
-		return RSG::scene_render->reflection_probe_instance_postprocess_step(reflection_probe->instance);
+		return scene_render->reflection_probe_instance_postprocess_step(reflection_probe->instance);
 	}
 
 	return false;
 }
 
-void RenderingServerScene::render_probes() {
+void RendererSceneCull::render_probes() {
 	/* REFLECTION PROBES */
 
 	SelfList<InstanceReflectionProbeData> *ref_probe = reflection_probe_render_list.first();
@@ -2595,7 +2679,8 @@ void RenderingServerScene::render_probes() {
 							cache->radius != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE) ||
 							cache->attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION) ||
 							cache->spot_angle != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE) ||
-							cache->spot_attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION)) {
+							cache->spot_attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION) ||
+							cache->sky_only != RSG::storage->light_directional_is_sky_only(instance->base)) {
 						cache_dirty = true;
 					}
 				}
@@ -2610,7 +2695,7 @@ void RenderingServerScene::render_probes() {
 			cache_count = idx;
 		}
 
-		bool update_lights = RSG::scene_render->gi_probe_needs_update(probe->probe_instance);
+		bool update_lights = scene_render->gi_probe_needs_update(probe->probe_instance);
 
 		if (cache_dirty) {
 			probe->light_cache.resize(cache_count);
@@ -2664,6 +2749,7 @@ void RenderingServerScene::render_probes() {
 					cache->attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION);
 					cache->spot_angle = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE);
 					cache->spot_attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION);
+					cache->sky_only = RSG::storage->light_directional_is_sky_only(instance->base);
 
 					idx++;
 				}
@@ -2700,7 +2786,7 @@ void RenderingServerScene::render_probes() {
 			}
 		}
 
-		RSG::scene_render->gi_probe_update(probe->probe_instance, update_lights, probe->light_instances, instance_cull_count, (RasterizerScene::InstanceBase **)instance_cull_result);
+		scene_render->gi_probe_update(probe->probe_instance, update_lights, probe->light_instances, instance_cull_count, (RendererSceneRender::InstanceBase **)instance_cull_result);
 
 		gi_probe_update_list.remove(gi_probe);
 
@@ -2708,7 +2794,7 @@ void RenderingServerScene::render_probes() {
 	}
 }
 
-void RenderingServerScene::render_particle_colliders() {
+void RendererSceneCull::render_particle_colliders() {
 	while (heightfield_particle_colliders_update_list.front()) {
 		Instance *hfpc = heightfield_particle_colliders_update_list.front()->get();
 
@@ -2723,16 +2809,16 @@ void RenderingServerScene::render_particle_colliders() {
 				}
 			}
 
-			RSG::scene_render->render_particle_collider_heightfield(hfpc->base, hfpc->transform, (RasterizerScene::InstanceBase **)instance_cull_result, cull_count);
+			scene_render->render_particle_collider_heightfield(hfpc->base, hfpc->transform, (RendererSceneRender::InstanceBase **)instance_cull_result, cull_count);
 		}
 		heightfield_particle_colliders_update_list.erase(heightfield_particle_colliders_update_list.front());
 	}
 }
 
-void RenderingServerScene::_update_instance_shader_parameters_from_material(Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter> &isparams, const Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter> &existing_isparams, RID p_material) {
-	List<RasterizerStorage::InstanceShaderParam> plist;
+void RendererSceneCull::_update_instance_shader_parameters_from_material(Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter> &isparams, const Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter> &existing_isparams, RID p_material) {
+	List<RendererStorage::InstanceShaderParam> plist;
 	RSG::storage->material_get_instance_shader_parameters(p_material, &plist);
-	for (List<RasterizerStorage::InstanceShaderParam>::Element *E = plist.front(); E; E = E->next()) {
+	for (List<RendererStorage::InstanceShaderParam>::Element *E = plist.front(); E; E = E->next()) {
 		StringName name = E->get().info.name;
 		if (isparams.has(name)) {
 			if (isparams[name].info.type != E->get().info.type) {
@@ -2744,7 +2830,7 @@ void RenderingServerScene::_update_instance_shader_parameters_from_material(Map<
 			continue; //first one found always has priority
 		}
 
-		RasterizerScene::InstanceBase::InstanceShaderParameter isp;
+		RendererSceneRender::InstanceBase::InstanceShaderParameter isp;
 		isp.index = E->get().index;
 		isp.info = E->get().info;
 		isp.default_value = E->get().default_value;
@@ -2757,7 +2843,7 @@ void RenderingServerScene::_update_instance_shader_parameters_from_material(Map<
 	}
 }
 
-void RenderingServerScene::_update_dirty_instance(Instance *p_instance) {
+void RendererSceneCull::_update_dirty_instance(Instance *p_instance) {
 	if (p_instance->update_aabb) {
 		_update_instance_aabb(p_instance);
 	}
@@ -2779,13 +2865,7 @@ void RenderingServerScene::_update_dirty_instance(Instance *p_instance) {
 			int new_mat_count = RSG::storage->mesh_get_surface_count(p_instance->base);
 			p_instance->materials.resize(new_mat_count);
 
-			int new_blend_shape_count = RSG::storage->mesh_get_blend_shape_count(p_instance->base);
-			if (new_blend_shape_count != p_instance->blend_values.size()) {
-				p_instance->blend_values.resize(new_blend_shape_count);
-				for (int i = 0; i < new_blend_shape_count; i++) {
-					p_instance->blend_values.write[i] = 0;
-				}
-			}
+			_instance_update_mesh_instance(p_instance);
 		}
 
 		if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) {
@@ -2793,7 +2873,7 @@ void RenderingServerScene::_update_dirty_instance(Instance *p_instance) {
 
 			bool can_cast_shadows = true;
 			bool is_animated = false;
-			Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter> isparams;
+			Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter> isparams;
 
 			if (p_instance->cast_shadows == RS::SHADOW_CASTING_SETTING_OFF) {
 				can_cast_shadows = false;
@@ -2944,7 +3024,7 @@ void RenderingServerScene::_update_dirty_instance(Instance *p_instance) {
 				p_instance->instance_allocated_shader_parameters = (p_instance->instance_shader_parameters.size() > 0);
 				if (p_instance->instance_allocated_shader_parameters) {
 					p_instance->instance_allocated_shader_parameters_offset = RSG::storage->global_variables_instance_allocate(p_instance->self);
-					for (Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter>::Element *E = p_instance->instance_shader_parameters.front(); E; E = E->next()) {
+					for (Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter>::Element *E = p_instance->instance_shader_parameters.front(); E; E = E->next()) {
 						if (E->get().value.get_type() != Variant::NIL) {
 							RSG::storage->global_variables_instance_update(p_instance->self, E->get().index, E->get().value);
 						}
@@ -2971,7 +3051,7 @@ void RenderingServerScene::_update_dirty_instance(Instance *p_instance) {
 	p_instance->update_dependencies = false;
 }
 
-void RenderingServerScene::update_dirty_instances() {
+void RendererSceneCull::update_dirty_instances() {
 	RSG::storage->update_dirty_resources();
 
 	while (_instance_update_list.first()) {
@@ -2979,7 +3059,17 @@ void RenderingServerScene::update_dirty_instances() {
 	}
 }
 
-bool RenderingServerScene::free(RID p_rid) {
+void RendererSceneCull::update() {
+	scene_render->update();
+	update_dirty_instances();
+	render_particle_colliders();
+}
+
+bool RendererSceneCull::free(RID p_rid) {
+	if (scene_render->free(p_rid)) {
+		return true;
+	}
+
 	if (camera_owner.owns(p_rid)) {
 		Camera *camera = camera_owner.getornull(p_rid);
 
@@ -2992,8 +3082,8 @@ bool RenderingServerScene::free(RID p_rid) {
 		while (scenario->instances.first()) {
 			instance_set_scenario(scenario->instances.first()->self()->self, RID());
 		}
-		RSG::scene_render->free(scenario->reflection_probe_shadow_atlas);
-		RSG::scene_render->free(scenario->reflection_atlas);
+		scene_render->free(scenario->reflection_probe_shadow_atlas);
+		scene_render->free(scenario->reflection_atlas);
 		scenario_owner.free(p_rid);
 		memdelete(scenario);
 
@@ -3025,16 +3115,22 @@ bool RenderingServerScene::free(RID p_rid) {
 	return true;
 }
 
-TypedArray<Image> RenderingServerScene::bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) {
-	return RSG::scene_render->bake_render_uv2(p_base, p_material_overrides, p_image_size);
+TypedArray<Image> RendererSceneCull::bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) {
+	return scene_render->bake_render_uv2(p_base, p_material_overrides, p_image_size);
 }
 
-RenderingServerScene *RenderingServerScene::singleton = nullptr;
+/*******************************/
+/* Passthrough to Scene Render */
+/*******************************/
+
+/* ENVIRONMENT API */
+
+RendererSceneCull *RendererSceneCull::singleton = nullptr;
 
-RenderingServerScene::RenderingServerScene() {
+RendererSceneCull::RendererSceneCull() {
 	render_pass = 1;
 	singleton = this;
 }
 
-RenderingServerScene::~RenderingServerScene() {
+RendererSceneCull::~RendererSceneCull() {
 }
diff --git a/servers/rendering/rendering_server_scene.h b/servers/rendering/renderer_scene_cull.h
index a30aac3bb1..4d82d873cc 100644
--- a/servers/rendering/rendering_server_scene.h
+++ b/servers/rendering/renderer_scene_cull.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_scene.h                                             */
+/*  renderer_scene_cull.h                                                */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,10 +28,11 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef VISUALSERVERSCENE_H
-#define VISUALSERVERSCENE_H
+#ifndef RENDERING_SERVER_SCENE_CULL_H
+#define RENDERING_SERVER_SCENE_CULL_H
 
-#include "servers/rendering/rasterizer.h"
+#include "core/templates/pass_func.h"
+#include "servers/rendering/renderer_compositor.h"
 
 #include "core/math/geometry_3d.h"
 #include "core/math/octree.h"
@@ -40,12 +41,15 @@
 #include "core/templates/local_vector.h"
 #include "core/templates/rid_owner.h"
 #include "core/templates/self_list.h"
+#include "servers/rendering/renderer_scene.h"
+#include "servers/rendering/renderer_scene_render.h"
 #include "servers/xr/xr_interface.h"
 
-class RenderingServerScene {
+class RendererSceneCull : public RendererScene {
 public:
-	enum {
+	RendererSceneRender *scene_render;
 
+	enum {
 		MAX_INSTANCE_CULL = 65536,
 		MAX_LIGHTS_CULLED = 4096,
 		MAX_REFLECTION_PROBES_CULLED = 4096,
@@ -58,7 +62,7 @@ public:
 
 	uint64_t render_pass;
 
-	static RenderingServerScene *singleton;
+	static RendererSceneCull *singleton;
 
 	/* CAMERA API */
 
@@ -85,7 +89,7 @@ public:
 			fov = 75;
 			type = PERSPECTIVE;
 			znear = 0.05;
-			zfar = 100;
+			zfar = 4000;
 			size = 1.0;
 			offset = Vector2();
 			vaspect = false;
@@ -103,6 +107,7 @@ public:
 	virtual void camera_set_environment(RID p_camera, RID p_env);
 	virtual void camera_set_camera_effects(RID p_camera, RID p_fx);
 	virtual void camera_set_use_vertical_aspect(RID p_camera, bool p_enable);
+	virtual bool is_camera(RID p_camera) const;
 
 	/* SCENARIO API */
 
@@ -133,6 +138,8 @@ public:
 	static void *_instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int);
 	static void _instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *);
 
+	static void _instance_update_mesh_instance(Instance *p_instance);
+
 	virtual RID scenario_create();
 
 	virtual void scenario_set_debug(RID p_scenario, RS::ScenarioDebugMode p_debug_mode);
@@ -140,6 +147,8 @@ public:
 	virtual void scenario_set_camera_effects(RID p_scenario, RID p_fx);
 	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment);
 	virtual void scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count);
+	virtual bool is_scenario(RID p_scenario) const;
+	virtual RID scenario_get_environment(RID p_scenario);
 
 	/* INSTANCING API */
 
@@ -147,7 +156,7 @@ public:
 		virtual ~InstanceBaseData() {}
 	};
 
-	struct Instance : RasterizerScene::InstanceBase {
+	struct Instance : RendererSceneRender::InstanceBase {
 		RID self;
 		//scenario stuff
 		OctreeElementID octree_id;
@@ -351,6 +360,7 @@ public:
 			float spot_angle;
 			float spot_attenuation;
 			bool has_shadow;
+			bool sky_only;
 		};
 
 		Vector<LightCache> light_cache;
@@ -437,8 +447,9 @@ public:
 	virtual void instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin);
 	virtual void instance_geometry_set_as_instance_lod(RID p_instance, RID p_as_lod_of_instance);
 	virtual void instance_geometry_set_lightmap(RID p_instance, RID p_lightmap, const Rect2 &p_lightmap_uv_scale, int p_slice_index);
+	virtual void instance_geometry_set_lod_bias(RID p_instance, float p_lod_bias);
 
-	void _update_instance_shader_parameters_from_material(Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter> &isparams, const Map<StringName, RasterizerScene::InstanceBase::InstanceShaderParameter> &existing_isparams, RID p_material);
+	void _update_instance_shader_parameters_from_material(Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter> &isparams, const Map<StringName, RendererSceneRender::InstanceBase::InstanceShaderParameter> &existing_isparams, RID p_material);
 
 	virtual void instance_geometry_set_shader_parameter(RID p_instance, const StringName &p_parameter, const Variant &p_value);
 	virtual void instance_geometry_get_shader_parameter_list(RID p_instance, List<PropertyInfo> *p_parameters) const;
@@ -450,28 +461,126 @@ public:
 	_FORCE_INLINE_ void _update_dirty_instance(Instance *p_instance);
 	_FORCE_INLINE_ void _update_instance_lightmap_captures(Instance *p_instance);
 
-	_FORCE_INLINE_ bool _light_instance_update_shadow(Instance *p_instance, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_shadow_atlas, Scenario *p_scenario);
+	_FORCE_INLINE_ bool _light_instance_update_shadow(Instance *p_instance, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_shadow_atlas, Scenario *p_scenario, float p_scren_lod_threshold);
 
 	RID _render_get_environment(RID p_camera, RID p_scenario);
 
 	bool _render_reflection_probe_step(Instance *p_instance, int p_step);
-	void _prepare_scene(const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_render_buffers, RID p_environment, uint32_t p_visible_layers, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, bool p_using_shadows = true);
-	void _render_scene(RID p_render_buffers, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, RID p_environment, RID p_force_camera_effects, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass);
+	void _prepare_scene(const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_render_buffers, RID p_environment, uint32_t p_visible_layers, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, float p_screen_lod_threshold, bool p_using_shadows = true);
+	void _render_scene(RID p_render_buffers, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, RID p_environment, RID p_force_camera_effects, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold);
 	void render_empty_scene(RID p_render_buffers, RID p_scenario, RID p_shadow_atlas);
 
-	void render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas);
-	void render_camera(RID p_render_buffers, Ref<XRInterface> &p_interface, XRInterface::Eyes p_eye, RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas);
+	void render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, Size2 p_viewport_size, float p_screen_lod_threshold, RID p_shadow_atlas);
+	void render_camera(RID p_render_buffers, Ref<XRInterface> &p_interface, XRInterface::Eyes p_eye, RID p_camera, RID p_scenario, Size2 p_viewport_size, float p_screen_lod_threshold, RID p_shadow_atlas);
 	void update_dirty_instances();
 
 	void render_particle_colliders();
-	void render_probes();
+	virtual void render_probes();
 
 	TypedArray<Image> bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size);
 
+	//pass to scene render
+
+	/* ENVIRONMENT API */
+
+#ifdef PASSBASE
+#undef PASSBASE
+#endif
+
+#define PASSBASE scene_render
+
+	PASS1(directional_shadow_atlas_set_size, int)
+	PASS1(gi_probe_set_quality, RS::GIProbeQuality)
+
+	/* SKY API */
+
+	PASS0R(RID, sky_create)
+	PASS2(sky_set_radiance_size, RID, int)
+	PASS2(sky_set_mode, RID, RS::SkyMode)
+	PASS2(sky_set_material, RID, RID)
+	PASS4R(Ref<Image>, sky_bake_panorama, RID, float, bool, const Size2i &)
+
+	PASS0R(RID, environment_create)
+
+	PASS1RC(bool, is_environment, RID)
+
+	PASS2(environment_set_background, RID, RS::EnvironmentBG)
+	PASS2(environment_set_sky, RID, RID)
+	PASS2(environment_set_sky_custom_fov, RID, float)
+	PASS2(environment_set_sky_orientation, RID, const Basis &)
+	PASS2(environment_set_bg_color, RID, const Color &)
+	PASS2(environment_set_bg_energy, RID, float)
+	PASS2(environment_set_canvas_max_layer, RID, int)
+	PASS7(environment_set_ambient_light, RID, const Color &, RS::EnvironmentAmbientSource, float, float, RS::EnvironmentReflectionSource, const Color &)
+
+	PASS6(environment_set_ssr, RID, bool, int, float, float, float)
+	PASS1(environment_set_ssr_roughness_quality, RS::EnvironmentSSRRoughnessQuality)
+
+	PASS9(environment_set_ssao, RID, bool, float, float, float, float, float, RS::EnvironmentSSAOBlur, float)
+	PASS2(environment_set_ssao_quality, RS::EnvironmentSSAOQuality, bool)
+
+	PASS11(environment_set_glow, RID, bool, Vector<float>, float, float, float, float, RS::EnvironmentGlowBlendMode, float, float, float)
+	PASS1(environment_glow_set_use_bicubic_upscale, bool)
+	PASS1(environment_glow_set_use_high_quality, bool)
+
+	PASS9(environment_set_tonemap, RID, RS::EnvironmentToneMapper, float, float, bool, float, float, float, float)
+
+	PASS7(environment_set_adjustment, RID, bool, float, float, float, bool, RID)
+
+	PASS9(environment_set_fog, RID, bool, const Color &, float, float, float, float, float, float)
+	PASS9(environment_set_volumetric_fog, RID, bool, float, const Color &, float, float, float, float, RS::EnvVolumetricFogShadowFilter)
+
+	PASS2(environment_set_volumetric_fog_volume_size, int, int)
+	PASS1(environment_set_volumetric_fog_filter_active, bool)
+	PASS1(environment_set_volumetric_fog_directional_shadow_shrink_size, int)
+	PASS1(environment_set_volumetric_fog_positional_shadow_shrink_size, int)
+
+	PASS11(environment_set_sdfgi, RID, bool, RS::EnvironmentSDFGICascades, float, RS::EnvironmentSDFGIYScale, bool, bool, bool, float, float, float)
+	PASS1(environment_set_sdfgi_ray_count, RS::EnvironmentSDFGIRayCount)
+	PASS1(environment_set_sdfgi_frames_to_converge, RS::EnvironmentSDFGIFramesToConverge)
+
+	PASS1RC(RS::EnvironmentBG, environment_get_background, RID)
+	PASS1RC(int, environment_get_canvas_max_layer, RID)
+
+	PASS3R(Ref<Image>, environment_bake_panorama, RID, bool, const Size2i &)
+
+	PASS3(screen_space_roughness_limiter_set_active, bool, float, float)
+	PASS1(sub_surface_scattering_set_quality, RS::SubSurfaceScatteringQuality)
+	PASS2(sub_surface_scattering_set_scale, float, float)
+
+	/* CAMERA EFFECTS */
+
+	PASS0R(RID, camera_effects_create)
+
+	PASS2(camera_effects_set_dof_blur_quality, RS::DOFBlurQuality, bool)
+	PASS1(camera_effects_set_dof_blur_bokeh_shape, RS::DOFBokehShape)
+
+	PASS8(camera_effects_set_dof_blur, RID, bool, float, float, bool, float, float, float)
+	PASS3(camera_effects_set_custom_exposure, RID, bool, float)
+
+	PASS1(shadows_quality_set, RS::ShadowQuality)
+	PASS1(directional_shadow_quality_set, RS::ShadowQuality)
+
+	PASS2(sdfgi_set_debug_probe_select, const Vector3 &, const Vector3 &)
+
+	/* Render Buffers */
+
+	PASS0R(RID, render_buffers_create)
+	PASS7(render_buffers_configure, RID, RID, int, int, RS::ViewportMSAA, RS::ViewportScreenSpaceAA, bool)
+
+	/* Shadow Atlas */
+	PASS0R(RID, shadow_atlas_create)
+	PASS2(shadow_atlas_set_size, RID, int)
+	PASS3(shadow_atlas_set_quadrant_subdivision, RID, int, int)
+
+	PASS1(set_debug_draw_mode, RS::ViewportDebugDraw)
+
+	virtual void update();
+
 	bool free(RID p_rid);
 
-	RenderingServerScene();
-	virtual ~RenderingServerScene();
+	RendererSceneCull();
+	virtual ~RendererSceneCull();
 };
 
 #endif // VISUALSERVERSCENE_H
diff --git a/servers/rendering/renderer_scene_render.cpp b/servers/rendering/renderer_scene_render.cpp
new file mode 100644
index 0000000000..2c36c5c59d
--- /dev/null
+++ b/servers/rendering/renderer_scene_render.cpp
@@ -0,0 +1,31 @@
+/*************************************************************************/
+/*  renderer_scene_render.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 "renderer_scene_render.h"
diff --git a/servers/rendering/renderer_scene_render.h b/servers/rendering/renderer_scene_render.h
new file mode 100644
index 0000000000..e1f3ea9b6b
--- /dev/null
+++ b/servers/rendering/renderer_scene_render.h
@@ -0,0 +1,271 @@
+/*************************************************************************/
+/*  renderer_scene_render.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 RENDERINGSERVERSCENERENDER_H
+#define RENDERINGSERVERSCENERENDER_H
+
+#include "core/math/camera_matrix.h"
+#include "servers/rendering/renderer_storage.h"
+
+class RendererSceneRender {
+public:
+	/* SHADOW ATLAS API */
+
+	virtual RID shadow_atlas_create() = 0;
+	virtual void shadow_atlas_set_size(RID p_atlas, int p_size) = 0;
+	virtual void shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) = 0;
+	virtual bool shadow_atlas_update_light(RID p_atlas, RID p_light_intance, float p_coverage, uint64_t p_light_version) = 0;
+
+	virtual void directional_shadow_atlas_set_size(int p_size) = 0;
+	virtual int get_directional_light_shadow_size(RID p_light_intance) = 0;
+	virtual void set_directional_shadow_count(int p_count) = 0;
+
+	/* SDFGI UPDATE */
+
+	struct InstanceBase;
+
+	virtual void sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position) = 0;
+	virtual int sdfgi_get_pending_region_count(RID p_render_buffers) const = 0;
+	virtual AABB sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const = 0;
+	virtual uint32_t sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const = 0;
+	virtual void sdfgi_update_probes(RID p_render_buffers, RID p_environment, const RID *p_directional_light_instances, uint32_t p_directional_light_count, const RID *p_positional_light_instances, uint32_t p_positional_light_count) = 0;
+
+	/* SKY API */
+
+	virtual RID sky_create() = 0;
+	virtual void sky_set_radiance_size(RID p_sky, int p_radiance_size) = 0;
+	virtual void sky_set_mode(RID p_sky, RS::SkyMode p_samples) = 0;
+	virtual void sky_set_material(RID p_sky, RID p_material) = 0;
+	virtual Ref<Image> sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) = 0;
+
+	/* ENVIRONMENT API */
+
+	virtual RID environment_create() = 0;
+
+	virtual void environment_set_background(RID p_env, RS::EnvironmentBG p_bg) = 0;
+	virtual void environment_set_sky(RID p_env, RID p_sky) = 0;
+	virtual void environment_set_sky_custom_fov(RID p_env, float p_scale) = 0;
+	virtual void environment_set_sky_orientation(RID p_env, const Basis &p_orientation) = 0;
+	virtual void environment_set_bg_color(RID p_env, const Color &p_color) = 0;
+	virtual void environment_set_bg_energy(RID p_env, float p_energy) = 0;
+	virtual void environment_set_canvas_max_layer(RID p_env, int p_max_layer) = 0;
+	virtual void environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient = RS::ENV_AMBIENT_SOURCE_BG, float p_energy = 1.0, float p_sky_contribution = 0.0, RS::EnvironmentReflectionSource p_reflection_source = RS::ENV_REFLECTION_SOURCE_BG, const Color &p_ao_color = Color()) = 0;
+// FIXME: Disabled during Vulkan refactoring, should be ported.
+#if 0
+	virtual void environment_set_camera_feed_id(RID p_env, int p_camera_feed_id) = 0;
+#endif
+
+	virtual void 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) = 0;
+	virtual void environment_glow_set_use_bicubic_upscale(bool p_enable) = 0;
+	virtual void environment_glow_set_use_high_quality(bool p_enable) = 0;
+
+	virtual void environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_light, float p_light_energy, float p_length, float p_detail_spread, float p_gi_inject, RS::EnvVolumetricFogShadowFilter p_shadow_filter) = 0;
+
+	virtual void environment_set_volumetric_fog_volume_size(int p_size, int p_depth) = 0;
+	virtual void environment_set_volumetric_fog_filter_active(bool p_enable) = 0;
+	virtual void environment_set_volumetric_fog_directional_shadow_shrink_size(int p_shrink_size) = 0;
+	virtual void environment_set_volumetric_fog_positional_shadow_shrink_size(int p_shrink_size) = 0;
+
+	virtual void 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) = 0;
+	virtual void environment_set_ssr_roughness_quality(RS::EnvironmentSSRRoughnessQuality p_quality) = 0;
+
+	virtual void environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_bias, float p_light_affect, float p_ao_channel_affect, RS::EnvironmentSSAOBlur p_blur, float p_bilateral_sharpness) = 0;
+
+	virtual void environment_set_ssao_quality(RS::EnvironmentSSAOQuality p_quality, bool p_half_size) = 0;
+
+	virtual void environment_set_sdfgi(RID p_env, bool p_enable, RS::EnvironmentSDFGICascades p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, bool p_use_multibounce, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) = 0;
+
+	virtual void environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) = 0;
+	virtual void environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) = 0;
+
+	virtual void 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) = 0;
+
+	virtual void 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) = 0;
+
+	virtual void environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_aerial_perspective) = 0;
+
+	virtual Ref<Image> environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) = 0;
+
+	virtual bool is_environment(RID p_env) const = 0;
+	virtual RS::EnvironmentBG environment_get_background(RID p_env) const = 0;
+	virtual int environment_get_canvas_max_layer(RID p_env) const = 0;
+
+	virtual RID camera_effects_create() = 0;
+
+	virtual void camera_effects_set_dof_blur_quality(RS::DOFBlurQuality p_quality, bool p_use_jitter) = 0;
+	virtual void camera_effects_set_dof_blur_bokeh_shape(RS::DOFBokehShape p_shape) = 0;
+
+	virtual void camera_effects_set_dof_blur(RID p_camera_effects, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) = 0;
+	virtual void camera_effects_set_custom_exposure(RID p_camera_effects, bool p_enable, float p_exposure) = 0;
+
+	virtual void shadows_quality_set(RS::ShadowQuality p_quality) = 0;
+	virtual void directional_shadow_quality_set(RS::ShadowQuality p_quality) = 0;
+
+	struct InstanceBase : public RendererStorage::InstanceBaseDependency {
+		RS::InstanceType base_type;
+		RID base;
+
+		RID skeleton;
+		RID material_override;
+
+		RID mesh_instance; //only used for meshes and when skeleton/blendshapes exist
+
+		Transform transform;
+
+		float lod_bias;
+
+		int depth_layer;
+		uint32_t layer_mask;
+
+		//RID sampled_light;
+
+		Vector<RID> materials;
+		Vector<RID> light_instances;
+		Vector<RID> reflection_probe_instances;
+		Vector<RID> gi_probe_instances;
+
+		RS::ShadowCastingSetting cast_shadows;
+
+		//fit in 32 bits
+		bool mirror : 8;
+		bool receive_shadows : 8;
+		bool visible : 8;
+		bool baked_light : 2; //this flag is only to know if it actually did use baked light
+		bool dynamic_gi : 2; //this flag is only to know if it actually did use baked light
+		bool redraw_if_visible : 4;
+
+		float depth; //used for sorting
+
+		InstanceBase *lightmap;
+		Rect2 lightmap_uv_scale;
+		int lightmap_slice_index;
+		uint32_t lightmap_cull_index;
+		Vector<Color> lightmap_sh; //spherical harmonic
+
+		AABB aabb;
+		AABB transformed_aabb;
+
+		struct InstanceShaderParameter {
+			int32_t index = -1;
+			Variant value;
+			Variant default_value;
+			PropertyInfo info;
+		};
+
+		Map<StringName, InstanceShaderParameter> instance_shader_parameters;
+		bool instance_allocated_shader_parameters = false;
+		int32_t instance_allocated_shader_parameters_offset = -1;
+
+		InstanceBase() {
+			base_type = RS::INSTANCE_NONE;
+			cast_shadows = RS::SHADOW_CASTING_SETTING_ON;
+			receive_shadows = true;
+			visible = true;
+			depth_layer = 0;
+			layer_mask = 1;
+			instance_version = 0;
+			baked_light = false;
+			dynamic_gi = false;
+			redraw_if_visible = false;
+			lightmap_slice_index = 0;
+			lightmap = nullptr;
+			lightmap_cull_index = 0;
+			lod_bias = 1.0;
+		}
+
+		virtual ~InstanceBase() {
+		}
+	};
+
+	virtual RID light_instance_create(RID p_light) = 0;
+	virtual void light_instance_set_transform(RID p_light_instance, const Transform &p_transform) = 0;
+	virtual void light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb) = 0;
+	virtual void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale = 1.0, float p_range_begin = 0, const Vector2 &p_uv_scale = Vector2()) = 0;
+	virtual void light_instance_mark_visible(RID p_light_instance) = 0;
+	virtual bool light_instances_can_render_shadow_cube() const {
+		return true;
+	}
+
+	virtual RID reflection_atlas_create() = 0;
+	virtual void reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count) = 0;
+	virtual int reflection_atlas_get_size(RID p_ref_atlas) const = 0;
+
+	virtual RID reflection_probe_instance_create(RID p_probe) = 0;
+	virtual void reflection_probe_instance_set_transform(RID p_instance, const Transform &p_transform) = 0;
+	virtual void reflection_probe_release_atlas_index(RID p_instance) = 0;
+	virtual bool reflection_probe_instance_needs_redraw(RID p_instance) = 0;
+	virtual bool reflection_probe_instance_has_reflection(RID p_instance) = 0;
+	virtual bool reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) = 0;
+	virtual bool reflection_probe_instance_postprocess_step(RID p_instance) = 0;
+
+	virtual RID decal_instance_create(RID p_decal) = 0;
+	virtual void decal_instance_set_transform(RID p_decal, const Transform &p_transform) = 0;
+
+	virtual RID gi_probe_instance_create(RID p_gi_probe) = 0;
+	virtual void gi_probe_instance_set_transform_to_data(RID p_probe, const Transform &p_xform) = 0;
+	virtual bool gi_probe_needs_update(RID p_probe) const = 0;
+	virtual void gi_probe_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, int p_dynamic_object_count, InstanceBase **p_dynamic_objects) = 0;
+
+	virtual void gi_probe_set_quality(RS::GIProbeQuality) = 0;
+
+	virtual void render_scene(RID p_render_buffers, const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID *p_gi_probe_cull_result, int p_gi_probe_cull_count, RID *p_decal_cull_result, int p_decal_cull_count, InstanceBase **p_lightmap_cull_result, int p_lightmap_cull_count, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold) = 0;
+
+	virtual void render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count, const Plane &p_camera_plane = Plane(), float p_lod_distance_multiplier = 0, float p_screen_lod_threshold = 0.0) = 0;
+	virtual void render_material(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID p_framebuffer, const Rect2i &p_region) = 0;
+	virtual void render_sdfgi(RID p_render_buffers, int p_region, InstanceBase **p_cull_result, int p_cull_count) = 0;
+	virtual void render_sdfgi_static_lights(RID p_render_buffers, uint32_t p_cascade_count, const uint32_t *p_cascade_indices, const RID **p_positional_light_cull_result, const uint32_t *p_positional_light_cull_count) = 0;
+	virtual void render_particle_collider_heightfield(RID p_collider, const Transform &p_transform, InstanceBase **p_cull_result, int p_cull_count) = 0;
+
+	virtual void set_scene_pass(uint64_t p_pass) = 0;
+	virtual void set_time(double p_time, double p_step) = 0;
+	virtual void set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) = 0;
+
+	virtual RID render_buffers_create() = 0;
+	virtual void render_buffers_configure(RID p_render_buffers, RID p_render_target, int p_width, int p_height, RS::ViewportMSAA p_msaa, RS::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_debanding) = 0;
+
+	virtual void screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) = 0;
+	virtual bool screen_space_roughness_limiter_is_active() const = 0;
+
+	virtual void sub_surface_scattering_set_quality(RS::SubSurfaceScatteringQuality p_quality) = 0;
+	virtual void sub_surface_scattering_set_scale(float p_scale, float p_depth_scale) = 0;
+
+	virtual TypedArray<Image> bake_render_uv2(RID p_base, const Vector<RID> &p_material_overrides, const Size2i &p_image_size) = 0;
+
+	virtual bool free(RID p_rid) = 0;
+
+	virtual void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) = 0;
+
+	virtual bool is_low_end() const = 0;
+
+	virtual void update() = 0;
+	virtual ~RendererSceneRender() {}
+};
+
+#endif // RENDERINGSERVERSCENERENDER_H
diff --git a/servers/rendering/rasterizer.cpp b/servers/rendering/renderer_storage.cpp
index 32084c8a3e..1b2773e404 100644
--- a/servers/rendering/rasterizer.cpp
+++ b/servers/rendering/renderer_storage.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rasterizer.cpp                                                       */
+/*  renderer_storage.cpp                                                 */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,49 +28,38 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rasterizer.h"
+#include "renderer_storage.h"
 
-#include "core/os/os.h"
-#include "core/string/print_string.h"
+RendererStorage *RendererStorage::base_singleton = nullptr;
 
-Rasterizer *(*Rasterizer::_create_func)() = nullptr;
-
-void RasterizerScene::InstanceDependency::instance_notify_changed(bool p_aabb, bool p_dependencies) {
-	for (Map<InstanceBase *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
+void RendererStorage::InstanceDependency::instance_notify_changed(bool p_aabb, bool p_dependencies) {
+	for (Map<InstanceBaseDependency *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
 		E->key()->dependency_changed(p_aabb, p_dependencies);
 	}
 }
 
-void RasterizerScene::InstanceDependency::instance_notify_deleted(RID p_deleted) {
-	for (Map<InstanceBase *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
+void RendererStorage::InstanceDependency::instance_notify_deleted(RID p_deleted) {
+	for (Map<InstanceBaseDependency *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
 		E->key()->dependency_deleted(p_deleted);
 	}
-	for (Map<InstanceBase *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
+	for (Map<InstanceBaseDependency *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
 		E->key()->dependencies.erase(this);
 	}
 
 	instances.clear();
 }
 
-RasterizerScene::InstanceDependency::~InstanceDependency() {
+RendererStorage::InstanceDependency::~InstanceDependency() {
 #ifdef DEBUG_ENABLED
 	if (instances.size()) {
 		WARN_PRINT("Leaked instance dependency: Bug - did not call instance_notify_deleted when freeing.");
-		for (Map<InstanceBase *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
+		for (Map<InstanceBaseDependency *, uint32_t>::Element *E = instances.front(); E; E = E->next()) {
 			E->key()->dependencies.erase(this);
 		}
 	}
 #endif
 }
 
-Rasterizer *Rasterizer::create() {
-	return _create_func();
-}
-
-RasterizerCanvas *RasterizerCanvas::singleton = nullptr;
-
-RasterizerStorage *RasterizerStorage::base_singleton = nullptr;
-
-RasterizerStorage::RasterizerStorage() {
+RendererStorage::RendererStorage() {
 	base_singleton = this;
 }
diff --git a/servers/rendering/renderer_storage.h b/servers/rendering/renderer_storage.h
new file mode 100644
index 0000000000..895a7a5be8
--- /dev/null
+++ b/servers/rendering/renderer_storage.h
@@ -0,0 +1,595 @@
+/*************************************************************************/
+/*  renderer_storage.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 RENDERINGSERVERSTORAGE_H
+#define RENDERINGSERVERSTORAGE_H
+
+#include "servers/rendering_server.h"
+
+class RendererStorage {
+	Color default_clear_color;
+
+public:
+	struct InstanceBaseDependency;
+
+	struct InstanceDependency {
+		void instance_notify_changed(bool p_aabb, bool p_dependencies);
+		void instance_notify_deleted(RID p_deleted);
+
+		~InstanceDependency();
+
+	private:
+		friend struct InstanceBaseDependency;
+		Map<InstanceBaseDependency *, uint32_t> instances;
+	};
+
+	struct InstanceBaseDependency {
+		uint32_t instance_version;
+		Set<InstanceDependency *> dependencies;
+
+		virtual void dependency_deleted(RID p_dependency) {}
+		virtual void dependency_changed(bool p_aabb, bool p_dependencies) {}
+
+		void instance_increase_version() {
+			instance_version++;
+		}
+
+		void update_dependency(InstanceDependency *p_dependency) {
+			dependencies.insert(p_dependency);
+			p_dependency->instances[this] = instance_version;
+		}
+
+		void clean_up_dependencies() {
+			List<Pair<InstanceDependency *, Map<InstanceBaseDependency *, uint32_t>::Element *>> to_clean_up;
+			for (Set<InstanceDependency *>::Element *E = dependencies.front(); E; E = E->next()) {
+				InstanceDependency *dep = E->get();
+				Map<InstanceBaseDependency *, uint32_t>::Element *F = dep->instances.find(this);
+				ERR_CONTINUE(!F);
+				if (F->get() != instance_version) {
+					Pair<InstanceDependency *, Map<InstanceBaseDependency *, uint32_t>::Element *> p;
+					p.first = dep;
+					p.second = F;
+					to_clean_up.push_back(p);
+				}
+			}
+
+			while (to_clean_up.size()) {
+				to_clean_up.front()->get().first->instances.erase(to_clean_up.front()->get().second);
+				to_clean_up.pop_front();
+			}
+		}
+
+		void clear_dependencies() {
+			for (Set<InstanceDependency *>::Element *E = dependencies.front(); E; E = E->next()) {
+				InstanceDependency *dep = E->get();
+				dep->instances.erase(this);
+			}
+			dependencies.clear();
+		}
+
+		virtual ~InstanceBaseDependency() { clear_dependencies(); }
+	};
+
+	/* TEXTURE API */
+
+	virtual RID texture_2d_create(const Ref<Image> &p_image) = 0;
+	virtual RID texture_2d_layered_create(const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) = 0;
+	virtual RID texture_3d_create(Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) = 0;
+	virtual RID texture_proxy_create(RID p_base) = 0; //all slices, then all the mipmaps, must be coherent
+
+	virtual void texture_2d_update_immediate(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) = 0; //mostly used for video and streaming
+	virtual void texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) = 0;
+	virtual void texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) = 0;
+	virtual void texture_proxy_update(RID p_proxy, RID p_base) = 0;
+
+	//these two APIs can be used together or in combination with the others.
+	virtual RID texture_2d_placeholder_create() = 0;
+	virtual RID texture_2d_layered_placeholder_create(RenderingServer::TextureLayeredType p_layered_type) = 0;
+	virtual RID texture_3d_placeholder_create() = 0;
+
+	virtual Ref<Image> texture_2d_get(RID p_texture) const = 0;
+	virtual Ref<Image> texture_2d_layer_get(RID p_texture, int p_layer) const = 0;
+	virtual Vector<Ref<Image>> texture_3d_get(RID p_texture) const = 0;
+
+	virtual void texture_replace(RID p_texture, RID p_by_texture) = 0;
+	virtual void texture_set_size_override(RID p_texture, int p_width, int p_height) = 0;
+
+	virtual void texture_set_path(RID p_texture, const String &p_path) = 0;
+	virtual String texture_get_path(RID p_texture) const = 0;
+
+	virtual void texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) = 0;
+	virtual void texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) = 0;
+	virtual void texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) = 0;
+
+	virtual void texture_debug_usage(List<RS::TextureInfo> *r_info) = 0;
+
+	virtual void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) = 0;
+
+	virtual Size2 texture_size_with_proxy(RID p_proxy) = 0;
+
+	virtual void texture_add_to_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) = 0;
+	virtual void texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) = 0;
+
+	/* CANVAS TEXTURE API */
+
+	virtual RID canvas_texture_create() = 0;
+	virtual void canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) = 0;
+	virtual void canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_base_color, float p_shininess) = 0;
+
+	virtual void canvas_texture_set_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) = 0;
+	virtual void canvas_texture_set_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) = 0;
+
+	/* SHADER API */
+
+	virtual RID shader_create() = 0;
+
+	virtual void shader_set_code(RID p_shader, const String &p_code) = 0;
+	virtual String shader_get_code(RID p_shader) const = 0;
+	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const = 0;
+
+	virtual void shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture) = 0;
+	virtual RID shader_get_default_texture_param(RID p_shader, const StringName &p_name) const = 0;
+	virtual Variant shader_get_param_default(RID p_material, const StringName &p_param) const = 0;
+
+	/* COMMON MATERIAL API */
+
+	virtual RID material_create() = 0;
+
+	virtual void material_set_render_priority(RID p_material, int priority) = 0;
+	virtual void material_set_shader(RID p_shader_material, RID p_shader) = 0;
+
+	virtual void material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) = 0;
+	virtual Variant material_get_param(RID p_material, const StringName &p_param) const = 0;
+
+	virtual void material_set_next_pass(RID p_material, RID p_next_material) = 0;
+
+	virtual bool material_is_animated(RID p_material) = 0;
+	virtual bool material_casts_shadows(RID p_material) = 0;
+
+	struct InstanceShaderParam {
+		PropertyInfo info;
+		int index;
+		Variant default_value;
+	};
+
+	virtual void material_get_instance_shader_parameters(RID p_material, List<InstanceShaderParam> *r_parameters) = 0;
+
+	virtual void material_update_dependency(RID p_material, InstanceBaseDependency *p_instance) = 0;
+
+	/* MESH API */
+
+	virtual RID mesh_create() = 0;
+
+	virtual void mesh_set_blend_shape_count(RID p_mesh, int p_blend_shape_count) = 0;
+
+	/// Returns stride
+	virtual void mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) = 0;
+
+	virtual int mesh_get_blend_shape_count(RID p_mesh) const = 0;
+
+	virtual void mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode p_mode) = 0;
+	virtual RS::BlendShapeMode mesh_get_blend_shape_mode(RID p_mesh) const = 0;
+
+	virtual void mesh_surface_update_region(RID p_mesh, int p_surface, int p_offset, const Vector<uint8_t> &p_data) = 0;
+
+	virtual void mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material) = 0;
+	virtual RID mesh_surface_get_material(RID p_mesh, int p_surface) const = 0;
+
+	virtual RS::SurfaceData mesh_get_surface(RID p_mesh, int p_surface) const = 0;
+
+	virtual int mesh_get_surface_count(RID p_mesh) const = 0;
+
+	virtual void mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) = 0;
+	virtual AABB mesh_get_custom_aabb(RID p_mesh) const = 0;
+
+	virtual AABB mesh_get_aabb(RID p_mesh, RID p_skeleton = RID()) = 0;
+
+	virtual void mesh_clear(RID p_mesh) = 0;
+
+	virtual bool mesh_needs_instance(RID p_mesh, bool p_has_skeleton) = 0;
+
+	/* MESH INSTANCE */
+
+	virtual RID mesh_instance_create(RID p_base) = 0;
+	virtual void mesh_instance_set_skeleton(RID p_mesh_instance, RID p_skeleton) = 0;
+	virtual void mesh_instance_set_blend_shape_weight(RID p_mesh_instance, int p_shape, float p_weight) = 0;
+	virtual void mesh_instance_check_for_update(RID p_mesh_instance) = 0;
+	virtual void update_mesh_instances() = 0;
+
+	/* MULTIMESH API */
+
+	virtual RID multimesh_create() = 0;
+
+	virtual void multimesh_allocate(RID p_multimesh, int p_instances, RS::MultimeshTransformFormat p_transform_format, bool p_use_colors = false, bool p_use_custom_data = false) = 0;
+
+	virtual int multimesh_get_instance_count(RID p_multimesh) const = 0;
+
+	virtual void multimesh_set_mesh(RID p_multimesh, RID p_mesh) = 0;
+	virtual void multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform &p_transform) = 0;
+	virtual void multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) = 0;
+	virtual void multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) = 0;
+	virtual void multimesh_instance_set_custom_data(RID p_multimesh, int p_index, const Color &p_color) = 0;
+
+	virtual RID multimesh_get_mesh(RID p_multimesh) const = 0;
+
+	virtual Transform multimesh_instance_get_transform(RID p_multimesh, int p_index) const = 0;
+	virtual Transform2D multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const = 0;
+	virtual Color multimesh_instance_get_color(RID p_multimesh, int p_index) const = 0;
+	virtual Color multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const = 0;
+
+	virtual void multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) = 0;
+	virtual Vector<float> multimesh_get_buffer(RID p_multimesh) const = 0;
+
+	virtual void multimesh_set_visible_instances(RID p_multimesh, int p_visible) = 0;
+	virtual int multimesh_get_visible_instances(RID p_multimesh) const = 0;
+
+	virtual AABB multimesh_get_aabb(RID p_multimesh) const = 0;
+
+	/* IMMEDIATE API */
+
+	virtual RID immediate_create() = 0;
+	virtual void immediate_begin(RID p_immediate, RS::PrimitiveType p_rimitive, RID p_texture = RID()) = 0;
+	virtual void immediate_vertex(RID p_immediate, const Vector3 &p_vertex) = 0;
+	virtual void immediate_normal(RID p_immediate, const Vector3 &p_normal) = 0;
+	virtual void immediate_tangent(RID p_immediate, const Plane &p_tangent) = 0;
+	virtual void immediate_color(RID p_immediate, const Color &p_color) = 0;
+	virtual void immediate_uv(RID p_immediate, const Vector2 &tex_uv) = 0;
+	virtual void immediate_uv2(RID p_immediate, const Vector2 &tex_uv) = 0;
+	virtual void immediate_end(RID p_immediate) = 0;
+	virtual void immediate_clear(RID p_immediate) = 0;
+	virtual void immediate_set_material(RID p_immediate, RID p_material) = 0;
+	virtual RID immediate_get_material(RID p_immediate) const = 0;
+	virtual AABB immediate_get_aabb(RID p_immediate) const = 0;
+
+	/* SKELETON API */
+
+	virtual RID skeleton_create() = 0;
+	virtual void skeleton_allocate(RID p_skeleton, int p_bones, bool p_2d_skeleton = false) = 0;
+	virtual int skeleton_get_bone_count(RID p_skeleton) const = 0;
+	virtual void skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform &p_transform) = 0;
+	virtual Transform skeleton_bone_get_transform(RID p_skeleton, int p_bone) const = 0;
+	virtual void skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) = 0;
+	virtual Transform2D skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const = 0;
+	virtual void skeleton_set_base_transform_2d(RID p_skeleton, const Transform2D &p_base_transform) = 0;
+
+	/* Light API */
+
+	virtual RID light_create(RS::LightType p_type) = 0;
+
+	RID directional_light_create() { return light_create(RS::LIGHT_DIRECTIONAL); }
+	RID omni_light_create() { return light_create(RS::LIGHT_OMNI); }
+	RID spot_light_create() { return light_create(RS::LIGHT_SPOT); }
+
+	virtual void light_set_color(RID p_light, const Color &p_color) = 0;
+	virtual void light_set_param(RID p_light, RS::LightParam p_param, float p_value) = 0;
+	virtual void light_set_shadow(RID p_light, bool p_enabled) = 0;
+	virtual void light_set_shadow_color(RID p_light, const Color &p_color) = 0;
+	virtual void light_set_projector(RID p_light, RID p_texture) = 0;
+	virtual void light_set_negative(RID p_light, bool p_enable) = 0;
+	virtual void light_set_cull_mask(RID p_light, uint32_t p_mask) = 0;
+	virtual void light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) = 0;
+	virtual void light_set_bake_mode(RID p_light, RS::LightBakeMode p_bake_mode) = 0;
+	virtual void light_set_max_sdfgi_cascade(RID p_light, uint32_t p_cascade) = 0;
+
+	virtual void light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMode p_mode) = 0;
+
+	virtual void light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode) = 0;
+	virtual void light_directional_set_blend_splits(RID p_light, bool p_enable) = 0;
+	virtual bool light_directional_get_blend_splits(RID p_light) const = 0;
+	virtual void light_directional_set_sky_only(RID p_light, bool p_sky_only) = 0;
+	virtual bool light_directional_is_sky_only(RID p_light) const = 0;
+	virtual void light_directional_set_shadow_depth_range_mode(RID p_light, RS::LightDirectionalShadowDepthRangeMode p_range_mode) = 0;
+	virtual RS::LightDirectionalShadowDepthRangeMode light_directional_get_shadow_depth_range_mode(RID p_light) const = 0;
+
+	virtual RS::LightDirectionalShadowMode light_directional_get_shadow_mode(RID p_light) = 0;
+	virtual RS::LightOmniShadowMode light_omni_get_shadow_mode(RID p_light) = 0;
+
+	virtual bool light_has_shadow(RID p_light) const = 0;
+
+	virtual RS::LightType light_get_type(RID p_light) const = 0;
+	virtual AABB light_get_aabb(RID p_light) const = 0;
+	virtual float light_get_param(RID p_light, RS::LightParam p_param) = 0;
+	virtual Color light_get_color(RID p_light) = 0;
+	virtual RS::LightBakeMode light_get_bake_mode(RID p_light) = 0;
+	virtual uint32_t light_get_max_sdfgi_cascade(RID p_light) = 0;
+	virtual uint64_t light_get_version(RID p_light) const = 0;
+
+	/* PROBE API */
+
+	virtual RID reflection_probe_create() = 0;
+
+	virtual void reflection_probe_set_update_mode(RID p_probe, RS::ReflectionProbeUpdateMode p_mode) = 0;
+	virtual void reflection_probe_set_resolution(RID p_probe, int p_resolution) = 0;
+	virtual void reflection_probe_set_intensity(RID p_probe, float p_intensity) = 0;
+	virtual void reflection_probe_set_ambient_mode(RID p_probe, RS::ReflectionProbeAmbientMode p_mode) = 0;
+	virtual void reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) = 0;
+	virtual void reflection_probe_set_ambient_energy(RID p_probe, float p_energy) = 0;
+	virtual void reflection_probe_set_max_distance(RID p_probe, float p_distance) = 0;
+	virtual void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) = 0;
+	virtual void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) = 0;
+	virtual void reflection_probe_set_as_interior(RID p_probe, bool p_enable) = 0;
+	virtual void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) = 0;
+	virtual void reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) = 0;
+	virtual void reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) = 0;
+	virtual void reflection_probe_set_lod_threshold(RID p_probe, float p_ratio) = 0;
+
+	virtual AABB reflection_probe_get_aabb(RID p_probe) const = 0;
+	virtual RS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const = 0;
+	virtual uint32_t reflection_probe_get_cull_mask(RID p_probe) const = 0;
+	virtual Vector3 reflection_probe_get_extents(RID p_probe) const = 0;
+	virtual Vector3 reflection_probe_get_origin_offset(RID p_probe) const = 0;
+	virtual float reflection_probe_get_origin_max_distance(RID p_probe) const = 0;
+	virtual bool reflection_probe_renders_shadows(RID p_probe) const = 0;
+	virtual float reflection_probe_get_lod_threshold(RID p_probe) const = 0;
+
+	virtual void base_update_dependency(RID p_base, InstanceBaseDependency *p_instance) = 0;
+	virtual void skeleton_update_dependency(RID p_base, InstanceBaseDependency *p_instance) = 0;
+
+	/* DECAL API */
+
+	virtual RID decal_create() = 0;
+	virtual void decal_set_extents(RID p_decal, const Vector3 &p_extents) = 0;
+	virtual void decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) = 0;
+	virtual void decal_set_emission_energy(RID p_decal, float p_energy) = 0;
+	virtual void decal_set_albedo_mix(RID p_decal, float p_mix) = 0;
+	virtual void decal_set_modulate(RID p_decal, const Color &p_modulate) = 0;
+	virtual void decal_set_cull_mask(RID p_decal, uint32_t p_layers) = 0;
+	virtual void decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) = 0;
+	virtual void decal_set_fade(RID p_decal, float p_above, float p_below) = 0;
+	virtual void decal_set_normal_fade(RID p_decal, float p_fade) = 0;
+
+	virtual AABB decal_get_aabb(RID p_decal) const = 0;
+
+	/* GI PROBE API */
+
+	virtual RID gi_probe_create() = 0;
+
+	virtual void gi_probe_allocate(RID p_gi_probe, const Transform &p_to_cell_xform, const AABB &p_aabb, const Vector3i &p_octree_size, const Vector<uint8_t> &p_octree_cells, const Vector<uint8_t> &p_data_cells, const Vector<uint8_t> &p_distance_field, const Vector<int> &p_level_counts) = 0;
+
+	virtual AABB gi_probe_get_bounds(RID p_gi_probe) const = 0;
+	virtual Vector3i gi_probe_get_octree_size(RID p_gi_probe) const = 0;
+	virtual Vector<uint8_t> gi_probe_get_octree_cells(RID p_gi_probe) const = 0;
+	virtual Vector<uint8_t> gi_probe_get_data_cells(RID p_gi_probe) const = 0;
+	virtual Vector<uint8_t> gi_probe_get_distance_field(RID p_gi_probe) const = 0;
+
+	virtual Vector<int> gi_probe_get_level_counts(RID p_gi_probe) const = 0;
+	virtual Transform gi_probe_get_to_cell_xform(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_dynamic_range(RID p_gi_probe, float p_range) = 0;
+	virtual float gi_probe_get_dynamic_range(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_propagation(RID p_gi_probe, float p_range) = 0;
+	virtual float gi_probe_get_propagation(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_energy(RID p_gi_probe, float p_energy) = 0;
+	virtual float gi_probe_get_energy(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_ao(RID p_gi_probe, float p_ao) = 0;
+	virtual float gi_probe_get_ao(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_ao_size(RID p_gi_probe, float p_strength) = 0;
+	virtual float gi_probe_get_ao_size(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_bias(RID p_gi_probe, float p_bias) = 0;
+	virtual float gi_probe_get_bias(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_normal_bias(RID p_gi_probe, float p_range) = 0;
+	virtual float gi_probe_get_normal_bias(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_interior(RID p_gi_probe, bool p_enable) = 0;
+	virtual bool gi_probe_is_interior(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_use_two_bounces(RID p_gi_probe, bool p_enable) = 0;
+	virtual bool gi_probe_is_using_two_bounces(RID p_gi_probe) const = 0;
+
+	virtual void gi_probe_set_anisotropy_strength(RID p_gi_probe, float p_strength) = 0;
+	virtual float gi_probe_get_anisotropy_strength(RID p_gi_probe) const = 0;
+
+	virtual uint32_t gi_probe_get_version(RID p_probe) = 0;
+
+	/* LIGHTMAP CAPTURE */
+
+	virtual RID lightmap_create() = 0;
+
+	virtual void lightmap_set_textures(RID p_lightmap, RID p_light, bool p_uses_spherical_haromics) = 0;
+	virtual void lightmap_set_probe_bounds(RID p_lightmap, const AABB &p_bounds) = 0;
+	virtual void lightmap_set_probe_interior(RID p_lightmap, bool p_interior) = 0;
+	virtual void lightmap_set_probe_capture_data(RID p_lightmap, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) = 0;
+	virtual PackedVector3Array lightmap_get_probe_capture_points(RID p_lightmap) const = 0;
+	virtual PackedColorArray lightmap_get_probe_capture_sh(RID p_lightmap) const = 0;
+	virtual PackedInt32Array lightmap_get_probe_capture_tetrahedra(RID p_lightmap) const = 0;
+	virtual PackedInt32Array lightmap_get_probe_capture_bsp_tree(RID p_lightmap) const = 0;
+	virtual AABB lightmap_get_aabb(RID p_lightmap) const = 0;
+	virtual void lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) = 0;
+	virtual bool lightmap_is_interior(RID p_lightmap) const = 0;
+	virtual void lightmap_set_probe_capture_update_speed(float p_speed) = 0;
+	virtual float lightmap_get_probe_capture_update_speed() const = 0;
+
+	/* PARTICLES */
+
+	virtual RID particles_create() = 0;
+
+	virtual void particles_set_emitting(RID p_particles, bool p_emitting) = 0;
+	virtual bool particles_get_emitting(RID p_particles) = 0;
+
+	virtual void particles_set_amount(RID p_particles, int p_amount) = 0;
+	virtual void particles_set_lifetime(RID p_particles, float p_lifetime) = 0;
+	virtual void particles_set_one_shot(RID p_particles, bool p_one_shot) = 0;
+	virtual void particles_set_pre_process_time(RID p_particles, float p_time) = 0;
+	virtual void particles_set_explosiveness_ratio(RID p_particles, float p_ratio) = 0;
+	virtual void particles_set_randomness_ratio(RID p_particles, float p_ratio) = 0;
+	virtual void particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) = 0;
+	virtual void particles_set_speed_scale(RID p_particles, float p_scale) = 0;
+	virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable) = 0;
+	virtual void particles_set_process_material(RID p_particles, RID p_material) = 0;
+	virtual void particles_set_fixed_fps(RID p_particles, int p_fps) = 0;
+	virtual void particles_set_fractional_delta(RID p_particles, bool p_enable) = 0;
+	virtual void particles_set_collision_base_size(RID p_particles, float p_size) = 0;
+	virtual void particles_restart(RID p_particles) = 0;
+	virtual void particles_emit(RID p_particles, const Transform &p_transform, const Vector3 &p_velocity, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) = 0;
+	virtual void particles_set_subemitter(RID p_particles, RID p_subemitter_particles) = 0;
+
+	virtual bool particles_is_inactive(RID p_particles) const = 0;
+
+	virtual void particles_set_draw_order(RID p_particles, RS::ParticlesDrawOrder p_order) = 0;
+
+	virtual void particles_set_draw_passes(RID p_particles, int p_count) = 0;
+	virtual void particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) = 0;
+
+	virtual void particles_request_process(RID p_particles) = 0;
+	virtual AABB particles_get_current_aabb(RID p_particles) = 0;
+	virtual AABB particles_get_aabb(RID p_particles) const = 0;
+
+	virtual void particles_set_emission_transform(RID p_particles, const Transform &p_transform) = 0;
+
+	virtual int particles_get_draw_passes(RID p_particles) const = 0;
+	virtual RID particles_get_draw_pass_mesh(RID p_particles, int p_pass) const = 0;
+
+	virtual void particles_set_view_axis(RID p_particles, const Vector3 &p_axis) = 0;
+
+	virtual void particles_add_collision(RID p_particles, InstanceBaseDependency *p_instance) = 0;
+	virtual void particles_remove_collision(RID p_particles, InstanceBaseDependency *p_instance) = 0;
+
+	virtual void update_particles() = 0;
+
+	/* PARTICLES COLLISION */
+
+	virtual RID particles_collision_create() = 0;
+	virtual void particles_collision_set_collision_type(RID p_particles_collision, RS::ParticlesCollisionType p_type) = 0;
+	virtual void particles_collision_set_cull_mask(RID p_particles_collision, uint32_t p_cull_mask) = 0;
+	virtual void particles_collision_set_sphere_radius(RID p_particles_collision, float p_radius) = 0; //for spheres
+	virtual void particles_collision_set_box_extents(RID p_particles_collision, const Vector3 &p_extents) = 0; //for non-spheres
+	virtual void particles_collision_set_attractor_strength(RID p_particles_collision, float p_strength) = 0;
+	virtual void particles_collision_set_attractor_directionality(RID p_particles_collision, float p_directionality) = 0;
+	virtual void particles_collision_set_attractor_attenuation(RID p_particles_collision, float p_curve) = 0;
+	virtual void particles_collision_set_field_texture(RID p_particles_collision, RID p_texture) = 0; //for SDF and vector field, heightfield is dynamic
+	virtual void particles_collision_height_field_update(RID p_particles_collision) = 0; //for SDF and vector field
+	virtual void particles_collision_set_height_field_resolution(RID p_particles_collision, RS::ParticlesCollisionHeightfieldResolution p_resolution) = 0; //for SDF and vector field
+	virtual AABB particles_collision_get_aabb(RID p_particles_collision) const = 0;
+	virtual bool particles_collision_is_heightfield(RID p_particles_collision) const = 0;
+	virtual RID particles_collision_get_heightfield_framebuffer(RID p_particles_collision) const = 0;
+
+	/* GLOBAL VARIABLES */
+
+	virtual void global_variable_add(const StringName &p_name, RS::GlobalVariableType p_type, const Variant &p_value) = 0;
+	virtual void global_variable_remove(const StringName &p_name) = 0;
+	virtual Vector<StringName> global_variable_get_list() const = 0;
+
+	virtual void global_variable_set(const StringName &p_name, const Variant &p_value) = 0;
+	virtual void global_variable_set_override(const StringName &p_name, const Variant &p_value) = 0;
+	virtual Variant global_variable_get(const StringName &p_name) const = 0;
+	virtual RS::GlobalVariableType global_variable_get_type(const StringName &p_name) const = 0;
+
+	virtual void global_variables_load_settings(bool p_load_textures = true) = 0;
+	virtual void global_variables_clear() = 0;
+
+	virtual int32_t global_variables_instance_allocate(RID p_instance) = 0;
+	virtual void global_variables_instance_free(RID p_instance) = 0;
+	virtual void global_variables_instance_update(RID p_instance, int p_index, const Variant &p_value) = 0;
+
+	/* RENDER TARGET */
+
+	enum RenderTargetFlags {
+		RENDER_TARGET_TRANSPARENT,
+		RENDER_TARGET_DIRECT_TO_SCREEN,
+		RENDER_TARGET_FLAG_MAX
+	};
+
+	virtual RID render_target_create() = 0;
+	virtual void render_target_set_position(RID p_render_target, int p_x, int p_y) = 0;
+	virtual void render_target_set_size(RID p_render_target, int p_width, int p_height) = 0;
+	virtual RID render_target_get_texture(RID p_render_target) = 0;
+	virtual void render_target_set_external_texture(RID p_render_target, unsigned int p_texture_id) = 0;
+	virtual void render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value) = 0;
+	virtual bool render_target_was_used(RID p_render_target) = 0;
+	virtual void render_target_set_as_unused(RID p_render_target) = 0;
+
+	virtual void render_target_request_clear(RID p_render_target, const Color &p_clear_color) = 0;
+	virtual bool render_target_is_clear_requested(RID p_render_target) = 0;
+	virtual Color render_target_get_clear_request_color(RID p_render_target) = 0;
+	virtual void render_target_disable_clear_request(RID p_render_target) = 0;
+	virtual void render_target_do_clear_request(RID p_render_target) = 0;
+
+	virtual void render_target_set_sdf_size_and_scale(RID p_render_target, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) = 0;
+	virtual Rect2i render_target_get_sdf_rect(RID p_render_target) const = 0;
+
+	virtual RS::InstanceType get_base_type(RID p_rid) const = 0;
+	virtual bool free(RID p_rid) = 0;
+
+	virtual bool has_os_feature(const String &p_feature) const = 0;
+
+	virtual void update_dirty_resources() = 0;
+
+	virtual void set_debug_generate_wireframes(bool p_generate) = 0;
+
+	virtual void render_info_begin_capture() = 0;
+	virtual void render_info_end_capture() = 0;
+	virtual int get_captured_render_info(RS::RenderInfo p_info) = 0;
+
+	virtual int get_render_info(RS::RenderInfo p_info) = 0;
+	virtual String get_video_adapter_name() const = 0;
+	virtual String get_video_adapter_vendor() const = 0;
+
+	static RendererStorage *base_singleton;
+
+	void set_default_clear_color(const Color &p_color) {
+		default_clear_color = p_color;
+	}
+
+	Color get_default_clear_color() const {
+		return default_clear_color;
+	}
+#define TIMESTAMP_BEGIN()                             \
+	{                                                 \
+		if (RSG::storage->capturing_timestamps)       \
+			RSG::storage->capture_timestamps_begin(); \
+	}
+
+#define RENDER_TIMESTAMP(m_text)                     \
+	{                                                \
+		if (RSG::storage->capturing_timestamps)      \
+			RSG::storage->capture_timestamp(m_text); \
+	}
+
+	bool capturing_timestamps = false;
+
+	virtual void capture_timestamps_begin() = 0;
+	virtual void capture_timestamp(const String &p_name) = 0;
+	virtual uint32_t get_captured_timestamps_count() const = 0;
+	virtual uint64_t get_captured_timestamps_frame() const = 0;
+	virtual uint64_t get_captured_timestamp_gpu_time(uint32_t p_index) const = 0;
+	virtual uint64_t get_captured_timestamp_cpu_time(uint32_t p_index) const = 0;
+	virtual String get_captured_timestamp_name(uint32_t p_index) const = 0;
+
+	RendererStorage();
+	virtual ~RendererStorage() {}
+};
+
+#endif // RENDERINGSERVERSTORAGE_H
diff --git a/servers/rendering/rendering_server_viewport.cpp b/servers/rendering/renderer_viewport.cpp
index c6682b1fcd..ea95eb1189 100644
--- a/servers/rendering/rendering_server_viewport.cpp
+++ b/servers/rendering/renderer_viewport.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_viewport.cpp                                        */
+/*  renderer_viewport.cpp                                                */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,14 +28,14 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rendering_server_viewport.h"
+#include "renderer_viewport.h"
 
 #include "core/config/project_settings.h"
-#include "rendering_server_canvas.h"
+#include "renderer_canvas_cull.h"
+#include "renderer_scene_cull.h"
 #include "rendering_server_globals.h"
-#include "rendering_server_scene.h"
 
-static Transform2D _canvas_get_transform(RenderingServerViewport::Viewport *p_viewport, RenderingServerCanvas::Canvas *p_canvas, RenderingServerViewport::Viewport::CanvasData *p_canvas_data, const Vector2 &p_vp_size) {
+static Transform2D _canvas_get_transform(RendererViewport::Viewport *p_viewport, RendererCanvasCull::Canvas *p_canvas, RendererViewport::Viewport::CanvasData *p_canvas_data, const Vector2 &p_vp_size) {
 	Transform2D xf = p_viewport->global_transform;
 
 	float scale = 1.0;
@@ -71,7 +71,7 @@ static Transform2D _canvas_get_transform(RenderingServerViewport::Viewport *p_vi
 	return xf;
 }
 
-void RenderingServerViewport::_draw_3d(Viewport *p_viewport, XRInterface::Eyes p_eye) {
+void RendererViewport::_draw_3d(Viewport *p_viewport, XRInterface::Eyes p_eye) {
 	RENDER_TIMESTAMP(">Begin Rendering 3D Scene");
 
 	Ref<XRInterface> xr_interface;
@@ -79,15 +79,16 @@ void RenderingServerViewport::_draw_3d(Viewport *p_viewport, XRInterface::Eyes p
 		xr_interface = XRServer::get_singleton()->get_primary_interface();
 	}
 
+	float screen_lod_threshold = p_viewport->lod_threshold / float(p_viewport->size.width);
 	if (p_viewport->use_xr && xr_interface.is_valid()) {
-		RSG::scene->render_camera(p_viewport->render_buffers, xr_interface, p_eye, p_viewport->camera, p_viewport->scenario, p_viewport->size, p_viewport->shadow_atlas);
+		RSG::scene->render_camera(p_viewport->render_buffers, xr_interface, p_eye, p_viewport->camera, p_viewport->scenario, p_viewport->size, screen_lod_threshold, p_viewport->shadow_atlas);
 	} else {
-		RSG::scene->render_camera(p_viewport->render_buffers, p_viewport->camera, p_viewport->scenario, p_viewport->size, p_viewport->shadow_atlas);
+		RSG::scene->render_camera(p_viewport->render_buffers, p_viewport->camera, p_viewport->scenario, p_viewport->size, screen_lod_threshold, p_viewport->shadow_atlas);
 	}
 	RENDER_TIMESTAMP("<End Rendering 3D Scene");
 }
 
-void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::Eyes p_eye) {
+void RendererViewport::_draw_viewport(Viewport *p_viewport, XRInterface::Eyes p_eye) {
 	if (p_viewport->measure_render_time) {
 		String rt_id = "vp_begin_" + itos(p_viewport->self.get_id());
 		RSG::storage->capture_timestamp(rt_id);
@@ -101,17 +102,15 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 
 	Color bgcolor = RSG::storage->get_default_clear_color();
 
-	if (!p_viewport->hide_canvas && !p_viewport->disable_environment && RSG::scene->scenario_owner.owns(p_viewport->scenario)) {
-		RenderingServerScene::Scenario *scenario = RSG::scene->scenario_owner.getornull(p_viewport->scenario);
-		ERR_FAIL_COND(!scenario);
-		if (RSG::scene_render->is_environment(scenario->environment)) {
-			scenario_draw_canvas_bg = RSG::scene_render->environment_get_background(scenario->environment) == RS::ENV_BG_CANVAS;
-
-			scenario_canvas_max_layer = RSG::scene_render->environment_get_canvas_max_layer(scenario->environment);
+	if (!p_viewport->hide_canvas && !p_viewport->disable_environment && RSG::scene->is_scenario(p_viewport->scenario)) {
+		RID environment = RSG::scene->scenario_get_environment(p_viewport->scenario);
+		if (RSG::scene->is_environment(environment)) {
+			scenario_draw_canvas_bg = RSG::scene->environment_get_background(environment) == RS::ENV_BG_CANVAS;
+			scenario_canvas_max_layer = RSG::scene->environment_get_canvas_max_layer(environment);
 		}
 	}
 
-	bool can_draw_3d = RSG::scene->camera_owner.owns(p_viewport->camera);
+	bool can_draw_3d = RSG::scene->is_camera(p_viewport->camera);
 
 	if (p_viewport->clear_mode != RS::VIEWPORT_CLEAR_NEVER) {
 		if (p_viewport->transparent_bg) {
@@ -124,8 +123,8 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 
 	if ((scenario_draw_canvas_bg || can_draw_3d) && !p_viewport->render_buffers.is_valid()) {
 		//wants to draw 3D but there is no render buffer, create
-		p_viewport->render_buffers = RSG::scene_render->render_buffers_create();
-		RSG::scene_render->render_buffers_configure(p_viewport->render_buffers, p_viewport->render_target, p_viewport->size.width, p_viewport->size.height, p_viewport->msaa, p_viewport->screen_space_aa, p_viewport->use_debanding);
+		p_viewport->render_buffers = RSG::scene->render_buffers_create();
+		RSG::scene->render_buffers_configure(p_viewport->render_buffers, p_viewport->render_target, p_viewport->size.width, p_viewport->size.height, p_viewport->msaa, p_viewport->screen_space_aa, p_viewport->use_debanding);
 	}
 
 	RSG::storage->render_target_request_clear(p_viewport->render_target, bgcolor);
@@ -140,11 +139,41 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 		Map<Viewport::CanvasKey, Viewport::CanvasData *> canvas_map;
 
 		Rect2 clip_rect(0, 0, p_viewport->size.x, p_viewport->size.y);
-		RasterizerCanvas::Light *lights = nullptr;
-		RasterizerCanvas::Light *lights_with_shadow = nullptr;
+		RendererCanvasRender::Light *lights = nullptr;
+		RendererCanvasRender::Light *lights_with_shadow = nullptr;
+
+		RendererCanvasRender::Light *directional_lights = nullptr;
+		RendererCanvasRender::Light *directional_lights_with_shadow = nullptr;
+
+		if (p_viewport->sdf_active) {
+			//process SDF
+
+			Rect2 sdf_rect = RSG::storage->render_target_get_sdf_rect(p_viewport->render_target);
+
+			RendererCanvasRender::LightOccluderInstance *occluders = nullptr;
+
+			//make list of occluders
+			for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
+				RendererCanvasCull::Canvas *canvas = static_cast<RendererCanvasCull::Canvas *>(E->get().canvas);
+				Transform2D xf = _canvas_get_transform(p_viewport, canvas, &E->get(), clip_rect.size);
+
+				for (Set<RendererCanvasRender::LightOccluderInstance *>::Element *F = canvas->occluders.front(); F; F = F->next()) {
+					if (!F->get()->enabled) {
+						continue;
+					}
+					F->get()->xform_cache = xf * F->get()->xform;
+
+					if (sdf_rect.intersects_transformed(F->get()->xform_cache, F->get()->aabb_cache)) {
+						F->get()->next = occluders;
+						occluders = F->get();
+					}
+				}
+			}
 
-		RasterizerCanvas::Light *directional_lights = nullptr;
-		RasterizerCanvas::Light *directional_lights_with_shadow = nullptr;
+			RSG::canvas_render->render_sdf(p_viewport->render_target, occluders);
+
+			p_viewport->sdf_active = false; // if used, gets set active again
+		}
 
 		Rect2 shadow_rect;
 
@@ -154,14 +183,14 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 
 		RENDER_TIMESTAMP("Cull Canvas Lights");
 		for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
-			RenderingServerCanvas::Canvas *canvas = static_cast<RenderingServerCanvas::Canvas *>(E->get().canvas);
+			RendererCanvasCull::Canvas *canvas = static_cast<RendererCanvasCull::Canvas *>(E->get().canvas);
 
 			Transform2D xf = _canvas_get_transform(p_viewport, canvas, &E->get(), clip_rect.size);
 
 			//find lights in canvas
 
-			for (Set<RasterizerCanvas::Light *>::Element *F = canvas->lights.front(); F; F = F->next()) {
-				RasterizerCanvas::Light *cl = F->get();
+			for (Set<RendererCanvasRender::Light *>::Element *F = canvas->lights.front(); F; F = F->next()) {
+				RendererCanvasRender::Light *cl = F->get();
 				if (cl->enabled && cl->texture.is_valid()) {
 					//not super efficient..
 					Size2 tsize = RSG::storage->texture_size_with_proxy(cl->texture);
@@ -195,12 +224,11 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 					}
 
 					//guess this is not needed, but keeping because it may be
-					//RSG::canvas_render->light_internal_update(cl->light_internal, cl);
 				}
 			}
 
-			for (Set<RasterizerCanvas::Light *>::Element *F = canvas->directional_lights.front(); F; F = F->next()) {
-				RasterizerCanvas::Light *cl = F->get();
+			for (Set<RendererCanvasRender::Light *>::Element *F = canvas->directional_lights.front(); F; F = F->next()) {
+				RendererCanvasRender::Light *cl = F->get();
 				if (cl->enabled) {
 					cl->filter_next_ptr = directional_lights;
 					directional_lights = cl;
@@ -225,17 +253,17 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 		if (lights_with_shadow) {
 			//update shadows if any
 
-			RasterizerCanvas::LightOccluderInstance *occluders = nullptr;
+			RendererCanvasRender::LightOccluderInstance *occluders = nullptr;
 
 			RENDER_TIMESTAMP(">Render 2D Shadows");
 			RENDER_TIMESTAMP("Cull Occluders");
 
 			//make list of occluders
 			for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
-				RenderingServerCanvas::Canvas *canvas = static_cast<RenderingServerCanvas::Canvas *>(E->get().canvas);
+				RendererCanvasCull::Canvas *canvas = static_cast<RendererCanvasCull::Canvas *>(E->get().canvas);
 				Transform2D xf = _canvas_get_transform(p_viewport, canvas, &E->get(), clip_rect.size);
 
-				for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *F = canvas->occluders.front(); F; F = F->next()) {
+				for (Set<RendererCanvasRender::LightOccluderInstance *>::Element *F = canvas->occluders.front(); F; F = F->next()) {
 					if (!F->get()->enabled) {
 						continue;
 					}
@@ -248,7 +276,7 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 			}
 			//update the light shadowmaps with them
 
-			RasterizerCanvas::Light *light = lights_with_shadow;
+			RendererCanvasRender::Light *light = lights_with_shadow;
 			while (light) {
 				RENDER_TIMESTAMP("Render Shadow");
 
@@ -256,13 +284,12 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 				light = light->shadows_next_ptr;
 			}
 
-			//RSG::canvas_render->reset_canvas();
 			RENDER_TIMESTAMP("<End rendering 2D Shadows");
 		}
 
 		if (directional_lights_with_shadow) {
 			//update shadows if any
-			RasterizerCanvas::Light *light = directional_lights_with_shadow;
+			RendererCanvasRender::Light *light = directional_lights_with_shadow;
 			while (light) {
 				Vector2 light_dir = -light->xform_cache.elements[1].normalized(); // Y is light direction
 				float cull_distance = light->directional_distance;
@@ -307,17 +334,17 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 
 				Vector2 xf_points[6];
 
-				RasterizerCanvas::LightOccluderInstance *occluders = nullptr;
+				RendererCanvasRender::LightOccluderInstance *occluders = nullptr;
 
 				RENDER_TIMESTAMP(">Render Directional 2D Shadows");
 
 				//make list of occluders
 				int occ_cullded = 0;
 				for (Map<RID, Viewport::CanvasData>::Element *E = p_viewport->canvas_map.front(); E; E = E->next()) {
-					RenderingServerCanvas::Canvas *canvas = static_cast<RenderingServerCanvas::Canvas *>(E->get().canvas);
+					RendererCanvasCull::Canvas *canvas = static_cast<RendererCanvasCull::Canvas *>(E->get().canvas);
 					Transform2D xf = _canvas_get_transform(p_viewport, canvas, &E->get(), clip_rect.size);
 
-					for (Set<RasterizerCanvas::LightOccluderInstance *>::Element *F = canvas->occluders.front(); F; F = F->next()) {
+					for (Set<RendererCanvasRender::LightOccluderInstance *>::Element *F = canvas->occluders.front(); F; F = F->next()) {
 						if (!F->get()->enabled) {
 							continue;
 						}
@@ -340,7 +367,6 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 				light = light->shadows_next_ptr;
 			}
 
-			//RSG::canvas_render->reset_canvas();
 			RENDER_TIMESTAMP("<Render Directional 2D Shadows");
 		}
 
@@ -354,14 +380,14 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 		}
 
 		for (Map<Viewport::CanvasKey, Viewport::CanvasData *>::Element *E = canvas_map.front(); E; E = E->next()) {
-			RenderingServerCanvas::Canvas *canvas = static_cast<RenderingServerCanvas::Canvas *>(E->get()->canvas);
+			RendererCanvasCull::Canvas *canvas = static_cast<RendererCanvasCull::Canvas *>(E->get()->canvas);
 
 			Transform2D xform = _canvas_get_transform(p_viewport, canvas, E->get(), clip_rect.size);
 
-			RasterizerCanvas::Light *canvas_lights = nullptr;
-			RasterizerCanvas::Light *canvas_directional_lights = nullptr;
+			RendererCanvasRender::Light *canvas_lights = nullptr;
+			RendererCanvasRender::Light *canvas_directional_lights = nullptr;
 
-			RasterizerCanvas::Light *ptr = lights;
+			RendererCanvasRender::Light *ptr = lights;
 			while (ptr) {
 				if (E->get()->layer >= ptr->layer_min && E->get()->layer <= ptr->layer_max) {
 					ptr->next_ptr = canvas_lights;
@@ -380,6 +406,9 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 			}
 
 			RSG::canvas->render_canvas(p_viewport->render_target, canvas, xform, canvas_lights, canvas_directional_lights, clip_rect, p_viewport->texture_filter, p_viewport->texture_repeat, p_viewport->snap_2d_transforms_to_pixel, p_viewport->snap_2d_vertices_to_pixel);
+			if (RSG::canvas->was_sdf_used()) {
+				p_viewport->sdf_active = true;
+			}
 			i++;
 
 			if (scenario_draw_canvas_bg && E->key().get_layer() >= scenario_canvas_max_layer) {
@@ -400,8 +429,6 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 				_draw_3d(p_viewport, p_eye);
 			}
 		}
-
-		//RSG::canvas_render->canvas_debug_viewport_shadows(lights_with_shadow);
 	}
 
 	if (RSG::storage->render_target_is_clear_requested(p_viewport->render_target)) {
@@ -416,7 +443,7 @@ void RenderingServerViewport::_draw_viewport(Viewport *p_viewport, XRInterface::
 	}
 }
 
-void RenderingServerViewport::draw_viewports() {
+void RendererViewport::draw_viewports() {
 	timestamp_vp_map.clear();
 
 	// get our xr interface in case we need it
@@ -436,7 +463,7 @@ void RenderingServerViewport::draw_viewports() {
 	//sort viewports
 	active_viewports.sort_custom<ViewportSort>();
 
-	Map<DisplayServer::WindowID, Vector<Rasterizer::BlitToScreen>> blit_to_screen_list;
+	Map<DisplayServer::WindowID, Vector<RendererCompositor::BlitToScreen>> blit_to_screen_list;
 	//draw viewports
 	RENDER_TIMESTAMP(">Render Viewports");
 
@@ -531,7 +558,7 @@ void RenderingServerViewport::draw_viewports() {
 		{
 			RSG::storage->render_target_set_external_texture(vp->render_target, 0);
 
-			RSG::scene_render->set_debug_draw_mode(vp->debug_draw);
+			RSG::scene->set_debug_draw_mode(vp->debug_draw);
 			RSG::storage->render_info_begin_capture();
 
 			// render standard mono camera
@@ -547,7 +574,7 @@ void RenderingServerViewport::draw_viewports() {
 
 			if (vp->viewport_to_screen != DisplayServer::INVALID_WINDOW_ID && (!vp->viewport_render_direct_to_screen || !RSG::rasterizer->is_low_end())) {
 				//copy to screen if set as such
-				Rasterizer::BlitToScreen blit;
+				RendererCompositor::BlitToScreen blit;
 				blit.render_target = vp->render_target;
 				if (vp->viewport_to_screen_rect != Rect2()) {
 					blit.rect = vp->viewport_to_screen_rect;
@@ -557,7 +584,7 @@ void RenderingServerViewport::draw_viewports() {
 				}
 
 				if (!blit_to_screen_list.has(vp->viewport_to_screen)) {
-					blit_to_screen_list[vp->viewport_to_screen] = Vector<Rasterizer::BlitToScreen>();
+					blit_to_screen_list[vp->viewport_to_screen] = Vector<RendererCompositor::BlitToScreen>();
 				}
 
 				blit_to_screen_list[vp->viewport_to_screen].push_back(blit);
@@ -570,18 +597,18 @@ void RenderingServerViewport::draw_viewports() {
 
 		RENDER_TIMESTAMP("<Rendering Viewport " + itos(i));
 	}
-	RSG::scene_render->set_debug_draw_mode(RS::VIEWPORT_DEBUG_DRAW_DISABLED);
+	RSG::scene->set_debug_draw_mode(RS::VIEWPORT_DEBUG_DRAW_DISABLED);
 
 	RENDER_TIMESTAMP("<Render Viewports");
 	//this needs to be called to make screen swapping more efficient
 	RSG::rasterizer->prepare_for_blitting_render_targets();
 
-	for (Map<int, Vector<Rasterizer::BlitToScreen>>::Element *E = blit_to_screen_list.front(); E; E = E->next()) {
+	for (Map<int, Vector<RendererCompositor::BlitToScreen>>::Element *E = blit_to_screen_list.front(); E; E = E->next()) {
 		RSG::rasterizer->blit_render_targets_to_screen(E->key(), E->get().ptr(), E->get().size());
 	}
 }
 
-RID RenderingServerViewport::viewport_create() {
+RID RendererViewport::viewport_create() {
 	Viewport *viewport = memnew(Viewport);
 
 	RID rid = viewport_owner.make_rid(viewport);
@@ -590,20 +617,20 @@ RID RenderingServerViewport::viewport_create() {
 	viewport->hide_scenario = false;
 	viewport->hide_canvas = false;
 	viewport->render_target = RSG::storage->render_target_create();
-	viewport->shadow_atlas = RSG::scene_render->shadow_atlas_create();
+	viewport->shadow_atlas = RSG::scene->shadow_atlas_create();
 	viewport->viewport_render_direct_to_screen = false;
 
 	return rid;
 }
 
-void RenderingServerViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) {
+void RendererViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->use_xr = p_use_xr;
 }
 
-void RenderingServerViewport::viewport_set_size(RID p_viewport, int p_width, int p_height) {
+void RendererViewport::viewport_set_size(RID p_viewport, int p_width, int p_height) {
 	ERR_FAIL_COND(p_width < 0 && p_height < 0);
 
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
@@ -613,15 +640,15 @@ void RenderingServerViewport::viewport_set_size(RID p_viewport, int p_width, int
 	RSG::storage->render_target_set_size(viewport->render_target, p_width, p_height);
 	if (viewport->render_buffers.is_valid()) {
 		if (p_width == 0 || p_height == 0) {
-			RSG::scene_render->free(viewport->render_buffers);
+			RSG::scene->free(viewport->render_buffers);
 			viewport->render_buffers = RID();
 		} else {
-			RSG::scene_render->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, viewport->msaa, viewport->screen_space_aa, viewport->use_debanding);
+			RSG::scene->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, viewport->msaa, viewport->screen_space_aa, viewport->use_debanding);
 		}
 	}
 }
 
-void RenderingServerViewport::viewport_set_active(RID p_viewport, bool p_active) {
+void RendererViewport::viewport_set_active(RID p_viewport, bool p_active) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -633,21 +660,21 @@ void RenderingServerViewport::viewport_set_active(RID p_viewport, bool p_active)
 	}
 }
 
-void RenderingServerViewport::viewport_set_parent_viewport(RID p_viewport, RID p_parent_viewport) {
+void RendererViewport::viewport_set_parent_viewport(RID p_viewport, RID p_parent_viewport) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->parent = p_parent_viewport;
 }
 
-void RenderingServerViewport::viewport_set_clear_mode(RID p_viewport, RS::ViewportClearMode p_clear_mode) {
+void RendererViewport::viewport_set_clear_mode(RID p_viewport, RS::ViewportClearMode p_clear_mode) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->clear_mode = p_clear_mode;
 }
 
-void RenderingServerViewport::viewport_attach_to_screen(RID p_viewport, const Rect2 &p_rect, DisplayServer::WindowID p_screen) {
+void RendererViewport::viewport_attach_to_screen(RID p_viewport, const Rect2 &p_rect, DisplayServer::WindowID p_screen) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -673,7 +700,7 @@ void RenderingServerViewport::viewport_attach_to_screen(RID p_viewport, const Re
 	}
 }
 
-void RenderingServerViewport::viewport_set_render_direct_to_screen(RID p_viewport, bool p_enable) {
+void RendererViewport::viewport_set_render_direct_to_screen(RID p_viewport, bool p_enable) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -687,7 +714,7 @@ void RenderingServerViewport::viewport_set_render_direct_to_screen(RID p_viewpor
 		RSG::storage->render_target_set_size(viewport->render_target, viewport->size.x, viewport->size.y);
 	}
 
-	RSG::storage->render_target_set_flag(viewport->render_target, RasterizerStorage::RENDER_TARGET_DIRECT_TO_SCREEN, p_enable);
+	RSG::storage->render_target_set_flag(viewport->render_target, RendererStorage::RENDER_TARGET_DIRECT_TO_SCREEN, p_enable);
 	viewport->viewport_render_direct_to_screen = p_enable;
 
 	// if attached to screen already, setup screen size and position, this needs to happen after setting flag to avoid an unnecessary buffer allocation
@@ -697,61 +724,61 @@ void RenderingServerViewport::viewport_set_render_direct_to_screen(RID p_viewpor
 	}
 }
 
-void RenderingServerViewport::viewport_set_update_mode(RID p_viewport, RS::ViewportUpdateMode p_mode) {
+void RendererViewport::viewport_set_update_mode(RID p_viewport, RS::ViewportUpdateMode p_mode) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->update_mode = p_mode;
 }
 
-RID RenderingServerViewport::viewport_get_texture(RID p_viewport) const {
+RID RendererViewport::viewport_get_texture(RID p_viewport) const {
 	const Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND_V(!viewport, RID());
 
 	return RSG::storage->render_target_get_texture(viewport->render_target);
 }
 
-void RenderingServerViewport::viewport_set_hide_scenario(RID p_viewport, bool p_hide) {
+void RendererViewport::viewport_set_hide_scenario(RID p_viewport, bool p_hide) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->hide_scenario = p_hide;
 }
 
-void RenderingServerViewport::viewport_set_hide_canvas(RID p_viewport, bool p_hide) {
+void RendererViewport::viewport_set_hide_canvas(RID p_viewport, bool p_hide) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->hide_canvas = p_hide;
 }
 
-void RenderingServerViewport::viewport_set_disable_environment(RID p_viewport, bool p_disable) {
+void RendererViewport::viewport_set_disable_environment(RID p_viewport, bool p_disable) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->disable_environment = p_disable;
 }
 
-void RenderingServerViewport::viewport_attach_camera(RID p_viewport, RID p_camera) {
+void RendererViewport::viewport_attach_camera(RID p_viewport, RID p_camera) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->camera = p_camera;
 }
 
-void RenderingServerViewport::viewport_set_scenario(RID p_viewport, RID p_scenario) {
+void RendererViewport::viewport_set_scenario(RID p_viewport, RID p_scenario) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->scenario = p_scenario;
 }
 
-void RenderingServerViewport::viewport_attach_canvas(RID p_viewport, RID p_canvas) {
+void RendererViewport::viewport_attach_canvas(RID p_viewport, RID p_canvas) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	ERR_FAIL_COND(viewport->canvas_map.has(p_canvas));
-	RenderingServerCanvas::Canvas *canvas = RSG::canvas->canvas_owner.getornull(p_canvas);
+	RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.getornull(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
 	canvas->viewports.insert(p_viewport);
@@ -761,18 +788,18 @@ void RenderingServerViewport::viewport_attach_canvas(RID p_viewport, RID p_canva
 	viewport->canvas_map[p_canvas].canvas = canvas;
 }
 
-void RenderingServerViewport::viewport_remove_canvas(RID p_viewport, RID p_canvas) {
+void RendererViewport::viewport_remove_canvas(RID p_viewport, RID p_canvas) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	RenderingServerCanvas::Canvas *canvas = RSG::canvas->canvas_owner.getornull(p_canvas);
+	RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.getornull(p_canvas);
 	ERR_FAIL_COND(!canvas);
 
 	viewport->canvas_map.erase(p_canvas);
 	canvas->viewports.erase(p_viewport);
 }
 
-void RenderingServerViewport::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Transform2D &p_offset) {
+void RendererViewport::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Transform2D &p_offset) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -780,22 +807,22 @@ void RenderingServerViewport::viewport_set_canvas_transform(RID p_viewport, RID
 	viewport->canvas_map[p_canvas].transform = p_offset;
 }
 
-void RenderingServerViewport::viewport_set_transparent_background(RID p_viewport, bool p_enabled) {
+void RendererViewport::viewport_set_transparent_background(RID p_viewport, bool p_enabled) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	RSG::storage->render_target_set_flag(viewport->render_target, RasterizerStorage::RENDER_TARGET_TRANSPARENT, p_enabled);
+	RSG::storage->render_target_set_flag(viewport->render_target, RendererStorage::RENDER_TARGET_TRANSPARENT, p_enabled);
 	viewport->transparent_bg = p_enabled;
 }
 
-void RenderingServerViewport::viewport_set_global_canvas_transform(RID p_viewport, const Transform2D &p_transform) {
+void RendererViewport::viewport_set_global_canvas_transform(RID p_viewport, const Transform2D &p_transform) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->global_transform = p_transform;
 }
 
-void RenderingServerViewport::viewport_set_canvas_stacking(RID p_viewport, RID p_canvas, int p_layer, int p_sublayer) {
+void RendererViewport::viewport_set_canvas_stacking(RID p_viewport, RID p_canvas, int p_layer, int p_sublayer) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -804,23 +831,23 @@ void RenderingServerViewport::viewport_set_canvas_stacking(RID p_viewport, RID p
 	viewport->canvas_map[p_canvas].sublayer = p_sublayer;
 }
 
-void RenderingServerViewport::viewport_set_shadow_atlas_size(RID p_viewport, int p_size) {
+void RendererViewport::viewport_set_shadow_atlas_size(RID p_viewport, int p_size) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->shadow_atlas_size = p_size;
 
-	RSG::scene_render->shadow_atlas_set_size(viewport->shadow_atlas, viewport->shadow_atlas_size);
+	RSG::scene->shadow_atlas_set_size(viewport->shadow_atlas, viewport->shadow_atlas_size);
 }
 
-void RenderingServerViewport::viewport_set_shadow_atlas_quadrant_subdivision(RID p_viewport, int p_quadrant, int p_subdiv) {
+void RendererViewport::viewport_set_shadow_atlas_quadrant_subdivision(RID p_viewport, int p_quadrant, int p_subdiv) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(viewport->shadow_atlas, p_quadrant, p_subdiv);
+	RSG::scene->shadow_atlas_set_quadrant_subdivision(viewport->shadow_atlas, p_quadrant, p_subdiv);
 }
 
-void RenderingServerViewport::viewport_set_msaa(RID p_viewport, RS::ViewportMSAA p_msaa) {
+void RendererViewport::viewport_set_msaa(RID p_viewport, RS::ViewportMSAA p_msaa) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -829,11 +856,11 @@ void RenderingServerViewport::viewport_set_msaa(RID p_viewport, RS::ViewportMSAA
 	}
 	viewport->msaa = p_msaa;
 	if (viewport->render_buffers.is_valid()) {
-		RSG::scene_render->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, p_msaa, viewport->screen_space_aa, viewport->use_debanding);
+		RSG::scene->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, p_msaa, viewport->screen_space_aa, viewport->use_debanding);
 	}
 }
 
-void RenderingServerViewport::viewport_set_screen_space_aa(RID p_viewport, RS::ViewportScreenSpaceAA p_mode) {
+void RendererViewport::viewport_set_screen_space_aa(RID p_viewport, RS::ViewportScreenSpaceAA p_mode) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -842,11 +869,11 @@ void RenderingServerViewport::viewport_set_screen_space_aa(RID p_viewport, RS::V
 	}
 	viewport->screen_space_aa = p_mode;
 	if (viewport->render_buffers.is_valid()) {
-		RSG::scene_render->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, viewport->msaa, p_mode, viewport->use_debanding);
+		RSG::scene->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, viewport->msaa, p_mode, viewport->use_debanding);
 	}
 }
 
-void RenderingServerViewport::viewport_set_use_debanding(RID p_viewport, bool p_use_debanding) {
+void RendererViewport::viewport_set_use_debanding(RID p_viewport, bool p_use_debanding) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
@@ -855,11 +882,18 @@ void RenderingServerViewport::viewport_set_use_debanding(RID p_viewport, bool p_
 	}
 	viewport->use_debanding = p_use_debanding;
 	if (viewport->render_buffers.is_valid()) {
-		RSG::scene_render->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, viewport->msaa, viewport->screen_space_aa, p_use_debanding);
+		RSG::scene->render_buffers_configure(viewport->render_buffers, viewport->render_target, viewport->size.width, viewport->size.height, viewport->msaa, viewport->screen_space_aa, p_use_debanding);
 	}
 }
 
-int RenderingServerViewport::viewport_get_render_info(RID p_viewport, RS::ViewportRenderInfo p_info) {
+void RendererViewport::viewport_set_lod_threshold(RID p_viewport, float p_pixels) {
+	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	ERR_FAIL_COND(!viewport);
+
+	viewport->lod_threshold = p_pixels;
+}
+
+int RendererViewport::viewport_get_render_info(RID p_viewport, RS::ViewportRenderInfo p_info) {
 	ERR_FAIL_INDEX_V(p_info, RS::VIEWPORT_RENDER_INFO_MAX, -1);
 
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
@@ -870,54 +904,54 @@ int RenderingServerViewport::viewport_get_render_info(RID p_viewport, RS::Viewpo
 	return viewport->render_info[p_info];
 }
 
-void RenderingServerViewport::viewport_set_debug_draw(RID p_viewport, RS::ViewportDebugDraw p_draw) {
+void RendererViewport::viewport_set_debug_draw(RID p_viewport, RS::ViewportDebugDraw p_draw) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->debug_draw = p_draw;
 }
 
-void RenderingServerViewport::viewport_set_measure_render_time(RID p_viewport, bool p_enable) {
+void RendererViewport::viewport_set_measure_render_time(RID p_viewport, bool p_enable) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->measure_render_time = p_enable;
 }
 
-float RenderingServerViewport::viewport_get_measured_render_time_cpu(RID p_viewport) const {
+float RendererViewport::viewport_get_measured_render_time_cpu(RID p_viewport) const {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND_V(!viewport, 0);
 
 	return double(viewport->time_cpu_end - viewport->time_cpu_begin) / 1000.0;
 }
 
-float RenderingServerViewport::viewport_get_measured_render_time_gpu(RID p_viewport) const {
+float RendererViewport::viewport_get_measured_render_time_gpu(RID p_viewport) const {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND_V(!viewport, 0);
 
 	return double((viewport->time_gpu_end - viewport->time_gpu_begin) / 1000) / 1000.0;
 }
 
-void RenderingServerViewport::viewport_set_snap_2d_transforms_to_pixel(RID p_viewport, bool p_enabled) {
+void RendererViewport::viewport_set_snap_2d_transforms_to_pixel(RID p_viewport, bool p_enabled) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 	viewport->snap_2d_transforms_to_pixel = p_enabled;
 }
 
-void RenderingServerViewport::viewport_set_snap_2d_vertices_to_pixel(RID p_viewport, bool p_enabled) {
+void RendererViewport::viewport_set_snap_2d_vertices_to_pixel(RID p_viewport, bool p_enabled) {
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 	viewport->snap_2d_vertices_to_pixel = p_enabled;
 }
 
-void RenderingServerViewport::viewport_set_default_canvas_item_texture_filter(RID p_viewport, RS::CanvasItemTextureFilter p_filter) {
+void RendererViewport::viewport_set_default_canvas_item_texture_filter(RID p_viewport, RS::CanvasItemTextureFilter p_filter) {
 	ERR_FAIL_COND_MSG(p_filter == RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT, "Viewport does not accept DEFAULT as texture filter (it's the topmost choice already).)");
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	viewport->texture_filter = p_filter;
 }
-void RenderingServerViewport::viewport_set_default_canvas_item_texture_repeat(RID p_viewport, RS::CanvasItemTextureRepeat p_repeat) {
+void RendererViewport::viewport_set_default_canvas_item_texture_repeat(RID p_viewport, RS::CanvasItemTextureRepeat p_repeat) {
 	ERR_FAIL_COND_MSG(p_repeat == RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT, "Viewport does not accept DEFAULT as texture repeat (it's the topmost choice already).)");
 	Viewport *viewport = viewport_owner.getornull(p_viewport);
 	ERR_FAIL_COND(!viewport);
@@ -925,14 +959,21 @@ void RenderingServerViewport::viewport_set_default_canvas_item_texture_repeat(RI
 	viewport->texture_repeat = p_repeat;
 }
 
-bool RenderingServerViewport::free(RID p_rid) {
+void RendererViewport::viewport_set_sdf_oversize_and_scale(RID p_viewport, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) {
+	Viewport *viewport = viewport_owner.getornull(p_viewport);
+	ERR_FAIL_COND(!viewport);
+
+	RSG::storage->render_target_set_sdf_size_and_scale(viewport->render_target, p_size, p_scale);
+}
+
+bool RendererViewport::free(RID p_rid) {
 	if (viewport_owner.owns(p_rid)) {
 		Viewport *viewport = viewport_owner.getornull(p_rid);
 
 		RSG::storage->free(viewport->render_target);
-		RSG::scene_render->free(viewport->shadow_atlas);
+		RSG::scene->free(viewport->shadow_atlas);
 		if (viewport->render_buffers.is_valid()) {
-			RSG::scene_render->free(viewport->render_buffers);
+			RSG::scene->free(viewport->render_buffers);
 		}
 
 		while (viewport->canvas_map.front()) {
@@ -951,7 +992,7 @@ bool RenderingServerViewport::free(RID p_rid) {
 	return false;
 }
 
-void RenderingServerViewport::handle_timestamp(String p_timestamp, uint64_t p_cpu_time, uint64_t p_gpu_time) {
+void RendererViewport::handle_timestamp(String p_timestamp, uint64_t p_cpu_time, uint64_t p_gpu_time) {
 	RID *vp = timestamp_vp_map.getptr(p_timestamp);
 	if (!vp) {
 		return;
@@ -973,9 +1014,9 @@ void RenderingServerViewport::handle_timestamp(String p_timestamp, uint64_t p_cp
 	}
 }
 
-void RenderingServerViewport::set_default_clear_color(const Color &p_color) {
+void RendererViewport::set_default_clear_color(const Color &p_color) {
 	RSG::storage->set_default_clear_color(p_color);
 }
 
-RenderingServerViewport::RenderingServerViewport() {
+RendererViewport::RendererViewport() {
 }
diff --git a/servers/rendering/rendering_server_viewport.h b/servers/rendering/renderer_viewport.h
index 081f63690b..e836d05dfc 100644
--- a/servers/rendering/rendering_server_viewport.h
+++ b/servers/rendering/renderer_viewport.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_viewport.h                                          */
+/*  renderer_viewport.h                                                  */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -33,11 +33,11 @@
 
 #include "core/templates/rid_owner.h"
 #include "core/templates/self_list.h"
-#include "rasterizer.h"
+#include "renderer_compositor.h"
 #include "servers/rendering_server.h"
 #include "servers/xr/xr_interface.h"
 
-class RenderingServerViewport {
+class RendererViewport {
 public:
 	struct CanvasBase {
 	};
@@ -82,6 +82,10 @@ public:
 		RID shadow_atlas;
 		int shadow_atlas_size;
 
+		bool sdf_active;
+
+		float lod_threshold = 1.0;
+
 		uint64_t last_pass = 0;
 
 		int render_info[RS::VIEWPORT_RENDER_INFO_MAX];
@@ -146,6 +150,7 @@ public:
 				render_info[i] = 0;
 			}
 			use_xr = false;
+			sdf_active = false;
 
 			time_cpu_begin = 0;
 			time_cpu_end = 0;
@@ -219,6 +224,8 @@ public:
 	void viewport_set_screen_space_aa(RID p_viewport, RS::ViewportScreenSpaceAA p_mode);
 	void viewport_set_use_debanding(RID p_viewport, bool p_use_debanding);
 
+	void viewport_set_lod_threshold(RID p_viewport, float p_pixels);
+
 	virtual int viewport_get_render_info(RID p_viewport, RS::ViewportRenderInfo p_info);
 	virtual void viewport_set_debug_draw(RID p_viewport, RS::ViewportDebugDraw p_draw);
 
@@ -232,6 +239,8 @@ public:
 	void viewport_set_default_canvas_item_texture_filter(RID p_viewport, RS::CanvasItemTextureFilter p_filter);
 	void viewport_set_default_canvas_item_texture_repeat(RID p_viewport, RS::CanvasItemTextureRepeat p_repeat);
 
+	void viewport_set_sdf_oversize_and_scale(RID p_viewport, RS::ViewportSDFOversize p_over_size, RS::ViewportSDFScale p_scale);
+
 	void handle_timestamp(String p_timestamp, uint64_t p_cpu_time, uint64_t p_gpu_time);
 
 	void set_default_clear_color(const Color &p_color);
@@ -239,8 +248,8 @@ public:
 
 	bool free(RID p_rid);
 
-	RenderingServerViewport();
-	virtual ~RenderingServerViewport() {}
+	RendererViewport();
+	virtual ~RendererViewport() {}
 };
 
 #endif // VISUALSERVERVIEWPORT_H
diff --git a/servers/rendering/rendering_device.cpp b/servers/rendering/rendering_device.cpp
index 1259b161bd..ba30670082 100644
--- a/servers/rendering/rendering_device.cpp
+++ b/servers/rendering/rendering_device.cpp
@@ -270,7 +270,7 @@ void RenderingDevice::_bind_methods() {
 
 	ClassDB::bind_method(D_METHOD("sampler_create", "state"), &RenderingDevice::_sampler_create);
 
-	ClassDB::bind_method(D_METHOD("vertex_buffer_create", "size_bytes", "data"), &RenderingDevice::vertex_buffer_create, DEFVAL(Vector<uint8_t>()));
+	ClassDB::bind_method(D_METHOD("vertex_buffer_create", "size_bytes", "data", "use_as_storage"), &RenderingDevice::vertex_buffer_create, DEFVAL(Vector<uint8_t>()), DEFVAL(false));
 	ClassDB::bind_method(D_METHOD("vertex_format_create", "vertex_descriptions"), &RenderingDevice::_vertex_format_create);
 
 	ClassDB::bind_method(D_METHOD("index_buffer_create", "size_indices", "format", "data"), &RenderingDevice::index_buffer_create, DEFVAL(Vector<uint8_t>()), DEFVAL(false));
diff --git a/servers/rendering/rendering_device.h b/servers/rendering/rendering_device.h
index f1f8b3cda0..524d7749c9 100644
--- a/servers/rendering/rendering_device.h
+++ b/servers/rendering/rendering_device.h
@@ -392,7 +392,7 @@ public:
 		uint32_t depth;
 		uint32_t array_layers;
 		uint32_t mipmaps;
-		TextureType type;
+		TextureType texture_type;
 		TextureSamples samples;
 		uint32_t usage_bits;
 		Vector<DataFormat> shareable_formats;
@@ -404,7 +404,7 @@ public:
 			depth = 1;
 			array_layers = 1;
 			mipmaps = 1;
-			type = TEXTURE_TYPE_2D;
+			texture_type = TEXTURE_TYPE_2D;
 			samples = TEXTURE_SAMPLES_1;
 			usage_bits = 0;
 		}
@@ -564,7 +564,7 @@ public:
 			frequency = VERTEX_FREQUENCY_VERTEX;
 		}
 	};
-	virtual RID vertex_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data = Vector<uint8_t>()) = 0;
+	virtual RID vertex_buffer_create(uint32_t p_size_bytes, const Vector<uint8_t> &p_data = Vector<uint8_t>(), bool p_use_as_storage = false) = 0;
 
 	typedef int64_t VertexFormatID;
 
@@ -629,7 +629,7 @@ public:
 	virtual RID texture_buffer_create(uint32_t p_size_elements, DataFormat p_format, const Vector<uint8_t> &p_data = Vector<uint8_t>()) = 0;
 
 	struct Uniform {
-		UniformType type;
+		UniformType uniform_type;
 		int binding; //binding index as specified in shader
 
 		//for single items, provide one ID, for
@@ -640,7 +640,7 @@ public:
 		Vector<RID> ids;
 
 		Uniform() {
-			type = UNIFORM_TYPE_IMAGE;
+			uniform_type = UNIFORM_TYPE_IMAGE;
 			binding = 0;
 		}
 	};
diff --git a/servers/rendering/rendering_device_binds.h b/servers/rendering/rendering_device_binds.h
index 66c6a1c3a9..5deeec3ffe 100644
--- a/servers/rendering/rendering_device_binds.h
+++ b/servers/rendering/rendering_device_binds.h
@@ -64,7 +64,7 @@ public:
 	RD_SETGET(uint32_t, depth)
 	RD_SETGET(uint32_t, array_layers)
 	RD_SETGET(uint32_t, mipmaps)
-	RD_SETGET(RD::TextureType, type)
+	RD_SETGET(RD::TextureType, texture_type)
 	RD_SETGET(RD::TextureSamples, samples)
 	RD_SETGET(uint32_t, usage_bits)
 
@@ -79,7 +79,7 @@ protected:
 		RD_BIND(Variant::INT, RDTextureFormat, depth);
 		RD_BIND(Variant::INT, RDTextureFormat, array_layers);
 		RD_BIND(Variant::INT, RDTextureFormat, mipmaps);
-		RD_BIND(Variant::INT, RDTextureFormat, type);
+		RD_BIND(Variant::INT, RDTextureFormat, texture_type);
 		RD_BIND(Variant::INT, RDTextureFormat, samples);
 		RD_BIND(Variant::INT, RDTextureFormat, usage_bits);
 		ClassDB::bind_method(D_METHOD("add_shareable_format", "format"), &RDTextureFormat::add_shareable_format);
@@ -392,7 +392,7 @@ class RDUniform : public Reference {
 	RD::Uniform base;
 
 public:
-	RD_SETGET(RD::UniformType, type)
+	RD_SETGET(RD::UniformType, uniform_type)
 	RD_SETGET(int32_t, binding)
 
 	void add_id(const RID &p_id) { base.ids.push_back(p_id); }
@@ -415,7 +415,7 @@ protected:
 		}
 	}
 	static void _bind_methods() {
-		RD_BIND(Variant::INT, RDUniform, type);
+		RD_BIND(Variant::INT, RDUniform, uniform_type);
 		RD_BIND(Variant::INT, RDUniform, binding);
 		ClassDB::bind_method(D_METHOD("add_id", "id"), &RDUniform::add_id);
 		ClassDB::bind_method(D_METHOD("clear_ids"), &RDUniform::clear_ids);
diff --git a/servers/rendering/rendering_server_raster.cpp b/servers/rendering/rendering_server_default.cpp
index 94cfb6b752..47f7fa07d5 100644
--- a/servers/rendering/rendering_server_raster.cpp
+++ b/servers/rendering/rendering_server_default.cpp
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_raster.cpp                                          */
+/*  rendering_server_default.cpp                                         */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,43 +28,43 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#include "rendering_server_raster.h"
+#include "rendering_server_default.h"
 
 #include "core/config/project_settings.h"
 #include "core/io/marshalls.h"
 #include "core/os/os.h"
 #include "core/templates/sort_array.h"
-#include "rendering_server_canvas.h"
+#include "renderer_canvas_cull.h"
+#include "renderer_scene_cull.h"
 #include "rendering_server_globals.h"
-#include "rendering_server_scene.h"
 
 // careful, these may run in different threads than the visual server
 
-int RenderingServerRaster::changes = 0;
+int RenderingServerDefault::changes = 0;
 
 /* BLACK BARS */
 
-void RenderingServerRaster::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom) {
+void RenderingServerDefault::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom) {
 	black_margin[MARGIN_LEFT] = p_left;
 	black_margin[MARGIN_TOP] = p_top;
 	black_margin[MARGIN_RIGHT] = p_right;
 	black_margin[MARGIN_BOTTOM] = p_bottom;
 }
 
-void RenderingServerRaster::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom) {
+void RenderingServerDefault::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom) {
 	black_image[MARGIN_LEFT] = p_left;
 	black_image[MARGIN_TOP] = p_top;
 	black_image[MARGIN_RIGHT] = p_right;
 	black_image[MARGIN_BOTTOM] = p_bottom;
 }
 
-void RenderingServerRaster::_draw_margins() {
+void RenderingServerDefault::_draw_margins() {
 	RSG::canvas_render->draw_window_margins(black_margin, black_image);
 };
 
 /* FREE */
 
-void RenderingServerRaster::free(RID p_rid) {
+void RenderingServerDefault::free(RID p_rid) {
 	if (RSG::storage->free(p_rid)) {
 		return;
 	}
@@ -77,14 +77,11 @@ void RenderingServerRaster::free(RID p_rid) {
 	if (RSG::scene->free(p_rid)) {
 		return;
 	}
-	if (RSG::scene_render->free(p_rid)) {
-		return;
-	}
 }
 
 /* EVENT QUEUING */
 
-void RenderingServerRaster::request_frame_drawn_callback(Object *p_where, const StringName &p_method, const Variant &p_userdata) {
+void RenderingServerDefault::request_frame_drawn_callback(Object *p_where, const StringName &p_method, const Variant &p_userdata) {
 	ERR_FAIL_NULL(p_where);
 	FrameDrawnCallbacks fdc;
 	fdc.object = p_where->get_instance_id();
@@ -94,7 +91,7 @@ void RenderingServerRaster::request_frame_drawn_callback(Object *p_where, const
 	frame_drawn_callbacks.push_back(fdc);
 }
 
-void RenderingServerRaster::draw(bool p_swap_buffers, double frame_step) {
+void RenderingServerDefault::draw(bool p_swap_buffers, double frame_step) {
 	//needs to be done before changes is reset to 0, to not force the editor to redraw
 	RS::get_singleton()->emit_signal("frame_pre_draw");
 
@@ -104,11 +101,8 @@ void RenderingServerRaster::draw(bool p_swap_buffers, double frame_step) {
 
 	TIMESTAMP_BEGIN()
 
-	RSG::scene_render->update(); //update scenes stuff before updating instances
-
-	RSG::scene->update_dirty_instances(); //update scene stuff
+	RSG::scene->update(); //update scenes stuff before updating instances
 
-	RSG::scene->render_particle_colliders();
 	RSG::storage->update_particles(); //need to be done after instances are updated (colliders and particle transforms), and colliders are rendered
 
 	RSG::scene->render_probes();
@@ -165,18 +159,18 @@ void RenderingServerRaster::draw(bool p_swap_buffers, double frame_step) {
 	frame_profile_frame = RSG::storage->get_captured_timestamps_frame();
 }
 
-void RenderingServerRaster::sync() {
+void RenderingServerDefault::sync() {
 }
 
-bool RenderingServerRaster::has_changed() const {
+bool RenderingServerDefault::has_changed() const {
 	return changes > 0;
 }
 
-void RenderingServerRaster::init() {
+void RenderingServerDefault::init() {
 	RSG::rasterizer->initialize();
 }
 
-void RenderingServerRaster::finish() {
+void RenderingServerDefault::finish() {
 	if (test_cube.is_valid()) {
 		free(test_cube);
 	}
@@ -186,69 +180,69 @@ void RenderingServerRaster::finish() {
 
 /* STATUS INFORMATION */
 
-int RenderingServerRaster::get_render_info(RenderInfo p_info) {
+int RenderingServerDefault::get_render_info(RenderInfo p_info) {
 	return RSG::storage->get_render_info(p_info);
 }
 
-String RenderingServerRaster::get_video_adapter_name() const {
+String RenderingServerDefault::get_video_adapter_name() const {
 	return RSG::storage->get_video_adapter_name();
 }
 
-String RenderingServerRaster::get_video_adapter_vendor() const {
+String RenderingServerDefault::get_video_adapter_vendor() const {
 	return RSG::storage->get_video_adapter_vendor();
 }
 
-void RenderingServerRaster::set_frame_profiling_enabled(bool p_enable) {
+void RenderingServerDefault::set_frame_profiling_enabled(bool p_enable) {
 	RSG::storage->capturing_timestamps = p_enable;
 }
 
-uint64_t RenderingServerRaster::get_frame_profile_frame() {
+uint64_t RenderingServerDefault::get_frame_profile_frame() {
 	return frame_profile_frame;
 }
 
-Vector<RenderingServer::FrameProfileArea> RenderingServerRaster::get_frame_profile() {
+Vector<RenderingServer::FrameProfileArea> RenderingServerDefault::get_frame_profile() {
 	return frame_profile;
 }
 
 /* TESTING */
 
-void RenderingServerRaster::set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter) {
+void RenderingServerDefault::set_boot_image(const Ref<Image> &p_image, const Color &p_color, bool p_scale, bool p_use_filter) {
 	redraw_request();
 	RSG::rasterizer->set_boot_image(p_image, p_color, p_scale, p_use_filter);
 }
 
-void RenderingServerRaster::set_default_clear_color(const Color &p_color) {
+void RenderingServerDefault::set_default_clear_color(const Color &p_color) {
 	RSG::viewport->set_default_clear_color(p_color);
 }
 
-bool RenderingServerRaster::has_feature(Features p_feature) const {
+bool RenderingServerDefault::has_feature(Features p_feature) const {
 	return false;
 }
 
-void RenderingServerRaster::sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) {
-	RSG::scene_render->sdfgi_set_debug_probe_select(p_position, p_dir);
+void RenderingServerDefault::sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) {
+	RSG::scene->sdfgi_set_debug_probe_select(p_position, p_dir);
 }
 
-RID RenderingServerRaster::get_test_cube() {
+RID RenderingServerDefault::get_test_cube() {
 	if (!test_cube.is_valid()) {
 		test_cube = _make_test_cube();
 	}
 	return test_cube;
 }
 
-bool RenderingServerRaster::has_os_feature(const String &p_feature) const {
+bool RenderingServerDefault::has_os_feature(const String &p_feature) const {
 	return RSG::storage->has_os_feature(p_feature);
 }
 
-void RenderingServerRaster::set_debug_generate_wireframes(bool p_generate) {
+void RenderingServerDefault::set_debug_generate_wireframes(bool p_generate) {
 	RSG::storage->set_debug_generate_wireframes(p_generate);
 }
 
-void RenderingServerRaster::call_set_use_vsync(bool p_enable) {
+void RenderingServerDefault::call_set_use_vsync(bool p_enable) {
 	DisplayServer::get_singleton()->_set_use_vsync(p_enable);
 }
 
-bool RenderingServerRaster::is_low_end() const {
+bool RenderingServerDefault::is_low_end() const {
 	// FIXME: Commented out when rebasing vulkan branch on master,
 	// causes a crash, it seems rasterizer is not initialized yet the
 	// first time it's called.
@@ -256,14 +250,15 @@ bool RenderingServerRaster::is_low_end() const {
 	return false;
 }
 
-RenderingServerRaster::RenderingServerRaster() {
-	RSG::canvas = memnew(RenderingServerCanvas);
-	RSG::viewport = memnew(RenderingServerViewport);
-	RSG::scene = memnew(RenderingServerScene);
-	RSG::rasterizer = Rasterizer::create();
+RenderingServerDefault::RenderingServerDefault() {
+	RSG::canvas = memnew(RendererCanvasCull);
+	RSG::viewport = memnew(RendererViewport);
+	RendererSceneCull *sr = memnew(RendererSceneCull);
+	RSG::scene = sr;
+	RSG::rasterizer = RendererCompositor::create();
 	RSG::storage = RSG::rasterizer->get_storage();
 	RSG::canvas_render = RSG::rasterizer->get_canvas();
-	RSG::scene_render = RSG::rasterizer->get_scene();
+	sr->scene_render = RSG::rasterizer->get_scene();
 
 	frame_profile_frame = 0;
 
@@ -273,7 +268,7 @@ RenderingServerRaster::RenderingServerRaster() {
 	}
 }
 
-RenderingServerRaster::~RenderingServerRaster() {
+RenderingServerDefault::~RenderingServerDefault() {
 	memdelete(RSG::canvas);
 	memdelete(RSG::viewport);
 	memdelete(RSG::rasterizer);
diff --git a/servers/rendering/rendering_server_raster.h b/servers/rendering/rendering_server_default.h
index daad706f8e..dd1a41a4f7 100644
--- a/servers/rendering/rendering_server_raster.h
+++ b/servers/rendering/rendering_server_default.h
@@ -1,5 +1,5 @@
 /*************************************************************************/
-/*  rendering_server_raster.h                                            */
+/*  rendering_server_default.h                                           */
 /*************************************************************************/
 /*                       This file is part of:                           */
 /*                           GODOT ENGINE                                */
@@ -28,20 +28,19 @@
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
 
-#ifndef RENDERING_SERVER_RASTER_H
-#define RENDERING_SERVER_RASTER_H
+#ifndef RENDERING_SERVER_DEFAULT_H
+#define RENDERING_SERVER_DEFAULT_H
 
 #include "core/math/octree.h"
-#include "rendering_server_canvas.h"
+#include "renderer_canvas_cull.h"
+#include "renderer_scene_cull.h"
+#include "renderer_viewport.h"
 #include "rendering_server_globals.h"
-#include "rendering_server_scene.h"
-#include "rendering_server_viewport.h"
-#include "servers/rendering/rasterizer.h"
+#include "servers/rendering/renderer_compositor.h"
 #include "servers/rendering_server.h"
 
-class RenderingServerRaster : public RenderingServer {
+class RenderingServerDefault : public RenderingServer {
 	enum {
-
 		MAX_INSTANCE_CULL = 8192,
 		MAX_INSTANCE_LIGHTS = 4,
 		LIGHT_CACHE_DIRTY = -1,
@@ -232,14 +231,17 @@ public:
 
 	/* MESH API */
 
-	virtual RID mesh_create_from_surfaces(const Vector<SurfaceData> &p_surfaces) {
+	virtual RID mesh_create_from_surfaces(const Vector<SurfaceData> &p_surfaces, int p_blend_shape_count = 0) {
 		RID mesh = mesh_create();
+		mesh_set_blend_shape_count(mesh, p_blend_shape_count);
 		for (int i = 0; i < p_surfaces.size(); i++) {
 			mesh_add_surface(mesh, p_surfaces[i]);
 		}
 		return mesh;
 	}
 
+	BIND2(mesh_set_blend_shape_count, RID, int)
+
 	BIND0R(RID, mesh_create)
 
 	BIND2(mesh_add_surface, RID, const SurfaceData &)
@@ -337,6 +339,7 @@ public:
 
 	BIND2(light_directional_set_shadow_mode, RID, LightDirectionalShadowMode)
 	BIND2(light_directional_set_blend_splits, RID, bool)
+	BIND2(light_directional_set_sky_only, RID, bool)
 	BIND2(light_directional_set_shadow_depth_range_mode, RID, LightDirectionalShadowDepthRangeMode)
 
 	/* PROBE API */
@@ -356,6 +359,7 @@ public:
 	BIND2(reflection_probe_set_enable_shadows, RID, bool)
 	BIND2(reflection_probe_set_cull_mask, RID, uint32_t)
 	BIND2(reflection_probe_set_resolution, RID, int)
+	BIND2(reflection_probe_set_lod_threshold, RID, float)
 
 	/* DECAL API */
 
@@ -537,10 +541,12 @@ public:
 	BIND2(viewport_set_global_canvas_transform, RID, const Transform2D &)
 	BIND4(viewport_set_canvas_stacking, RID, RID, int, int)
 	BIND2(viewport_set_shadow_atlas_size, RID, int)
+	BIND3(viewport_set_sdf_oversize_and_scale, RID, ViewportSDFOversize, ViewportSDFScale)
 	BIND3(viewport_set_shadow_atlas_quadrant_subdivision, RID, int, int)
 	BIND2(viewport_set_msaa, RID, ViewportMSAA)
 	BIND2(viewport_set_screen_space_aa, RID, ViewportScreenSpaceAA)
 	BIND2(viewport_set_use_debanding, RID, bool)
+	BIND2(viewport_set_lod_threshold, RID, float)
 
 	BIND2R(int, viewport_get_render_info, RID, ViewportRenderInfo)
 	BIND2(viewport_set_debug_draw, RID, ViewportDebugDraw)
@@ -553,7 +559,7 @@ public:
 
 #undef BINDBASE
 //from now on, calls forwarded to this singleton
-#define BINDBASE RSG::scene_render
+#define BINDBASE RSG::scene
 
 	BIND1(directional_shadow_atlas_set_size, int)
 	BIND1(gi_probe_set_quality, GIProbeQuality)
@@ -593,7 +599,7 @@ public:
 
 	BIND9(environment_set_tonemap, RID, EnvironmentToneMapper, float, float, bool, float, float, float, float)
 
-	BIND6(environment_set_adjustment, RID, bool, float, float, float, RID)
+	BIND7(environment_set_adjustment, RID, bool, float, float, float, bool, RID)
 
 	BIND9(environment_set_fog, RID, bool, const Color &, float, float, float, float, float, float)
 	BIND9(environment_set_volumetric_fog, RID, bool, float, const Color &, float, float, float, float, EnvVolumetricFogShadowFilter)
@@ -669,6 +675,7 @@ public:
 	BIND5(instance_geometry_set_draw_range, RID, float, float, float, float)
 	BIND2(instance_geometry_set_as_instance_lod, RID, RID)
 	BIND4(instance_geometry_set_lightmap, RID, RID, const Rect2 &, int)
+	BIND2(instance_geometry_set_lod_bias, RID, float)
 
 	BIND3(instance_geometry_set_shader_parameter, RID, const StringName &, const Variant &)
 	BIND2RC(Variant, instance_geometry_get_shader_parameter, RID, const StringName &)
@@ -717,7 +724,7 @@ public:
 	BIND2(canvas_item_set_draw_behind_parent, RID, bool)
 
 	BIND5(canvas_item_add_line, RID, const Point2 &, const Point2 &, const Color &, float)
-	BIND4(canvas_item_add_polyline, RID, const Vector<Point2> &, const Vector<Color> &, float)
+	BIND5(canvas_item_add_polyline, RID, const Vector<Point2> &, const Vector<Color> &, float, bool)
 	BIND4(canvas_item_add_multiline, RID, const Vector<Point2> &, const Vector<Color> &, float)
 	BIND3(canvas_item_add_rect, RID, const Rect2 &, const Color &)
 	BIND4(canvas_item_add_circle, RID, const Point2 &, float, const Color &)
@@ -777,12 +784,12 @@ public:
 	BIND2(canvas_light_occluder_attach_to_canvas, RID, RID)
 	BIND2(canvas_light_occluder_set_enabled, RID, bool)
 	BIND2(canvas_light_occluder_set_polygon, RID, RID)
+	BIND2(canvas_light_occluder_set_as_sdf_collision, RID, bool)
 	BIND2(canvas_light_occluder_set_transform, RID, const Transform2D &)
 	BIND2(canvas_light_occluder_set_light_mask, RID, int)
 
 	BIND0R(RID, canvas_occluder_polygon_create)
 	BIND3(canvas_occluder_polygon_set_shape, RID, const Vector<Vector2> &, bool)
-	BIND2(canvas_occluder_polygon_set_shape_as_lines, RID, const Vector<Vector2> &)
 
 	BIND2(canvas_occluder_polygon_set_cull_mode, RID, CanvasOccluderPolygonCullMode)
 
@@ -852,8 +859,8 @@ public:
 
 	virtual void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir);
 
-	RenderingServerRaster();
-	~RenderingServerRaster();
+	RenderingServerDefault();
+	~RenderingServerDefault();
 
 #undef DISPLAY_CHANGED
 
diff --git a/servers/rendering/rendering_server_globals.cpp b/servers/rendering/rendering_server_globals.cpp
index 5a270520a9..b9df36e93a 100644
--- a/servers/rendering/rendering_server_globals.cpp
+++ b/servers/rendering/rendering_server_globals.cpp
@@ -30,11 +30,10 @@
 
 #include "rendering_server_globals.h"
 
-RasterizerStorage *RenderingServerGlobals::storage = nullptr;
-RasterizerCanvas *RenderingServerGlobals::canvas_render = nullptr;
-RasterizerScene *RenderingServerGlobals::scene_render = nullptr;
-Rasterizer *RenderingServerGlobals::rasterizer = nullptr;
+RendererStorage *RenderingServerGlobals::storage = nullptr;
+RendererCanvasRender *RenderingServerGlobals::canvas_render = nullptr;
+RendererCompositor *RenderingServerGlobals::rasterizer = nullptr;
 
-RenderingServerCanvas *RenderingServerGlobals::canvas = nullptr;
-RenderingServerViewport *RenderingServerGlobals::viewport = nullptr;
-RenderingServerScene *RenderingServerGlobals::scene = nullptr;
+RendererCanvasCull *RenderingServerGlobals::canvas = nullptr;
+RendererViewport *RenderingServerGlobals::viewport = nullptr;
+RendererScene *RenderingServerGlobals::scene = nullptr;
diff --git a/servers/rendering/rendering_server_globals.h b/servers/rendering/rendering_server_globals.h
index b33f328b69..580526f7e0 100644
--- a/servers/rendering/rendering_server_globals.h
+++ b/servers/rendering/rendering_server_globals.h
@@ -31,22 +31,23 @@
 #ifndef RENDERING_SERVER_GLOBALS_H
 #define RENDERING_SERVER_GLOBALS_H
 
-#include "rasterizer.h"
+#include "servers/rendering/renderer_canvas_cull.h"
+#include "servers/rendering/renderer_canvas_render.h"
+#include "servers/rendering/renderer_scene.h"
 
-class RenderingServerCanvas;
-class RenderingServerViewport;
-class RenderingServerScene;
+class RendererCanvasCull;
+class RendererViewport;
+class RendererScene;
 
 class RenderingServerGlobals {
 public:
-	static RasterizerStorage *storage;
-	static RasterizerCanvas *canvas_render;
-	static RasterizerScene *scene_render;
-	static Rasterizer *rasterizer;
+	static RendererStorage *storage;
+	static RendererCanvasRender *canvas_render;
+	static RendererCompositor *rasterizer;
 
-	static RenderingServerCanvas *canvas;
-	static RenderingServerViewport *viewport;
-	static RenderingServerScene *scene;
+	static RendererCanvasCull *canvas;
+	static RendererViewport *viewport;
+	static RendererScene *scene;
 };
 
 #define RSG RenderingServerGlobals
diff --git a/servers/rendering/rendering_server_wrap_mt.h b/servers/rendering/rendering_server_wrap_mt.h
index d27b851d1d..20556779fe 100644
--- a/servers/rendering/rendering_server_wrap_mt.h
+++ b/servers/rendering/rendering_server_wrap_mt.h
@@ -143,10 +143,12 @@ public:
 
 	/* MESH API */
 
-	virtual RID mesh_create_from_surfaces(const Vector<SurfaceData> &p_surfaces) {
-		return rendering_server->mesh_create_from_surfaces(p_surfaces);
+	virtual RID mesh_create_from_surfaces(const Vector<SurfaceData> &p_surfaces, int p_blend_shape_count = 0) {
+		return rendering_server->mesh_create_from_surfaces(p_surfaces, p_blend_shape_count);
 	}
 
+	FUNC2(mesh_set_blend_shape_count, RID, int)
+
 	FUNCRID(mesh)
 
 	FUNC2(mesh_add_surface, RID, const SurfaceData &)
@@ -244,6 +246,7 @@ public:
 
 	FUNC2(light_directional_set_shadow_mode, RID, LightDirectionalShadowMode)
 	FUNC2(light_directional_set_blend_splits, RID, bool)
+	FUNC2(light_directional_set_sky_only, RID, bool)
 	FUNC2(light_directional_set_shadow_depth_range_mode, RID, LightDirectionalShadowDepthRangeMode)
 
 	/* PROBE API */
@@ -263,6 +266,7 @@ public:
 	FUNC2(reflection_probe_set_enable_shadows, RID, bool)
 	FUNC2(reflection_probe_set_cull_mask, RID, uint32_t)
 	FUNC2(reflection_probe_set_resolution, RID, int)
+	FUNC2(reflection_probe_set_lod_threshold, RID, float)
 
 	/* DECAL API */
 
@@ -440,11 +444,15 @@ public:
 	FUNC2(viewport_set_global_canvas_transform, RID, const Transform2D &)
 	FUNC4(viewport_set_canvas_stacking, RID, RID, int, int)
 	FUNC2(viewport_set_shadow_atlas_size, RID, int)
+	FUNC3(viewport_set_sdf_oversize_and_scale, RID, ViewportSDFOversize, ViewportSDFScale)
+
 	FUNC3(viewport_set_shadow_atlas_quadrant_subdivision, RID, int, int)
 	FUNC2(viewport_set_msaa, RID, ViewportMSAA)
 	FUNC2(viewport_set_screen_space_aa, RID, ViewportScreenSpaceAA)
 	FUNC2(viewport_set_use_debanding, RID, bool)
 
+	FUNC2(viewport_set_lod_threshold, RID, float)
+
 	//this passes directly to avoid stalling, but it's pretty dangerous, so don't call after freeing a viewport
 	virtual int viewport_get_render_info(RID p_viewport, ViewportRenderInfo p_info) {
 		return rendering_server->viewport_get_render_info(p_viewport, p_info);
@@ -504,7 +512,7 @@ public:
 
 	FUNC9(environment_set_tonemap, RID, EnvironmentToneMapper, float, float, bool, float, float, float, float)
 
-	FUNC6(environment_set_adjustment, RID, bool, float, float, float, RID)
+	FUNC7(environment_set_adjustment, RID, bool, float, float, float, bool, RID)
 
 	FUNC9(environment_set_fog, RID, bool, const Color &, float, float, float, float, float, float)
 
@@ -570,6 +578,7 @@ public:
 	FUNC5(instance_geometry_set_draw_range, RID, float, float, float, float)
 	FUNC2(instance_geometry_set_as_instance_lod, RID, RID)
 	FUNC4(instance_geometry_set_lightmap, RID, RID, const Rect2 &, int)
+	FUNC2(instance_geometry_set_lod_bias, RID, float)
 
 	FUNC3(instance_geometry_set_shader_parameter, RID, const StringName &, const Variant &)
 	FUNC2RC(Variant, instance_geometry_get_shader_parameter, RID, const StringName &)
@@ -616,7 +625,7 @@ public:
 	FUNC2(canvas_item_set_draw_behind_parent, RID, bool)
 
 	FUNC5(canvas_item_add_line, RID, const Point2 &, const Point2 &, const Color &, float)
-	FUNC4(canvas_item_add_polyline, RID, const Vector<Point2> &, const Vector<Color> &, float)
+	FUNC5(canvas_item_add_polyline, RID, const Vector<Point2> &, const Vector<Color> &, float, bool)
 	FUNC4(canvas_item_add_multiline, RID, const Vector<Point2> &, const Vector<Color> &, float)
 	FUNC3(canvas_item_add_rect, RID, const Rect2 &, const Color &)
 	FUNC4(canvas_item_add_circle, RID, const Point2 &, float, const Color &)
@@ -676,12 +685,12 @@ public:
 	FUNC2(canvas_light_occluder_attach_to_canvas, RID, RID)
 	FUNC2(canvas_light_occluder_set_enabled, RID, bool)
 	FUNC2(canvas_light_occluder_set_polygon, RID, RID)
+	FUNC2(canvas_light_occluder_set_as_sdf_collision, RID, bool)
 	FUNC2(canvas_light_occluder_set_transform, RID, const Transform2D &)
 	FUNC2(canvas_light_occluder_set_light_mask, RID, int)
 
 	FUNCRID(canvas_occluder_polygon)
 	FUNC3(canvas_occluder_polygon_set_shape, RID, const Vector<Vector2> &, bool)
-	FUNC2(canvas_occluder_polygon_set_shape_as_lines, RID, const Vector<Vector2> &)
 
 	FUNC2(canvas_occluder_polygon_set_cull_mode, RID, CanvasOccluderPolygonCullMode)
 
diff --git a/servers/rendering/shader_language.cpp b/servers/rendering/shader_language.cpp
index 046c6ba580..742ad8a7bf 100644
--- a/servers/rendering/shader_language.cpp
+++ b/servers/rendering/shader_language.cpp
@@ -223,7 +223,7 @@ const char *ShaderLanguage::token_names[TK_MAX] = {
 
 String ShaderLanguage::get_token_text(Token p_token) {
 	String name = token_names[p_token.type];
-	if (p_token.type == TK_INT_CONSTANT || p_token.type == TK_REAL_CONSTANT) {
+	if (p_token.type == TK_INT_CONSTANT || p_token.type == TK_FLOAT_CONSTANT) {
 		name += "(" + rtos(p_token.constant) + ")";
 	} else if (p_token.type == TK_IDENTIFIER) {
 		name += "(" + String(p_token.text) + ")";
@@ -637,7 +637,7 @@ ShaderLanguage::Token ShaderLanguage::_get_token() {
 					char_idx += str.length();
 					Token tk;
 					if (period_found || exponent_found || float_suffix_found) {
-						tk.type = TK_REAL_CONSTANT;
+						tk.type = TK_FLOAT_CONSTANT;
 					} else {
 						tk.type = TK_INT_CONSTANT;
 					}
@@ -2157,7 +2157,6 @@ const ShaderLanguage::BuiltinFuncDef ShaderLanguage::builtin_func_defs[] = {
 	{ "fma", TYPE_VEC4, { TYPE_VEC4, TYPE_VEC4, TYPE_VEC4, TYPE_VOID }, TAG_GLOBAL, false },
 
 	{ nullptr, TYPE_VOID, { TYPE_VOID }, TAG_GLOBAL, false }
-
 };
 
 const ShaderLanguage::BuiltinFuncOutArgs ShaderLanguage::builtin_func_out_args[] = {
@@ -3175,7 +3174,7 @@ bool ShaderLanguage::_validate_assign(Node *p_node, const FunctionInfo &p_functi
 }
 
 bool ShaderLanguage::_propagate_function_call_sampler_uniform_settings(StringName p_name, int p_argument, TextureFilter p_filter, TextureRepeat p_repeat) {
-	for (int i = 0; shader->functions.size(); i++) {
+	for (int i = 0; i < shader->functions.size(); i++) {
 		if (shader->functions[i].name == p_name) {
 			ERR_FAIL_INDEX_V(p_argument, shader->functions[i].function->arguments.size(), false);
 			FunctionNode::Argument *arg = &shader->functions[i].function->arguments.write[p_argument];
@@ -3209,7 +3208,7 @@ bool ShaderLanguage::_propagate_function_call_sampler_uniform_settings(StringNam
 }
 
 bool ShaderLanguage::_propagate_function_call_sampler_builtin_reference(StringName p_name, int p_argument, const StringName &p_builtin) {
-	for (int i = 0; shader->functions.size(); i++) {
+	for (int i = 0; i < shader->functions.size(); i++) {
 		if (shader->functions[i].name == p_name) {
 			ERR_FAIL_INDEX_V(p_argument, shader->functions[i].function->arguments.size(), false);
 			FunctionNode::Argument *arg = &shader->functions[i].function->arguments.write[p_argument];
@@ -3270,7 +3269,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons
 				return nullptr;
 			}
 
-		} else if (tk.type == TK_REAL_CONSTANT) {
+		} else if (tk.type == TK_FLOAT_CONSTANT) {
 			ConstantNode *constant = alloc_node<ConstantNode>();
 			ConstantNode::Value v;
 			v.real = tk.constant;
@@ -6261,7 +6260,7 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_funct
 									tk = _get_token();
 								}
 
-								if (tk.type != TK_REAL_CONSTANT && tk.type != TK_INT_CONSTANT) {
+								if (tk.type != TK_FLOAT_CONSTANT && tk.type != TK_INT_CONSTANT) {
 									_set_error("Expected integer constant");
 									return ERR_PARSE_ERROR;
 								}
@@ -6285,7 +6284,7 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_funct
 									tk = _get_token();
 								}
 
-								if (tk.type != TK_REAL_CONSTANT && tk.type != TK_INT_CONSTANT) {
+								if (tk.type != TK_FLOAT_CONSTANT && tk.type != TK_INT_CONSTANT) {
 									_set_error("Expected integer constant after ','");
 									return ERR_PARSE_ERROR;
 								}
@@ -6298,7 +6297,7 @@ Error ShaderLanguage::_parse_shader(const Map<StringName, FunctionInfo> &p_funct
 								if (tk.type == TK_COMMA) {
 									tk = _get_token();
 
-									if (tk.type != TK_REAL_CONSTANT && tk.type != TK_INT_CONSTANT) {
+									if (tk.type != TK_FLOAT_CONSTANT && tk.type != TK_INT_CONSTANT) {
 										_set_error("Expected integer constant after ','");
 										return ERR_PARSE_ERROR;
 									}
diff --git a/servers/rendering/shader_language.h b/servers/rendering/shader_language.h
index 3a9f408dc0..9d2d591542 100644
--- a/servers/rendering/shader_language.h
+++ b/servers/rendering/shader_language.h
@@ -46,7 +46,7 @@ public:
 		TK_IDENTIFIER,
 		TK_TRUE,
 		TK_FALSE,
-		TK_REAL_CONSTANT,
+		TK_FLOAT_CONSTANT,
 		TK_INT_CONSTANT,
 		TK_TYPE_VOID,
 		TK_TYPE_BOOL,
@@ -519,7 +519,7 @@ public:
 		DataType basetype = TYPE_VOID;
 		bool basetype_const = false;
 		StringName base_struct_name;
-		DataPrecision precision;
+		DataPrecision precision = PRECISION_DEFAULT;
 		DataType datatype = TYPE_VOID;
 		int array_size = 0;
 		StringName struct_name;
diff --git a/servers/rendering/shader_types.cpp b/servers/rendering/shader_types.cpp
index 4d21807735..0c9b2ddf2f 100644
--- a/servers/rendering/shader_types.cpp
+++ b/servers/rendering/shader_types.cpp
@@ -67,6 +67,12 @@ ShaderTypes::ShaderTypes() {
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["INSTANCE_ID"] = constt(ShaderLanguage::TYPE_INT);
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["INSTANCE_CUSTOM"] = constt(ShaderLanguage::TYPE_VEC4);
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["ROUGHNESS"] = ShaderLanguage::TYPE_FLOAT;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["BONE_INDICES"] = ShaderLanguage::TYPE_UVEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["BONE_WEIGHTS"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM0"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM1"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM2"] = ShaderLanguage::TYPE_VEC4;
+	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].built_ins["CUSTOM3"] = ShaderLanguage::TYPE_VEC4;
 	shader_modes[RS::SHADER_SPATIAL].functions["vertex"].can_discard = false;
 
 	//builtins
@@ -252,6 +258,27 @@ ShaderTypes::ShaderTypes() {
 	shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].built_ins["SCREEN_TEXTURE"] = constt(ShaderLanguage::TYPE_SAMPLER2D);
 	shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].can_discard = true;
 
+	{
+		ShaderLanguage::StageFunctionInfo func;
+		func.arguments.push_back(ShaderLanguage::StageFunctionInfo::Argument("sdf_pos", ShaderLanguage::TYPE_VEC2));
+		func.return_type = ShaderLanguage::TYPE_FLOAT; //whether it could emit
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].stage_functions["texture_sdf"] = func;
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["light"].stage_functions["texture_sdf"] = func;
+		func.return_type = ShaderLanguage::TYPE_VEC2; //whether it could emit
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].stage_functions["sdf_to_screen_uv"] = func;
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["light"].stage_functions["sdf_to_screen_uv"] = func;
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].stage_functions["texture_sdf_normal"] = func;
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["light"].stage_functions["texture_sdf_normal"] = func;
+	}
+
+	{
+		ShaderLanguage::StageFunctionInfo func;
+		func.arguments.push_back(ShaderLanguage::StageFunctionInfo::Argument("uv", ShaderLanguage::TYPE_VEC2));
+		func.return_type = ShaderLanguage::TYPE_VEC2; //whether it could emit
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["fragment"].stage_functions["screen_uv_to_sdf"] = func;
+		shader_modes[RS::SHADER_CANVAS_ITEM].functions["light"].stage_functions["screen_uv_to_sdf"] = func;
+	}
+
 	shader_modes[RS::SHADER_CANVAS_ITEM].functions["light"].built_ins["FRAGCOORD"] = constt(ShaderLanguage::TYPE_VEC4);
 	shader_modes[RS::SHADER_CANVAS_ITEM].functions["light"].built_ins["NORMAL"] = constt(ShaderLanguage::TYPE_VEC3);
 	shader_modes[RS::SHADER_CANVAS_ITEM].functions["light"].built_ins["COLOR"] = constt(ShaderLanguage::TYPE_VEC4);