#ifndef RENDERINGSERVERSCENE_H
#define RENDERINGSERVERSCENE_H
/*************************************************************************/
/*  rendering_server_scene.h                                                */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2022 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 "servers/rendering/rasterizer.h"

#include "core/containers/self_list.h"
#include "core/math/bvh.h"
#include "core/math/geometry.h"
#include "core/math/octree.h"
#include "core/os/safe_refcount.h"
#include "core/os/semaphore.h"
#include "core/os/thread.h"
#include "portals/portal_renderer.h"

class RenderingServerScene {
public:
	enum {

		MAX_INSTANCE_CULL = 65536,
		MAX_LIGHTS_CULLED = 4096,
		MAX_REFLECTION_PROBES_CULLED = 4096,
		MAX_ROOM_CULL = 32,
		MAX_EXTERIOR_PORTALS = 128,
	};

	uint64_t render_pass;
	static RenderingServerScene *singleton;

	/* EVENT QUEUING */

	void tick();
	void pre_draw(bool p_will_draw);

	/* CAMERA API */

	struct Scenario;

	struct Camera : public RID_Data {
		enum Type {
			PERSPECTIVE,
			ORTHOGONAL,
			FRUSTUM
		};
		Type type;
		float fov;
		float znear, zfar;
		float size;
		Vector2 offset;
		uint32_t visible_layers;
		RID env;

		// transform_prev is only used when using fixed timestep interpolation
		Transform transform;
		Transform transform_prev;

		bool interpolated : 1;
		bool on_interpolate_transform_list : 1;

		bool vaspect : 1;
		TransformInterpolator::Method interpolation_method : 3;

		int32_t previous_room_id_hint;

		Transform get_transform_interpolated() const;

		Camera() {
			visible_layers = 0xFFFFFFFF;
			fov = 70;
			type = PERSPECTIVE;
			znear = 0.05;
			zfar = 100;
			size = 1.0;
			offset = Vector2();
			vaspect = false;
			previous_room_id_hint = -1;
			interpolated = true;
			on_interpolate_transform_list = false;
			interpolation_method = TransformInterpolator::INTERP_LERP;
		}
	};

	mutable RID_Owner<Camera> camera_owner;

	virtual RID camera_create();
	virtual void camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far);
	virtual void camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far);
	virtual void camera_set_frustum(RID p_camera, float p_size, Vector2 p_offset, float p_z_near, float p_z_far);
	virtual void camera_set_transform(RID p_camera, const Transform &p_transform);
	virtual void camera_set_interpolated(RID p_camera, bool p_interpolated);
	virtual void camera_reset_physics_interpolation(RID p_camera);
	virtual void camera_set_cull_mask(RID p_camera, uint32_t p_layers);
	virtual void camera_set_environment(RID p_camera, RID p_env);
	virtual void camera_set_use_vertical_aspect(RID p_camera, bool p_enable);

	/* SCENARIO API */

	struct Instance;

	// common interface for all spatial partitioning schemes
	// this is a bit excessive boilerplatewise but can be removed if we decide to stick with one method

	// note this is actually the BVH id +1, so that visual server can test against zero
	// for validity to maintain compatibility with octree (where 0 indicates invalid)
	typedef uint32_t SpatialPartitionID;

	class SpatialPartitioningScene {
	public:
		virtual SpatialPartitionID create(Instance *p_userdata, const AABB &p_aabb, int p_subindex, bool p_pairable, uint32_t p_pairable_type, uint32_t pairable_mask) = 0;
		virtual void erase(SpatialPartitionID p_handle) = 0;
		virtual void move(SpatialPartitionID p_handle, const AABB &p_aabb) = 0;
		virtual void activate(SpatialPartitionID p_handle, const AABB &p_aabb) {}
		virtual void deactivate(SpatialPartitionID p_handle) {}
		virtual void force_collision_check(SpatialPartitionID p_handle) {}
		virtual void update() {}
		virtual void update_collisions() {}
		virtual void set_pairable(Instance *p_instance, bool p_pairable, uint32_t p_pairable_type, uint32_t p_pairable_mask) = 0;
		virtual int cull_convex(const Vector<Plane> &p_convex, Instance **p_result_array, int p_result_max, uint32_t p_mask = 0xFFFFFFFF) = 0;
		virtual int cull_aabb(const AABB &p_aabb, Instance **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF) = 0;
		virtual int cull_segment(const Vector3 &p_from, const Vector3 &p_to, Instance **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF) = 0;

		typedef void *(*PairCallback)(void *, uint32_t, Instance *, int, uint32_t, Instance *, int);
		typedef void (*UnpairCallback)(void *, uint32_t, Instance *, int, uint32_t, Instance *, int, void *);

		virtual void set_pair_callback(PairCallback p_callback, void *p_userdata) = 0;
		virtual void set_unpair_callback(UnpairCallback p_callback, void *p_userdata) = 0;

		// bvh specific
		virtual void params_set_node_expansion(real_t p_value) {}
		virtual void params_set_pairing_expansion(real_t p_value) {}

		// octree specific
		virtual void set_balance(float p_balance) {}

		virtual ~SpatialPartitioningScene() {}
	};

	class SpatialPartitioningScene_Octree : public SpatialPartitioningScene {
		Octree_CL<Instance, true> _octree;

	public:
		SpatialPartitionID create(Instance *p_userdata, const AABB &p_aabb, int p_subindex, bool p_pairable, uint32_t p_pairable_type, uint32_t pairable_mask);
		void erase(SpatialPartitionID p_handle);
		void move(SpatialPartitionID p_handle, const AABB &p_aabb);
		void set_pairable(Instance *p_instance, bool p_pairable, uint32_t p_pairable_type, uint32_t p_pairable_mask);
		int cull_convex(const Vector<Plane> &p_convex, Instance **p_result_array, int p_result_max, uint32_t p_mask = 0xFFFFFFFF);
		int cull_aabb(const AABB &p_aabb, Instance **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF);
		int cull_segment(const Vector3 &p_from, const Vector3 &p_to, Instance **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF);
		void set_pair_callback(PairCallback p_callback, void *p_userdata);
		void set_unpair_callback(UnpairCallback p_callback, void *p_userdata);
		void set_balance(float p_balance);
	};

	class SpatialPartitioningScene_BVH : public SpatialPartitioningScene {
		template <class T>
		class UserPairTestFunction {
		public:
			static bool user_pair_check(const T *p_a, const T *p_b) {
				// return false if no collision, decided by masks etc
				return true;
			}
		};

		template <class T>
		class UserCullTestFunction {
			// write this logic once for use in all routines
			// double check this as a possible source of bugs in future.
			static bool _cull_pairing_mask_test_hit(uint32_t p_maskA, uint32_t p_typeA, uint32_t p_maskB, uint32_t p_typeB) {
				// double check this as a possible source of bugs in future.
				bool A_match_B = p_maskA & p_typeB;

				if (!A_match_B) {
					bool B_match_A = p_maskB & p_typeA;
					if (!B_match_A) {
						return false;
					}
				}

				return true;
			}

		public:
			static bool user_cull_check(const T *p_a, const T *p_b) {
				DEV_ASSERT(p_a);
				DEV_ASSERT(p_b);

				uint32_t a_mask = p_a->bvh_pairable_mask;
				uint32_t a_type = p_a->bvh_pairable_type;
				uint32_t b_mask = p_b->bvh_pairable_mask;
				uint32_t b_type = p_b->bvh_pairable_type;

				if (!_cull_pairing_mask_test_hit(a_mask, a_type, b_mask, b_type)) {
					return false;
				}

				return true;
			}
		};

	private:
		// Note that SpatialPartitionIDs are +1 based when stored in visual server, to enable 0 to indicate invalid ID.
		BVH_Manager<Instance, 2, true, 256, UserPairTestFunction<Instance>, UserCullTestFunction<Instance>> _bvh;
		Instance *_dummy_cull_object;

		uint32_t find_tree_id_and_collision_mask(bool p_pairable, uint32_t &r_tree_collision_mask) const {
			// "pairable" (lights etc) can pair with geometry (non pairable) or other pairables.
			// Geometry never pairs with other geometry, so we can eliminate geometry - geometry collision checks.

			// Additionally, when lights are made invisible their p_pairable_mask is set to zero to stop their collisions.
			// We could potentially choose `tree_collision_mask` based on whether p_pairable_mask is zero,
			// in order to catch invisible lights, but in practice these instances will already have been deactivated within
			// the BVH so this step is unnecessary. So we can keep the simpler logic of geometry collides with pairable,
			// pairable collides with everything.
			r_tree_collision_mask = !p_pairable ? 2 : 3;

			// Returns tree_id.
			return p_pairable ? 1 : 0;
		}

	public:
		SpatialPartitioningScene_BVH();
		~SpatialPartitioningScene_BVH();
		SpatialPartitionID create(Instance *p_userdata, const AABB &p_aabb, int p_subindex, bool p_pairable, uint32_t p_pairable_type, uint32_t p_pairable_mask);
		void erase(SpatialPartitionID p_handle);
		void move(SpatialPartitionID p_handle, const AABB &p_aabb);
		void activate(SpatialPartitionID p_handle, const AABB &p_aabb);
		void deactivate(SpatialPartitionID p_handle);
		void force_collision_check(SpatialPartitionID p_handle);
		void update();
		void update_collisions();
		void set_pairable(Instance *p_instance, bool p_pairable, uint32_t p_pairable_type, uint32_t p_pairable_mask);
		int cull_convex(const Vector<Plane> &p_convex, Instance **p_result_array, int p_result_max, uint32_t p_mask = 0xFFFFFFFF);
		int cull_aabb(const AABB &p_aabb, Instance **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF);
		int cull_segment(const Vector3 &p_from, const Vector3 &p_to, Instance **p_result_array, int p_result_max, int *p_subindex_array = nullptr, uint32_t p_mask = 0xFFFFFFFF);
		void set_pair_callback(PairCallback p_callback, void *p_userdata);
		void set_unpair_callback(UnpairCallback p_callback, void *p_userdata);

		void params_set_node_expansion(real_t p_value) { _bvh.params_set_node_expansion(p_value); }
		void params_set_pairing_expansion(real_t p_value) { _bvh.params_set_pairing_expansion(p_value); }
	};

	struct Scenario : RID_Data {
		RS::ScenarioDebugMode debug;
		RID self;

		SpatialPartitioningScene *sps;
		PortalRenderer _portal_renderer;

		List<Instance *> directional_lights;
		RID environment;
		RID fallback_environment;
		RID reflection_probe_shadow_atlas;
		RID reflection_atlas;

		SelfList<Instance>::List instances;

		Scenario();
		~Scenario() { memdelete(sps); }
	};

	mutable RID_Owner<Scenario> scenario_owner;

	static void *_instance_pair(void *p_self, SpatialPartitionID, Instance *p_A, int, SpatialPartitionID, Instance *p_B, int);
	static void _instance_unpair(void *p_self, SpatialPartitionID, Instance *p_A, int, SpatialPartitionID, Instance *p_B, int, void *);

	virtual RID scenario_create();

	virtual void scenario_set_debug(RID p_scenario, RS::ScenarioDebugMode p_debug_mode);
	virtual void scenario_set_environment(RID p_scenario, RID p_environment);
	virtual void scenario_set_fallback_environment(RID p_scenario, RID p_environment);
	virtual void scenario_set_reflection_atlas_size(RID p_scenario, int p_size, int p_subdiv);

	/* INSTANCING API */

	struct InstanceBaseData {
		virtual ~InstanceBaseData() {}
	};

	struct Instance : RasterizerScene::InstanceBase {
		RID self;
		//scenario stuff
		SpatialPartitionID spatial_partition_id;

		// rooms & portals
		OcclusionHandle occlusion_handle; // handle of instance in occlusion system (or 0)
		RenderingServer::InstancePortalMode portal_mode;

		Scenario *scenario;
		SelfList<Instance> scenario_item;

		//aabb stuff
		bool update_aabb;
		bool update_materials;

		SelfList<Instance> update_item;

		AABB aabb;
		AABB transformed_aabb;
		AABB *custom_aabb; // <Zylann> would using aabb directly with a bool be better?
		float sorting_offset;
		bool use_aabb_center;
		float extra_margin;
		uint32_t object_id;

		float lod_begin;
		float lod_end;
		float lod_begin_hysteresis;
		float lod_end_hysteresis;
		RID lod_instance;

		// These are used for the user cull testing function
		// in the BVH, this is precached rather than recalculated each time.
		uint32_t bvh_pairable_mask;
		uint32_t bvh_pairable_type;

		uint64_t last_render_pass;
		uint64_t last_frame_pass;

		uint64_t version; // changes to this, and changes to base increase version

		InstanceBaseData *base_data;

		virtual void base_removed() {
			singleton->instance_set_base(self, RID());
		}

		virtual void base_changed(bool p_aabb, bool p_materials) {
			singleton->_instance_queue_update(this, p_aabb, p_materials);
		}

		Instance() :
				scenario_item(this),
				update_item(this) {
			spatial_partition_id = 0;
			scenario = nullptr;

			update_aabb = false;
			update_materials = false;

			extra_margin = 0;

			object_id = 0;
			visible = true;

			occlusion_handle = 0;
			portal_mode = RenderingServer::InstancePortalMode::INSTANCE_PORTAL_MODE_STATIC;

			lod_begin = 0;
			lod_end = 0;
			lod_begin_hysteresis = 0;
			lod_end_hysteresis = 0;

			bvh_pairable_mask = 0;
			bvh_pairable_type = 0;

			last_render_pass = 0;
			last_frame_pass = 0;
			version = 1;
			base_data = nullptr;

			custom_aabb = nullptr;
			sorting_offset = 0.0f;
			use_aabb_center = true;
		}

		~Instance() {
			if (base_data) {
				memdelete(base_data);
			}
			if (custom_aabb) {
				memdelete(custom_aabb);
			}
		}
	};

	SelfList<Instance>::List _instance_update_list;

	// fixed timestep interpolation
	virtual void set_physics_interpolation_enabled(bool p_enabled);

	struct InterpolationData {
		void notify_free_camera(RID p_rid, Camera &r_camera);
		void notify_free_instance(RID p_rid, Instance &r_instance);
		LocalVector<RID> instance_interpolate_update_list;
		LocalVector<RID> instance_transform_update_lists[2];
		LocalVector<RID> *instance_transform_update_list_curr = &instance_transform_update_lists[0];
		LocalVector<RID> *instance_transform_update_list_prev = &instance_transform_update_lists[1];
		LocalVector<RID> instance_teleport_list;

		LocalVector<RID> camera_transform_update_lists[2];
		LocalVector<RID> *camera_transform_update_list_curr = &camera_transform_update_lists[0];
		LocalVector<RID> *camera_transform_update_list_prev = &camera_transform_update_lists[1];
		LocalVector<RID> camera_teleport_list;

		bool interpolation_enabled = false;
	} _interpolation_data;

	void _instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_materials = false);

	struct InstanceGeometryData : public InstanceBaseData {
		List<Instance *> lighting;
		bool lighting_dirty;
		bool can_cast_shadows;
		bool material_is_animated;

		List<Instance *> reflection_probes;
		bool reflection_dirty;

		InstanceGeometryData() {
			lighting_dirty = true;
			reflection_dirty = true;
			can_cast_shadows = true;
			material_is_animated = true;
		}
	};

	struct InstanceReflectionProbeData : public InstanceBaseData {
		Instance *owner;

		struct PairInfo {
			List<Instance *>::Element *L; //reflection iterator in geometry
			Instance *geometry;
		};
		List<PairInfo> geometries;

		RID instance;
		bool reflection_dirty;
		SelfList<InstanceReflectionProbeData> update_list;

		int render_step;
		int32_t previous_room_id_hint;

		InstanceReflectionProbeData() :
				update_list(this) {
			reflection_dirty = true;
			render_step = -1;
			previous_room_id_hint = -1;
		}
	};

	SelfList<InstanceReflectionProbeData>::List reflection_probe_render_list;

	struct InstanceLightData : public InstanceBaseData {
		struct PairInfo {
			List<Instance *>::Element *L; //light iterator in geometry
			Instance *geometry;
		};

		RID instance;
		uint64_t last_version;
		List<Instance *>::Element *D; // directional light in scenario

		bool shadow_dirty;

		List<PairInfo> geometries;

		int32_t previous_room_id_hint;

		InstanceLightData() {
			shadow_dirty = true;
			D = nullptr;
			last_version = 0;
			previous_room_id_hint = -1;
		}
	};

	int instance_cull_count;
	Instance *instance_cull_result[MAX_INSTANCE_CULL];
	Instance *instance_shadow_cull_result[MAX_INSTANCE_CULL]; //used for generating shadowmaps
	Instance *light_cull_result[MAX_LIGHTS_CULLED];
	RID light_instance_cull_result[MAX_LIGHTS_CULLED];
	int light_cull_count;
	int directional_light_count;
	RID reflection_probe_instance_cull_result[MAX_REFLECTION_PROBES_CULLED];
	int reflection_probe_cull_count;

	RID_Owner<Instance> instance_owner;

	virtual RID instance_create();

	virtual void instance_set_base(RID p_instance, RID p_base);
	virtual void instance_set_scenario(RID p_instance, RID p_scenario);
	virtual void instance_set_layer_mask(RID p_instance, uint32_t p_mask);
	virtual void instance_set_pivot_data(RID p_instance, float p_sorting_offset, bool p_use_aabb_center);
	virtual void instance_set_transform(RID p_instance, const Transform &p_transform);
	virtual void instance_set_interpolated(RID p_instance, bool p_interpolated);
	virtual void instance_reset_physics_interpolation(RID p_instance);
	virtual void instance_attach_object_instance_id(RID p_instance, ObjectID p_id);
	virtual void instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight);
	virtual void instance_set_surface_material(RID p_instance, int p_surface, RID p_material);
	virtual void instance_set_visible(RID p_instance, bool p_visible);

	virtual void instance_set_custom_aabb(RID p_instance, AABB p_aabb);

	virtual void instance_attach_skeleton(RID p_instance, RID p_skeleton);
	virtual void instance_set_exterior(RID p_instance, bool p_enabled);

	virtual void instance_set_extra_visibility_margin(RID p_instance, real_t p_margin);

	// Portals
	virtual void instance_set_portal_mode(RID p_instance, RenderingServer::InstancePortalMode p_mode);
	bool _instance_get_transformed_aabb(RID p_instance, AABB &r_aabb);
	bool _instance_get_transformed_aabb_for_occlusion(VSInstance *p_instance, AABB &r_aabb) const {
		r_aabb = ((Instance *)p_instance)->transformed_aabb;
		return ((Instance *)p_instance)->portal_mode != RenderingServer::INSTANCE_PORTAL_MODE_GLOBAL;
	}
	void *_instance_get_from_rid(RID p_instance);
	bool _instance_cull_check(VSInstance *p_instance, uint32_t p_cull_mask) const {
		uint32_t pairable_type = 1 << ((Instance *)p_instance)->base_type;
		return pairable_type & p_cull_mask;
	}
	ObjectID _instance_get_object_ID(VSInstance *p_instance) const {
		if (p_instance) {
			return ((Instance *)p_instance)->object_id;
		}
		return 0;
	}

private:
	void _instance_create_occlusion_rep(Instance *p_instance);
	void _instance_destroy_occlusion_rep(Instance *p_instance);

public:
	struct Ghost : RID_Data {
		// all interactions with actual ghosts are indirect, as the ghost is part of the scenario
		Scenario *scenario = nullptr;
		uint32_t object_id = 0;
		RGhostHandle rghost_handle = 0; // handle in occlusion system (or 0)
		AABB aabb;
		virtual ~Ghost() {
			if (scenario) {
				if (rghost_handle) {
					scenario->_portal_renderer.rghost_destroy(rghost_handle);
					rghost_handle = 0;
				}
				scenario = nullptr;
			}
		}
	};
	RID_Owner<Ghost> ghost_owner;

	virtual RID ghost_create();
	virtual void ghost_set_scenario(RID p_ghost, RID p_scenario, ObjectID p_id, const AABB &p_aabb);
	virtual void ghost_update(RID p_ghost, const AABB &p_aabb);

private:
	void _ghost_create_occlusion_rep(Ghost *p_ghost);
	void _ghost_destroy_occlusion_rep(Ghost *p_ghost);

public:
	/* PORTALS API */

	struct Portal : RID_Data {
		// all interactions with actual portals are indirect, as the portal is part of the scenario
		uint32_t scenario_portal_id = 0;
		Scenario *scenario = nullptr;
		virtual ~Portal() {
			if (scenario) {
				scenario->_portal_renderer.portal_destroy(scenario_portal_id);
				scenario = nullptr;
				scenario_portal_id = 0;
			}
		}
	};
	RID_Owner<Portal> portal_owner;

	virtual RID portal_create();
	virtual void portal_set_scenario(RID p_portal, RID p_scenario);
	virtual void portal_set_geometry(RID p_portal, const Vector<Vector3> &p_points, real_t p_margin);
	virtual void portal_link(RID p_portal, RID p_room_from, RID p_room_to, bool p_two_way);
	virtual void portal_set_active(RID p_portal, bool p_active);

	/* ROOMGROUPS API */

	struct RoomGroup : RID_Data {
		// all interactions with actual roomgroups are indirect, as the roomgroup is part of the scenario
		uint32_t scenario_roomgroup_id = 0;
		Scenario *scenario = nullptr;
		virtual ~RoomGroup() {
			if (scenario) {
				scenario->_portal_renderer.roomgroup_destroy(scenario_roomgroup_id);
				scenario = nullptr;
				scenario_roomgroup_id = 0;
			}
		}
	};
	RID_Owner<RoomGroup> roomgroup_owner;

	virtual RID roomgroup_create();
	virtual void roomgroup_prepare(RID p_roomgroup, ObjectID p_roomgroup_object_id);
	virtual void roomgroup_set_scenario(RID p_roomgroup, RID p_scenario);
	virtual void roomgroup_add_room(RID p_roomgroup, RID p_room);

	/* OCCLUDERS API */

	struct OccluderInstance : RID_Data {
		uint32_t scenario_occluder_id = 0;
		Scenario *scenario = nullptr;
		virtual ~OccluderInstance() {
			if (scenario) {
				scenario->_portal_renderer.occluder_instance_destroy(scenario_occluder_id);
				scenario = nullptr;
				scenario_occluder_id = 0;
			}
		}
	};
	RID_Owner<OccluderInstance> occluder_instance_owner;

	struct OccluderResource : RID_Data {
		uint32_t occluder_resource_id = 0;
		void destroy(PortalResources &r_portal_resources) {
			r_portal_resources.occluder_resource_destroy(occluder_resource_id);
			occluder_resource_id = 0;
		}
		virtual ~OccluderResource() {
			DEV_ASSERT(occluder_resource_id == 0);
		}
	};
	RID_Owner<OccluderResource> occluder_resource_owner;

	virtual RID occluder_instance_create();
	virtual void occluder_instance_set_scenario(RID p_occluder_instance, RID p_scenario);
	virtual void occluder_instance_link_resource(RID p_occluder_instance, RID p_occluder_resource);
	virtual void occluder_instance_set_transform(RID p_occluder_instance, const Transform &p_xform);
	virtual void occluder_instance_set_active(RID p_occluder_instance, bool p_active);

	virtual RID occluder_resource_create();
	virtual void occluder_resource_prepare(RID p_occluder_resource, RenderingServer::OccluderType p_type);
	virtual void occluder_resource_spheres_update(RID p_occluder_resource, const Vector<Plane> &p_spheres);
	virtual void occluder_resource_mesh_update(RID p_occluder_resource, const Geometry::OccluderMeshData &p_mesh_data);
	virtual void set_use_occlusion_culling(bool p_enable);

	// editor only .. slow
	virtual Geometry::MeshData occlusion_debug_get_current_polys(RID p_scenario) const;
	const PortalResources &get_portal_resources() const {
		return _portal_resources;
	}
	PortalResources &get_portal_resources() {
		return _portal_resources;
	}

	/* ROOMS API */

	struct Room : RID_Data {
		// all interactions with actual rooms are indirect, as the room is part of the scenario
		uint32_t scenario_room_id = 0;
		Scenario *scenario = nullptr;
		virtual ~Room() {
			if (scenario) {
				scenario->_portal_renderer.room_destroy(scenario_room_id);
				scenario = nullptr;
				scenario_room_id = 0;
			}
		}
	};
	RID_Owner<Room> room_owner;

	virtual RID room_create();
	virtual void room_set_scenario(RID p_room, RID p_scenario);
	virtual void room_add_instance(RID p_room, RID p_instance, const AABB &p_aabb, const Vector<Vector3> &p_object_pts);
	virtual void room_add_ghost(RID p_room, ObjectID p_object_id, const AABB &p_aabb);
	virtual void room_set_bound(RID p_room, ObjectID p_room_object_id, const Vector<Plane> &p_convex, const AABB &p_aabb, const Vector<Vector3> &p_verts);
	virtual void room_prepare(RID p_room, int32_t p_priority);
	virtual void rooms_and_portals_clear(RID p_scenario);
	virtual void rooms_unload(RID p_scenario, String p_reason);
	virtual void rooms_finalize(RID p_scenario, bool p_generate_pvs, bool p_cull_using_pvs, bool p_use_secondary_pvs, bool p_use_signals, String p_pvs_filename, bool p_use_simple_pvs, bool p_log_pvs_generation);
	virtual void rooms_override_camera(RID p_scenario, bool p_override, const Vector3 &p_point, const Vector<Plane> *p_convex);
	virtual void rooms_set_active(RID p_scenario, bool p_active);
	virtual void rooms_set_params(RID p_scenario, int p_portal_depth_limit, real_t p_roaming_expansion_margin);
	virtual void rooms_set_debug_feature(RID p_scenario, RenderingServer::RoomsDebugFeature p_feature, bool p_active);
	virtual void rooms_update_gameplay_monitor(RID p_scenario, const Vector<Vector3> &p_camera_positions);

	// don't use this in a game
	virtual bool rooms_is_loaded(RID p_scenario) const;

	virtual void callbacks_register(RenderingServerCallbacks *p_callbacks);
	RenderingServerCallbacks *get_callbacks() const {
		return _rendering_server_callbacks;
	}

	// don't use these in a game!
	virtual Vector<ObjectID> instances_cull_aabb(const AABB &p_aabb, RID p_scenario = RID()) const;
	virtual Vector<ObjectID> instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario = RID()) const;
	virtual Vector<ObjectID> instances_cull_convex(const Vector<Plane> &p_convex, RID p_scenario = RID()) const;

	// internal (uses portals when available)
	int _cull_convex_from_point(Scenario *p_scenario, const Transform &p_cam_transform, const Projection &p_cam_projection, const Vector<Plane> &p_convex, Instance **p_result_array, int p_result_max, int32_t &r_previous_room_id_hint, uint32_t p_mask = 0xFFFFFFFF);
	void _rooms_instance_update(Instance *p_instance, const AABB &p_aabb);

	virtual void instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled);
	virtual void instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting);
	virtual void instance_geometry_set_material_override(RID p_instance, RID p_material);
	virtual void instance_geometry_set_material_overlay(RID p_instance, RID p_material);

	virtual void instance_geometry_set_draw_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin);
	virtual void instance_geometry_set_as_instance_lod(RID p_instance, RID p_as_lod_of_instance);

	_FORCE_INLINE_ void _update_instance(Instance *p_instance);
	_FORCE_INLINE_ void _update_instance_aabb(Instance *p_instance);
	_FORCE_INLINE_ void _update_dirty_instance(Instance *p_instance);

	_FORCE_INLINE_ bool _light_instance_update_shadow(Instance *p_instance, const Transform p_cam_transform, const Projection &p_cam_projection, bool p_cam_orthogonal, RID p_shadow_atlas, Scenario *p_scenario, uint32_t p_visible_layers = 0xFFFFFF);

	void _prepare_scene(const Transform p_cam_transform, const Projection &p_cam_projection, bool p_cam_orthogonal, RID p_force_environment, uint32_t p_visible_layers, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, int32_t &r_previous_room_id_hint);
	void _render_scene(const Transform p_cam_transform, const Projection &p_cam_projection, const int p_eye, bool p_cam_orthogonal, RID p_force_environment, RID p_scenario, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass);
	void render_empty_scene(RID p_scenario, RID p_shadow_atlas);

	void render_camera(RID p_camera, RID p_scenario, Size2 p_viewport_size, RID p_shadow_atlas);
	void update_dirty_instances();

	// interpolation
	void update_interpolation_tick(bool p_process = true);
	void update_interpolation_frame(bool p_process = true);

	bool free(RID p_rid);

private:
	bool _use_bvh;
	RenderingServerCallbacks *_rendering_server_callbacks;
	PortalResources _portal_resources;

public:
	RenderingServerScene();
	virtual ~RenderingServerScene();
};

#endif // RENDERINGSERVERSCENE_H