code: /*************************************************************************/
  /*  rendering_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 "rendering_server_scene.h"
  
  #include "core/os/os.h"
  #include "rendering_server_globals.h"
  #include "rendering_server_raster.h"
  
  #include <new>
  
  /* CAMERA API */
  
  RID RenderingServerScene::camera_create() {
  
  	Camera *camera = memnew(Camera);
  	return camera_owner.make_rid(camera);
  }
  
  void RenderingServerScene::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) {
  
  	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 RenderingServerScene::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 RenderingServerScene::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 RenderingServerScene::camera_set_transform(RID p_camera, const Transform &p_transform) {
  
  	Camera *camera = camera_owner.getornull(p_camera);
  	ERR_FAIL_COND(!camera);
  	camera->transform = p_transform.orthonormalized();
  }
  
  void RenderingServerScene::camera_set_cull_mask(RID p_camera, uint32_t p_layers) {
  
  	Camera *camera = camera_owner.getornull(p_camera);
  	ERR_FAIL_COND(!camera);
  
  	camera->visible_layers = p_layers;
  }
  
  void RenderingServerScene::camera_set_environment(RID p_camera, RID p_env) {
  
  	Camera *camera = camera_owner.getornull(p_camera);
  	ERR_FAIL_COND(!camera);
  	camera->env = p_env;
  }
  
  void RenderingServerScene::camera_set_camera_effects(RID p_camera, RID p_fx) {
  
  	Camera *camera = camera_owner.getornull(p_camera);
  	ERR_FAIL_COND(!camera);
  	camera->effects = p_fx;
  }
  
  void RenderingServerScene::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) {
  
  	Camera *camera = camera_owner.getornull(p_camera);
  	ERR_FAIL_COND(!camera);
  	camera->vaspect = p_enable;
  }
  
  /* SCENARIO API */
  
  void *RenderingServerScene::_instance_pair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int) {
  
  	//RenderingServerScene *self = (RenderingServerScene*)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 == RS::INSTANCE_LIGHT && ((1 << A->base_type) & RS::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 == RS::INSTANCE_REFLECTION_PROBE && ((1 << A->base_type) & RS::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 == RS::INSTANCE_LIGHTMAP_CAPTURE && ((1 << A->base_type) & RS::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);
  		((RenderingServerScene *)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 == RS::INSTANCE_GI_PROBE && ((1 << A->base_type) & RS::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 == RS::INSTANCE_GI_PROBE && A->base_type == RS::INSTANCE_LIGHT) {
  
  		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(B->base_data);
  		return gi_probe->lights.insert(A);
  	}
  
  	return NULL;
  }
  void RenderingServerScene::_instance_unpair(void *p_self, OctreeElementID, Instance *p_A, int, OctreeElementID, Instance *p_B, int, void *udata) {
  
  	//RenderingServerScene *self = (RenderingServerScene*)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 == RS::INSTANCE_LIGHT && ((1 << A->base_type) & RS::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 == RS::INSTANCE_REFLECTION_PROBE && ((1 << A->base_type) & RS::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 == RS::INSTANCE_LIGHTMAP_CAPTURE && ((1 << A->base_type) & RS::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);
  		((RenderingServerScene *)p_self)->_instance_queue_update(A, false, false); //need to update capture
  
  	} else if (B->base_type == RS::INSTANCE_GI_PROBE && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) {
  
  		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 == RS::INSTANCE_GI_PROBE && A->base_type == RS::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 RenderingServerScene::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 = RSG::scene_render->shadow_atlas_create();
  	RSG::scene_render->shadow_atlas_set_size(scenario->reflection_probe_shadow_atlas, 1024); //make enough shadows for close distance, don't bother with rest
  	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 0, 4);
  	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 1, 4);
  	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 2, 4);
  	RSG::scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 3, 8);
  	scenario->reflection_atlas = RSG::scene_render->reflection_atlas_create();
  	return scenario_rid;
  }
  
  void RenderingServerScene::scenario_set_debug(RID p_scenario, RS::ScenarioDebugMode p_debug_mode) {
  
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND(!scenario);
  	scenario->debug = p_debug_mode;
  }
  
  void RenderingServerScene::scenario_set_environment(RID p_scenario, RID p_environment) {
  
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND(!scenario);
  	scenario->environment = p_environment;
  }
  
  void RenderingServerScene::scenario_set_camera_effects(RID p_scenario, RID p_camera_effects) {
  
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND(!scenario);
  	scenario->camera_effects = p_camera_effects;
  }
  
  void RenderingServerScene::scenario_set_fallback_environment(RID p_scenario, RID p_environment) {
  
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND(!scenario);
  	scenario->fallback_environment = p_environment;
  }
  
  void RenderingServerScene::scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count) {
  
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND(!scenario);
  	RSG::scene_render->reflection_atlas_set_size(scenario->reflection_atlas, p_reflection_size, p_reflection_count);
  }
  
  /* INSTANCING API */
  
  void RenderingServerScene::_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 RenderingServerScene::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 RenderingServerScene::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 != RS::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 RS::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;
  				}
  				RSG::scene_render->free(light->instance);
  			} break;
  			case RS::INSTANCE_REFLECTION_PROBE: {
  
  				InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(instance->base_data);
  				RSG::scene_render->free(reflection_probe->instance);
  				if (reflection_probe->update_list.in_list()) {
  					reflection_probe_render_list.remove(&reflection_probe->update_list);
  				}
  			} break;
  			case RS::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 RS::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();
  				}
  
  				RSG::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 = RS::INSTANCE_NONE;
  	instance->base = RID();
  
  	if (p_base.is_valid()) {
  
  		instance->base_type = RSG::storage->get_base_type(p_base);
  		ERR_FAIL_COND(instance->base_type == RS::INSTANCE_NONE);
  
  		switch (instance->base_type) {
  			case RS::INSTANCE_LIGHT: {
  
  				InstanceLightData *light = memnew(InstanceLightData);
  
  				if (scenario && RSG::storage->light_get_type(p_base) == RS::LIGHT_DIRECTIONAL) {
  					light->D = scenario->directional_lights.push_back(instance);
  				}
  
  				light->instance = RSG::scene_render->light_instance_create(p_base);
  
  				instance->base_data = light;
  			} break;
  			case RS::INSTANCE_MESH:
  			case RS::INSTANCE_MULTIMESH:
  			case RS::INSTANCE_IMMEDIATE:
  			case RS::INSTANCE_PARTICLES: {
  
  				InstanceGeometryData *geom = memnew(InstanceGeometryData);
  				instance->base_data = geom;
  				if (instance->base_type == RS::INSTANCE_MESH) {
  					instance->blend_values.resize(RSG::storage->mesh_get_blend_shape_count(p_base));
  				}
  			} break;
  			case RS::INSTANCE_REFLECTION_PROBE: {
  
  				InstanceReflectionProbeData *reflection_probe = memnew(InstanceReflectionProbeData);
  				reflection_probe->owner = instance;
  				instance->base_data = reflection_probe;
  
  				reflection_probe->instance = RSG::scene_render->reflection_probe_instance_create(p_base);
  			} break;
  			case RS::INSTANCE_LIGHTMAP_CAPTURE: {
  
  				InstanceLightmapCaptureData *lightmap_capture = memnew(InstanceLightmapCaptureData);
  				instance->base_data = lightmap_capture;
  				//lightmap_capture->instance = RSG::scene_render->lightmap_capture_instance_create(p_base);
  			} break;
  			case RS::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 = RSG::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
  		RSG::storage->base_update_dependency(p_base, instance);
  	}
  
  	_instance_queue_update(instance, true, true);
  }
  void RenderingServerScene::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 RS::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 RS::INSTANCE_REFLECTION_PROBE: {
  				InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(instance->base_data);
  				RSG::scene_render->reflection_probe_release_atlas_index(reflection_probe->instance);
  
  			} break;
  			case RS::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 RS::INSTANCE_LIGHT: {
  
  				InstanceLightData *light = static_cast<InstanceLightData *>(instance->base_data);
  
  				if (RSG::storage->light_get_type(instance->base) == RS::LIGHT_DIRECTIONAL) {
  					light->D = scenario->directional_lights.push_back(instance);
  				}
  			} break;
  			case RS::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 RenderingServerScene::instance_set_layer_mask(RID p_instance, uint32_t p_mask) {
  
  	Instance *instance = instance_owner.getornull(p_instance);
  	ERR_FAIL_COND(!instance);
  
  	instance->layer_mask = p_mask;
  }
  void RenderingServerScene::instance_set_transform(RID p_instance, const Transform &p_transform) {
  
  	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 RenderingServerScene::instance_attach_object_instance_id(RID p_instance, ObjectID p_id) {
  
  	Instance *instance = instance_owner.getornull(p_instance);
  	ERR_FAIL_COND(!instance);
  
  	instance->object_id = p_id;
  }
  void RenderingServerScene::instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight) {
  
  	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 RenderingServerScene::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 == RS::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, RSG::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 RenderingServerScene::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 RS::INSTANCE_LIGHT: {
  			if (RSG::storage->light_get_type(instance->base) != RS::LIGHT_DIRECTIONAL && instance->octree_id && instance->scenario) {
  				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << RS::INSTANCE_LIGHT, p_visible ? RS::INSTANCE_GEOMETRY_MASK : 0);
  			}
  
  		} break;
  		case RS::INSTANCE_REFLECTION_PROBE: {
  			if (instance->octree_id && instance->scenario) {
  				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << RS::INSTANCE_REFLECTION_PROBE, p_visible ? RS::INSTANCE_GEOMETRY_MASK : 0);
  			}
  
  		} break;
  		case RS::INSTANCE_LIGHTMAP_CAPTURE: {
  			if (instance->octree_id && instance->scenario) {
  				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << RS::INSTANCE_LIGHTMAP_CAPTURE, p_visible ? RS::INSTANCE_GEOMETRY_MASK : 0);
  			}
  
  		} break;
  		case RS::INSTANCE_GI_PROBE: {
  			if (instance->octree_id && instance->scenario) {
  				instance->scenario->octree.set_pairable(instance->octree_id, p_visible, 1 << RS::INSTANCE_GI_PROBE, p_visible ? (RS::INSTANCE_GEOMETRY_MASK | (1 << RS::INSTANCE_LIGHT)) : 0);
  			}
  
  		} break;
  		default: {
  		}
  	}
  }
  inline bool is_geometry_instance(RenderingServer::InstanceType p_type) {
  	return p_type == RS::INSTANCE_MESH || p_type == RS::INSTANCE_MULTIMESH || p_type == RS::INSTANCE_PARTICLES || p_type == RS::INSTANCE_IMMEDIATE;
  }
  
  void RenderingServerScene::instance_set_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 != RS::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 RenderingServerScene::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 RenderingServerScene::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
  		RSG::storage->skeleton_update_dependency(p_skeleton, instance);
  	}
  	_instance_queue_update(instance, true, true);
  }
  
  void RenderingServerScene::instance_set_exterior(RID p_instance, bool p_enabled) {
  }
  
  void RenderingServerScene::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> RenderingServerScene::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const {
  
  	Vector<ObjectID> instances;
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND_V(!scenario, instances);
  
  	const_cast<RenderingServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
  
  	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> RenderingServerScene::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const {
  
  	Vector<ObjectID> instances;
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND_V(!scenario, instances);
  	const_cast<RenderingServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
  
  	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> RenderingServerScene::instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario) const {
  
  	Vector<ObjectID> instances;
  	Scenario *scenario = scenario_owner.getornull(p_scenario);
  	ERR_FAIL_COND_V(!scenario, instances);
  	const_cast<RenderingServerScene *>(this)->update_dirty_instances(); // check dirty instances before culling
  
  	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 RenderingServerScene::instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) {
  
  	Instance *instance = instance_owner.getornull(p_instance);
  	ERR_FAIL_COND(!instance);
  
  	//ERR_FAIL_COND(((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK));
  
  	switch (p_flags) {
  
  		case RS::INSTANCE_FLAG_USE_BAKED_LIGHT: {
  
  			instance->baked_light = p_enabled;
  
  		} break;
  		case RS::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 RS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE: {
  
  			instance->redraw_if_visible = p_enabled;
  
  		} break;
  		default: {
  		}
  	}
  }
  void RenderingServerScene::instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting) {
  
  	Instance *instance = instance_owner.getornull(p_instance);
  	ERR_FAIL_COND(!instance);
  
  	instance->cast_shadows = p_shadow_casting_setting;
  	_instance_queue_update(instance, false, true);
  }
  void RenderingServerScene::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 RenderingServerScene::instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin) {
  }
  void RenderingServerScene::instance_geometry_set_as_instance_lod(RID p_instance, RID p_as_lod_of_instance) {
  }
  
  void RenderingServerScene::_update_instance(Instance *p_instance) {
  
  	p_instance->version++;
  
  	if (p_instance->base_type == RS::INSTANCE_LIGHT) {
  
  		InstanceLightData *light = static_cast<InstanceLightData *>(p_instance->base_data);
  
  		RSG::scene_render->light_instance_set_transform(light->instance, p_instance->transform);
  		light->shadow_dirty = true;
  	}
  
  	if (p_instance->base_type == RS::INSTANCE_REFLECTION_PROBE) {
  
  		InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(p_instance->base_data);
  
  		RSG::scene_render->reflection_probe_instance_set_transform(reflection_probe->instance, p_instance->transform);
  		reflection_probe->reflection_dirty = true;
  	}
  
  	if (p_instance->base_type == RS::INSTANCE_GI_PROBE) {
  
  		InstanceGIProbeData *gi_probe = static_cast<InstanceGIProbeData *>(p_instance->base_data);
  
  		RSG::scene_render->gi_probe_instance_set_transform_to_data(gi_probe->probe_instance, p_instance->transform);
  	}
  
  	if (p_instance->base_type == RS::INSTANCE_PARTICLES) {
  
  		RSG::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) & RS::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 == RS::INSTANCE_LIGHT || p_instance->base_type == RS::INSTANCE_REFLECTION_PROBE || p_instance->base_type == RS::INSTANCE_LIGHTMAP_CAPTURE) {
  
  			pairable_mask = p_instance->visible ? RS::INSTANCE_GEOMETRY_MASK : 0;
  			pairable = true;
  		}
  
  		if (p_instance->base_type == RS::INSTANCE_GI_PROBE) {
  			//lights and geometries
  			pairable_mask = p_instance->visible ? RS::INSTANCE_GEOMETRY_MASK | (1 << RS::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 RenderingServerScene::_update_instance_aabb(Instance *p_instance) {
  
  	AABB new_aabb;
  
  	ERR_FAIL_COND(p_instance->base_type != RS::INSTANCE_NONE && !p_instance->base.is_valid());
  
  	switch (p_instance->base_type) {
  		case RenderingServer::INSTANCE_NONE: {
  
  			// do nothing
  		} break;
  		case RenderingServer::INSTANCE_MESH: {
  
  			if (p_instance->custom_aabb)
  				new_aabb = *p_instance->custom_aabb;
  			else
  				new_aabb = RSG::storage->mesh_get_aabb(p_instance->base, p_instance->skeleton);
  
  		} break;
  
  		case RenderingServer::INSTANCE_MULTIMESH: {
  
  			if (p_instance->custom_aabb)
  				new_aabb = *p_instance->custom_aabb;
  			else
  				new_aabb = RSG::storage->multimesh_get_aabb(p_instance->base);
  
  		} break;
  		case RenderingServer::INSTANCE_IMMEDIATE: {
  
  			if (p_instance->custom_aabb)
  				new_aabb = *p_instance->custom_aabb;
  			else
  				new_aabb = RSG::storage->immediate_get_aabb(p_instance->base);
  
  		} break;
  		case RenderingServer::INSTANCE_PARTICLES: {
  
  			if (p_instance->custom_aabb)
  				new_aabb = *p_instance->custom_aabb;
  			else
  				new_aabb = RSG::storage->particles_get_aabb(p_instance->base);
  
  		} break;
  		case RenderingServer::INSTANCE_LIGHT: {
  
  			new_aabb = RSG::storage->light_get_aabb(p_instance->base);
  
  		} break;
  		case RenderingServer::INSTANCE_REFLECTION_PROBE: {
  
  			new_aabb = RSG::storage->reflection_probe_get_aabb(p_instance->base);
  
  		} break;
  		case RenderingServer::INSTANCE_GI_PROBE: {
  
  			new_aabb = RSG::storage->gi_probe_get_bounds(p_instance->base);
  
  		} break;
  		case RenderingServer::INSTANCE_LIGHTMAP_CAPTURE: {
  
  			new_aabb = RSG::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 RenderingServerScene::_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 = RSG::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 = RSG::storage->lightmap_capture_get_octree_cell_transform(E->get()->base);
  		int cell_subdiv = RSG::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 RenderingServerScene::_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 (RSG::storage->light_get_type(p_instance->base)) {
  
  		case RS::LIGHT_DIRECTIONAL: {
  
  			float max_distance = p_cam_projection.get_z_far();
  			float shadow_max = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SHADOW_MAX_DISTANCE);
  			if (shadow_max > 0 && !p_cam_orthogonal) { //its impractical (and leads to unwanted behaviors) to set max distance in orthogonal camera
  				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);
  
  			RS::LightDirectionalShadowDepthRangeMode depth_range_mode = RSG::storage->light_directional_get_shadow_depth_range_mode(p_instance->base);
  
  			if (depth_range_mode == RS::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, RS::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) & RS::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 (RSG::storage->light_directional_get_shadow_mode(p_instance->base)) {
  				case RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: splits = 1; break;
  				case RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: splits = 2; break;
  				case RS::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 + RSG::storage->light_get_param(p_instance->base, RS::LightParam(RS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET + i)) * range;
  			};
  
  			distances[splits] = max_distance;
  
  			float texture_size = RSG::scene_render->get_directional_light_shadow_size(light->instance);
  
  			bool overlap = RSG::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 == RS::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, RS::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) & RS::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;
  
  					RSG::scene_render->light_instance_set_shadow_transform(light->instance, ortho_camera, ortho_transform, 0, distances[i + 1], i, bias_scale);
  				}
  
  				RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
  			}
  
  		} break;
  		case RS::LIGHT_OMNI: {
  
  			RS::LightOmniShadowMode shadow_mode = RSG::storage->light_omni_get_shadow_mode(p_instance->base);
  
  			if (shadow_mode == RS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID || !RSG::scene_render->light_instances_can_render_shadow_cube()) {
  
  				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 = RSG::storage->light_get_param(p_instance->base, RS::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, RS::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) & RS::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;
  						}
  					}
  
  					RSG::scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, i);
  					RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
  				}
  			} else { //shadow cube
  
  				float radius = RSG::storage->light_get_param(p_instance->base, RS::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, RS::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) & RS::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;
  						}
  					}
  
  					RSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, xform, radius, 0, i);
  					RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
  				}
  
  				//restore the regular DP matrix
  				RSG::scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, 0);
  			}
  
  		} break;
  		case RS::LIGHT_SPOT: {
  
  			RENDER_TIMESTAMP("Culling Spot Light");
  
  			float radius = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_RANGE);
  			float angle = RSG::storage->light_get_param(p_instance->base, RS::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, RS::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) & RS::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;
  				}
  			}
  
  			RSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, light_transform, radius, 0, 0);
  			RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, 0, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
  
  		} break;
  	}
  
  	return animated_material_found;
  }
  
  void RenderingServerScene::render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas) {
  // 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 RenderingServerScene::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 RenderingServerScene::_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;
  
  	RSG::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 == RS::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() && RSG::storage->light_has_shadow(ins->base)) {
  						RSG::scene_render->light_instance_mark_visible(light->instance); //mark it visible for shadow allocation later
  					}
  
  					light_cull_count++;
  				}
  			}
  		} else if (ins->base_type == RS::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 || RSG::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 (RSG::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 == RS::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) & RS::INSTANCE_GEOMETRY_MASK) && ins->visible && ins->cast_shadows != RS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) {
  
  			keep = true;
  
  			InstanceGeometryData *geom = static_cast<InstanceGeometryData *>(ins->base_data);
  
  			if (ins->redraw_if_visible) {
  				RenderingServerRaster::redraw_request();
  			}
  
  			if (ins->base_type == RS::INSTANCE_PARTICLES) {
  				//particles visible? process them
  				if (RSG::storage->particles_is_inactive(ins->base)) {
  					//but if nothing is going on, don't do it.
  					keep = false;
  				} else {
  					RSG::storage->particles_request_process(ins->base);
  					//particles visible? request redraw
  					RenderingServerRaster::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() && RSG::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;
  			}
  		}
  
  		RSG::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() || !RSG::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 (RSG::storage->light_get_type(ins->base)) {
  
  					case RS::LIGHT_OMNI: {
  
  						float radius = RSG::storage->light_get_param(ins->base, RS::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 RS::LIGHT_SPOT: {
  
  						float radius = RSG::storage->light_get_param(ins->base, RS::LIGHT_PARAM_RANGE);
  						float angle = RSG::storage->light_get_param(ins->base, RS::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 = RSG::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 RenderingServerScene::_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 ");
  	RSG::scene_render->render_scene(p_render_buffers, p_cam_transform, p_cam_projection, p_cam_orthogonal, (RasterizerScene::InstanceBase **)instance_cull_result, instance_cull_count, light_instance_cull_result, light_cull_count + directional_light_count, reflection_probe_instance_cull_result, reflection_probe_cull_count, gi_probe_instance_cull_result, gi_probe_cull_count, environment, camera_effects, p_shadow_atlas, p_reflection_probe.is_valid() ? RID() : scenario->reflection_atlas, p_reflection_probe, p_reflection_probe_pass);
  }
  
  void RenderingServerScene::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 ");
  	RSG::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 RenderingServerScene::_render_reflection_probe_step(Instance *p_instance, int p_step) {
  
  	InstanceReflectionProbeData *reflection_probe = static_cast<InstanceReflectionProbeData *>(p_instance->base_data);
  	Scenario *scenario = p_instance->scenario;
  	ERR_FAIL_COND_V(!scenario, true);
  
  	RenderingServerRaster::redraw_request(); //update, so it updates in editor
  
  	if (p_step == 0) {
  
  		if (!RSG::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 = RSG::storage->reflection_probe_get_extents(p_instance->base);
  		Vector3 origin_offset = RSG::storage->reflection_probe_get_origin_offset(p_instance->base);
  		float max_distance = RSG::storage->reflection_probe_get_origin_max_distance(p_instance->base);
  
  		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 = RSG::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(), RSG::storage->reflection_probe_get_cull_mask(p_instance->base), p_instance->scenario->self, shadow_atlas, reflection_probe->instance, use_shadows);
  		_render_scene(RID(), xform, cm, false, RID(), RID(), p_instance->scenario->self, shadow_atlas, reflection_probe->instance, p_step);
  
  	} else {
  		//do roughness postprocess step until it believes it's done
  		RENDER_TIMESTAMP("Post-Process Reflection Probe, Step " + itos(p_step));
  		return RSG::scene_render->reflection_probe_instance_postprocess_step(reflection_probe->instance);
  	}
  
  	return false;
  }
  
  void RenderingServerScene::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 (RSG::storage->reflection_probe_get_update_mode(base)) {
  
  			case RS::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 RS::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 != RSG::storage->light_has_shadow(instance->base) ||
  							cache->type != RSG::storage->light_get_type(instance->base) ||
  							cache->transform != instance->transform ||
  							cache->color != RSG::storage->light_get_color(instance->base) ||
  							cache->energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY) ||
  							cache->bake_energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY) ||
  							cache->radius != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE) ||
  							cache->attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION) ||
  							cache->spot_angle != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE) ||
  							cache->spot_attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION)) {
  						cache_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 != RSG::storage->light_has_shadow(instance->base) ||
  							cache->type != RSG::storage->light_get_type(instance->base) ||
  							cache->transform != instance->transform ||
  							cache->color != RSG::storage->light_get_color(instance->base) ||
  							cache->energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY) ||
  							cache->bake_energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY) ||
  							cache->radius != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE) ||
  							cache->attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION) ||
  							cache->spot_angle != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE) ||
  							cache->spot_attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION)) {
  						cache_dirty = true;
  					}
  				}
  
  				idx++;
  			}
  
  			if (idx != light_cache_size) {
  				cache_dirty = true;
  			}
  
  			cache_count = idx;
  		}
  
  		bool update_lights = RSG::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 = RSG::storage->light_has_shadow(instance->base);
  					cache->type = RSG::storage->light_get_type(instance->base);
  					cache->transform = instance->transform;
  					cache->color = RSG::storage->light_get_color(instance->base);
  					cache->energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY);
  					cache->bake_energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY);
  					cache->radius = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE);
  					cache->attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION);
  					cache->spot_angle = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE);
  					cache->spot_attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION);
  
  					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 = RSG::storage->light_has_shadow(instance->base);
  					cache->type = RSG::storage->light_get_type(instance->base);
  					cache->transform = instance->transform;
  					cache->color = RSG::storage->light_get_color(instance->base);
  					cache->energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY);
  					cache->bake_energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY);
  					cache->radius = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE);
  					cache->attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION);
  					cache->spot_angle = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE);
  					cache->spot_attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION);
  
  					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;
  			}
  		}
  
  		RSG::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 RenderingServerScene::_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()) {
  			RSG::storage->base_update_dependency(p_instance->base, p_instance);
  		}
  
  		if (p_instance->material_override.is_valid()) {
  			RSG::storage->material_update_dependency(p_instance->material_override, p_instance);
  		}
  
  		if (p_instance->base_type == RS::INSTANCE_MESH) {
  			//remove materials no longer used and un-own them
  
  			int new_mat_count = RSG::storage->mesh_get_surface_count(p_instance->base);
  			p_instance->materials.resize(new_mat_count);
  
  			int new_blend_shape_count = RSG::storage->mesh_get_blend_shape_count(p_instance->base);
  			if (new_blend_shape_count != p_instance->blend_values.size()) {
  				p_instance->blend_values.resize(new_blend_shape_count);
  				for (int i = 0; i < new_blend_shape_count; i++) {
  					p_instance->blend_values.write[i] = 0;
  				}
  			}
  		}
  
  		if ((1 << p_instance->base_type) & RS::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 == RS::SHADOW_CASTING_SETTING_OFF) {
  				can_cast_shadows = false;
  			} else if (p_instance->material_override.is_valid()) {
  				can_cast_shadows = RSG::storage->material_casts_shadows(p_instance->material_override);
  				is_animated = RSG::storage->material_is_animated(p_instance->material_override);
  			} else {
  
  				if (p_instance->base_type == RS::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] : RSG::storage->mesh_surface_get_material(mesh, i);
  
  							if (!mat.is_valid()) {
  								cast_shadows = true;
  							} else {
  
  								if (RSG::storage->material_casts_shadows(mat)) {
  									cast_shadows = true;
  								}
  
  								if (RSG::storage->material_is_animated(mat)) {
  									is_animated = true;
  								}
  
  								RSG::storage->material_update_dependency(mat, p_instance);
  							}
  						}
  
  						if (!cast_shadows) {
  							can_cast_shadows = false;
  						}
  					}
  
  				} else if (p_instance->base_type == RS::INSTANCE_MULTIMESH) {
  					RID mesh = RSG::storage->multimesh_get_mesh(p_instance->base);
  					if (mesh.is_valid()) {
  
  						bool cast_shadows = false;
  
  						int sc = RSG::storage->mesh_get_surface_count(mesh);
  						for (int i = 0; i < sc; i++) {
  
  							RID mat = RSG::storage->mesh_surface_get_material(mesh, i);
  
  							if (!mat.is_valid()) {
  								cast_shadows = true;
  
  							} else {
  
  								if (RSG::storage->material_casts_shadows(mat)) {
  									cast_shadows = true;
  								}
  								if (RSG::storage->material_is_animated(mat)) {
  									is_animated = true;
  								}
  
  								RSG::storage->material_update_dependency(mat, p_instance);
  							}
  						}
  
  						if (!cast_shadows) {
  							can_cast_shadows = false;
  						}
  
  						RSG::storage->base_update_dependency(mesh, p_instance);
  					}
  				} else if (p_instance->base_type == RS::INSTANCE_IMMEDIATE) {
  
  					RID mat = RSG::storage->immediate_get_material(p_instance->base);
  
  					can_cast_shadows = !mat.is_valid() || RSG::storage->material_casts_shadows(mat);
  
  					if (mat.is_valid() && RSG::storage->material_is_animated(mat)) {
  						is_animated = true;
  					}
  
  					if (mat.is_valid()) {
  						RSG::storage->material_update_dependency(mat, p_instance);
  					}
  
  				} else if (p_instance->base_type == RS::INSTANCE_PARTICLES) {
  
  					bool cast_shadows = false;
  
  					int dp = RSG::storage->particles_get_draw_passes(p_instance->base);
  
  					for (int i = 0; i < dp; i++) {
  
  						RID mesh = RSG::storage->particles_get_draw_pass_mesh(p_instance->base, i);
  						if (!mesh.is_valid())
  							continue;
  
  						int sc = RSG::storage->mesh_get_surface_count(mesh);
  						for (int j = 0; j < sc; j++) {
  
  							RID mat = RSG::storage->mesh_surface_get_material(mesh, j);
  
  							if (!mat.is_valid()) {
  								cast_shadows = true;
  							} else {
  
  								if (RSG::storage->material_casts_shadows(mat)) {
  									cast_shadows = true;
  								}
  
  								if (RSG::storage->material_is_animated(mat)) {
  									is_animated = true;
  								}
  
  								RSG::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()) {
  			RSG::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 RenderingServerScene::update_dirty_instances() {
  
  	RSG::storage->update_dirty_resources();
  
  	while (_instance_update_list.first()) {
  
  		_update_dirty_instance(_instance_update_list.first()->self());
  	}
  }
  
  bool RenderingServerScene::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());
  		}
  		RSG::scene_render->free(scenario->reflection_probe_shadow_atlas);
  		RSG::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;
  }
  
  RenderingServerScene *RenderingServerScene::singleton = NULL;
  
  RenderingServerScene::RenderingServerScene() {
  
  	render_pass = 1;
  	singleton = this;
  }
  
  RenderingServerScene::~RenderingServerScene() {
  }
  