cfe806a929
Fixes a bug whereby it read from the primary PVS in the gameplay monitor, using the size from the secondary PVS. This would read out of bounds and crash. Removed debug code to update the gameplay monitor from the preview camera - this is no longer required. Temporarily revert to the simple PVS generation method, because I've noticed a bug in the complex version, and the simple version is safer while I fix this.
652 lines
21 KiB
C++
652 lines
21 KiB
C++
/*************************************************************************/
|
|
/* portal_pvs_builder.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2021 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_pvs_builder.h"
|
|
|
|
#include "core/os/file_access.h"
|
|
#include "core/os/os.h"
|
|
#include "core/print_string.h"
|
|
#include "portal_renderer.h"
|
|
|
|
bool PVSBuilder::_log_active = false;
|
|
|
|
void PVSBuilder::find_neighbors(LocalVector<Neighbours> &r_neighbors) {
|
|
// first find the neighbors
|
|
int num_rooms = _portal_renderer->get_num_rooms();
|
|
|
|
for (int n = 0; n < num_rooms; n++) {
|
|
const VSRoom &room = _portal_renderer->get_room(n);
|
|
|
|
// go through each portal
|
|
int num_portals = room._portal_ids.size();
|
|
|
|
for (int p = 0; p < num_portals; p++) {
|
|
int portal_id = room._portal_ids[p];
|
|
const VSPortal &portal = _portal_renderer->get_portal(portal_id);
|
|
|
|
// 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 != n) {
|
|
outgoing = 0;
|
|
DEV_ASSERT(portal._linkedroom_ID[1] == n);
|
|
}
|
|
|
|
// trace through this portal to the next room
|
|
int linked_room_id = portal._linkedroom_ID[outgoing];
|
|
|
|
// not relevant, portal doesn't go anywhere
|
|
if (linked_room_id == -1)
|
|
continue;
|
|
|
|
r_neighbors[n].room_ids.push_back(linked_room_id);
|
|
} // for p through portals
|
|
|
|
} // for n through rooms
|
|
|
|
// the secondary PVS is the primary PVS plus the neighbors
|
|
}
|
|
|
|
void PVSBuilder::create_secondary_pvs(int p_room_id, const LocalVector<Neighbours> &p_neighbors, BitFieldDynamic &r_bitfield_rooms) {
|
|
VSRoom &room = _portal_renderer->get_room(p_room_id);
|
|
room._secondary_pvs_first = _pvs->get_secondary_pvs_size();
|
|
|
|
// go through each primary PVS room, and add the neighbors in the secondary pvs
|
|
for (int r = 0; r < room._pvs_size; r++) {
|
|
int pvs_entry = room._pvs_first + r;
|
|
int pvs_room_id = _pvs->get_pvs_room_id(pvs_entry);
|
|
|
|
// add the visible rooms first
|
|
_pvs->add_to_secondary_pvs(pvs_room_id);
|
|
room._secondary_pvs_size += 1;
|
|
|
|
// now any neighbors of this that are not already added
|
|
const Neighbours &neigh = p_neighbors[pvs_room_id];
|
|
for (int n = 0; n < neigh.room_ids.size(); n++) {
|
|
int neigh_room_id = neigh.room_ids[n];
|
|
|
|
//log("\tconsidering neigh " + itos(neigh_room_id));
|
|
|
|
if (r_bitfield_rooms.check_and_set(neigh_room_id)) {
|
|
// add to the secondary pvs for this room
|
|
_pvs->add_to_secondary_pvs(neigh_room_id);
|
|
room._secondary_pvs_size += 1;
|
|
} // neighbor room has not been added yet
|
|
} // go through the neighbors
|
|
} // go through each room in the primary pvs
|
|
}
|
|
|
|
#ifdef GODOT_PVS_SUPPORT_SAVE_FILE
|
|
|
|
bool PVSBuilder::load_pvs(String p_filename) {
|
|
if (p_filename == "") {
|
|
return false;
|
|
}
|
|
|
|
Error err;
|
|
FileAccess *file = FileAccess::open(p_filename, FileAccess::READ, &err);
|
|
|
|
if (err || !file) {
|
|
if (file) {
|
|
memdelete(file);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// goto needs vars declaring ahead of time
|
|
int32_t num_rooms;
|
|
int32_t pvs_size;
|
|
|
|
if (!((file->get_8() == 'p') &&
|
|
(file->get_8() == 'v') &&
|
|
(file->get_8() == 's') &&
|
|
(file->get_8() == ' '))) {
|
|
goto failed;
|
|
}
|
|
|
|
num_rooms = file->get_32();
|
|
if (num_rooms != _portal_renderer->get_num_rooms()) {
|
|
goto failed;
|
|
}
|
|
|
|
for (int n = 0; n < num_rooms; n++) {
|
|
if (file->eof_reached())
|
|
goto failed;
|
|
|
|
VSRoom &room = _portal_renderer->get_room(n);
|
|
room._pvs_first = file->get_32();
|
|
room._pvs_size = file->get_32();
|
|
room._secondary_pvs_first = file->get_32();
|
|
room._secondary_pvs_size = file->get_32();
|
|
}
|
|
|
|
pvs_size = file->get_32();
|
|
|
|
for (int n = 0; n < pvs_size; n++) {
|
|
_pvs->add_to_pvs(file->get_16());
|
|
}
|
|
|
|
// secondary pvs
|
|
pvs_size = file->get_32();
|
|
|
|
for (int n = 0; n < pvs_size; n++) {
|
|
_pvs->add_to_secondary_pvs(file->get_16());
|
|
}
|
|
|
|
if (file) {
|
|
memdelete(file);
|
|
}
|
|
|
|
return true;
|
|
|
|
failed:
|
|
if (file) {
|
|
memdelete(file);
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void PVSBuilder::save_pvs(String p_filename) {
|
|
if (p_filename == "") {
|
|
p_filename = "res://test.pvs";
|
|
}
|
|
|
|
Error err;
|
|
FileAccess *file = FileAccess::open(p_filename, FileAccess::WRITE, &err);
|
|
|
|
if (err || !file) {
|
|
if (file) {
|
|
memdelete(file);
|
|
}
|
|
return;
|
|
}
|
|
|
|
file->store_8('p');
|
|
file->store_8('v');
|
|
file->store_8('s');
|
|
file->store_8(' ');
|
|
|
|
// hash? NYI
|
|
|
|
// first save the room indices into the pvs
|
|
int num_rooms = _portal_renderer->get_num_rooms();
|
|
file->store_32(num_rooms);
|
|
|
|
for (int n = 0; n < num_rooms; n++) {
|
|
VSRoom &room = _portal_renderer->get_room(n);
|
|
file->store_32(room._pvs_first);
|
|
file->store_32(room._pvs_size);
|
|
file->store_32(room._secondary_pvs_first);
|
|
file->store_32(room._secondary_pvs_size);
|
|
}
|
|
|
|
int32_t pvs_size = _pvs->get_pvs_size();
|
|
file->store_32(pvs_size);
|
|
|
|
for (int n = 0; n < pvs_size; n++) {
|
|
int16_t room_id = _pvs->get_pvs_room_id(n);
|
|
file->store_16(room_id);
|
|
}
|
|
|
|
pvs_size = _pvs->get_secondary_pvs_size();
|
|
file->store_32(pvs_size);
|
|
|
|
for (int n = 0; n < pvs_size; n++) {
|
|
int16_t room_id = _pvs->get_secondary_pvs_room_id(n);
|
|
file->store_16(room_id);
|
|
}
|
|
|
|
if (file) {
|
|
memdelete(file);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
void PVSBuilder::calculate_pvs(PortalRenderer &p_portal_renderer, String p_filename, int p_depth_limit) {
|
|
_portal_renderer = &p_portal_renderer;
|
|
_pvs = &p_portal_renderer.get_pvs();
|
|
_depth_limit = p_depth_limit;
|
|
|
|
// attempt to load from file rather than create each time
|
|
#ifdef GODOT_PVS_SUPPORT_SAVE_FILE
|
|
if (load_pvs(p_filename)) {
|
|
print_line("loaded pvs successfully from file " + p_filename);
|
|
_pvs->set_loaded(true);
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
uint32_t time_before = OS::get_singleton()->get_ticks_msec();
|
|
|
|
int num_rooms = _portal_renderer->get_num_rooms();
|
|
BitFieldDynamic bf;
|
|
bf.create(num_rooms);
|
|
|
|
LocalVector<Neighbours> neighbors;
|
|
neighbors.resize(num_rooms);
|
|
|
|
// find the immediate neighbors of each room -
|
|
// this is needed to create the secondary pvs
|
|
find_neighbors(neighbors);
|
|
|
|
for (int n = 0; n < num_rooms; n++) {
|
|
bf.blank();
|
|
|
|
//_visible_rooms.clear();
|
|
|
|
LocalVector<Plane, int32_t> dummy_planes;
|
|
|
|
VSRoom &room = _portal_renderer->get_room(n);
|
|
room._pvs_first = _pvs->get_pvs_size();
|
|
|
|
log("pvs from room : " + itos(n));
|
|
|
|
trace_rooms_recursive_simple(0, n, n, -1, false, -1, dummy_planes, bf);
|
|
// trace_rooms_recursive(0, n, n, -1, false, -1, dummy_planes, bf);
|
|
|
|
create_secondary_pvs(n, neighbors, bf);
|
|
|
|
if (_log_active) {
|
|
String string = "";
|
|
for (int i = 0; i < room._pvs_size; i++) {
|
|
int visible_room = _pvs->get_pvs_room_id(room._pvs_first + i);
|
|
string += itos(visible_room);
|
|
string += ", ";
|
|
}
|
|
|
|
log("\t" + string);
|
|
|
|
string = "secondary : ";
|
|
for (int i = 0; i < room._secondary_pvs_size; i++) {
|
|
int visible_room = _pvs->get_secondary_pvs_room_id(room._secondary_pvs_first + i);
|
|
string += itos(visible_room);
|
|
string += ", ";
|
|
}
|
|
|
|
log("\t" + string);
|
|
}
|
|
}
|
|
|
|
_pvs->set_loaded(true);
|
|
|
|
uint32_t time_after = OS::get_singleton()->get_ticks_msec();
|
|
|
|
print_verbose("calculated PVS in " + itos(time_after - time_before) + " ms.");
|
|
|
|
#ifdef GODOT_PVS_SUPPORT_SAVE_FILE
|
|
save_pvs(p_filename);
|
|
#endif
|
|
}
|
|
|
|
void PVSBuilder::logd(int p_depth, String p_string) {
|
|
return;
|
|
|
|
String string_long;
|
|
for (int n = 0; n < p_depth; n++) {
|
|
string_long += "\t";
|
|
}
|
|
string_long += p_string;
|
|
log(string_long);
|
|
}
|
|
|
|
void PVSBuilder::log(String p_string) {
|
|
if (_log_active) {
|
|
print_line(p_string);
|
|
}
|
|
}
|
|
|
|
// The full routine deals with re-entrant rooms. I.e. more than one portal path can lead into a room.
|
|
// This makes the logic more complex, because we cannot terminate on the second entry to a room,
|
|
// and have to account for internal rooms, and the possibility of portal paths going back on themselves.
|
|
void PVSBuilder::trace_rooms_recursive(int p_depth, int p_source_room_id, int p_room_id, int p_first_portal_id, bool p_first_portal_outgoing, int p_previous_portal_id, const LocalVector<Plane, int32_t> &p_planes, BitFieldDynamic &r_bitfield_rooms, int p_from_external_room_id) {
|
|
// prevent too much depth
|
|
if (p_depth > _depth_limit) {
|
|
WARN_PRINT_ONCE("PVS Depth Limit reached (seeing through too many portals)");
|
|
return;
|
|
}
|
|
|
|
// is this room hit first time?
|
|
if (r_bitfield_rooms.check_and_set(p_room_id)) {
|
|
// only add to the room PVS of the source room once
|
|
VSRoom &source_room = _portal_renderer->get_room(p_source_room_id);
|
|
_pvs->add_to_pvs(p_room_id);
|
|
source_room._pvs_size += 1;
|
|
}
|
|
|
|
logd(p_depth, "trace_rooms_recursive room " + itos(p_room_id));
|
|
|
|
// get the room
|
|
const VSRoom &room = _portal_renderer->get_room(p_room_id);
|
|
|
|
// go through each portal
|
|
int num_portals = room._portal_ids.size();
|
|
|
|
for (int p = 0; p < num_portals; p++) {
|
|
int portal_id = room._portal_ids[p];
|
|
const VSPortal &portal = _portal_renderer->get_portal(portal_id);
|
|
|
|
// 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];
|
|
|
|
// not relevant, portal doesn't go anywhere
|
|
if (linked_room_id == -1)
|
|
continue;
|
|
|
|
// For pvs there is no real start point, but we will use the centre of the first portal.
|
|
// This is used for checking portals are pointing outward from start point.
|
|
if (p_source_room_id == p_room_id) {
|
|
_trace_start_point = portal._pt_center;
|
|
|
|
// We will use a small epsilon because we don't want to trace out
|
|
// to coplanar portals for the first to second portals, before planes
|
|
// have been added. So we will place the trace start point slightly
|
|
// behind the first portal plane (e.g. slightly in the source room).
|
|
// The epsilon must balance being enough in not to cause numerical error
|
|
// at large distances from the origin, but too large and this will also
|
|
// prevent the PVS entering portals that are very closely aligned
|
|
// to the portal in.
|
|
// Closely aligned portals should not happen in normal level design,
|
|
// and will usually be a design error.
|
|
// Watch for bugs here though, caused by closely aligned portals.
|
|
_trace_start_point -= portal._plane.normal * 0.1;
|
|
|
|
} else {
|
|
// 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) {
|
|
// logd(p_depth + 2, "portal WRONG DIRECTION");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
logd(p_depth + 1, "portal to room " + itos(linked_room_id));
|
|
|
|
// 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 (int32_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) {
|
|
logd(p_depth + 2, "portal 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;
|
|
}
|
|
}
|
|
|
|
// construct new planes
|
|
LocalVector<Plane, int32_t> planes;
|
|
|
|
if (p_first_portal_id != -1) {
|
|
// add new planes
|
|
const VSPortal &first_portal = _portal_renderer->get_portal(p_first_portal_id);
|
|
portal.add_pvs_planes(first_portal, p_first_portal_outgoing, planes, outgoing != 0);
|
|
|
|
//#define GODOT_PVS_EXTRA_REJECT_TEST
|
|
#ifdef GODOT_PVS_EXTRA_REJECT_TEST
|
|
// extra reject test for pvs - was the previous portal points outside the planes formed by the new portal?
|
|
// not fully tested and not yet found a situation where needed, but will leave in in case testers find
|
|
// such a situation.
|
|
if (p_previous_portal_id != -1) {
|
|
const VSPortal &prev_portal = _portal_renderer->get_portal(p_previous_portal_id);
|
|
if (prev_portal._pvs_is_outside_planes(planes)) {
|
|
continue;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// 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)
|
|
if (overall_res != VSPortal::ClipResult::CLIP_INSIDE) {
|
|
// if it WASNT 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++)
|
|
planes.push_back(p_planes[partial_planes[n]]);
|
|
}
|
|
|
|
// hopefully the portal actually leads somewhere...
|
|
if (linked_room_id != -1) {
|
|
// we either pass on the first portal id, or we start
|
|
// it here, because we are looking through the first portal
|
|
int first_portal_id = p_first_portal_id;
|
|
if (first_portal_id == -1) {
|
|
first_portal_id = portal_id;
|
|
p_first_portal_outgoing = outgoing != 0;
|
|
}
|
|
|
|
trace_rooms_recursive(p_depth + 1, p_source_room_id, linked_room_id, first_portal_id, p_first_portal_outgoing, portal_id, planes, r_bitfield_rooms, p_from_external_room_id);
|
|
} // linked room is valid
|
|
}
|
|
}
|
|
|
|
// This simpler routine was the first used. It is reliable and no epsilons, and fast.
|
|
// But it will not create the correct result where there are multiple portal paths
|
|
// through a room when building the PVS.
|
|
void PVSBuilder::trace_rooms_recursive_simple(int p_depth, int p_source_room_id, int p_room_id, int p_first_portal_id, bool p_first_portal_outgoing, int p_previous_portal_id, const LocalVector<Plane, int32_t> &p_planes, BitFieldDynamic &r_bitfield_rooms) {
|
|
// has this room been done already?
|
|
if (!r_bitfield_rooms.check_and_set(p_room_id)) {
|
|
return;
|
|
}
|
|
|
|
// prevent too much depth
|
|
if (p_depth > _depth_limit) {
|
|
WARN_PRINT_ONCE("Portal Depth Limit reached (seeing through too many portals)");
|
|
return;
|
|
}
|
|
|
|
logd(p_depth, "trace_rooms_recursive room " + itos(p_room_id));
|
|
|
|
// get the room
|
|
const VSRoom &room = _portal_renderer->get_room(p_room_id);
|
|
|
|
// add to the room PVS of the source room
|
|
VSRoom &source_room = _portal_renderer->get_room(p_source_room_id);
|
|
_pvs->add_to_pvs(p_room_id);
|
|
source_room._pvs_size += 1;
|
|
|
|
// go through each portal
|
|
int num_portals = room._portal_ids.size();
|
|
|
|
for (int p = 0; p < num_portals; p++) {
|
|
int portal_id = room._portal_ids[p];
|
|
const VSPortal &portal = _portal_renderer->get_portal(portal_id);
|
|
|
|
// 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];
|
|
|
|
logd(p_depth + 1, "portal to room " + itos(linked_room_id));
|
|
|
|
// not relevant, portal doesn't go anywhere
|
|
if (linked_room_id == -1)
|
|
continue;
|
|
|
|
// linked room done already?
|
|
if (r_bitfield_rooms.get_bit(linked_room_id))
|
|
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 (int32_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) {
|
|
logd(p_depth + 2, "portal CLIP_OUTSIDE");
|
|
continue;
|
|
}
|
|
|
|
// construct new planes
|
|
LocalVector<Plane, int32_t> planes;
|
|
|
|
if (p_first_portal_id != -1) {
|
|
// add new planes
|
|
const VSPortal &first_portal = _portal_renderer->get_portal(p_first_portal_id);
|
|
portal.add_pvs_planes(first_portal, p_first_portal_outgoing, planes, outgoing != 0);
|
|
|
|
#ifdef GODOT_PVS_EXTRA_REJECT_TEST
|
|
// extra reject test for pvs - was the previous portal points outside the planes formed by the new portal?
|
|
// not fully tested and not yet found a situation where needed, but will leave in in case testers find
|
|
// such a situation.
|
|
if (p_previous_portal_id != -1) {
|
|
const VSPortal &prev_portal = _portal_renderer->get_portal(p_previous_portal_id);
|
|
if (prev_portal._pvs_is_outside_planes(planes)) {
|
|
continue;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// 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)
|
|
if (overall_res != VSPortal::ClipResult::CLIP_INSIDE) {
|
|
// if it WASNT 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++)
|
|
planes.push_back(p_planes[partial_planes[n]]);
|
|
}
|
|
|
|
// hopefully the portal actually leads somewhere...
|
|
if (linked_room_id != -1) {
|
|
// we either pass on the first portal id, or we start
|
|
// it here, because we are looking through the first portal
|
|
int first_portal_id = p_first_portal_id;
|
|
if (first_portal_id == -1) {
|
|
first_portal_id = portal_id;
|
|
p_first_portal_outgoing = outgoing != 0;
|
|
}
|
|
|
|
trace_rooms_recursive(p_depth + 1, p_source_room_id, linked_room_id, first_portal_id, p_first_portal_outgoing, portal_id, planes, r_bitfield_rooms);
|
|
} // linked room is valid
|
|
}
|
|
}
|