pandemonium_engine/servers/visual/portals/portal_tracer.cpp

/*************************************************************************/
/*  portal_tracer.cpp                                                    */
/*************************************************************************/
/*                       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 "portal_tracer.h"

#include "portal_renderer.h"
#include "servers/visual/visual_server_globals.h"
#include "servers/visual/visual_server_scene.h"

PortalTracer::PlanesPool::PlanesPool() {
	reset();

	// preallocate the vectors to a reasonable size
	for (int n = 0; n < POOL_MAX; n++) {
		_planes[n].resize(32);
	}
}

void PortalTracer::PlanesPool::reset() {
	for (int n = 0; n < POOL_MAX; n++) {
		_freelist[n] = POOL_MAX - n - 1;
	}

	_num_free = POOL_MAX;
}

unsigned int PortalTracer::PlanesPool::request() {
	if (!_num_free) {
		return -1;
	}

	_num_free--;
	return _freelist[_num_free];
}

void PortalTracer::PlanesPool::free(unsigned int ui) {
	DEV_ASSERT(ui < POOL_MAX);
	DEV_ASSERT(_num_free < POOL_MAX);

	_freelist[_num_free] = ui;
	_num_free++;
}

void PortalTracer::trace_debug_sprawl(PortalRenderer &p_portal_renderer, const Vector3 &p_pos, int p_start_room_id, TraceResult &r_result) {
	_portal_renderer = &p_portal_renderer;
	_trace_start_point = p_pos;
	_result = &r_result;

	// all the statics should be not hit to start with
	_result->clear();

	// new test, new tick, to prevent hitting objects more than once
	// on a test.
	_tick++;

	// if the camera is not in a room do nothing
	if (p_start_room_id == -1) {
		return;
	}

	trace_debug_sprawl_recursive(0, p_start_room_id);
}

void PortalTracer::trace(PortalRenderer &p_portal_renderer, const Vector3 &p_pos, const LocalVector<Plane> &p_planes, int p_start_room_id, TraceResult &r_result) {
	// store local versions to prevent passing around recursive functions
	_portal_renderer = &p_portal_renderer;
	_trace_start_point = p_pos;
	_result = &r_result;

	// The near and far clipping planes needs special treatment. The problem is, if it is
	// say a metre from the camera, it will clip out a portal immediately in front of the camera.
	// as a result we want to use the near clipping plane for objects, but construct a fake
	// near plane at exactly the position of the camera, to clip out portals that are behind us.
	_near_and_far_planes[0] = p_planes[0];
	_near_and_far_planes[1] = p_planes[1];

	// all the statics should be not hit to start with
	_result->clear();

	// new test, new tick, to prevent hitting objects more than once
	// on a test.
	_tick++;

	// if the camera is not in a room do nothing
	// (this will return no hits, but is unlikely because the find_rooms lookup will return the nearest
	// room even if not inside)
	if (p_start_room_id == -1) {
		return;
	}

	// start off the trace with the planes from the camera
	LocalVector<Plane> cam_planes;
	cam_planes = p_planes;

	if (p_portal_renderer.get_cull_using_pvs()) {
		trace_pvs(p_start_room_id, cam_planes);
	} else {
		// alternative : instead of copying straight, we create the first (near) clipping
		// plane manually, at 0 distance from the camera. This ensures that portals will not be
		// missed, while still culling portals and objects behind us. If we use the actual near clipping plane
		// then a portal in front of the camera may not be seen through, giving glitches
		cam_planes[0] = Plane(p_pos, cam_planes[0].normal);

		TraceParams params;
		params.use_pvs = p_portal_renderer.get_pvs().is_loaded();

		// create bitfield
		if (params.use_pvs) {
			const PVS &pvs = _portal_renderer->get_pvs();
			if (!pvs.get_pvs_size()) {
				params.use_pvs = false;
			} else {
				// decompress a simple to read roomlist bitfield (could use bits maybe but bytes ok for now)
				params.decompressed_room_pvs = nullptr;
				params.decompressed_room_pvs = (uint8_t *)alloca(sizeof(uint8_t) * pvs.get_pvs_size());
				memset(params.decompressed_room_pvs, 0, sizeof(uint8_t) * pvs.get_pvs_size());
				const VSRoom &source_room = _portal_renderer->get_room(p_start_room_id);

				for (int n = 0; n < source_room._pvs_size; n++) {
					int room_id = pvs.get_pvs_room_id(source_room._pvs_first + n);
					params.decompressed_room_pvs[room_id] = 255;
				}
			}
		}

		trace_recursive(params, 0, p_start_room_id, cam_planes);
	}
}

void PortalTracer::cull_roamers(const VSRoom &p_room, const LocalVector<Plane> &p_planes) {
	int num_roamers = p_room._roamer_pool_ids.size();

	for (int n = 0; n < num_roamers; n++) {
		uint32_t pool_id = p_room._roamer_pool_ids[n];

		PortalRenderer::Moving &moving = _portal_renderer->get_pool_moving(pool_id);

		// done already?
		if (moving.last_tick_hit == _tick) {
			continue;
		}

		if (test_cull_inside(moving.exact_aabb, p_planes)) {
			if (!_occlusion_culler.cull_aabb(moving.exact_aabb)) {
				// mark as done (and on visible list)
				moving.last_tick_hit = _tick;

				_result->visible_roamer_pool_ids.push_back(pool_id);
			}
		}
	}
}

void PortalTracer::cull_statics_debug_sprawl(const VSRoom &p_room) {
	int num_statics = p_room._static_ids.size();

	for (int n = 0; n < num_statics; n++) {
		uint32_t static_id = p_room._static_ids[n];

		// VSStatic &stat = _portal_renderer->get_static(static_id);

		// deal with dynamic stats
		// if (stat.dynamic) {
		// VSG::scene->_instance_get_transformed_aabb(stat.instance, stat.aabb);
		// }

		// set the visible bit if not set
		if (!_result->bf_visible_statics.check_and_set(static_id)) {
			_result->visible_static_ids.push_back(static_id);
		}
	}
}

void PortalTracer::cull_statics(const VSRoom &p_room, const LocalVector<Plane> &p_planes) {
	int num_statics = p_room._static_ids.size();

	for (int n = 0; n < num_statics; n++) {
		uint32_t static_id = p_room._static_ids[n];

		VSStatic &stat = _portal_renderer->get_static(static_id);

		// deal with dynamic stats
		if (stat.dynamic) {
			VSG::scene->_instance_get_transformed_aabb(stat.instance, stat.aabb);
		}

		// estimate the radius .. for now
		const AABB &bb = stat.aabb;

		// print("\t\t\tculling object " + pObj->get_name());

		if (test_cull_inside(bb, p_planes)) {
			if (_occlusion_culler.cull_aabb(bb)) {
				continue;
			}

			// bypass the bitfield for now and just show / hide
			//stat.show(bShow);

			// set the visible bit if not set
			if (_result->bf_visible_statics.check_and_set(static_id)) {
				// if wasn't previously set, add to the visible list
				_result->visible_static_ids.push_back(static_id);
			}
		}

	} // for n through statics
}

int PortalTracer::trace_globals(const LocalVector<Plane> &p_planes, VSInstance **p_result_array, int first_result, int p_result_max, uint32_t p_mask, bool p_override_camera) {
	uint32_t num_globals = _portal_renderer->get_num_moving_globals();
	int current_result = first_result;

	if (!p_override_camera) {
		for (uint32_t n = 0; n < num_globals; n++) {
			const PortalRenderer::Moving &moving = _portal_renderer->get_moving_global(n);

#ifdef PORTAL_RENDERER_STORE_MOVING_RIDS
			// debug check the instance is valid
			void *vss_instance = VSG::scene->_instance_get_from_rid(moving.instance_rid);

			if (vss_instance) {
#endif
				if (test_cull_inside(moving.exact_aabb, p_planes, false)) {
					if (VSG::scene->_instance_cull_check(moving.instance, p_mask)) {
						p_result_array[current_result++] = moving.instance;

						// full up?
						if (current_result >= p_result_max) {
							return current_result;
						}
					}
				}

#ifdef PORTAL_RENDERER_STORE_MOVING_RIDS
			} else {
				WARN_PRINT("vss instance is null " + PortalRenderer::_addr_to_string(moving.instance));
			}
#endif
		}
	} // if not override camera
	else {
		// If we are overriding the camera there is a potential problem in the editor:
		// gizmos BEHIND the override camera will not be drawn.
		// As this should be editor only and performance is not critical, we will just disable
		// frustum culling for global objects when the camera is overridden.
		for (uint32_t n = 0; n < num_globals; n++) {
			const PortalRenderer::Moving &moving = _portal_renderer->get_moving_global(n);

			if (VSG::scene->_instance_cull_check(moving.instance, p_mask)) {
				p_result_array[current_result++] = moving.instance;

				// full up?
				if (current_result >= p_result_max) {
					return current_result;
				}
			}
		}
	} // if override camera

	return current_result;
}

void PortalTracer::trace_debug_sprawl_recursive(int p_depth, int p_room_id) {
	if (p_depth > 1) {
		return;
	}

	// prevent too much depth
	ERR_FAIL_COND_MSG(p_depth > 8, "Portal Depth Limit reached");

	// get the room
	const VSRoom &room = _portal_renderer->get_room(p_room_id);

	int num_portals = room._portal_ids.size();

	for (int p = 0; p < num_portals; p++) {
		const VSPortal &portal = _portal_renderer->get_portal(room._portal_ids[p]);

		if (!portal._active) {
			continue;
		}

		cull_statics_debug_sprawl(room);

		// everything depends on whether the portal is incoming or outgoing.
		int outgoing = 1;

		int room_a_id = portal._linkedroom_ID[0];
		if (room_a_id != p_room_id) {
			outgoing = 0;
			DEV_ASSERT(portal._linkedroom_ID[1] == p_room_id);
		}

		// trace through this portal to the next room
		int linked_room_id = portal._linkedroom_ID[outgoing];

		if (linked_room_id != -1) {
			trace_debug_sprawl_recursive(p_depth + 1, linked_room_id);
		} // if a linked room exists

	} // for p through portals
}

void PortalTracer::trace_pvs(int p_source_room_id, const LocalVector<Plane> &p_planes) {
	const PVS &pvs = _portal_renderer->get_pvs();
	const VSRoom &source_room = _portal_renderer->get_room(p_source_room_id);

	for (int r = 0; r < source_room._pvs_size; r++) {
		int room_id = pvs.get_pvs_room_id(source_room._pvs_first + r);

		// get the room
		const VSRoom &room = _portal_renderer->get_room(room_id);

		cull_statics(room, p_planes);
		cull_roamers(room, p_planes);
	}
}

void PortalTracer::trace_recursive(const TraceParams &p_params, int p_depth, int p_room_id, const LocalVector<Plane> &p_planes, int p_from_external_room_id) {
	// prevent too much depth
	if (p_depth > _depth_limit) {
		WARN_PRINT_ONCE("Portal Depth Limit reached (seeing through too many portals)");
		return;
	}

	// get the room
	const VSRoom &room = _portal_renderer->get_room(p_room_id);

	// set up the occlusion culler as a one off
	_occlusion_culler.prepare(*_portal_renderer, room, _trace_start_point, p_planes, &_near_and_far_planes[0]);

	cull_statics(room, p_planes);
	cull_roamers(room, p_planes);

	int num_portals = room._portal_ids.size();

	for (int p = 0; p < num_portals; p++) {
		const VSPortal &portal = _portal_renderer->get_portal(room._portal_ids[p]);

		// portals can be switched on and off at runtime, like opening and closing a door
		if (!portal._active) {
			continue;
		}

		// everything depends on whether the portal is incoming or outgoing.
		// if incoming we reverse the logic.
		int outgoing = 1;

		int room_a_id = portal._linkedroom_ID[0];
		if (room_a_id != p_room_id) {
			outgoing = 0;
			DEV_ASSERT(portal._linkedroom_ID[1] == p_room_id);
		}

		// trace through this portal to the next room
		int linked_room_id = portal._linkedroom_ID[outgoing];

		// cull by PVS
		if (p_params.use_pvs && (!p_params.decompressed_room_pvs[linked_room_id])) {
			continue;
		}

		// cull by portal angle to camera.

		// much better way of culling portals by direction to camera...
		// instead of using dot product with a varying view direction, we simply find which side of the portal
		// plane the camera is on! If it is behind, the portal can be seen through, if in front, it can't
		real_t dist_cam = portal._plane.distance_to(_trace_start_point);

		if (!outgoing) {
			dist_cam = -dist_cam;
		}

		if (dist_cam >= 0.0) {
			continue;
		}

		// is it culled by the planes?
		VSPortal::ClipResult overall_res = VSPortal::ClipResult::CLIP_INSIDE;

		// while clipping to the planes we maintain a list of partial planes, so we can add them to the
		// recursive next iteration of planes to check
		static LocalVector<int> partial_planes;
		partial_planes.clear();

		// for portals, we want to ignore the near clipping plane, as we might be right on the edge of a doorway
		// and still want to look through the portal.
		// so earlier we have set it that the first plane (ASSUMING that plane zero is the near clipping plane)
		// starts from the camera position, and NOT the actual near clipping plane.
		// if we need quite a distant near plane, we may need a different strategy.
		for (uint32_t l = 0; l < p_planes.size(); l++) {
			VSPortal::ClipResult res = portal.clip_with_plane(p_planes[l]);

			switch (res) {
				case VSPortal::ClipResult::CLIP_OUTSIDE: {
					overall_res = res;
				} break;
				case VSPortal::ClipResult::CLIP_PARTIAL: {
					// if the portal intersects one of the planes, we should take this plane into account
					// in the next call of this recursive trace, because it can be used to cull out more objects
					overall_res = res;
					partial_planes.push_back(l);
				} break;
				default: // suppress warning
					break;
			}

			// if the portal was totally outside the 'frustum' then we can ignore it
			if (overall_res == VSPortal::ClipResult::CLIP_OUTSIDE)
				break;
		}

		// this portal is culled
		if (overall_res == VSPortal::ClipResult::CLIP_OUTSIDE) {
			continue;
		}

		// Don't allow portals from internal to external room to be followed
		// if the external room has already been processed in this trace stack. This prevents
		// unneeded processing, and also prevents recursive feedback where you
		// see into internal room -> external room and back into the same internal room
		// via the same portal.
		if (portal._internal && (linked_room_id != -1)) {
			if (outgoing) {
				if (linked_room_id == p_from_external_room_id) {
					continue;
				}
			} else {
				// We are entering an internal portal from an external room.
				// set the external room id, so we can recognise this when we are
				// later exiting the internal rooms.
				// Note that as we can only store 1 previous external room, this system
				// won't work completely correctly when you have 2 levels of internal room
				// and you can see from roomgroup a -> b -> c. However this should just result
				// in a little slower culling for that particular view, and hopefully will not break
				// with recursive loop looking through the same portal multiple times. (don't think this
				// is possible in this scenario).
				p_from_external_room_id = p_room_id;
			}
		}

		// occlusion culling of portals
		if (_occlusion_culler.cull_sphere(portal._pt_center, portal._bounding_sphere_radius)) {
			continue;
		}

		// hopefully the portal actually leads somewhere...
		if (linked_room_id != -1) {
			// we need some new planes
			unsigned int pool_mem = _planes_pool.request();

			// if the planes pool is not empty, we got some planes, and can recurse
			if (pool_mem != (unsigned int)-1) {
				// get a new vector of planes from the pool
				LocalVector<Plane> &new_planes = _planes_pool.get(pool_mem);

				// makes sure there are none left over (as the pool may not clear them)
				new_planes.clear();

				// if portal is totally inside the planes, don't copy the old planes ..
				// i.e. we can now cull using the portal and forget about the rest of the frustum (yay)
				// note that this loses the far clipping plane .. but that shouldn't be important usually?
				// (maybe we might need to account for this in future .. look for issues)
				if (overall_res != VSPortal::ClipResult::CLIP_INSIDE) {
					// if it WASN'T totally inside the existing frustum, we also need to add any existing planes
					// that cut the portal.
					for (uint32_t n = 0; n < partial_planes.size(); n++) {
						new_planes.push_back(p_planes[partial_planes[n]]);
					}
				}

				// we will always add the portals planes. This could probably be optimized, as some
				// portal planes may be culled out by partial planes... NYI
				portal.add_planes(_trace_start_point, new_planes, outgoing != 0);

				// always add the far plane. It is likely the portal is inside the far plane,
				// but it is still needed in future for culling portals and objects.
				// note that there is a small possibility of far plane being added twice here
				// in some situations, but I don't think it should be a problem.
				// The fake near plane BTW is almost never added (otherwise it would prematurely
				// break traversal through the portals), so near clipping must be done
				// explicitly on objects.
				new_planes.push_back(_near_and_far_planes[1]);

				// go and do the whole lot again in the next room
				trace_recursive(p_params, p_depth + 1, linked_room_id, new_planes, p_from_external_room_id);

				// no longer need these planes, return them to the pool
				_planes_pool.free(pool_mem);

			} // pool mem allocated
			else {
				// planes pool is empty!
				// This will happen if the view goes through shedloads of portals
				// The solution is either to increase the plane pool size, or not build levels
				// with views through multiple portals. Looking through multiple portals is likely to be
				// slow anyway because of the number of planes to test.
				WARN_PRINT_ONCE("planes pool is empty");
				// note we also have a depth check at the top of this function. Which will probably get hit
				// before the pool gets empty.
			}

		} // if a linked room exists
	} // for p through portals
}

int PortalTracer::occlusion_cull(PortalRenderer &p_portal_renderer, const Vector3 &p_point, const Vector3 &p_cam_dir, const CameraMatrix &p_cam_matrix, const Vector<Plane> &p_convex, VSInstance **p_result_array, int p_num_results) {
	_occlusion_culler.prepare_camera(p_cam_matrix, p_cam_dir);

	// silly conversion of vector to local vector
	// can this be avoided? NYI
	// pretty cheap anyway as it will just copy 6 planes, max a few times per frame...
	static LocalVector<Plane> local_planes;
	if ((int)local_planes.size() != p_convex.size()) {
		local_planes.resize(p_convex.size());
	}
	for (int n = 0; n < p_convex.size(); n++) {
		local_planes[n] = p_convex[n];
	}

	_occlusion_culler.prepare_generic(p_portal_renderer, p_portal_renderer.get_occluders_active_list(), p_point, local_planes);

	// cull each instance
	int count = p_num_results;
	AABB bb;

	for (int n = 0; n < count; n++) {
		VSInstance *instance = p_result_array[n];

		// this will return false for GLOBAL instances, so we don't occlusion cull gizmos
		if (VSG::scene->_instance_get_transformed_aabb_for_occlusion(instance, bb)) {
			if (_occlusion_culler.cull_aabb(bb)) {
				// remove from list with unordered swap from the end of list
				p_result_array[n] = p_result_array[count - 1];
				count--;
				n--; // repeat this element, as it will have changed
			}
		}
	}

	return count;
}