Renaming of servers for coherency.

VisualServer -> RenderingServer
PhysicsServer -> PhysicsServer3D
Physics2DServer -> PhysicsServer2D
NavigationServer -> NavigationServer3D
Navigation2DServer -> NavigationServer2D

Also renamed corresponding files.

1 files changed, 0 insertions, 2839 deletions

diff --git a/servers/visual/visual_server_scene.cpp b/servers/visual/visual_server_scene.cpp
deleted file mode 100644
index 1a9ecae23a..0000000000
--- a/servers/visual/visual_server_scene.cpp
+++ /dev/null
@@ -1,2839 +0,0 @@
-/*************************************************************************/
-/*  visual_server_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 "visual_server_scene.h"
-
-#include "core/os/os.h"
-#include "visual_server_globals.h"
-#include "visual_server_raster.h"
-
-#include <new>
-
-/* CAMERA API */
-
-RID VisualServerScene::camera_create() {
-
-	Camera *camera = memnew(Camera);
-	return camera_owner.make_rid(camera);
-}
-
-void VisualServerScene::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;
-	camera->fov = p_fovy_degrees;
-	camera->znear = p_z_near;
-	camera->zfar = p_z_far;
-}
-
-void VisualServerScene::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;
-	camera->size = p_size;
-	camera->znear = p_z_near;
-	camera->zfar = p_z_far;
-}
-
-void VisualServerScene::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;
-	camera->size = p_size;
-	camera->offset = p_offset;
-	camera->znear = p_z_near;
-	camera->zfar = p_z_far;
-}
-
-void VisualServerScene::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 VisualServerScene::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 VisualServerScene::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 VisualServerScene::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 VisualServerScene::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;
-}
-
-/* SCENARIO API */
-
-void *VisualServerScene::_instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int) {
-
-	//VisualServerScene *self = (VisualServerScene*)p_self;
-	Instance *A = p_A;
-	Instance *B = p_B;
-
-	//instance indices are designed so greater always contains lesser
-	if (A->base_type > B->base_type) {
-		SWAP(A, B); //lesser always first
-	}
-
-	if (B->base_type == VS::INSTANCE_LIGHT && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceLightData *light = static_cast<InstanceLightData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		InstanceLightData::PairInfo pinfo;
-		pinfo.geometry = A;
-		pinfo.L = geom->lighting.push_back(B);
-
-		List<InstanceLightData::PairInfo>::Element *E = light->geometries.push_back(pinfo);
-
-		if (geom->can_cast_shadows) {
-
-			light->shadow_dirty = true;
-		}
-		geom->lighting_dirty = true;
-
-		return E; //this element should make freeing faster
-	} else if (B->base_type == VS::INSTANCE_REFLECTION_PROBE && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		InstanceReflectionProbeData::PairInfo pinfo;
-		pinfo.geometry = A;
-		pinfo.L = geom->reflection_probes.push_back(B);
-
-		List<InstanceReflectionProbeData::PairInfo>::Element *E = reflection_probe->geometries.push_back(pinfo);
-
-		geom->reflection_dirty = true;
-
-		return E; //this element should make freeing faster
-	} else if (B->base_type == VS::INSTANCE_LIGHTMAP_CAPTURE && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceLightmapCaptureData *lightmap_capture = static_cast<InstanceLightmapCaptureData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		InstanceLightmapCaptureData::PairInfo pinfo;
-		pinfo.geometry = A;
-		pinfo.L = geom->lightmap_captures.push_back(B);
-
-		List<InstanceLightmapCaptureData::PairInfo>::Element *E = lightmap_capture->geometries.push_back(pinfo);
-		((VisualServerScene *)p_self)->_instance_queue_update(A, false, false); //need to update capture
-
-		return E; //this element should make freeing faster
-	} else if (B->base_type == VS::INSTANCE_GI_PROBE && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		InstanceGIProbeData::PairInfo pinfo;
-		pinfo.geometry = A;
-		pinfo.L = geom->gi_probes.push_back(B);
-
-		List<InstanceGIProbeData::PairInfo>::Element *E;
-		if (A->dynamic_gi) {
-			E = gi_probe->dynamic_geometries.push_back(pinfo);
-		} else {
-			E = gi_probe->geometries.push_back(pinfo);
-		}
-
-		geom->gi_probes_dirty = true;
-
-		return E; //this element should make freeing faster
-
-	} else if (B->base_type == VS::INSTANCE_GI_PROBE && A->base_type == VS::INSTANCE_LIGHT) {
-
-		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(B->base_data);
-		return gi_probe->lights.insert(A);
-	}
-
-	return NULL;
-}
-void VisualServerScene::_instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *udata) {
-
-	//VisualServerScene *self = (VisualServerScene*)p_self;
-	Instance *A = p_A;
-	Instance *B = p_B;
-
-	//instance indices are designed so greater always contains lesser
-	if (A->base_type > B->base_type) {
-		SWAP(A, B); //lesser always first
-	}
-
-	if (B->base_type == VS::INSTANCE_LIGHT && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceLightData *light = static_cast<InstanceLightData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		List<InstanceLightData::PairInfo>::Element *E = reinterpret_cast<List<InstanceLightData::PairInfo>::Element *>(udata);
-
-		geom->lighting.erase(E->get().L);
-		light->geometries.erase(E);
-
-		if (geom->can_cast_shadows) {
-			light->shadow_dirty = true;
-		}
-		geom->lighting_dirty = true;
-
-	} else if (B->base_type == VS::INSTANCE_REFLECTION_PROBE && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		List<InstanceReflectionProbeData::PairInfo>::Element *E = reinterpret_cast<List<InstanceReflectionProbeData::PairInfo>::Element *>(udata);
-
-		geom->reflection_probes.erase(E->get().L);
-		reflection_probe->geometries.erase(E);
-
-		geom->reflection_dirty = true;
-	} else if (B->base_type == VS::INSTANCE_LIGHTMAP_CAPTURE && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceLightmapCaptureData *lightmap_capture = static_cast<InstanceLightmapCaptureData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		List<InstanceLightmapCaptureData::PairInfo>::Element *E = reinterpret_cast<List<InstanceLightmapCaptureData::PairInfo>::Element *>(udata);
-
-		geom->lightmap_captures.erase(E->get().L);
-		lightmap_capture->geometries.erase(E);
-		((VisualServerScene *)p_self)->_instance_queue_update(A, false, false); //need to update capture
-
-	} else if (B->base_type == VS::INSTANCE_GI_PROBE && ((1 << A->base_type) & VS::INSTANCE_GEOMETRY_MASK)) {
-
-		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(B->base_data);
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(A->base_data);
-
-		List<InstanceGIProbeData::PairInfo>::Element *E = reinterpret_cast<List<InstanceGIProbeData::PairInfo>::Element *>(udata);
-
-		geom->gi_probes.erase(E->get().L);
-		if (A->dynamic_gi) {
-			gi_probe->dynamic_geometries.erase(E);
-		} else {
-			gi_probe->geometries.erase(E);
-		}
-
-		geom->gi_probes_dirty = true;
-
-	} else if (B->base_type == VS::INSTANCE_GI_PROBE && A->base_type == VS::INSTANCE_LIGHT) {
-
-		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(B->base_data);
-		Set<Instance *>::Element *E = reinterpret_cast<Set<Instance *>::Element *>(udata);
-
-		gi_probe->lights.erase(E);
-	}
-}
-
-RID VisualServerScene::scenario_create() {
-
-	Scenario *scenario = memnew(Scenario);
-	ERR_FAIL_COND_V(!scenario, RID());
-	RID scenario_rid = scenario_owner.make_rid(scenario);
-	scenario->self = scenario_rid;
-
-	scenario->octree.set_pair_callback(_instance_pair, this);
-	scenario->octree.set_unpair_callback(_instance_unpair, this);
-	scenario->reflection_probe_shadow_atlas = VSG::scene_render->shadow_atlas_create();
-	VSG::scene_render->shadow_atlas_set_size(scenario->reflection_probe_shadow_atlas, 1024); //make enough shadows for close distance, don't bother with rest
-	VSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 0, 4);
-	VSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 1, 4);
-	VSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 2, 4);
-	VSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 3, 8);
-	scenario->reflection_atlas = VSG::scene_render->reflection_atlas_create();
-	return scenario_rid;
-}
-
-void VisualServerScene::scenario_set_debug(RID p_scenario, VS::ScenarioDebugMode p_debug_mode) {
-
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
-	ERR_FAIL_COND(!scenario);
-	scenario->debug = p_debug_mode;
-}
-
-void VisualServerScene::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 VisualServerScene::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 VisualServerScene::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 VisualServerScene::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);
-	VSG::scene_render->reflection_atlas_set_size(scenario->reflection_atlas, p_reflection_size, p_reflection_count);
-}
-
-/* INSTANCING API */
-
-void VisualServerScene::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_dependencies) {
-
-	if (p_update_aabb)
-		p_instance->update_aabb = true;
-	if (p_update_dependencies)
-		p_instance->update_dependencies = true;
-
-	if (p_instance->update_item.in_list())
-		return;
-
-	_instance_update_list.add(&p_instance->update_item);
-}
-
-RID VisualServerScene::instance_create() {
-
-	Instance *instance = memnew(Instance);
-	ERR_FAIL_COND_V(!instance, RID());
-
-	RID instance_rid = instance_owner.make_rid(instance);
-	instance->self = instance_rid;
-
-	return instance_rid;
-}
-
-void VisualServerScene::instance_set_base(RID p_instance, RID p_base) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	Scenario *scenario = instance->scenario;
-
-	if (instance->base_type != VS::INSTANCE_NONE) {
-		//free anything related to that base
-
-		if (scenario && instance->octree_id) {
-			scenario->octree.erase(instance->octree_id); //make dependencies generated by the octree go away
-			instance->octree_id = 0;
-		}
-
-		switch (instance->base_type) {
-			case VS::INSTANCE_LIGHT: {
-
-				InstanceLightData *light = static_cast<InstanceLightData *>(instance->base_data);
-#ifdef DEBUG_ENABLED
-				if (light->geometries.size()) {
-					ERR_PRINT("BUG, indexing did not unpair geometries from light.");
-				}
-#endif
-				if (instance->scenario && light->D) {
-					instance->scenario->directional_lights.erase(light->D);
-					light->D = NULL;
-				}
-				VSG::scene_render->free(light->instance);
-			} break;
-			case VS::INSTANCE_REFLECTION_PROBE: {
-
-				InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(instance->base_data);
-				VSG::scene_render->free(reflection_probe->instance);
-				if (reflection_probe->update_list.in_list()) {
-					reflection_probe_render_list.remove(&reflection_probe->update_list);
-				}
-			} break;
-			case VS::INSTANCE_LIGHTMAP_CAPTURE: {
-
-				InstanceLightmapCaptureData *lightmap_capture = static_cast<InstanceLightmapCaptureData *>(instance->base_data);
-				//erase dependencies, since no longer a lightmap
-				while (lightmap_capture->users.front()) {
-					instance_set_use_lightmap(lightmap_capture->users.front()->get()->self, RID(), RID());
-				}
-			} break;
-			case VS::INSTANCE_GI_PROBE: {
-
-				InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(instance->base_data);
-#ifdef DEBUG_ENABLED
-				if (gi_probe->geometries.size()) {
-					ERR_PRINT("BUG, indexing did not unpair geometries from GIProbe.");
-				}
-#endif
-#ifdef DEBUG_ENABLED
-				if (gi_probe->lights.size()) {
-					ERR_PRINT("BUG, indexing did not unpair lights from GIProbe.");
-				}
-#endif
-				if (gi_probe->update_element.in_list()) {
-					gi_probe_update_list.remove(&gi_probe->update_element);
-				}
-
-				if (instance->lightmap_capture) {
-					Instance *capture = (Instance *)instance->lightmap_capture;
-					InstanceLightmapCaptureData *lightmap_capture = static_cast<InstanceLightmapCaptureData *>(capture->base_data);
-					lightmap_capture->users.erase(instance);
-					instance->lightmap_capture = NULL;
-					instance->lightmap = RID();
-				}
-
-				VSG::scene_render->free(gi_probe->probe_instance);
-
-			} break;
-			default: {
-			}
-		}
-
-		if (instance->base_data) {
-			memdelete(instance->base_data);
-			instance->base_data = NULL;
-		}
-
-		instance->blend_values.clear();
-		instance->materials.clear();
-	}
-
-	instance->base_type = VS::INSTANCE_NONE;
-	instance->base = RID();
-
-	if (p_base.is_valid()) {
-
-		instance->base_type = VSG::storage->get_base_type(p_base);
-		ERR_FAIL_COND(instance->base_type == VS::INSTANCE_NONE);
-
-		switch (instance->base_type) {
-			case VS::INSTANCE_LIGHT: {
-
-				InstanceLightData *light = memnew(InstanceLightData);
-
-				if (scenario && VSG::storage->light_get_type(p_base) == VS::LIGHT_DIRECTIONAL) {
-					light->D = scenario->directional_lights.push_back(instance);
-				}
-
-				light->instance = VSG::scene_render->light_instance_create(p_base);
-
-				instance->base_data = light;
-			} break;
-			case VS::INSTANCE_MESH:
-			case VS::INSTANCE_MULTIMESH:
-			case VS::INSTANCE_IMMEDIATE:
-			case VS::INSTANCE_PARTICLES: {
-
-				InstanceGeometryData *geom = memnew(InstanceGeometryData);
-				instance->base_data = geom;
-				if (instance->base_type == VS::INSTANCE_MESH) {
-					instance->blend_values.resize(VSG::storage->mesh_get_blend_shape_count(p_base));
-				}
-			} break;
-			case VS::INSTANCE_REFLECTION_PROBE: {
-
-				InstanceReflectionProbeData *reflection_probe = memnew(InstanceReflectionProbeData);
-				reflection_probe->owner = instance;
-				instance->base_data = reflection_probe;
-
-				reflection_probe->instance = VSG::scene_render->reflection_probe_instance_create(p_base);
-			} break;
-			case VS::INSTANCE_LIGHTMAP_CAPTURE: {
-
-				InstanceLightmapCaptureData *lightmap_capture = memnew(InstanceLightmapCaptureData);
-				instance->base_data = lightmap_capture;
-				//lightmap_capture->instance = VSG::scene_render->lightmap_capture_instance_create(p_base);
-			} break;
-			case VS::INSTANCE_GI_PROBE: {
-
-				InstanceGIProbeData *gi_probe = memnew(InstanceGIProbeData);
-				instance->base_data = gi_probe;
-				gi_probe->owner = instance;
-
-				if (scenario && !gi_probe->update_element.in_list()) {
-					gi_probe_update_list.add(&gi_probe->update_element);
-				}
-
-				gi_probe->probe_instance = VSG::scene_render->gi_probe_instance_create(p_base);
-
-			} break;
-			default: {
-			}
-		}
-
-		instance->base = p_base;
-
-		//forcefully update the dependency now, so if for some reason it gets removed, we can immediately clear it
-		VSG::storage->base_update_dependency(p_base, instance);
-	}
-
-	_instance_queue_update(instance, true, true);
-}
-void VisualServerScene::instance_set_scenario(RID p_instance, RID p_scenario) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	if (instance->scenario) {
-
-		instance->scenario->instances.remove(&instance->scenario_item);
-
-		if (instance->octree_id) {
-			instance->scenario->octree.erase(instance->octree_id); //make dependencies generated by the octree go away
-			instance->octree_id = 0;
-		}
-
-		switch (instance->base_type) {
-
-			case VS::INSTANCE_LIGHT: {
-
-				InstanceLightData *light = static_cast<InstanceLightData *>(instance->base_data);
-#ifdef DEBUG_ENABLED
-				if (light->geometries.size()) {
-					ERR_PRINT("BUG, indexing did not unpair geometries from light.");
-				}
-#endif
-				if (light->D) {
-					instance->scenario->directional_lights.erase(light->D);
-					light->D = NULL;
-				}
-			} break;
-			case VS::INSTANCE_REFLECTION_PROBE: {
-				InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(instance->base_data);
-				VSG::scene_render->reflection_probe_release_atlas_index(reflection_probe->instance);
-
-			} break;
-			case VS::INSTANCE_GI_PROBE: {
-
-				InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(instance->base_data);
-
-#ifdef DEBUG_ENABLED
-				if (gi_probe->geometries.size()) {
-					ERR_PRINT("BUG, indexing did not unpair geometries from GIProbe.");
-				}
-#endif
-#ifdef DEBUG_ENABLED
-				if (gi_probe->lights.size()) {
-					ERR_PRINT("BUG, indexing did not unpair lights from GIProbe.");
-				}
-#endif
-
-				if (gi_probe->update_element.in_list()) {
-					gi_probe_update_list.remove(&gi_probe->update_element);
-				}
-			} break;
-			default: {
-			}
-		}
-
-		instance->scenario = NULL;
-	}
-
-	if (p_scenario.is_valid()) {
-
-		Scenario *scenario = scenario_owner.getornull(p_scenario);
-		ERR_FAIL_COND(!scenario);
-
-		instance->scenario = scenario;
-
-		scenario->instances.add(&instance->scenario_item);
-
-		switch (instance->base_type) {
-
-			case VS::INSTANCE_LIGHT: {
-
-				InstanceLightData *light = static_cast<InstanceLightData *>(instance->base_data);
-
-				if (VSG::storage->light_get_type(instance->base) == VS::LIGHT_DIRECTIONAL) {
-					light->D = scenario->directional_lights.push_back(instance);
-				}
-			} break;
-			case VS::INSTANCE_GI_PROBE: {
-
-				InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(instance->base_data);
-				if (!gi_probe->update_element.in_list()) {
-					gi_probe_update_list.add(&gi_probe->update_element);
-				}
-			} break;
-			default: {
-			}
-		}
-
-		_instance_queue_update(instance, true, true);
-	}
-}
-void VisualServerScene::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 VisualServerScene::instance_set_transform(RID p_instance, const Transform &p_transform) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	if (instance->transform == p_transform)
-		return; //must be checked to avoid worst evil
-
-#ifdef DEBUG_ENABLED
-
-	for (int i = 0; i < 4; i++) {
-		const Vector3 &v = i < 3 ? p_transform.basis.elements[i] : p_transform.origin;
-		ERR_FAIL_COND(Math::is_inf(v.x));
-		ERR_FAIL_COND(Math::is_nan(v.x));
-		ERR_FAIL_COND(Math::is_inf(v.y));
-		ERR_FAIL_COND(Math::is_nan(v.y));
-		ERR_FAIL_COND(Math::is_inf(v.z));
-		ERR_FAIL_COND(Math::is_nan(v.z));
-	}
-
-#endif
-	instance->transform = p_transform;
-	_instance_queue_update(instance, true);
-}
-void VisualServerScene::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 VisualServerScene::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);
-
-	if (instance->update_item.in_list()) {
-		_update_dirty_instance(instance);
-	}
-
-	ERR_FAIL_INDEX(p_shape, instance->blend_values.size());
-	instance->blend_values.write[p_shape] = p_weight;
-}
-
-void VisualServerScene::instance_set_surface_material(RID p_instance, int p_surface, RID p_material) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	if (instance->base_type == VS::INSTANCE_MESH) {
-		//may not have been updated yet, may also have not been set yet. When updated will be correcte, worst case
-		instance->materials.resize(MAX(p_surface + 1, VSG::storage->mesh_get_surface_count(instance->base)));
-	}
-
-	ERR_FAIL_INDEX(p_surface, instance->materials.size());
-
-	instance->materials.write[p_surface] = p_material;
-
-	_instance_queue_update(instance, false, true);
-}
-
-void VisualServerScene::instance_set_visible(RID p_instance, bool p_visible) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	if (instance->visible == p_visible)
-		return;
-
-	instance->visible = p_visible;
-
-	switch (instance->base_type) {
-		case VS::INSTANCE_LIGHT: {
-			if (VSG::storage->light_get_type(instance->base) != VS::LIGHT_DIRECTIONAL && instance->octree_id && instance->scenario) {
-				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << VS::INSTANCE_LIGHT, p_visible ? VS::INSTANCE_GEOMETRY_MASK : 0);
-			}
-
-		} break;
-		case VS::INSTANCE_REFLECTION_PROBE: {
-			if (instance->octree_id && instance->scenario) {
-				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << VS::INSTANCE_REFLECTION_PROBE, p_visible ? VS::INSTANCE_GEOMETRY_MASK : 0);
-			}
-
-		} break;
-		case VS::INSTANCE_LIGHTMAP_CAPTURE: {
-			if (instance->octree_id && instance->scenario) {
-				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << VS::INSTANCE_LIGHTMAP_CAPTURE, p_visible ? VS::INSTANCE_GEOMETRY_MASK : 0);
-			}
-
-		} break;
-		case VS::INSTANCE_GI_PROBE: {
-			if (instance->octree_id && instance->scenario) {
-				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << VS::INSTANCE_GI_PROBE, p_visible ? (VS::INSTANCE_GEOMETRY_MASK | (1 << VS::INSTANCE_LIGHT)) : 0);
-			}
-
-		} break;
-		default: {
-		}
-	}
-}
-inline bool is_geometry_instance(VisualServer::InstanceType p_type) {
-	return p_type == VS::INSTANCE_MESH || p_type == VS::INSTANCE_MULTIMESH || p_type == VS::INSTANCE_PARTICLES || p_type == VS::INSTANCE_IMMEDIATE;
-}
-
-void VisualServerScene::instance_set_use_lightmap(RID p_instance, RID p_lightmap_instance, RID p_lightmap) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	if (instance->lightmap_capture) {
-		InstanceLightmapCaptureData *lightmap_capture = static_cast<InstanceLightmapCaptureData *>(((Instance *)instance->lightmap_capture)->base_data);
-		lightmap_capture->users.erase(instance);
-		instance->lightmap = RID();
-		instance->lightmap_capture = NULL;
-	}
-
-	if (p_lightmap_instance.is_valid()) {
-		Instance *lightmap_instance = instance_owner.getornull(p_lightmap_instance);
-		ERR_FAIL_COND(!lightmap_instance);
-		ERR_FAIL_COND(lightmap_instance->base_type != VS::INSTANCE_LIGHTMAP_CAPTURE);
-		instance->lightmap_capture = lightmap_instance;
-
-		InstanceLightmapCaptureData *lightmap_capture = static_cast<InstanceLightmapCaptureData *>(((Instance *)instance->lightmap_capture)->base_data);
-		lightmap_capture->users.insert(instance);
-		instance->lightmap = p_lightmap;
-	}
-}
-
-void VisualServerScene::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));
-
-	if (p_aabb != AABB()) {
-
-		// Set custom AABB
-		if (instance->custom_aabb == NULL)
-			instance->custom_aabb = memnew(AABB);
-		*instance->custom_aabb = p_aabb;
-
-	} else {
-
-		// Clear custom AABB
-		if (instance->custom_aabb != NULL) {
-			memdelete(instance->custom_aabb);
-			instance->custom_aabb = NULL;
-		}
-	}
-
-	if (instance->scenario)
-		_instance_queue_update(instance, true, false);
-}
-
-void VisualServerScene::instance_attach_skeleton(RID p_instance, RID p_skeleton) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	if (instance->skeleton == p_skeleton)
-		return;
-
-	instance->skeleton = p_skeleton;
-
-	if (p_skeleton.is_valid()) {
-		//update the dependency now, so if cleared, we remove it
-		VSG::storage->skeleton_update_dependency(p_skeleton, instance);
-	}
-	_instance_queue_update(instance, true, true);
-}
-
-void VisualServerScene::instance_set_exterior(RID p_instance, bool p_enabled) {
-}
-
-void VisualServerScene::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) {
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	instance->extra_margin = p_margin;
-	_instance_queue_update(instance, true, false);
-}
-
-Vector<ObjectID> VisualServerScene::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<VisualServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
-
-	int culled = 0;
-	Instance *cull[1024];
-	culled = scenario->octree.cull_aabb(p_aabb, cull, 1024);
-
-	for (int i = 0; i < culled; i++) {
-
-		Instance *instance = cull[i];
-		ERR_CONTINUE(!instance);
-		if (instance->object_id.is_null())
-			continue;
-
-		instances.push_back(instance->object_id);
-	}
-
-	return instances;
-}
-Vector<ObjectID> VisualServerScene::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<VisualServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
-
-	int culled = 0;
-	Instance *cull[1024];
-	culled = scenario->octree.cull_segment(p_from, p_from + p_to * 10000, cull, 1024);
-
-	for (int i = 0; i < culled; i++) {
-		Instance *instance = cull[i];
-		ERR_CONTINUE(!instance);
-		if (instance->object_id.is_null())
-			continue;
-
-		instances.push_back(instance->object_id);
-	}
-
-	return instances;
-}
-Vector<ObjectID> VisualServerScene::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<VisualServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
-
-	int culled = 0;
-	Instance *cull[1024];
-
-	culled = scenario->octree.cull_convex(p_convex, cull, 1024);
-
-	for (int i = 0; i < culled; i++) {
-
-		Instance *instance = cull[i];
-		ERR_CONTINUE(!instance);
-		if (instance->object_id.is_null())
-			continue;
-
-		instances.push_back(instance->object_id);
-	}
-
-	return instances;
-}
-
-void VisualServerScene::instance_geometry_set_flag(RID p_instance, VS::InstanceFlags p_flags, bool p_enabled) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	//ERR_FAIL_COND(((1 << instance->base_type) & VS::INSTANCE_GEOMETRY_MASK));
-
-	switch (p_flags) {
-
-		case VS::INSTANCE_FLAG_USE_BAKED_LIGHT: {
-
-			instance->baked_light = p_enabled;
-
-		} break;
-		case VS::INSTANCE_FLAG_USE_DYNAMIC_GI: {
-
-			if (p_enabled == instance->dynamic_gi) {
-				//bye, redundant
-				return;
-			}
-
-			if (instance->octree_id != 0) {
-				//remove from octree, it needs to be re-paired
-				instance->scenario->octree.erase(instance->octree_id);
-				instance->octree_id = 0;
-				_instance_queue_update(instance, true, true);
-			}
-
-			//once out of octree, can be changed
-			instance->dynamic_gi = p_enabled;
-
-		} break;
-		case VS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE: {
-
-			instance->redraw_if_visible = p_enabled;
-
-		} break;
-		default: {
-		}
-	}
-}
-void VisualServerScene::instance_geometry_set_cast_shadows_setting(RID p_instance, VS::ShadowCastingSetting p_shadow_casting_setting) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	instance->cast_shadows = p_shadow_casting_setting;
-	_instance_queue_update(instance, false, true);
-}
-void VisualServerScene::instance_geometry_set_material_override(RID p_instance, RID p_material) {
-
-	Instance *instance = instance_owner.getornull(p_instance);
-	ERR_FAIL_COND(!instance);
-
-	instance->material_override = p_material;
-	_instance_queue_update(instance, false, true);
-}
-
-void VisualServerScene::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin) {
-}
-void VisualServerScene::instance_geometry_set_as_instance_lod(RID p_instance, RID p_as_lod_of_instance) {
-}
-
-void VisualServerScene::_update_instance(Instance *p_instance) {
-
-	p_instance->version++;
-
-	if (p_instance->base_type == VS::INSTANCE_LIGHT) {
-
-		InstanceLightData *light = static_cast<InstanceLightData *>(p_instance->base_data);
-
-		VSG::scene_render->light_instance_set_transform(light->instance, p_instance->transform);
-		light->shadow_dirty = true;
-	}
-
-	if (p_instance->base_type == VS::INSTANCE_REFLECTION_PROBE) {
-
-		InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(p_instance->base_data);
-
-		VSG::scene_render->reflection_probe_instance_set_transform(reflection_probe->instance, p_instance->transform);
-		reflection_probe->reflection_dirty = true;
-	}
-
-	if (p_instance->base_type == VS::INSTANCE_GI_PROBE) {
-
-		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(p_instance->base_data);
-
-		VSG::scene_render->gi_probe_instance_set_transform_to_data(gi_probe->probe_instance, p_instance->transform);
-	}
-
-	if (p_instance->base_type == VS::INSTANCE_PARTICLES) {
-
-		VSG::storage->particles_set_emission_transform(p_instance->base, p_instance->transform);
-	}
-
-	if (p_instance->aabb.has_no_surface()) {
-		return;
-	}
-
-	if ((1 << p_instance->base_type) & VS::INSTANCE_GEOMETRY_MASK) {
-
-		InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(p_instance->base_data);
-		//make sure lights are updated if it casts shadow
-
-		if (geom->can_cast_shadows) {
-			for (List<Instance *>::Element *E = geom->lighting.front(); E; E = E->next()) {
-				InstanceLightData *light = static_cast<InstanceLightData *>(E->get()->base_data);
-				light->shadow_dirty = true;
-			}
-		}
-
-		if (!p_instance->lightmap_capture && geom->lightmap_captures.size()) {
-			//affected by lightmap captures, must update capture info!
-			_update_instance_lightmap_captures(p_instance);
-		} else {
-			if (!p_instance->lightmap_capture_data.empty()) {
-				p_instance->lightmap_capture_data.resize(0); //not in use, clear capture data
-			}
-		}
-	}
-
-	p_instance->mirror = p_instance->transform.basis.determinant() < 0.0;
-
-	AABB new_aabb;
-
-	new_aabb = p_instance->transform.xform(p_instance->aabb);
-
-	p_instance->transformed_aabb = new_aabb;
-
-	if (!p_instance->scenario) {
-
-		return;
-	}
-
-	if (p_instance->octree_id == 0) {
-
-		uint32_t base_type = 1 << p_instance->base_type;
-		uint32_t pairable_mask = 0;
-		bool pairable = false;
-
-		if (p_instance->base_type == VS::INSTANCE_LIGHT || p_instance->base_type == VS::INSTANCE_REFLECTION_PROBE || p_instance->base_type == VS::INSTANCE_LIGHTMAP_CAPTURE) {
-
-			pairable_mask = p_instance->visible ? VS::INSTANCE_GEOMETRY_MASK : 0;
-			pairable = true;
-		}
-
-		if (p_instance->base_type == VS::INSTANCE_GI_PROBE) {
-			//lights and geometries
-			pairable_mask = p_instance->visible ? VS::INSTANCE_GEOMETRY_MASK | (1 << VS::INSTANCE_LIGHT) : 0;
-			pairable = true;
-		}
-
-		// not inside octree
-		p_instance->octree_id = p_instance->scenario->octree.create(p_instance, new_aabb, 0, pairable, base_type, pairable_mask);
-
-	} else {
-
-		/*
-		if (new_aabb==p_instance->data.transformed_aabb)
-			return;
-		*/
-
-		p_instance->scenario->octree.move(p_instance->octree_id, new_aabb);
-	}
-}
-
-void VisualServerScene::_update_instance_aabb(Instance *p_instance) {
-
-	AABB new_aabb;
-
-	ERR_FAIL_COND(p_instance->base_type != VS::INSTANCE_NONE && !p_instance->base.is_valid());
-
-	switch (p_instance->base_type) {
-		case VisualServer::INSTANCE_NONE: {
-
-			// do nothing
-		} break;
-		case VisualServer::INSTANCE_MESH: {
-
-			if (p_instance->custom_aabb)
-				new_aabb = *p_instance->custom_aabb;
-			else
-				new_aabb = VSG::storage->mesh_get_aabb(p_instance->base, p_instance->skeleton);
-
-		} break;
-
-		case VisualServer::INSTANCE_MULTIMESH: {
-
-			if (p_instance->custom_aabb)
-				new_aabb = *p_instance->custom_aabb;
-			else
-				new_aabb = VSG::storage->multimesh_get_aabb(p_instance->base);
-
-		} break;
-		case VisualServer::INSTANCE_IMMEDIATE: {
-
-			if (p_instance->custom_aabb)
-				new_aabb = *p_instance->custom_aabb;
-			else
-				new_aabb = VSG::storage->immediate_get_aabb(p_instance->base);
-
-		} break;
-		case VisualServer::INSTANCE_PARTICLES: {
-
-			if (p_instance->custom_aabb)
-				new_aabb = *p_instance->custom_aabb;
-			else
-				new_aabb = VSG::storage->particles_get_aabb(p_instance->base);
-
-		} break;
-		case VisualServer::INSTANCE_LIGHT: {
-
-			new_aabb = VSG::storage->light_get_aabb(p_instance->base);
-
-		} break;
-		case VisualServer::INSTANCE_REFLECTION_PROBE: {
-
-			new_aabb = VSG::storage->reflection_probe_get_aabb(p_instance->base);
-
-		} break;
-		case VisualServer::INSTANCE_GI_PROBE: {
-
-			new_aabb = VSG::storage->gi_probe_get_bounds(p_instance->base);
-
-		} break;
-		case VisualServer::INSTANCE_LIGHTMAP_CAPTURE: {
-
-			new_aabb = VSG::storage->lightmap_capture_get_bounds(p_instance->base);
-
-		} break;
-		default: {
-		}
-	}
-
-	// <Zylann> This is why I didn't re-use Instance::aabb to implement custom AABBs
-	if (p_instance->extra_margin)
-		new_aabb.grow_by(p_instance->extra_margin);
-
-	p_instance->aabb = new_aabb;
-}
-
-_FORCE_INLINE_ static void _light_capture_sample_octree(const RasterizerStorage::LightmapCaptureOctree *p_octree, int p_cell_subdiv, const Vector3 &p_pos, const Vector3 &p_dir, float p_level, Vector3 &r_color, float &r_alpha) {
-
-	static const Vector3 aniso_normal[6] = {
-		Vector3(-1, 0, 0),
-		Vector3(1, 0, 0),
-		Vector3(0, -1, 0),
-		Vector3(0, 1, 0),
-		Vector3(0, 0, -1),
-		Vector3(0, 0, 1)
-	};
-
-	int size = 1 << (p_cell_subdiv - 1);
-
-	int clamp_v = size - 1;
-	//first of all, clamp
-	Vector3 pos;
-	pos.x = CLAMP(p_pos.x, 0, clamp_v);
-	pos.y = CLAMP(p_pos.y, 0, clamp_v);
-	pos.z = CLAMP(p_pos.z, 0, clamp_v);
-
-	float level = (p_cell_subdiv - 1) - p_level;
-
-	int target_level;
-	float level_filter;
-	if (level <= 0.0) {
-		level_filter = 0;
-		target_level = 0;
-	} else {
-		target_level = Math::ceil(level);
-		level_filter = target_level - level;
-	}
-
-	Vector3 color[2][8];
-	float alpha[2][8];
-	zeromem(alpha, sizeof(float) * 2 * 8);
-
-	//find cell at given level first
-
-	for (int c = 0; c < 2; c++) {
-
-		int current_level = MAX(0, target_level - c);
-		int level_cell_size = (1 << (p_cell_subdiv - 1)) >> current_level;
-
-		for (int n = 0; n < 8; n++) {
-
-			int x = int(pos.x);
-			int y = int(pos.y);
-			int z = int(pos.z);
-
-			if (n & 1)
-				x += level_cell_size;
-			if (n & 2)
-				y += level_cell_size;
-			if (n & 4)
-				z += level_cell_size;
-
-			int ofs_x = 0;
-			int ofs_y = 0;
-			int ofs_z = 0;
-
-			x = CLAMP(x, 0, clamp_v);
-			y = CLAMP(y, 0, clamp_v);
-			z = CLAMP(z, 0, clamp_v);
-
-			int half = size / 2;
-			uint32_t cell = 0;
-			for (int i = 0; i < current_level; i++) {
-
-				const RasterizerStorage::LightmapCaptureOctree *bc = &p_octree[cell];
-
-				int child = 0;
-				if (x >= ofs_x + half) {
-					child |= 1;
-					ofs_x += half;
-				}
-				if (y >= ofs_y + half) {
-					child |= 2;
-					ofs_y += half;
-				}
-				if (z >= ofs_z + half) {
-					child |= 4;
-					ofs_z += half;
-				}
-
-				cell = bc->children[child];
-				if (cell == RasterizerStorage::LightmapCaptureOctree::CHILD_EMPTY)
-					break;
-
-				half >>= 1;
-			}
-
-			if (cell == RasterizerStorage::LightmapCaptureOctree::CHILD_EMPTY) {
-				alpha[c][n] = 0;
-			} else {
-				alpha[c][n] = p_octree[cell].alpha;
-
-				for (int i = 0; i < 6; i++) {
-					//anisotropic read light
-					float amount = p_dir.dot(aniso_normal[i]);
-					if (amount < 0)
-						amount = 0;
-					color[c][n].x += p_octree[cell].light[i][0] / 1024.0 * amount;
-					color[c][n].y += p_octree[cell].light[i][1] / 1024.0 * amount;
-					color[c][n].z += p_octree[cell].light[i][2] / 1024.0 * amount;
-				}
-			}
-
-			//print_line("\tlev " + itos(c) + " - " + itos(n) + " alpha: " + rtos(cells[test_cell].alpha) + " col: " + color[c][n]);
-		}
-	}
-
-	float target_level_size = size >> target_level;
-	Vector3 pos_fract[2];
-
-	pos_fract[0].x = Math::fmod(pos.x, target_level_size) / target_level_size;
-	pos_fract[0].y = Math::fmod(pos.y, target_level_size) / target_level_size;
-	pos_fract[0].z = Math::fmod(pos.z, target_level_size) / target_level_size;
-
-	target_level_size = size >> MAX(0, target_level - 1);
-
-	pos_fract[1].x = Math::fmod(pos.x, target_level_size) / target_level_size;
-	pos_fract[1].y = Math::fmod(pos.y, target_level_size) / target_level_size;
-	pos_fract[1].z = Math::fmod(pos.z, target_level_size) / target_level_size;
-
-	float alpha_interp[2];
-	Vector3 color_interp[2];
-
-	for (int i = 0; i < 2; i++) {
-
-		Vector3 color_x00 = color[i][0].linear_interpolate(color[i][1], pos_fract[i].x);
-		Vector3 color_xy0 = color[i][2].linear_interpolate(color[i][3], pos_fract[i].x);
-		Vector3 blend_z0 = color_x00.linear_interpolate(color_xy0, pos_fract[i].y);
-
-		Vector3 color_x0z = color[i][4].linear_interpolate(color[i][5], pos_fract[i].x);
-		Vector3 color_xyz = color[i][6].linear_interpolate(color[i][7], pos_fract[i].x);
-		Vector3 blend_z1 = color_x0z.linear_interpolate(color_xyz, pos_fract[i].y);
-
-		color_interp[i] = blend_z0.linear_interpolate(blend_z1, pos_fract[i].z);
-
-		float alpha_x00 = Math::lerp(alpha[i][0], alpha[i][1], pos_fract[i].x);
-		float alpha_xy0 = Math::lerp(alpha[i][2], alpha[i][3], pos_fract[i].x);
-		float alpha_z0 = Math::lerp(alpha_x00, alpha_xy0, pos_fract[i].y);
-
-		float alpha_x0z = Math::lerp(alpha[i][4], alpha[i][5], pos_fract[i].x);
-		float alpha_xyz = Math::lerp(alpha[i][6], alpha[i][7], pos_fract[i].x);
-		float alpha_z1 = Math::lerp(alpha_x0z, alpha_xyz, pos_fract[i].y);
-
-		alpha_interp[i] = Math::lerp(alpha_z0, alpha_z1, pos_fract[i].z);
-	}
-
-	r_color = color_interp[0].linear_interpolate(color_interp[1], level_filter);
-	r_alpha = Math::lerp(alpha_interp[0], alpha_interp[1], level_filter);
-
-	//print_line("pos: " + p_posf + " level " + rtos(p_level) + " down to " + itos(target_level) + "." + rtos(level_filter) + " color " + r_color + " alpha " + rtos(r_alpha));
-}
-
-_FORCE_INLINE_ static Color _light_capture_voxel_cone_trace(const RasterizerStorage::LightmapCaptureOctree *p_octree, const Vector3 &p_pos, const Vector3 &p_dir, float p_aperture, int p_cell_subdiv) {
-
-	float bias = 0.0; //no need for bias here
-	float max_distance = (Vector3(1, 1, 1) * (1 << (p_cell_subdiv - 1))).length();
-
-	float dist = bias;
-	float alpha = 0.0;
-	Vector3 color;
-
-	Vector3 scolor;
-	float salpha;
-
-	while (dist < max_distance && alpha < 0.95) {
-		float diameter = MAX(1.0, 2.0 * p_aperture * dist);
-		_light_capture_sample_octree(p_octree, p_cell_subdiv, p_pos + dist * p_dir, p_dir, log2(diameter), scolor, salpha);
-		float a = (1.0 - alpha);
-		color += scolor * a;
-		alpha += a * salpha;
-		dist += diameter * 0.5;
-	}
-
-	return Color(color.x, color.y, color.z, alpha);
-}
-
-void VisualServerScene::_update_instance_lightmap_captures(Instance *p_instance) {
-
-	InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(p_instance->base_data);
-
-	static const Vector3 cone_traces[12] = {
-		Vector3(0, 0, 1),
-		Vector3(0.866025, 0, 0.5),
-		Vector3(0.267617, 0.823639, 0.5),
-		Vector3(-0.700629, 0.509037, 0.5),
-		Vector3(-0.700629, -0.509037, 0.5),
-		Vector3(0.267617, -0.823639, 0.5),
-		Vector3(0, 0, -1),
-		Vector3(0.866025, 0, -0.5),
-		Vector3(0.267617, 0.823639, -0.5),
-		Vector3(-0.700629, 0.509037, -0.5),
-		Vector3(-0.700629, -0.509037, -0.5),
-		Vector3(0.267617, -0.823639, -0.5)
-	};
-
-	float cone_aperture = 0.577; // tan(angle) 60 degrees
-
-	if (p_instance->lightmap_capture_data.empty()) {
-		p_instance->lightmap_capture_data.resize(12);
-	}
-
-	//print_line("update captures for pos: " + p_instance->transform.origin);
-
-	for (int i = 0; i < 12; i++)
-		new (&p_instance->lightmap_capture_data.ptrw()[i]) Color;
-
-	//this could use some sort of blending..
-	for (List<Instance *>::Element *E = geom->lightmap_captures.front(); E; E = E->next()) {
-		const Vector<RasterizerStorage::LightmapCaptureOctree> *octree = VSG::storage->lightmap_capture_get_octree_ptr(E->get()->base);
-		//print_line("octree size: " + itos(octree->size()));
-		if (octree->size() == 0)
-			continue;
-		Transform to_cell_xform = VSG::storage->lightmap_capture_get_octree_cell_transform(E->get()->base);
-		int cell_subdiv = VSG::storage->lightmap_capture_get_octree_cell_subdiv(E->get()->base);
-		to_cell_xform = to_cell_xform * E->get()->transform.affine_inverse();
-
-		const RasterizerStorage::LightmapCaptureOctree *octree_r = octree->ptr();
-
-		Vector3 pos = to_cell_xform.xform(p_instance->transform.origin);
-
-		for (int i = 0; i < 12; i++) {
-
-			Vector3 dir = to_cell_xform.basis.xform(cone_traces[i]).normalized();
-			Color capture = _light_capture_voxel_cone_trace(octree_r, pos, dir, cone_aperture, cell_subdiv);
-			p_instance->lightmap_capture_data.write[i] += capture;
-		}
-	}
-}
-
-bool VisualServerScene::_light_instance_update_shadow(Instance *p_instance, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, RID p_shadow_atlas, Scenario *p_scenario) {
-
-	InstanceLightData *light = static_cast<InstanceLightData *>(p_instance->base_data);
-
-	Transform light_transform = p_instance->transform;
-	light_transform.orthonormalize(); //scale does not count on lights
-
-	bool animated_material_found = false;
-
-	switch (VSG::storage->light_get_type(p_instance->base)) {
-
-		case VS::LIGHT_DIRECTIONAL: {
-
-			float max_distance = p_cam_projection.get_z_far();
-			float shadow_max = VSG::storage->light_get_param(p_instance->base, VS::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
-				max_distance = MIN(shadow_max, max_distance);
-			}
-			max_distance = MAX(max_distance, p_cam_projection.get_z_near() + 0.001);
-			float min_distance = MIN(p_cam_projection.get_z_near(), max_distance);
-
-			VS::LightDirectionalShadowDepthRangeMode depth_range_mode = VSG::storage->light_directional_get_shadow_depth_range_mode(p_instance->base);
-
-			if (depth_range_mode == VS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_OPTIMIZED) {
-				//optimize min/max
-				Vector<Plane> planes = p_cam_projection.get_projection_planes(p_cam_transform);
-				int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, VS::INSTANCE_GEOMETRY_MASK);
-				Plane base(p_cam_transform.origin, -p_cam_transform.basis.get_axis(2));
-				//check distance max and min
-
-				bool found_items = false;
-				float z_max = -1e20;
-				float z_min = 1e20;
-
-				for (int i = 0; i < cull_count; i++) {
-
-					Instance *instance = instance_shadow_cull_result[i];
-					if (!instance->visible || !((1 << instance->base_type) & VS::INSTANCE_GEOMETRY_MASK) || !static_cast<InstanceGeometryData *>(instance->base_data)->can_cast_shadows) {
-						continue;
-					}
-
-					if (static_cast<InstanceGeometryData *>(instance->base_data)->material_is_animated) {
-						animated_material_found = true;
-					}
-
-					float max, min;
-					instance->transformed_aabb.project_range_in_plane(base, min, max);
-
-					if (max > z_max) {
-						z_max = max;
-					}
-
-					if (min < z_min) {
-						z_min = min;
-					}
-
-					found_items = true;
-				}
-
-				if (found_items) {
-					min_distance = MAX(min_distance, z_min);
-					max_distance = MIN(max_distance, z_max);
-				}
-			}
-
-			float range = max_distance - min_distance;
-
-			int splits = 0;
-			switch (VSG::storage->light_directional_get_shadow_mode(p_instance->base)) {
-				case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: splits = 1; break;
-				case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: splits = 2; break;
-				case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: splits = 4; break;
-			}
-
-			float distances[5];
-
-			distances[0] = min_distance;
-			for (int i = 0; i < splits; i++) {
-				distances[i + 1] = min_distance + VSG::storage->light_get_param(p_instance->base, VS::LightParam(VS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET + i)) * range;
-			};
-
-			distances[splits] = max_distance;
-
-			float texture_size = VSG::scene_render->get_directional_light_shadow_size(light->instance);
-
-			bool overlap = VSG::storage->light_directional_get_blend_splits(p_instance->base);
-
-			float first_radius = 0.0;
-
-			for (int i = 0; i < splits; i++) {
-
-				RENDER_TIMESTAMP("Culling Directional Light split" + itos(i));
-
-				// setup a camera matrix for that range!
-				CameraMatrix camera_matrix;
-
-				float aspect = p_cam_projection.get_aspect();
-
-				if (p_cam_orthogonal) {
-
-					Vector2 vp_he = p_cam_projection.get_viewport_half_extents();
-
-					camera_matrix.set_orthogonal(vp_he.y * 2.0, aspect, distances[(i == 0 || !overlap) ? i : i - 1], distances[i + 1], false);
-				} else {
-
-					float fov = p_cam_projection.get_fov();
-					camera_matrix.set_perspective(fov, aspect, distances[(i == 0 || !overlap) ? i : i - 1], distances[i + 1], false);
-				}
-
-				//obtain the frustum endpoints
-
-				Vector3 endpoints[8]; // frustum plane endpoints
-				bool res = camera_matrix.get_endpoints(p_cam_transform, endpoints);
-				ERR_CONTINUE(!res);
-
-				// obtain the light frustm ranges (given endpoints)
-
-				Transform transform = light_transform; //discard scale and stabilize light
-
-				Vector3 x_vec = transform.basis.get_axis(Vector3::AXIS_X).normalized();
-				Vector3 y_vec = transform.basis.get_axis(Vector3::AXIS_Y).normalized();
-				Vector3 z_vec = transform.basis.get_axis(Vector3::AXIS_Z).normalized();
-				//z_vec points agsint the camera, like in default opengl
-
-				float x_min = 0.f, x_max = 0.f;
-				float y_min = 0.f, y_max = 0.f;
-				float z_min = 0.f, z_max = 0.f;
-
-				// FIXME: z_max_cam is defined, computed, but not used below when setting up
-				// ortho_camera. Commented out for now to fix warnings but should be investigated.
-				float x_min_cam = 0.f, x_max_cam = 0.f;
-				float y_min_cam = 0.f, y_max_cam = 0.f;
-				float z_min_cam = 0.f;
-				//float z_max_cam = 0.f;
-
-				float bias_scale = 1.0;
-
-				//used for culling
-
-				for (int j = 0; j < 8; j++) {
-
-					float d_x = x_vec.dot(endpoints[j]);
-					float d_y = y_vec.dot(endpoints[j]);
-					float d_z = z_vec.dot(endpoints[j]);
-
-					if (j == 0 || d_x < x_min)
-						x_min = d_x;
-					if (j == 0 || d_x > x_max)
-						x_max = d_x;
-
-					if (j == 0 || d_y < y_min)
-						y_min = d_y;
-					if (j == 0 || d_y > y_max)
-						y_max = d_y;
-
-					if (j == 0 || d_z < z_min)
-						z_min = d_z;
-					if (j == 0 || d_z > z_max)
-						z_max = d_z;
-				}
-
-				{
-					//camera viewport stuff
-
-					Vector3 center;
-
-					for (int j = 0; j < 8; j++) {
-
-						center += endpoints[j];
-					}
-					center /= 8.0;
-
-					//center=x_vec*(x_max-x_min)*0.5 + y_vec*(y_max-y_min)*0.5 + z_vec*(z_max-z_min)*0.5;
-
-					float radius = 0;
-
-					for (int j = 0; j < 8; j++) {
-
-						float d = center.distance_to(endpoints[j]);
-						if (d > radius)
-							radius = d;
-					}
-
-					radius *= texture_size / (texture_size - 2.0); //add a texel by each side
-
-					if (i == 0) {
-						first_radius = radius;
-					} else {
-						bias_scale = radius / first_radius;
-					}
-
-					x_max_cam = x_vec.dot(center) + radius;
-					x_min_cam = x_vec.dot(center) - radius;
-					y_max_cam = y_vec.dot(center) + radius;
-					y_min_cam = y_vec.dot(center) - radius;
-					//z_max_cam = z_vec.dot(center) + radius;
-					z_min_cam = z_vec.dot(center) - radius;
-
-					if (depth_range_mode == VS::LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE) {
-						//this trick here is what stabilizes the shadow (make potential jaggies to not move)
-						//at the cost of some wasted resolution. Still the quality increase is very well worth it
-
-						float unit = radius * 2.0 / texture_size;
-
-						x_max_cam = Math::stepify(x_max_cam, unit);
-						x_min_cam = Math::stepify(x_min_cam, unit);
-						y_max_cam = Math::stepify(y_max_cam, unit);
-						y_min_cam = Math::stepify(y_min_cam, unit);
-					}
-				}
-
-				//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
-
-				Vector<Plane> light_frustum_planes;
-				light_frustum_planes.resize(6);
-
-				//right/left
-				light_frustum_planes.write[0] = Plane(x_vec, x_max);
-				light_frustum_planes.write[1] = Plane(-x_vec, -x_min);
-				//top/bottom
-				light_frustum_planes.write[2] = Plane(y_vec, y_max);
-				light_frustum_planes.write[3] = Plane(-y_vec, -y_min);
-				//near/far
-				light_frustum_planes.write[4] = Plane(z_vec, z_max + 1e6);
-				light_frustum_planes.write[5] = Plane(-z_vec, -z_min); // z_min is ok, since casters further than far-light plane are not needed
-
-				int cull_count = p_scenario->octree.cull_convex(light_frustum_planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, VS::INSTANCE_GEOMETRY_MASK);
-
-				// a pre pass will need to be needed to determine the actual z-near to be used
-
-				Plane near_plane(light_transform.origin, -light_transform.basis.get_axis(2));
-
-				for (int j = 0; j < cull_count; j++) {
-
-					float min, max;
-					Instance *instance = instance_shadow_cull_result[j];
-					if (!instance->visible || !((1 << instance->base_type) & VS::INSTANCE_GEOMETRY_MASK) || !static_cast<InstanceGeometryData *>(instance->base_data)->can_cast_shadows) {
-						cull_count--;
-						SWAP(instance_shadow_cull_result[j], instance_shadow_cull_result[cull_count]);
-						j--;
-						continue;
-					}
-
-					instance->transformed_aabb.project_range_in_plane(Plane(z_vec, 0), min, max);
-					instance->depth = near_plane.distance_to(instance->transform.origin);
-					instance->depth_layer = 0;
-					if (max > z_max)
-						z_max = max;
-				}
-
-				{
-
-					CameraMatrix ortho_camera;
-					real_t half_x = (x_max_cam - x_min_cam) * 0.5;
-					real_t half_y = (y_max_cam - y_min_cam) * 0.5;
-
-					ortho_camera.set_orthogonal(-half_x, half_x, -half_y, half_y, 0, (z_max - z_min_cam));
-
-					Transform ortho_transform;
-					ortho_transform.basis = transform.basis;
-					ortho_transform.origin = x_vec * (x_min_cam + half_x) + y_vec * (y_min_cam + half_y) + z_vec * z_max;
-
-					VSG::scene_render->light_instance_set_shadow_transform(light->instance, ortho_camera, ortho_transform, 0, distances[i + 1], i, bias_scale);
-				}
-
-				VSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
-			}
-
-		} break;
-		case VS::LIGHT_OMNI: {
-
-			VS::LightOmniShadowMode shadow_mode = VSG::storage->light_omni_get_shadow_mode(p_instance->base);
-
-			if (shadow_mode == VS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID || !VSG::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));
-
-					float radius = VSG::storage->light_get_param(p_instance->base, VS::LIGHT_PARAM_RANGE);
-
-					float z = i == 0 ? -1 : 1;
-					Vector<Plane> planes;
-					planes.resize(5);
-					planes.write[0] = light_transform.xform(Plane(Vector3(0, 0, z), radius));
-					planes.write[1] = light_transform.xform(Plane(Vector3(1, 0, z).normalized(), radius));
-					planes.write[2] = light_transform.xform(Plane(Vector3(-1, 0, z).normalized(), radius));
-					planes.write[3] = light_transform.xform(Plane(Vector3(0, 1, z).normalized(), radius));
-					planes.write[4] = light_transform.xform(Plane(Vector3(0, -1, z).normalized(), radius));
-
-					int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, VS::INSTANCE_GEOMETRY_MASK);
-					Plane near_plane(light_transform.origin, light_transform.basis.get_axis(2) * z);
-
-					for (int j = 0; j < cull_count; j++) {
-
-						Instance *instance = instance_shadow_cull_result[j];
-						if (!instance->visible || !((1 << instance->base_type) & VS::INSTANCE_GEOMETRY_MASK) || !static_cast<InstanceGeometryData *>(instance->base_data)->can_cast_shadows) {
-							cull_count--;
-							SWAP(instance_shadow_cull_result[j], instance_shadow_cull_result[cull_count]);
-							j--;
-						} else {
-							if (static_cast<InstanceGeometryData *>(instance->base_data)->material_is_animated) {
-								animated_material_found = true;
-							}
-
-							instance->depth = near_plane.distance_to(instance->transform.origin);
-							instance->depth_layer = 0;
-						}
-					}
-
-					VSG::scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, i);
-					VSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
-				}
-			} else { //shadow cube
-
-				float radius = VSG::storage->light_get_param(p_instance->base, VS::LIGHT_PARAM_RANGE);
-				CameraMatrix cm;
-				cm.set_perspective(90, 1, 0.01, radius);
-
-				for (int i = 0; i < 6; i++) {
-
-					RENDER_TIMESTAMP("Culling Shadow Cube side" + itos(i));
-					//using this one ensures that raster deferred will have it
-
-					static const Vector3 view_normals[6] = {
-						Vector3(+1, 0, 0),
-						Vector3(-1, 0, 0),
-						Vector3(0, -1, 0),
-						Vector3(0, +1, 0),
-						Vector3(0, 0, +1),
-						Vector3(0, 0, -1)
-					};
-					static const Vector3 view_up[6] = {
-						Vector3(0, -1, 0),
-						Vector3(0, -1, 0),
-						Vector3(0, 0, -1),
-						Vector3(0, 0, +1),
-						Vector3(0, -1, 0),
-						Vector3(0, -1, 0)
-					};
-
-					Transform xform = light_transform * Transform().looking_at(view_normals[i], view_up[i]);
-
-					Vector<Plane> planes = cm.get_projection_planes(xform);
-
-					int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, VS::INSTANCE_GEOMETRY_MASK);
-
-					Plane near_plane(xform.origin, -xform.basis.get_axis(2));
-					for (int j = 0; j < cull_count; j++) {
-
-						Instance *instance = instance_shadow_cull_result[j];
-						if (!instance->visible || !((1 << instance->base_type) & VS::INSTANCE_GEOMETRY_MASK) || !static_cast<InstanceGeometryData *>(instance->base_data)->can_cast_shadows) {
-							cull_count--;
-							SWAP(instance_shadow_cull_result[j], instance_shadow_cull_result[cull_count]);
-							j--;
-						} else {
-							if (static_cast<InstanceGeometryData *>(instance->base_data)->material_is_animated) {
-								animated_material_found = true;
-							}
-							instance->depth = near_plane.distance_to(instance->transform.origin);
-							instance->depth_layer = 0;
-						}
-					}
-
-					VSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, xform, radius, 0, i);
-					VSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
-				}
-
-				//restore the regular DP matrix
-				VSG::scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, 0);
-			}
-
-		} break;
-		case VS::LIGHT_SPOT: {
-
-			RENDER_TIMESTAMP("Culling Spot Light");
-
-			float radius = VSG::storage->light_get_param(p_instance->base, VS::LIGHT_PARAM_RANGE);
-			float angle = VSG::storage->light_get_param(p_instance->base, VS::LIGHT_PARAM_SPOT_ANGLE);
-
-			CameraMatrix cm;
-			cm.set_perspective(angle * 2.0, 1.0, 0.01, radius);
-
-			Vector<Plane> planes = cm.get_projection_planes(light_transform);
-			int cull_count = p_scenario->octree.cull_convex(planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, VS::INSTANCE_GEOMETRY_MASK);
-
-			Plane near_plane(light_transform.origin, -light_transform.basis.get_axis(2));
-			for (int j = 0; j < cull_count; j++) {
-
-				Instance *instance = instance_shadow_cull_result[j];
-				if (!instance->visible || !((1 << instance->base_type) & VS::INSTANCE_GEOMETRY_MASK) || !static_cast<InstanceGeometryData *>(instance->base_data)->can_cast_shadows) {
-					cull_count--;
-					SWAP(instance_shadow_cull_result[j], instance_shadow_cull_result[cull_count]);
-					j--;
-				} else {
-					if (static_cast<InstanceGeometryData *>(instance->base_data)->material_is_animated) {
-						animated_material_found = true;
-					}
-					instance->depth = near_plane.distance_to(instance->transform.origin);
-					instance->depth_layer = 0;
-				}
-			}
-
-			VSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, light_transform, radius, 0, 0);
-			VSG::scene_render->render_shadow(light->instance, p_shadow_atlas, 0, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
-
-		} break;
-	}
-
-	return animated_material_found;
-}
-
-void VisualServerScene::render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas) {
-// render to mono camera
-#ifndef _3D_DISABLED
-
-	Camera *camera = camera_owner.getornull(p_camera);
-	ERR_FAIL_COND(!camera);
-
-	/* STEP 1 - SETUP CAMERA */
-	CameraMatrix camera_matrix;
-	bool ortho = false;
-
-	switch (camera->type) {
-		case Camera::ORTHOGONAL: {
-
-			camera_matrix.set_orthogonal(
-					camera->size,
-					p_viewport_size.width / (float)p_viewport_size.height,
-					camera->znear,
-					camera->zfar,
-					camera->vaspect);
-			ortho = true;
-		} break;
-		case Camera::PERSPECTIVE: {
-
-			camera_matrix.set_perspective(
-					camera->fov,
-					p_viewport_size.width / (float)p_viewport_size.height,
-					camera->znear,
-					camera->zfar,
-					camera->vaspect);
-			ortho = false;
-
-		} break;
-		case Camera::FRUSTUM: {
-
-			camera_matrix.set_frustum(
-					camera->size,
-					p_viewport_size.width / (float)p_viewport_size.height,
-					camera->offset,
-					camera->znear,
-					camera->zfar,
-					camera->vaspect);
-			ortho = false;
-		} break;
-	}
-
-	_prepare_scene(camera->transform, camera_matrix, ortho, camera->env, camera->effects, camera->visible_layers, p_scenario, p_shadow_atlas, RID());
-	_render_scene(p_render_buffers, camera->transform, camera_matrix, ortho, camera->env, camera->effects, p_scenario, p_shadow_atlas, RID(), -1);
-#endif
-}
-
-void VisualServerScene::render_camera(RID p_render_buffers, Ref<ARVRInterface> &p_interface, ARVRInterface::Eyes p_eye, RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas) {
-	// render for AR/VR interface
-
-	Camera *camera = camera_owner.getornull(p_camera);
-	ERR_FAIL_COND(!camera);
-
-	/* SETUP CAMERA, we are ignoring type and FOV here */
-	float aspect = p_viewport_size.width / (float)p_viewport_size.height;
-	CameraMatrix camera_matrix = p_interface->get_projection_for_eye(p_eye, aspect, camera->znear, camera->zfar);
-
-	// We also ignore our camera position, it will have been positioned with a slightly old tracking position.
-	// Instead we take our origin point and have our ar/vr interface add fresh tracking data! Whoohoo!
-	Transform world_origin = ARVRServer::get_singleton()->get_world_origin();
-	Transform cam_transform = p_interface->get_transform_for_eye(p_eye, world_origin);
-
-	// For stereo render we only prepare for our left eye and then reuse the outcome for our right eye
-	if (p_eye == ARVRInterface::EYE_LEFT) {
-		///@TODO possibly move responsibility for this into our ARVRServer or ARVRInterface?
-
-		// Center our transform, we assume basis is equal.
-		Transform mono_transform = cam_transform;
-		Transform right_transform = p_interface->get_transform_for_eye(ARVRInterface::EYE_RIGHT, world_origin);
-		mono_transform.origin += right_transform.origin;
-		mono_transform.origin *= 0.5;
-
-		// We need to combine our projection frustums for culling.
-		// Ideally we should use our clipping planes for this and combine them,
-		// however our shadow map logic uses our projection matrix.
-		// Note: as our left and right frustums should be mirrored, we don't need our right projection matrix.
-
-		// - get some base values we need
-		float eye_dist = (mono_transform.origin - cam_transform.origin).length();
-		float z_near = camera_matrix.get_z_near(); // get our near plane
-		float z_far = camera_matrix.get_z_far(); // get our far plane
-		float width = (2.0 * z_near) / camera_matrix.matrix[0][0];
-		float x_shift = width * camera_matrix.matrix[2][0];
-		float height = (2.0 * z_near) / camera_matrix.matrix[1][1];
-		float y_shift = height * camera_matrix.matrix[2][1];
-
-		// printf("Eye_dist = %f, Near = %f, Far = %f, Width = %f, Shift = %f\n", eye_dist, z_near, z_far, width, x_shift);
-
-		// - calculate our near plane size (horizontal only, right_near is mirrored)
-		float left_near = -eye_dist - ((width - x_shift) * 0.5);
-
-		// - calculate our far plane size (horizontal only, right_far is mirrored)
-		float left_far = -eye_dist - (z_far * (width - x_shift) * 0.5 / z_near);
-		float left_far_right_eye = eye_dist - (z_far * (width + x_shift) * 0.5 / z_near);
-		if (left_far > left_far_right_eye) {
-			// on displays smaller then double our iod, the right eye far frustrum can overtake the left eyes.
-			left_far = left_far_right_eye;
-		}
-
-		// - figure out required z-shift
-		float slope = (left_far - left_near) / (z_far - z_near);
-		float z_shift = (left_near / slope) - z_near;
-
-		// - figure out new vertical near plane size (this will be slightly oversized thanks to our z-shift)
-		float top_near = (height - y_shift) * 0.5;
-		top_near += (top_near / z_near) * z_shift;
-		float bottom_near = -(height + y_shift) * 0.5;
-		bottom_near += (bottom_near / z_near) * z_shift;
-
-		// printf("Left_near = %f, Left_far = %f, Top_near = %f, Bottom_near = %f, Z_shift = %f\n", left_near, left_far, top_near, bottom_near, z_shift);
-
-		// - generate our frustum
-		CameraMatrix combined_matrix;
-		combined_matrix.set_frustum(left_near, -left_near, bottom_near, top_near, z_near + z_shift, z_far + z_shift);
-
-		// and finally move our camera back
-		Transform apply_z_shift;
-		apply_z_shift.origin = Vector3(0.0, 0.0, z_shift); // z negative is forward so this moves it backwards
-		mono_transform *= apply_z_shift;
-
-		// now prepare our scene with our adjusted transform projection matrix
-		_prepare_scene(mono_transform, combined_matrix, false, camera->env, camera->effects, camera->visible_layers, p_scenario, p_shadow_atlas, RID());
-	} else if (p_eye == ARVRInterface::EYE_MONO) {
-		// For mono render, prepare as per usual
-		_prepare_scene(cam_transform, camera_matrix, false, camera->env, camera->effects, camera->visible_layers, p_scenario, p_shadow_atlas, RID());
-	}
-
-	// And render our scene...
-	_render_scene(p_render_buffers, cam_transform, camera_matrix, false, camera->env, camera->effects, p_scenario, p_shadow_atlas, RID(), -1);
-};
-
-void VisualServerScene::_prepare_scene(const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, RID p_force_environment, RID p_force_camera_effects, uint32_t p_visible_layers, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, 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
-
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
-
-	render_pass++;
-	uint32_t camera_layer_mask = p_visible_layers;
-
-	VSG::scene_render->set_scene_pass(render_pass);
-
-	RENDER_TIMESTAMP("Frustum Culling");
-
-	//rasterizer->set_camera(camera->transform, camera_matrix,ortho);
-
-	Vector<Plane> planes = p_cam_projection.get_projection_planes(p_cam_transform);
-
-	Plane near_plane(p_cam_transform.origin, -p_cam_transform.basis.get_axis(2).normalized());
-	float z_far = p_cam_projection.get_z_far();
-
-	/* STEP 2 - CULL */
-	instance_cull_count = scenario->octree.cull_convex(planes, instance_cull_result, MAX_INSTANCE_CULL);
-	light_cull_count = 0;
-
-	reflection_probe_cull_count = 0;
-	gi_probe_cull_count = 0;
-
-	//light_samplers_culled=0;
-
-	/*
-	print_line("OT: "+rtos( (OS::get_singleton()->get_ticks_usec()-t)/1000.0));
-	print_line("OTO: "+itos(p_scenario->octree.get_octant_count()));
-	print_line("OTE: "+itos(p_scenario->octree.get_elem_count()));
-	print_line("OTP: "+itos(p_scenario->octree.get_pair_count()));
-	*/
-
-	/* STEP 3 - PROCESS PORTALS, VALIDATE ROOMS */
-	//removed, will replace with culling
-
-	/* STEP 4 - REMOVE FURTHER CULLED OBJECTS, ADD LIGHTS */
-
-	for (int i = 0; i < instance_cull_count; i++) {
-
-		Instance *ins = instance_cull_result[i];
-
-		bool keep = false;
-
-		if ((camera_layer_mask & ins->layer_mask) == 0) {
-			//failure
-		} else if (ins->base_type == VS::INSTANCE_LIGHT && ins->visible) {
-
-			if (light_cull_count < MAX_LIGHTS_CULLED) {
-
-				InstanceLightData *light = static_cast<InstanceLightData *>(ins->base_data);
-
-				if (!light->geometries.empty()) {
-					//do not add this light if no geometry is affected by it..
-					light_cull_result[light_cull_count] = ins;
-					light_instance_cull_result[light_cull_count] = light->instance;
-					if (p_shadow_atlas.is_valid() && VSG::storage->light_has_shadow(ins->base)) {
-						VSG::scene_render->light_instance_mark_visible(light->instance); //mark it visible for shadow allocation later
-					}
-
-					light_cull_count++;
-				}
-			}
-		} else if (ins->base_type == VS::INSTANCE_REFLECTION_PROBE && ins->visible) {
-
-			if (reflection_probe_cull_count < MAX_REFLECTION_PROBES_CULLED) {
-
-				InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(ins->base_data);
-
-				if (p_reflection_probe != reflection_probe->instance) {
-					//avoid entering The Matrix
-
-					if (!reflection_probe->geometries.empty()) {
-						//do not add this light if no geometry is affected by it..
-
-						if (reflection_probe->reflection_dirty || VSG::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);
-							}
-
-							reflection_probe->reflection_dirty = false;
-						}
-
-						if (VSG::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++;
-						}
-					}
-				}
-			}
-
-		} else if (ins->base_type == VS::INSTANCE_GI_PROBE && ins->visible) {
-
-			InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(ins->base_data);
-			if (!gi_probe->update_element.in_list()) {
-				gi_probe_update_list.add(&gi_probe->update_element);
-			}
-
-			if (gi_probe_cull_count < MAX_GI_PROBES_CULLED) {
-				gi_probe_instance_cull_result[gi_probe_cull_count] = gi_probe->probe_instance;
-				gi_probe_cull_count++;
-			}
-
-		} else if (((1 << ins->base_type) & VS::INSTANCE_GEOMETRY_MASK) && ins->visible && ins->cast_shadows != VS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) {
-
-			keep = true;
-
-			InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(ins->base_data);
-
-			if (ins->redraw_if_visible) {
-				VisualServerRaster::redraw_request();
-			}
-
-			if (ins->base_type == VS::INSTANCE_PARTICLES) {
-				//particles visible? process them
-				if (VSG::storage->particles_is_inactive(ins->base)) {
-					//but if nothing is going on, don't do it.
-					keep = false;
-				} else {
-					VSG::storage->particles_request_process(ins->base);
-					//particles visible? request redraw
-					VisualServerRaster::redraw_request();
-				}
-			}
-
-			if (geom->lighting_dirty) {
-				int l = 0;
-				//only called when lights AABB enter/exit this geometry
-				ins->light_instances.resize(geom->lighting.size());
-
-				for (List<Instance *>::Element *E = geom->lighting.front(); E; E = E->next()) {
-
-					InstanceLightData *light = static_cast<InstanceLightData *>(E->get()->base_data);
-
-					ins->light_instances.write[l++] = light->instance;
-				}
-
-				geom->lighting_dirty = false;
-			}
-
-			if (geom->reflection_dirty) {
-				int l = 0;
-				//only called when reflection probe AABB enter/exit this geometry
-				ins->reflection_probe_instances.resize(geom->reflection_probes.size());
-
-				for (List<Instance *>::Element *E = geom->reflection_probes.front(); E; E = E->next()) {
-
-					InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(E->get()->base_data);
-
-					ins->reflection_probe_instances.write[l++] = reflection_probe->instance;
-				}
-
-				geom->reflection_dirty = false;
-			}
-
-			if (geom->gi_probes_dirty) {
-				int l = 0;
-				//only called when reflection probe AABB enter/exit this geometry
-				ins->gi_probe_instances.resize(geom->gi_probes.size());
-
-				for (List<Instance *>::Element *E = geom->gi_probes.front(); E; E = E->next()) {
-
-					InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(E->get()->base_data);
-
-					ins->gi_probe_instances.write[l++] = gi_probe->probe_instance;
-				}
-
-				geom->gi_probes_dirty = false;
-			}
-
-			ins->depth = near_plane.distance_to(ins->transform.origin);
-			ins->depth_layer = CLAMP(int(ins->depth * 16 / z_far), 0, 15);
-		}
-
-		if (!keep) {
-			// remove, no reason to keep
-			instance_cull_count--;
-			SWAP(instance_cull_result[i], instance_cull_result[instance_cull_count]);
-			i--;
-			ins->last_render_pass = 0; // make invalid
-		} else {
-
-			ins->last_render_pass = render_pass;
-		}
-	}
-
-	/* STEP 5 - PROCESS LIGHTS */
-
-	RID *directional_light_ptr = &light_instance_cull_result[light_cull_count];
-	directional_light_count = 0;
-
-	// directional lights
-	{
-
-		Instance **lights_with_shadow = (Instance **)alloca(sizeof(Instance *) * scenario->directional_lights.size());
-		int directional_shadow_count = 0;
-
-		for (List<Instance *>::Element *E = scenario->directional_lights.front(); E; E = E->next()) {
-
-			if (light_cull_count + directional_light_count >= MAX_LIGHTS_CULLED) {
-				break;
-			}
-
-			if (!E->get()->visible)
-				continue;
-
-			InstanceLightData *light = static_cast<InstanceLightData *>(E->get()->base_data);
-
-			//check shadow..
-
-			if (light) {
-				if (p_using_shadows && p_shadow_atlas.is_valid() && VSG::storage->light_has_shadow(E->get()->base)) {
-					lights_with_shadow[directional_shadow_count++] = E->get();
-				}
-				//add to list
-				directional_light_ptr[directional_light_count++] = light->instance;
-			}
-		}
-
-		VSG::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_shadow_atlas, scenario);
-
-			RENDER_TIMESTAMP("<Rendering Directional Light " + itos(i));
-		}
-	}
-
-	if (p_using_shadows) { //setup shadow maps
-
-		//SortArray<Instance*,_InstanceLightsort> sorter;
-		//sorter.sort(light_cull_result,light_cull_count);
-		for (int i = 0; i < light_cull_count; i++) {
-
-			Instance *ins = light_cull_result[i];
-
-			if (!p_shadow_atlas.is_valid() || !VSG::storage->light_has_shadow(ins->base))
-				continue;
-
-			InstanceLightData *light = static_cast<InstanceLightData *>(ins->base_data);
-
-			float coverage = 0.f;
-
-			{ //compute coverage
-
-				Transform cam_xf = p_cam_transform;
-				float zn = p_cam_projection.get_z_near();
-				Plane p(cam_xf.origin + cam_xf.basis.get_axis(2) * -zn, -cam_xf.basis.get_axis(2)); //camera near plane
-
-				// near plane half width and height
-				Vector2 vp_half_extents = p_cam_projection.get_viewport_half_extents();
-
-				switch (VSG::storage->light_get_type(ins->base)) {
-
-					case VS::LIGHT_OMNI: {
-
-						float radius = VSG::storage->light_get_param(ins->base, VS::LIGHT_PARAM_RANGE);
-
-						//get two points parallel to near plane
-						Vector3 points[2] = {
-							ins->transform.origin,
-							ins->transform.origin + cam_xf.basis.get_axis(0) * radius
-						};
-
-						if (!p_cam_orthogonal) {
-							//if using perspetive, map them to near plane
-							for (int j = 0; j < 2; j++) {
-								if (p.distance_to(points[j]) < 0) {
-									points[j].z = -zn; //small hack to keep size constant when hitting the screen
-								}
-
-								p.intersects_segment(cam_xf.origin, points[j], &points[j]); //map to plane
-							}
-						}
-
-						float screen_diameter = points[0].distance_to(points[1]) * 2;
-						coverage = screen_diameter / (vp_half_extents.x + vp_half_extents.y);
-					} break;
-					case VS::LIGHT_SPOT: {
-
-						float radius = VSG::storage->light_get_param(ins->base, VS::LIGHT_PARAM_RANGE);
-						float angle = VSG::storage->light_get_param(ins->base, VS::LIGHT_PARAM_SPOT_ANGLE);
-
-						float w = radius * Math::sin(Math::deg2rad(angle));
-						float d = radius * Math::cos(Math::deg2rad(angle));
-
-						Vector3 base = ins->transform.origin - ins->transform.basis.get_axis(2).normalized() * d;
-
-						Vector3 points[2] = {
-							base,
-							base + cam_xf.basis.get_axis(0) * w
-						};
-
-						if (!p_cam_orthogonal) {
-							//if using perspetive, map them to near plane
-							for (int j = 0; j < 2; j++) {
-								if (p.distance_to(points[j]) < 0) {
-									points[j].z = -zn; //small hack to keep size constant when hitting the screen
-								}
-
-								p.intersects_segment(cam_xf.origin, points[j], &points[j]); //map to plane
-							}
-						}
-
-						float screen_diameter = points[0].distance_to(points[1]) * 2;
-						coverage = screen_diameter / (vp_half_extents.x + vp_half_extents.y);
-
-					} break;
-					default: {
-						ERR_PRINT("Invalid Light Type");
-					}
-				}
-			}
-
-			if (light->shadow_dirty) {
-				light->last_version++;
-				light->shadow_dirty = false;
-			}
-
-			bool redraw = VSG::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_shadow_atlas, scenario);
-				RENDER_TIMESTAMP("<Rendering Light " + itos(i));
-			}
-		}
-	}
-}
-
-void VisualServerScene::_render_scene(RID p_render_buffers, const Transform p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, RID p_force_environment, RID p_force_camera_effects, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass) {
-
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
-
-	/* ENVIRONMENT */
-
-	RID environment;
-	if (p_force_environment.is_valid()) //camera has more environment priority
-		environment = p_force_environment;
-	else if (scenario->environment.is_valid())
-		environment = scenario->environment;
-	else
-		environment = scenario->fallback_environment;
-
-	RID camera_effects;
-	if (p_force_camera_effects.is_valid()) {
-		camera_effects = p_force_camera_effects;
-	} else {
-		camera_effects = scenario->camera_effects;
-	}
-	/* PROCESS GEOMETRY AND DRAW SCENE */
-
-	RENDER_TIMESTAMP("Render Scene ");
-	VSG::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, environment, camera_effects, p_shadow_atlas, p_reflection_probe.is_valid() ? RID() : scenario->reflection_atlas, p_reflection_probe, p_reflection_probe_pass);
-}
-
-void VisualServerScene::render_empty_scene(RID p_render_buffers, RID p_scenario, RID p_shadow_atlas) {
-
-#ifndef _3D_DISABLED
-
-	Scenario *scenario = scenario_owner.getornull(p_scenario);
-
-	RID environment;
-	if (scenario->environment.is_valid())
-		environment = scenario->environment;
-	else
-		environment = scenario->fallback_environment;
-	RENDER_TIMESTAMP("Render Empty Scene ");
-	VSG::scene_render->render_scene(p_render_buffers, Transform(), CameraMatrix(), true, NULL, 0, NULL, 0, NULL, 0, NULL, 0, environment, RID(), p_shadow_atlas, scenario->reflection_atlas, RID(), 0);
-#endif
-}
-
-bool VisualServerScene::_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);
-
-	VisualServerRaster::redraw_request(); //update, so it updates in editor
-
-	if (p_step == 0) {
-
-		if (!VSG::scene_render->reflection_probe_instance_begin_render(reflection_probe->instance, scenario->reflection_atlas)) {
-			return true; //all full
-		}
-	}
-
-	if (p_step >= 0 && p_step < 6) {
-
-		static const Vector3 view_normals[6] = {
-			Vector3(+1, 0, 0),
-			Vector3(-1, 0, 0),
-			Vector3(0, +1, 0),
-			Vector3(0, -1, 0),
-			Vector3(0, 0, +1),
-			Vector3(0, 0, -1)
-		};
-		static const Vector3 view_up[6] = {
-			Vector3(0, -1, 0),
-			Vector3(0, -1, 0),
-			Vector3(0, 0, +1),
-			Vector3(0, 0, -1),
-			Vector3(0, -1, 0),
-			Vector3(0, -1, 0)
-		};
-
-		Vector3 extents = VSG::storage->reflection_probe_get_extents(p_instance->base);
-		Vector3 origin_offset = VSG::storage->reflection_probe_get_origin_offset(p_instance->base);
-		float max_distance = VSG::storage->reflection_probe_get_origin_max_distance(p_instance->base);
-
-		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
-
-		max_distance = MAX(max_distance, distance);
-
-		//render cubemap side
-		CameraMatrix cm;
-		cm.set_perspective(90, 1, 0.01, max_distance);
-
-		Transform local_view;
-		local_view.set_look_at(origin_offset, origin_offset + view_normals[p_step], view_up[p_step]);
-
-		Transform xform = p_instance->transform * local_view;
-
-		RID shadow_atlas;
-
-		bool use_shadows = VSG::storage->reflection_probe_renders_shadows(p_instance->base);
-		if (use_shadows) {
-
-			shadow_atlas = scenario->reflection_probe_shadow_atlas;
-		}
-
-		RENDER_TIMESTAMP("Render Reflection Probe, Step " + itos(p_step));
-		_prepare_scene(xform, cm, false, RID(), RID(), VSG::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);
-
-	} else {
-		//do roughness postprocess step until it believes it's done
-		RENDER_TIMESTAMP("Post-Process Reflection Probe, Step " + itos(p_step));
-		return VSG::scene_render->reflection_probe_instance_postprocess_step(reflection_probe->instance);
-	}
-
-	return false;
-}
-
-void VisualServerScene::render_probes() {
-
-	/* REFLECTION PROBES */
-
-	SelfList<InstanceReflectionProbeData> *ref_probe = reflection_probe_render_list.first();
-
-	bool busy = false;
-
-	while (ref_probe) {
-
-		SelfList<InstanceReflectionProbeData> *next = ref_probe->next();
-		RID base = ref_probe->self()->owner->base;
-
-		switch (VSG::storage->reflection_probe_get_update_mode(base)) {
-
-			case VS::REFLECTION_PROBE_UPDATE_ONCE: {
-				if (busy) //already rendering something
-					break;
-
-				bool done = _render_reflection_probe_step(ref_probe->self()->owner, ref_probe->self()->render_step);
-				if (done) {
-					reflection_probe_render_list.remove(ref_probe);
-				} else {
-					ref_probe->self()->render_step++;
-				}
-
-				busy = true; //do not render another one of this kind
-			} break;
-			case VS::REFLECTION_PROBE_UPDATE_ALWAYS: {
-
-				int step = 0;
-				bool done = false;
-				while (!done) {
-					done = _render_reflection_probe_step(ref_probe->self()->owner, step);
-					step++;
-				}
-
-				reflection_probe_render_list.remove(ref_probe);
-			} break;
-		}
-
-		ref_probe = next;
-	}
-
-	/* GI PROBES */
-
-	SelfList<InstanceGIProbeData> *gi_probe = gi_probe_update_list.first();
-
-	if (gi_probe) {
-		RENDER_TIMESTAMP("Render GI Probes");
-	}
-
-	while (gi_probe) {
-
-		SelfList<InstanceGIProbeData> *next = gi_probe->next();
-
-		InstanceGIProbeData *probe = gi_probe->self();
-		//Instance *instance_probe = probe->owner;
-
-		//check if probe must be setup, but don't do if on the lighting thread
-
-		bool cache_dirty = false;
-		int cache_count = 0;
-		{
-
-			int light_cache_size = probe->light_cache.size();
-			const InstanceGIProbeData::LightCache *caches = probe->light_cache.ptr();
-			const RID *instance_caches = probe->light_instances.ptr();
-
-			int idx = 0; //must count visible lights
-			for (Set<Instance *>::Element *E = probe->lights.front(); E; E = E->next()) {
-				Instance *instance = E->get();
-				InstanceLightData *instance_light = (InstanceLightData *)instance->base_data;
-				if (!instance->visible) {
-					continue;
-				}
-				if (cache_dirty) {
-					//do nothing, since idx must count all visible lights anyway
-				} else if (idx >= light_cache_size) {
-					cache_dirty = true;
-				} else {
-
-					const InstanceGIProbeData::LightCache *cache = &caches[idx];
-
-					if (
-							instance_caches[idx] != instance_light->instance ||
-							cache->has_shadow != VSG::storage->light_has_shadow(instance->base) ||
-							cache->type != VSG::storage->light_get_type(instance->base) ||
-							cache->transform != instance->transform ||
-							cache->color != VSG::storage->light_get_color(instance->base) ||
-							cache->energy != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ENERGY) ||
-							cache->bake_energy != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_INDIRECT_ENERGY) ||
-							cache->radius != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_RANGE) ||
-							cache->attenuation != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ATTENUATION) ||
-							cache->spot_angle != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ANGLE) ||
-							cache->spot_attenuation != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ATTENUATION)) {
-						cache_dirty = true;
-					}
-				}
-
-				idx++;
-			}
-
-			for (List<Instance *>::Element *E = probe->owner->scenario->directional_lights.front(); E; E = E->next()) {
-
-				Instance *instance = E->get();
-				InstanceLightData *instance_light = (InstanceLightData *)instance->base_data;
-				if (!instance->visible) {
-					continue;
-				}
-				if (cache_dirty) {
-					//do nothing, since idx must count all visible lights anyway
-				} else if (idx >= light_cache_size) {
-					cache_dirty = true;
-				} else {
-
-					const InstanceGIProbeData::LightCache *cache = &caches[idx];
-
-					if (
-							instance_caches[idx] != instance_light->instance ||
-							cache->has_shadow != VSG::storage->light_has_shadow(instance->base) ||
-							cache->type != VSG::storage->light_get_type(instance->base) ||
-							cache->transform != instance->transform ||
-							cache->color != VSG::storage->light_get_color(instance->base) ||
-							cache->energy != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ENERGY) ||
-							cache->bake_energy != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_INDIRECT_ENERGY) ||
-							cache->radius != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_RANGE) ||
-							cache->attenuation != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ATTENUATION) ||
-							cache->spot_angle != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ANGLE) ||
-							cache->spot_attenuation != VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ATTENUATION)) {
-						cache_dirty = true;
-					}
-				}
-
-				idx++;
-			}
-
-			if (idx != light_cache_size) {
-				cache_dirty = true;
-			}
-
-			cache_count = idx;
-		}
-
-		bool update_lights = VSG::scene_render->gi_probe_needs_update(probe->probe_instance);
-
-		if (cache_dirty) {
-			probe->light_cache.resize(cache_count);
-			probe->light_instances.resize(cache_count);
-
-			if (cache_count) {
-				InstanceGIProbeData::LightCache *caches = probe->light_cache.ptrw();
-				RID *instance_caches = probe->light_instances.ptrw();
-
-				int idx = 0; //must count visible lights
-				for (Set<Instance *>::Element *E = probe->lights.front(); E; E = E->next()) {
-					Instance *instance = E->get();
-					InstanceLightData *instance_light = (InstanceLightData *)instance->base_data;
-					if (!instance->visible) {
-						continue;
-					}
-
-					InstanceGIProbeData::LightCache *cache = &caches[idx];
-
-					instance_caches[idx] = instance_light->instance;
-					cache->has_shadow = VSG::storage->light_has_shadow(instance->base);
-					cache->type = VSG::storage->light_get_type(instance->base);
-					cache->transform = instance->transform;
-					cache->color = VSG::storage->light_get_color(instance->base);
-					cache->energy = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ENERGY);
-					cache->bake_energy = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_INDIRECT_ENERGY);
-					cache->radius = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_RANGE);
-					cache->attenuation = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ATTENUATION);
-					cache->spot_angle = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ANGLE);
-					cache->spot_attenuation = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ATTENUATION);
-
-					idx++;
-				}
-				for (List<Instance *>::Element *E = probe->owner->scenario->directional_lights.front(); E; E = E->next()) {
-					Instance *instance = E->get();
-					InstanceLightData *instance_light = (InstanceLightData *)instance->base_data;
-					if (!instance->visible) {
-						continue;
-					}
-
-					InstanceGIProbeData::LightCache *cache = &caches[idx];
-
-					instance_caches[idx] = instance_light->instance;
-					cache->has_shadow = VSG::storage->light_has_shadow(instance->base);
-					cache->type = VSG::storage->light_get_type(instance->base);
-					cache->transform = instance->transform;
-					cache->color = VSG::storage->light_get_color(instance->base);
-					cache->energy = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ENERGY);
-					cache->bake_energy = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_INDIRECT_ENERGY);
-					cache->radius = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_RANGE);
-					cache->attenuation = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_ATTENUATION);
-					cache->spot_angle = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ANGLE);
-					cache->spot_attenuation = VSG::storage->light_get_param(instance->base, VS::LIGHT_PARAM_SPOT_ATTENUATION);
-
-					idx++;
-				}
-			}
-
-			update_lights = true;
-		}
-
-		instance_cull_count = 0;
-		for (List<InstanceGIProbeData::PairInfo>::Element *E = probe->dynamic_geometries.front(); E; E = E->next()) {
-			if (instance_cull_count < MAX_INSTANCE_CULL) {
-				Instance *ins = E->get().geometry;
-				if (!ins->visible) {
-					continue;
-				}
-				InstanceGeometryData *geom = (InstanceGeometryData *)ins->base_data;
-
-				if (geom->gi_probes_dirty) {
-					//giprobes may be dirty, so update
-					int l = 0;
-					//only called when reflection probe AABB enter/exit this geometry
-					ins->gi_probe_instances.resize(geom->gi_probes.size());
-
-					for (List<Instance *>::Element *F = geom->gi_probes.front(); F; F = F->next()) {
-
-						InstanceGIProbeData *gi_probe2 = static_cast<InstanceGIProbeData *>(F->get()->base_data);
-
-						ins->gi_probe_instances.write[l++] = gi_probe2->probe_instance;
-					}
-
-					geom->gi_probes_dirty = false;
-				}
-
-				instance_cull_result[instance_cull_count++] = E->get().geometry;
-			}
-		}
-
-		VSG::scene_render->gi_probe_update(probe->probe_instance, update_lights, probe->light_instances, instance_cull_count, (RasterizerScene::InstanceBase **)instance_cull_result);
-
-		gi_probe_update_list.remove(gi_probe);
-
-		gi_probe = next;
-	}
-}
-
-void VisualServerScene::_update_dirty_instance(Instance *p_instance) {
-
-	if (p_instance->update_aabb) {
-		_update_instance_aabb(p_instance);
-	}
-
-	if (p_instance->update_dependencies) {
-
-		p_instance->instance_increase_version();
-
-		if (p_instance->base.is_valid()) {
-			VSG::storage->base_update_dependency(p_instance->base, p_instance);
-		}
-
-		if (p_instance->material_override.is_valid()) {
-			VSG::storage->material_update_dependency(p_instance->material_override, p_instance);
-		}
-
-		if (p_instance->base_type == VS::INSTANCE_MESH) {
-			//remove materials no longer used and un-own them
-
-			int new_mat_count = VSG::storage->mesh_get_surface_count(p_instance->base);
-			p_instance->materials.resize(new_mat_count);
-
-			int new_blend_shape_count = VSG::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;
-				}
-			}
-		}
-
-		if ((1 << p_instance->base_type) & VS::INSTANCE_GEOMETRY_MASK) {
-
-			InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(p_instance->base_data);
-
-			bool can_cast_shadows = true;
-			bool is_animated = false;
-
-			if (p_instance->cast_shadows == VS::SHADOW_CASTING_SETTING_OFF) {
-				can_cast_shadows = false;
-			} else if (p_instance->material_override.is_valid()) {
-				can_cast_shadows = VSG::storage->material_casts_shadows(p_instance->material_override);
-				is_animated = VSG::storage->material_is_animated(p_instance->material_override);
-			} else {
-
-				if (p_instance->base_type == VS::INSTANCE_MESH) {
-					RID mesh = p_instance->base;
-
-					if (mesh.is_valid()) {
-						bool cast_shadows = false;
-
-						for (int i = 0; i < p_instance->materials.size(); i++) {
-
-							RID mat = p_instance->materials[i].is_valid() ? p_instance->materials[i] : VSG::storage->mesh_surface_get_material(mesh, i);
-
-							if (!mat.is_valid()) {
-								cast_shadows = true;
-							} else {
-
-								if (VSG::storage->material_casts_shadows(mat)) {
-									cast_shadows = true;
-								}
-
-								if (VSG::storage->material_is_animated(mat)) {
-									is_animated = true;
-								}
-
-								VSG::storage->material_update_dependency(mat, p_instance);
-							}
-						}
-
-						if (!cast_shadows) {
-							can_cast_shadows = false;
-						}
-					}
-
-				} else if (p_instance->base_type == VS::INSTANCE_MULTIMESH) {
-					RID mesh = VSG::storage->multimesh_get_mesh(p_instance->base);
-					if (mesh.is_valid()) {
-
-						bool cast_shadows = false;
-
-						int sc = VSG::storage->mesh_get_surface_count(mesh);
-						for (int i = 0; i < sc; i++) {
-
-							RID mat = VSG::storage->mesh_surface_get_material(mesh, i);
-
-							if (!mat.is_valid()) {
-								cast_shadows = true;
-
-							} else {
-
-								if (VSG::storage->material_casts_shadows(mat)) {
-									cast_shadows = true;
-								}
-								if (VSG::storage->material_is_animated(mat)) {
-									is_animated = true;
-								}
-
-								VSG::storage->material_update_dependency(mat, p_instance);
-							}
-						}
-
-						if (!cast_shadows) {
-							can_cast_shadows = false;
-						}
-
-						VSG::storage->base_update_dependency(mesh, p_instance);
-					}
-				} else if (p_instance->base_type == VS::INSTANCE_IMMEDIATE) {
-
-					RID mat = VSG::storage->immediate_get_material(p_instance->base);
-
-					can_cast_shadows = !mat.is_valid() || VSG::storage->material_casts_shadows(mat);
-
-					if (mat.is_valid() && VSG::storage->material_is_animated(mat)) {
-						is_animated = true;
-					}
-
-					if (mat.is_valid()) {
-						VSG::storage->material_update_dependency(mat, p_instance);
-					}
-
-				} else if (p_instance->base_type == VS::INSTANCE_PARTICLES) {
-
-					bool cast_shadows = false;
-
-					int dp = VSG::storage->particles_get_draw_passes(p_instance->base);
-
-					for (int i = 0; i < dp; i++) {
-
-						RID mesh = VSG::storage->particles_get_draw_pass_mesh(p_instance->base, i);
-						if (!mesh.is_valid())
-							continue;
-
-						int sc = VSG::storage->mesh_get_surface_count(mesh);
-						for (int j = 0; j < sc; j++) {
-
-							RID mat = VSG::storage->mesh_surface_get_material(mesh, j);
-
-							if (!mat.is_valid()) {
-								cast_shadows = true;
-							} else {
-
-								if (VSG::storage->material_casts_shadows(mat)) {
-									cast_shadows = true;
-								}
-
-								if (VSG::storage->material_is_animated(mat)) {
-									is_animated = true;
-								}
-
-								VSG::storage->material_update_dependency(mat, p_instance);
-							}
-						}
-					}
-
-					if (!cast_shadows) {
-						can_cast_shadows = false;
-					}
-				}
-			}
-
-			if (can_cast_shadows != geom->can_cast_shadows) {
-				//ability to cast shadows change, let lights now
-				for (List<Instance *>::Element *E = geom->lighting.front(); E; E = E->next()) {
-					InstanceLightData *light = static_cast<InstanceLightData *>(E->get()->base_data);
-					light->shadow_dirty = true;
-				}
-
-				geom->can_cast_shadows = can_cast_shadows;
-			}
-
-			geom->material_is_animated = is_animated;
-		}
-
-		if (p_instance->skeleton.is_valid()) {
-			VSG::storage->skeleton_update_dependency(p_instance->skeleton, p_instance);
-		}
-
-		p_instance->clean_up_dependencies();
-	}
-
-	_instance_update_list.remove(&p_instance->update_item);
-
-	_update_instance(p_instance);
-
-	p_instance->update_aabb = false;
-	p_instance->update_dependencies = false;
-}
-
-void VisualServerScene::update_dirty_instances() {
-
-	VSG::storage->update_dirty_resources();
-
-	while (_instance_update_list.first()) {
-
-		_update_dirty_instance(_instance_update_list.first()->self());
-	}
-}
-
-bool VisualServerScene::free(RID p_rid) {
-
-	if (camera_owner.owns(p_rid)) {
-
-		Camera *camera = camera_owner.getornull(p_rid);
-
-		camera_owner.free(p_rid);
-		memdelete(camera);
-
-	} else if (scenario_owner.owns(p_rid)) {
-
-		Scenario *scenario = scenario_owner.getornull(p_rid);
-
-		while (scenario->instances.first()) {
-			instance_set_scenario(scenario->instances.first()->self()->self, RID());
-		}
-		VSG::scene_render->free(scenario->reflection_probe_shadow_atlas);
-		VSG::scene_render->free(scenario->reflection_atlas);
-		scenario_owner.free(p_rid);
-		memdelete(scenario);
-
-	} else if (instance_owner.owns(p_rid)) {
-		// delete the instance
-
-		update_dirty_instances();
-
-		Instance *instance = instance_owner.getornull(p_rid);
-
-		instance_set_use_lightmap(p_rid, RID(), RID());
-		instance_set_scenario(p_rid, RID());
-		instance_set_base(p_rid, RID());
-		instance_geometry_set_material_override(p_rid, RID());
-		instance_attach_skeleton(p_rid, RID());
-
-		update_dirty_instances(); //in case something changed this
-
-		instance_owner.free(p_rid);
-		memdelete(instance);
-	} else {
-		return false;
-	}
-
-	return true;
-}
-
-VisualServerScene *VisualServerScene::singleton = NULL;
-
-VisualServerScene::VisualServerScene() {
-
-	render_pass = 1;
-	singleton = this;
-}
-
-VisualServerScene::~VisualServerScene() {
-}