1426cd3b3a
As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see". Backported from #70885.
570 lines
20 KiB
C++
570 lines
20 KiB
C++
/**************************************************************************/
|
|
/* portal_tracer.cpp */
|
|
/**************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/**************************************************************************/
|
|
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
|
|
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
|
|
/* */
|
|
/* 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;
|
|
}
|