Relintai/pandemonium_engine_minimal
1
0
Fork 0
mirror of https://github.com/Relintai/pandemonium_engine_minimal.git synced 2025-03-30 23:05:29 +02:00
Code Issues Packages Projects Releases Wiki Activity

Removed Portals from the VisualServer.

Browse Source
This commit is contained in:
Relintai 2023-12-15 10:13:03 +01:00
parent b248f94cdc
commit 7a0bc5ed4d
40 changed files with 4 additions and 8488 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
core/config/engine.cpp
View File

@ -82,10 +82,6 @@ float Engine::get_time_scale() const {
return _time_scale;
}
void Engine::set_portals_active(bool p_active) {
_portals_active = p_active;
}
void Engine::add_global(const String &p_name, const Variant &p_global) {
ERR_FAIL_COND(_globals.has(p_name));
@ -272,7 +268,6 @@ Engine::Engine() {
_frame_ticks = 0;
_frame_step = 0;
editor_hint = false;
_portals_active = false;
}
Engine::Singleton::Singleton(const StringName &p_name, Object *p_ptr) :

3
core/config/engine.h
View File

@ -81,8 +81,6 @@ public:
Object *get_singleton_object(const String &p_name) const;
_FORCE_INLINE_ bool get_use_gpu_pixel_snap() const { return _gpu_pixel_snap; }
bool are_portals_active() const { return _portals_active; }
void set_portals_active(bool p_active);
#ifdef TOOLS_ENABLED
_FORCE_INLINE_ void set_editor_hint(bool p_enabled) {
@ -130,7 +128,6 @@ private:
bool _gpu_pixel_snap;
uint64_t _physics_frames;
float _physics_interpolation_fraction;
bool _portals_active;
bool _occlusion_culling_active;
uint64_t _idle_frames;

40
doc/classes/Room.xml
View File

@ -1,40 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="Room" inherits="Spatial" version="4.2">
<brief_description>
Room node, used to group objects together locally for [Portal] culling.
</brief_description>
<description>
The [Portal] culling system requires levels to be built using objects grouped together by location in areas called [Room]s. In many cases these will correspond to actual rooms in buildings, but not necessarily (a canyon area may be treated as a room).
Any [VisualInstance] that is a child or grandchild of a [Room] will be assigned to that room, if the [code]portal_mode[/code] of that [VisualInstance] is set to [code]STATIC[/code] (does not move) or [code]DYNAMIC[/code] (moves only within the room).
Internally the room boundary must form a [b]convex hull[/b], and by default this is determined automatically by the geometry of the objects you place within the room.
You can alternatively precisely specify a [b]manual bound[/b]. If you place a [MeshInstance] with a name prefixed by [code]Bound_[/code], it will turn off the bound generation from geometry, and instead use the vertices of this MeshInstance to directly calculate a convex hull during the conversion stage (see [RoomManager]).
In order to see from one room into an adjacent room, [Portal]s must be placed over non-occluded openings between rooms. These will often be placed over doors and windows.
</description>
<tutorials>
</tutorials>
<methods>
<method name="set_point">
<return type="void" />
<argument index="0" name="index" type="int" />
<argument index="1" name="position" type="Vector3" />
<description>
Sets individual points.
[b]Note:[/b] This function will not resize the point array. Set [member points] to set the number of points.
</description>
</method>
</methods>
<members>
<member name="points" type="PoolVector3Array" setter="set_points" getter="get_points" default="PoolVector3Array( )">
If [code]points[/code] are set, the [Room] bounding convex hull will be built from these points. If no points are set, the room bound will either be derived from a manual bound ([MeshInstance] with name prefix [code]Bound_[/code]), or from the geometry within the room.
Note that you can use the [code]Generate Points[/code] editor button to get started. This will use either the geometry or manual bound to generate the room hull, and save the resulting points, allowing you to edit them to further refine the bound.
</member>
<member name="room_simplify" type="float" setter="set_room_simplify" getter="get_room_simplify" default="0.5">
The [code]simplify[/code] value determines to what degree room hulls (bounds) are simplified, by removing similar planes. A value of 0 gives no simplification, 1 gives maximum simplification.
</member>
<member name="use_default_simplify" type="bool" setter="set_use_default_simplify" getter="get_use_default_simplify" default="true">
The room hull simplification can either use the default value set in the [RoomManager], or override this and use the per room setting.
</member>
</members>
<constants>
</constants>
</class>

24
doc/classes/RoomGroup.xml
View File

@ -1,24 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="RoomGroup" inherits="Spatial" version="4.2">
<brief_description>
Groups [Room]s together to allow common functionality.
</brief_description>
<description>
Although [Room] behavior can be specified individually, sometimes it is faster and more convenient to write functionality for a group of rooms.
[RoomGroup]s should be placed as children of the [b]room list[/b] (the parent [Node] of your [Room]s), and [Room]s should be placed in turn as children of a [RoomGroup] in order to assign them to the RoomGroup.
A [RoomGroup] can for example be used to specify [Room]s that are [b]outside[/b], and switch on or off a directional light, sky, or rain effect as the player enters / exits the area.
[RoomGroup]s receive [b]gameplay callbacks[/b] when the [code]gameplay_monitor[/code] is switched on, as [code]signal[/code]s or [code]notification[/code]s as they enter and exit the [b]gameplay area[/b] (see [RoomManager] for details).
</description>
<tutorials>
</tutorials>
<methods>
</methods>
<members>
<member name="roomgroup_priority" type="int" setter="set_roomgroup_priority" getter="get_roomgroup_priority" default="0">
This priority will be applied to [Room]s within the group. The [Room] priority allows the use of [b]internal rooms[/b], rooms [i]within[/i] another room or rooms.
When the [Camera] is within more than one room (regular and internal), the higher priority room will take precedence. So with for example, a house inside a terrain 'room', you would make the house higher priority, so that when the camera is within the house, the house is used as the source room, but outside the house, the terrain room would be used instead.
</member>
</members>
<constants>
</constants>
</class>

113
doc/classes/RoomManager.xml
View File

@ -1,113 +0,0 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="RoomManager" inherits="Spatial" version="4.2">
<brief_description>
The RoomManager node is used to control the portal culling system.
</brief_description>
<description>
In order to utilize the portal occlusion culling system, you must build your level using [Room]s and [Portal]s. Before these can be used at runtime, they must undergo a short conversion process to build the [code]room graph[/code], runtime data needed for portal culling. The [code]room graph[/code] is controlled by the [RoomManager] node, and the [RoomManager] also contains settings that are common throughout the portal system.
</description>
<tutorials>
</tutorials>
<methods>
<method name="rooms_clear">
<return type="void" />
<description>
This function clears all converted data from the [b]room graph[/b]. Use this before unloading a level, when transitioning from level to level, or returning to a main menu.
</description>
</method>
<method name="rooms_convert">
<return type="void" />
<description>
This is the most important function in the whole portal culling system. Without it, the system cannot function.
First it goes through every [Room] that is a child of the [code]room list[/code] node (and [RoomGroup]s within) and converts and adds it to the [code]room graph[/code].
This works for both [Room] nodes, and [Spatial] nodes that follow a special naming convention. They should begin with the prefix [i]'Room_'[/i], followed by the name you wish to give the room, e.g. [i]'Room_lounge'[/i]. This will automatically convert such [Spatial]s to [Room] nodes for you. This is useful if you want to build you entire room system in e.g. Blender, and reimport multiple times as you work on the level.
The conversion will try to assign [VisualInstance]s that are children and grandchildren of the [Room] to the room. These should be given a suitable [code]portal mode[/code] (see the [CullInstance] documentation). The default [code]portal mode[/code] is [code]STATIC[/code] - objects which are not expected to move while the level is played, which will typically be most objects.
The conversion will usually use the geometry of these [VisualInstance]s (and the [Portal]s) to calculate a convex hull bound for the room. These bounds will be shown in the editor with a wireframe. Alternatively you can specify a manual custom bound for any room, see the [Room] documentation.
By definition, [Camera]s within a room can see everything else within the room (that is one advantage to using convex hulls). However, in order to see from one room into adjacent rooms, you must place [Portal]s, which represent openings that the camera can see through, like windows and doors.
[Portal]s are really just specialized [MeshInstance]s. In fact you will usually first create a portal by creating a [MeshInstance], especially a [code]plane[/code] mesh instance. You would move the plane in the editor to cover a window or doorway, with the front face pointing outward from the room. To let the conversion process know you want this mesh to be a portal, again we use a special naming convention. [MeshInstance]s to be converted to a [Portal] should start with the prefix [i]'Portal_'[/i].
You now have a choice - you can leave the name as [i]'Portal_'[/i] and allow the system to automatically detect the nearest [Room] to link. In most cases this will work fine.
An alternative method is to specify the [Room] to link to manually, appending a suffix to the portal name, which should be the name of the room you intend to link to. For example [i]'Portal_lounge'[/i] will attempt to link to the room named [i]'Room_lounge'[/i].
There is a special case here - Godot does not allow two nodes to share the same name. What if you want to manually have more than one portal leading into the same room? Surely they will need to both be called, e.g. [i]'Portal_lounge'[/i]?
The solution is a wildcard character. After the room name, if you use the character [i]'*'[/i], this character and anything following it will be ignored. So you can use for example [i]'Portal_lounge*0'[/i], [i]'Portal_lounge*1'[/i] etc.
Note that [Portal]s that have already been converted to [Portal] nodes (rather than [MeshInstance]s) still need to follow the same naming convention, as they will be relinked each time during conversion.
It is recommended that you only place objects in rooms that are desired to stay within those rooms - i.e. [code]portal mode[/code]s [code]STATIC[/code] or [code]DYNAMIC[/code] (not crossing portals). [code]GLOBAL[/code] and [code]ROAMING[/code] objects are best placed in another part of the scene tree, to avoid confusion. See [CullInstance] for a full description of portal modes.
</description>
</method>
</methods>
<members>
<member name="active" type="bool" setter="rooms_set_active" getter="rooms_get_active" default="true">
Switches the portal culling system on and off.
It is important to note that when portal culling is active, it is responsible for [b]all[/b] the 3d culling. Some editor visual debugging helpers may not be available when active, so switching the active flag is intended to be used to ensure your [Room] / [Portal] layout works within the editor.
Switching to [code]active[/code] will have no effect when the [code]room graph[/code] is unloaded (the rooms have not yet been converted).
[b]Note:[/b] For efficiency, the portal system is designed to work with only the core visual object types. In particular, only nodes derived from [VisualInstance] are expected to show when the system is active.
</member>
<member name="debug_sprawl" type="bool" setter="set_debug_sprawl" getter="get_debug_sprawl" default="false">
Large objects can 'sprawl' over (be present in) more than one room. It can be useful to visualize which objects are sprawling outside the current room.
Toggling this setting turns this debug view on and off.
</member>
<member name="default_portal_margin" type="float" setter="set_default_portal_margin" getter="get_default_portal_margin" default="1.0">
Usually we don't want objects that only [b]just[/b] cross a boundary into an adjacent [Room] to sprawl into that room. To prevent this, each [Portal] has an extra margin, or tolerance zone where objects can enter without sprawling to a neighbouring room.
In most cases you can set this here for all portals. It is possible to override the margin for each portal.
</member>
<member name="gameplay_monitor" type="bool" setter="set_gameplay_monitor_enabled" getter="get_gameplay_monitor_enabled" default="false">
When using a partial or full PVS, the gameplay monitor allows you to receive callbacks when roaming objects or rooms enter or exit the [b]gameplay area[/b]. The gameplay area is defined as either the primary, or secondary PVS.
These callbacks allow you to, for example, reduce processing for objects that are far from the player, or turn on and off AI.
You can either choose to receive callbacks as notifications through the [code]_notification[/code] function, or as signals.
[code]NOTIFICATION_ENTER_GAMEPLAY[/code]
[code]NOTIFICATION_EXIT_GAMEPLAY[/code]
Signals: [code]"gameplay_entered"[/code], [code]"gameplay_exited"[/code]
</member>
<member name="merge_meshes" type="bool" setter="set_merge_meshes" getter="get_merge_meshes" default="false">
If enabled, the system will attempt to merge similar meshes (particularly in terms of materials) within [Room]s during conversion. This can significantly reduce the number of drawcalls and state changes required during rendering, albeit at a cost of reduced culling granularity.
[b]Note:[/b] This operates at runtime during the conversion process, and will only operate on exported or running projects, in order to prevent accidental alteration to the scene and loss of data.
</member>
<member name="overlap_warning_threshold" type="int" setter="set_overlap_warning_threshold" getter="get_overlap_warning_threshold" default="1">
When converting rooms, the editor will warn you if overlap is detected between rooms. Overlap can interfere with determining the room that cameras and objects are within. A small amount can be acceptable, depending on your level. Here you can alter the threshold at which the editor warning appears. There are no other side effects.
</member>
<member name="portal_depth_limit" type="int" setter="set_portal_depth_limit" getter="get_portal_depth_limit" default="16">
Portal rendering is recursive - each time a portal is seen through an earlier portal there is some cost. For this reason, and to prevent the possibility of infinite loops, this setting provides a hard limit on the recursion depth.
[b]Note:[/b] This value is unused when using [code]Full[/code] PVS mode.
</member>
<member name="preview_camera" type="NodePath" setter="set_preview_camera_path" getter="get_preview_camera_path" default="NodePath(&quot;&quot;)">
Portal culling normally operates using the current [Camera] / [Camera]s, however for debugging purposes within the editor, you can use this setting to override this behavior and force it to use a particular camera to get a better idea of what the occlusion culling is doing.
</member>
<member name="process_priority" type="int" setter="set_process_priority" getter="get_process_priority" overrides="Node" default="10000" />
<member name="pvs_mode" type="int" setter="set_pvs_mode" getter="get_pvs_mode" enum="RoomManager.PVSMode" default="1">
Optionally during conversion the potentially visible set (PVS) of rooms that are potentially visible from each room can be calculated. This can be used either to aid in dynamic portal culling, or to totally replace portal culling.
In [code]Full[/code] PVS Mode, all objects within the potentially visible rooms will be frustum culled, and rendered if they are within the view frustum.
</member>
<member name="roaming_expansion_margin" type="float" setter="set_roaming_expansion_margin" getter="get_roaming_expansion_margin" default="1.0">
In order to reduce processing for roaming objects, an expansion is applied to their AABB as they move. This expanded volume is used to calculate which rooms the roaming object is within. If the object's exact AABB is still within this expanded volume on the next move, there is no need to reprocess the object, which can save considerable CPU.
The downside is that if the expansion is too much, the object may end up unexpectedly sprawling into neighbouring rooms and showing up where it might otherwise be culled.
In order to balance roaming performance against culling accuracy, this expansion margin can be customized by the user. It will typically depend on your room and object sizes, and movement speeds. The default value should work reasonably in most circumstances.
</member>
<member name="room_simplify" type="float" setter="set_room_simplify" getter="get_room_simplify" default="0.5">
During the conversion process, the geometry of objects within [Room]s, or a custom specified manual bound, are used to generate a [b]convex hull bound[/b].
This convex hull is [b]required[/b] in the visibility system, and is used for many purposes. Most importantly, it is used to decide whether the [Camera] (or an object) is within a [Room]. The convex hull generating algorithm is good, but occasionally it can create too many (or too few) planes to give a good representation of the room volume.
The [code]room_simplify[/code] value can be used to gain fine control over this process. It determines how similar planes can be for them to be considered the same (and duplicates removed). The value can be set between 0 (no simplification) and 1 (maximum simplification).
The value set here is the default for all rooms, but individual rooms can override this value if desired.
The room convex hulls are shown as a wireframe in the editor.
</member>
<member name="roomlist" type="NodePath" setter="set_roomlist_path" getter="get_roomlist_path" default="NodePath(&quot;&quot;)">
For the [Room] conversion process to succeed, you must point the [RoomManager] to the parent [Node] of your [Room]s and [RoomGroup]s, which we refer to as the [code]roomlist[/code] (the roomlist is not a special node type, it is normally just a [Spatial]).
</member>
<member name="show_margins" type="bool" setter="set_show_margins" getter="get_show_margins" default="true">
Shows the [Portal] margins when the portal gizmo is used in the editor.
</member>
<member name="use_secondary_pvs" type="bool" setter="set_use_secondary_pvs" getter="get_use_secondary_pvs" default="false">
When receiving gameplay callbacks when objects enter and exit gameplay, the [b]gameplay area[/b] can be defined by either the primary PVS (potentially visible set) of [Room]s, or the secondary PVS (the primary PVS and their neighbouring [Room]s).
Sometimes using the larger gameplay area of the secondary PVS may be preferable.
</member>
</members>
<constants>
<constant name="PVS_MODE_DISABLED" value="0" enum="PVSMode">
Use only [Portal]s at runtime to determine visibility. PVS will not be generated at [Room]s conversion, and gameplay notifications cannot be used.
</constant>
<constant name="PVS_MODE_PARTIAL" value="1" enum="PVSMode">
Use a combination of PVS and [Portal]s to determine visibility (this is usually fastest and most accurate).
</constant>
<constant name="PVS_MODE_FULL" value="2" enum="PVSMode">
Use only the PVS (potentially visible set) of [Room]s to determine visibility.
</constant>
</constants>
</class>

181
scene/3d/occluder.cpp
View File

@ -1,181 +0,0 @@
/*************************************************************************/
/* occluder.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 "occluder.h"
#include "core/config/engine.h"
#include "scene/resources/occluder_shape.h"
#include "scene/resources/world_3d.h"
#include "servers/rendering/portals/portal_occlusion_culler.h"
#include "servers/rendering_server.h"
void Occluder::resource_changed(RES res) {
update_gizmos();
}
void Occluder::set_shape(const Ref<OccluderShape> &p_shape) {
if (p_shape == _shape) {
return;
}
if (!_shape.is_null()) {
_shape->unregister_owner(this);
}
_shape = p_shape;
if (_shape.is_valid()) {
_shape->register_owner(this);
if (is_inside_world() && get_world_3d().is_valid()) {
if (_occluder_instance.is_valid()) {
RenderingServer::get_singleton()->occluder_instance_link_resource(_occluder_instance, p_shape->get_rid());
}
}
}
update_gizmos();
update_configuration_warning();
}
Ref<OccluderShape> Occluder::get_shape() const {
return _shape;
}
#ifdef TOOLS_ENABLED
AABB Occluder::get_fallback_gizmo_aabb() const {
if (_shape.is_valid()) {
return _shape->get_fallback_gizmo_aabb();
}
return Spatial::get_fallback_gizmo_aabb();
}
#endif
String Occluder::get_configuration_warning() const {
String warning = Spatial::get_configuration_warning();
if (!_shape.is_valid()) {
if (!warning.empty()) {
warning += "\n\n";
}
warning += TTR("No shape is set.");
return warning;
}
#ifdef TOOLS_ENABLED
if (_shape.ptr()->requires_uniform_scale()) {
Transform tr = get_global_transform();
Vector3 scale = tr.basis.get_scale();
if ((!Math::is_equal_approx(scale.x, scale.y, 0.01f)) ||
(!Math::is_equal_approx(scale.x, scale.z, 0.01f))) {
if (!warning.empty()) {
warning += "\n\n";
}
warning += TTR("Only uniform scales are supported.");
}
}
#endif
return warning;
}
void Occluder::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_ENTER_WORLD: {
ERR_FAIL_COND(get_world_3d().is_null());
if (_occluder_instance.is_valid()) {
RenderingServer::get_singleton()->occluder_instance_set_scenario(_occluder_instance, get_world_3d()->get_scenario());
if (get_shape().is_valid()) {
RenderingServer::get_singleton()->occluder_instance_link_resource(_occluder_instance, get_shape()->get_rid());
}
RenderingServer::get_singleton()->occluder_instance_set_active(_occluder_instance, is_visible_in_tree());
RenderingServer::get_singleton()->occluder_instance_set_transform(_occluder_instance, get_global_transform());
}
#ifdef TOOLS_ENABLED
if (Engine::get_singleton()->is_editor_hint()) {
set_process_internal(true);
}
#endif
} break;
case NOTIFICATION_EXIT_WORLD: {
if (_occluder_instance.is_valid()) {
RenderingServer::get_singleton()->occluder_instance_set_scenario(_occluder_instance, RID());
}
#ifdef TOOLS_ENABLED
if (Engine::get_singleton()->is_editor_hint()) {
set_process_internal(false);
}
#endif
} break;
case NOTIFICATION_VISIBILITY_CHANGED: {
if (_occluder_instance.is_valid() && is_inside_tree()) {
RenderingServer::get_singleton()->occluder_instance_set_active(_occluder_instance, is_visible_in_tree());
}
} break;
case NOTIFICATION_TRANSFORM_CHANGED: {
if (_occluder_instance.is_valid()) {
RenderingServer::get_singleton()->occluder_instance_set_transform(_occluder_instance, get_global_transform());
#ifdef TOOLS_ENABLED
if (Engine::get_singleton()->is_editor_hint()) {
update_configuration_warning();
}
#endif
}
} break;
case NOTIFICATION_INTERNAL_PROCESS: {
if (PortalOcclusionCuller::_redraw_gizmo) {
PortalOcclusionCuller::_redraw_gizmo = false;
update_gizmos();
}
} break;
}
}
void Occluder::_bind_methods() {
ClassDB::bind_method(D_METHOD("resource_changed", "resource"), &Occluder::resource_changed);
ClassDB::bind_method(D_METHOD("set_shape", "shape"), &Occluder::set_shape);
ClassDB::bind_method(D_METHOD("get_shape"), &Occluder::get_shape);
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shape", PROPERTY_HINT_RESOURCE_TYPE, "OccluderShape"), "set_shape", "get_shape");
}
Occluder::Occluder() {
_occluder_instance = RID_PRIME(RenderingServer::get_singleton()->occluder_instance_create());
set_notify_transform(true);
}
Occluder::~Occluder() {
if (_occluder_instance != RID()) {
RenderingServer::get_singleton()->free(_occluder_instance);
}
if (!_shape.is_null()) {
_shape->unregister_owner(this);
}
}

68
scene/3d/occluder.h
View File

@ -1,68 +0,0 @@
#ifndef OCCLUDER_H
#define OCCLUDER_H
/*************************************************************************/
/* occluder.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 "core/object/reference.h"
#include "scene/main/spatial.h"
class OccluderShape;
class Occluder : public Spatial {
GDCLASS(Occluder, Spatial);
friend class OccluderSpatialGizmo;
friend class OccluderEditorPlugin;
RID _occluder_instance;
Ref<OccluderShape> _shape;
void resource_changed(RES res);
protected:
void _notification(int p_what);
static void _bind_methods();
public:
void set_shape(const Ref<OccluderShape> &p_shape);
Ref<OccluderShape> get_shape() const;
String get_configuration_warning() const;
#ifdef TOOLS_ENABLED
// for editor gizmo
virtual AABB get_fallback_gizmo_aabb() const;
#endif
Occluder();
~Occluder();
};
#endif // OCCLUDER_H

51
scene/3d/visibility_notifier.cpp
View File

@ -42,9 +42,7 @@ void VisibilityNotifier::_enter_camera(Camera *p_camera) {
cameras.insert(p_camera);
bool in_gameplay = _in_gameplay;
if (!Engine::get_singleton()->are_portals_active()) {
in_gameplay = true;
}
if ((cameras.size() == 1) && in_gameplay) {
emit_signal(SceneStringNames::get_singleton()->screen_entered);
@ -59,9 +57,6 @@ void VisibilityNotifier::_exit_camera(Camera *p_camera) {
cameras.erase(p_camera);
bool in_gameplay = _in_gameplay;
if (!Engine::get_singleton()->are_portals_active()) {
in_gameplay = true;
}
emit_signal(SceneStringNames::get_singleton()->camera_exited, p_camera);
if ((cameras.size() == 0) && (in_gameplay)) {
@ -110,33 +105,7 @@ AABB VisibilityNotifier::get_aabb() const {
}
void VisibilityNotifier::_refresh_portal_mode() {
// only create in the visual server if we are roaming.
// All other cases don't require a visual server rep.
// Global and ignore are the same (existing client side functionality only).
// Static and dynamic require only a one off creation at conversion.
if (get_portal_mode() == PORTAL_MODE_ROAMING) {
if (is_inside_world()) {
if (_cull_instance_rid == RID()) {
_cull_instance_rid = RID_PRIME(RenderingServer::get_singleton()->ghost_create());
}
if (is_inside_world() && get_world_3d().is_valid() && get_world_3d()->get_scenario().is_valid() && is_inside_tree()) {
AABB world_aabb = get_global_transform().xform(aabb);
RenderingServer::get_singleton()->ghost_set_scenario(_cull_instance_rid, get_world_3d()->get_scenario(), get_instance_id(), world_aabb);
}
} else {
if (_cull_instance_rid != RID()) {
RenderingServer::get_singleton()->free(_cull_instance_rid);
_cull_instance_rid = RID();
}
}
} else {
if (_cull_instance_rid != RID()) {
RenderingServer::get_singleton()->free(_cull_instance_rid);
_cull_instance_rid = RID();
}
}
}
void VisibilityNotifier::_notification(int p_what) {
@ -169,9 +138,6 @@ void VisibilityNotifier::_notification(int p_what) {
_world_aabb_center = world_aabb.get_center();
}
if (_cull_instance_rid != RID()) {
RenderingServer::get_singleton()->ghost_update(_cull_instance_rid, world_aabb);
}
} break;
case NOTIFICATION_EXIT_WORLD: {
ERR_FAIL_COND(!world.is_valid());
@ -183,32 +149,17 @@ void VisibilityNotifier::_notification(int p_what) {
world->_remove_notifier(this);
#endif
if (_cull_instance_rid != RID()) {
RenderingServer::get_singleton()->ghost_set_scenario(_cull_instance_rid, RID(), get_instance_id(), AABB());
}
} break;
case NOTIFICATION_ENTER_GAMEPLAY: {
_in_gameplay = true;
if (cameras.size() && Engine::get_singleton()->are_portals_active()) {
emit_signal(SceneStringNames::get_singleton()->screen_entered);
_screen_enter();
}
} break;
case NOTIFICATION_EXIT_GAMEPLAY: {
_in_gameplay = false;
if (cameras.size() && Engine::get_singleton()->are_portals_active()) {
emit_signal(SceneStringNames::get_singleton()->screen_exited);
_screen_exit();
}
} break;
}
}
bool VisibilityNotifier::is_on_screen() const {
if (!Engine::get_singleton()->are_portals_active()) {
return cameras.size() != 0;
}
return (cameras.size() != 0) && _in_gameplay;
}

1
scene/3d/visual_instance.cpp
View File

@ -41,7 +41,6 @@ AABB VisualInstance::get_transformed_aabb() const {
}
void VisualInstance::_refresh_portal_mode() {
RenderingServer::get_singleton()->instance_set_portal_mode(instance, (RenderingServer::InstancePortalMode)get_portal_mode());
}
void VisualInstance::_update_visibility() {

2
scene/register_scene_types.cpp
View File

@ -188,7 +188,6 @@
#include "scene/3d/listener.h"
#include "scene/3d/mesh_instance.h"
#include "scene/3d/multimesh_instance.h"
#include "scene/3d/occluder.h"
#include "scene/3d/path.h"
#include "scene/3d/position_3d.h"
#include "scene/3d/proximity_group.h"
@ -425,7 +424,6 @@ void register_scene_types() {
ClassDB::register_class<CPUParticles>();
ClassDB::register_class<Position3D>();
ClassDB::register_class<NavigationMesh>();
ClassDB::register_class<Occluder>();
ClassDB::register_class<RootMotionView>();
ClassDB::set_class_enabled("RootMotionView", false); //disabled by default, enabled by editor

6
scene/resources/occluder_shape.cpp
View File

@ -42,7 +42,6 @@ void OccluderShape::_bind_methods() {
}
OccluderShape::OccluderShape() {
_shape = RID_PRIME(RenderingServer::get_singleton()->occluder_resource_create());
}
OccluderShape::~OccluderShape() {
@ -93,7 +92,6 @@ AABB OccluderShapeSphere::get_fallback_gizmo_aabb() const {
#endif
void OccluderShapeSphere::update_shape_to_rendering_server() {
RenderingServer::get_singleton()->occluder_resource_spheres_update(get_shape(), _spheres);
}
Transform OccluderShapeSphere::center_node(const Transform &p_global_xform, const Transform &p_parent_xform, real_t p_snap) {
@ -237,10 +235,6 @@ void OccluderShapeSphere::set_sphere_radius(int p_idx, real_t p_radius) {
}
OccluderShapeSphere::OccluderShapeSphere() {
if (get_shape().is_valid()) {
RenderingServer::get_singleton()->occluder_resource_prepare(get_shape(), RenderingServer::OCCLUDER_TYPE_SPHERE);
}
// Create a default sphere
Vector<Plane> planes;
planes.push_back(Plane(Vector3(0, 0, 0), 1));

5
scene/resources/occluder_shape_polygon.cpp
View File

@ -174,8 +174,6 @@ void OccluderShapePolygon::update_shape_to_rendering_server() {
}
face.plane = Plane(Vector3(0, 0, 0), Vector3(0, 0, -1));
RenderingServer::get_singleton()->occluder_resource_mesh_update(get_shape(), md);
}
void OccluderShapePolygon::set_two_way(bool p_two_way) {
@ -219,9 +217,6 @@ void OccluderShapePolygon::_bind_methods() {
}
OccluderShapePolygon::OccluderShapePolygon() {
if (get_shape().is_valid()) {
RenderingServer::get_singleton()->occluder_resource_prepare(get_shape(), RenderingServer::OCCLUDER_TYPE_MESH);
}
clear();

2
servers/rendering/SCsub
View File

@ -3,5 +3,3 @@
Import("env")
env.add_source_files(env.servers_sources, "*.cpp")
SConscript("portals/SCsub")

5
servers/rendering/portals/SCsub
View File

@ -1,5 +0,0 @@
#!/usr/bin/env python
Import("env")
env.add_source_files(env.servers_sources, "*.cpp")

41
servers/rendering/portals/portal_defines.h
View File

@ -1,41 +0,0 @@
#ifndef PORTAL_DEFINES_H
#define PORTAL_DEFINES_H
/*************************************************************************/
/* portal_defines.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. */
/*************************************************************************/
// This file is to allow constants etc to be accessible from outside the visual server,
// while keeping the dependencies to an absolute minimum.
struct PortalDefines {
static const int OCCLUSION_POLY_MAX_VERTS = 8;
static const int OCCLUSION_POLY_MAX_HOLES = 4;
};
#endif // PORTAL_DEFINES_H

478
servers/rendering/portals/portal_gameplay_monitor.cpp
View File

@ -1,478 +0,0 @@
/*************************************************************************/
/* portal_gameplay_monitor.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_gameplay_monitor.h"
#include "portal_renderer.h"
#include "portal_types.h"
#include "servers/rendering/rendering_server_globals.h"
#include "servers/rendering/rendering_server_scene.h"
PortalGameplayMonitor::PortalGameplayMonitor() {
_active_moving_pool_ids_prev = &_active_moving_pool_ids[0];
_active_moving_pool_ids_curr = &_active_moving_pool_ids[1];
_active_rghost_pool_ids_curr = &_active_rghost_pool_ids[0];
_active_rghost_pool_ids_prev = &_active_rghost_pool_ids[1];
_active_room_ids_prev = &_active_room_ids[0];
_active_room_ids_curr = &_active_room_ids[1];
_active_roomgroup_ids_prev = &_active_roomgroup_ids[0];
_active_roomgroup_ids_curr = &_active_roomgroup_ids[1];
_active_sghost_ids_prev = &_active_sghost_ids[0];
_active_sghost_ids_curr = &_active_sghost_ids[1];
}
bool PortalGameplayMonitor::_source_rooms_changed(const int *p_source_room_ids, int p_num_source_rooms) {
bool source_rooms_changed = false;
if (p_num_source_rooms == _source_rooms_prev.size()) {
for (int n = 0; n < p_num_source_rooms; n++) {
if (p_source_room_ids[n] != (int)_source_rooms_prev[n]) {
source_rooms_changed = true;
break;
}
}
} else {
source_rooms_changed = true;
}
if (source_rooms_changed) {
_source_rooms_prev.clear();
for (int n = 0; n < p_num_source_rooms; n++) {
_source_rooms_prev.push_back(p_source_room_ids[n]);
}
}
return source_rooms_changed;
}
void PortalGameplayMonitor::unload(PortalRenderer &p_portal_renderer) {
// First : send gameplay exit signals for any objects still in gameplay
////////////////////////////////////////////////////////////////////
// lock output
RenderingServerCallbacks *callbacks = RSG::scene->get_callbacks();
callbacks->lock();
// Remove any movings
for (int n = 0; n < _active_moving_pool_ids_prev->size(); n++) {
int pool_id = (*_active_moving_pool_ids_prev)[n];
PortalRenderer::Moving &moving = p_portal_renderer.get_pool_moving(pool_id);
moving.last_gameplay_tick_hit = 0;
RenderingServerCallbacks::Message msg;
msg.object_id = RSG::scene->_instance_get_object_ID(moving.instance);
msg.type = _exit_callback_type;
callbacks->push_message(msg);
}
// Remove any roaming ghosts
for (int n = 0; n < _active_rghost_pool_ids_prev->size(); n++) {
int pool_id = (*_active_rghost_pool_ids_prev)[n];
PortalRenderer::RGhost &moving = p_portal_renderer.get_pool_rghost(pool_id);
moving.last_gameplay_tick_hit = 0;
RenderingServerCallbacks::Message msg;
msg.object_id = moving.object_id;
msg.type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_EXIT_GAMEPLAY;
callbacks->push_message(msg);
}
// Rooms
for (int n = 0; n < _active_room_ids_prev->size(); n++) {
int room_id = (*_active_room_ids_prev)[n];
VSRoom &room = p_portal_renderer.get_room(room_id);
room.last_room_tick_hit = 0;
RenderingServerCallbacks::Message msg;
msg.object_id = room._pandemonium_instance_ID;
msg.type = _exit_callback_type;
callbacks->push_message(msg);
}
// RoomGroups
for (int n = 0; n < _active_roomgroup_ids_prev->size(); n++) {
int roomgroup_id = (*_active_roomgroup_ids_prev)[n];
VSRoomGroup &roomgroup = p_portal_renderer.get_roomgroup(roomgroup_id);
roomgroup.last_room_tick_hit = 0;
RenderingServerCallbacks::Message msg;
msg.object_id = roomgroup._pandemonium_instance_ID;
msg.type = _exit_callback_type;
callbacks->push_message(msg);
}
// Static Ghosts
for (int n = 0; n < _active_sghost_ids_prev->size(); n++) {
int id = (*_active_sghost_ids_prev)[n];
VSStaticGhost &ghost = p_portal_renderer.get_static_ghost(id);
ghost.last_room_tick_hit = 0;
RenderingServerCallbacks::Message msg;
msg.object_id = ghost.object_id;
msg.type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_EXIT_GAMEPLAY;
callbacks->push_message(msg);
}
// unlock
callbacks->unlock();
// Clear all remaining data
for (int n = 0; n < 2; n++) {
_active_moving_pool_ids[n].clear();
_active_rghost_pool_ids[n].clear();
_active_room_ids[n].clear();
_active_roomgroup_ids[n].clear();
_active_sghost_ids[n].clear();
}
_source_rooms_prev.clear();
// Lets not reset this just in case because it may be possible to have a moving outside the room system
// which is preserved between levels, and has a stored gameplay tick. And with uint32_t this should take
// a *long* time to rollover... (828 days?). And I don't think a rollover would actually cause a problem in practice.
// But can revisit this in the case of e.g. servers running continuously.
// We could alternatively go through all movings (not just active) etc and reset the last_gameplay_tick_hit to 0.
// _gameplay_tick = 1;
}
void PortalGameplayMonitor::set_params(bool p_use_secondary_pvs, bool p_use_signals) {
_use_secondary_pvs = p_use_secondary_pvs;
_use_signals = p_use_signals;
if (_use_signals) {
_enter_callback_type = RenderingServerCallbacks::CALLBACK_SIGNAL_ENTER_GAMEPLAY;
_exit_callback_type = RenderingServerCallbacks::CALLBACK_SIGNAL_EXIT_GAMEPLAY;
} else {
_enter_callback_type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_ENTER_GAMEPLAY;
_exit_callback_type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_EXIT_GAMEPLAY;
}
}
// can work with 1 or multiple cameras
void PortalGameplayMonitor::update_gameplay(PortalRenderer &p_portal_renderer, const int *p_source_room_ids, int p_num_source_rooms) {
const PVS &pvs = p_portal_renderer.get_pvs();
_gameplay_tick++;
// if there is no change in the source room IDs, then we can optimize out a lot of the checks
// (anything not to do with roamers)
bool source_rooms_changed = _source_rooms_changed(p_source_room_ids, p_num_source_rooms);
if (source_rooms_changed) {
_room_tick++;
}
// lock output
RenderingServerCallbacks *callbacks = RSG::scene->get_callbacks();
callbacks->lock();
for (int n = 0; n < p_num_source_rooms; n++) {
const VSRoom &source_room = p_portal_renderer.get_room(p_source_room_ids[n]);
if (_use_secondary_pvs) {
int pvs_size = source_room._secondary_pvs_size;
int pvs_first = source_room._secondary_pvs_first;
for (int r = 0; r < pvs_size; r++) {
int room_id = pvs.get_secondary_pvs_room_id(pvs_first + r);
_update_gameplay_room(p_portal_renderer, room_id, source_rooms_changed);
} // for r through the rooms hit in the pvs
} else {
int pvs_size = source_room._pvs_size;
int pvs_first = source_room._pvs_first;
for (int r = 0; r < pvs_size; r++) {
int room_id = pvs.get_pvs_room_id(pvs_first + r);
_update_gameplay_room(p_portal_renderer, room_id, source_rooms_changed);
} // for r through the rooms hit in the pvs
}
} // for n through source rooms
// find any moving that were active last tick that are no longer active, and send notifications
for (int n = 0; n < _active_moving_pool_ids_prev->size(); n++) {
int pool_id = (*_active_moving_pool_ids_prev)[n];
PortalRenderer::Moving &moving = p_portal_renderer.get_pool_moving(pool_id);
// gone out of view
if (moving.last_gameplay_tick_hit != _gameplay_tick) {
RenderingServerCallbacks::Message msg;
msg.object_id = RSG::scene->_instance_get_object_ID(moving.instance);
msg.type = _exit_callback_type;
callbacks->push_message(msg);
}
}
// find any roaming ghosts that were active last tick that are no longer active, and send notifications
for (int n = 0; n < _active_rghost_pool_ids_prev->size(); n++) {
int pool_id = (*_active_rghost_pool_ids_prev)[n];
PortalRenderer::RGhost &moving = p_portal_renderer.get_pool_rghost(pool_id);
// gone out of view
if (moving.last_gameplay_tick_hit != _gameplay_tick) {
RenderingServerCallbacks::Message msg;
msg.object_id = moving.object_id;
msg.type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_EXIT_GAMEPLAY;
callbacks->push_message(msg);
}
}
if (source_rooms_changed) {
// find any rooms that were active last tick that are no longer active, and send notifications
for (int n = 0; n < _active_room_ids_prev->size(); n++) {
int room_id = (*_active_room_ids_prev)[n];
const VSRoom &room = p_portal_renderer.get_room(room_id);
// gone out of view
if (room.last_room_tick_hit != _room_tick) {
RenderingServerCallbacks::Message msg;
msg.object_id = room._pandemonium_instance_ID;
msg.type = _exit_callback_type;
callbacks->push_message(msg);
}
}
// find any roomgroups that were active last tick that are no longer active, and send notifications
for (int n = 0; n < _active_roomgroup_ids_prev->size(); n++) {
int roomgroup_id = (*_active_roomgroup_ids_prev)[n];
const VSRoomGroup &roomgroup = p_portal_renderer.get_roomgroup(roomgroup_id);
// gone out of view
if (roomgroup.last_room_tick_hit != _room_tick) {
RenderingServerCallbacks::Message msg;
msg.object_id = roomgroup._pandemonium_instance_ID;
msg.type = _exit_callback_type;
callbacks->push_message(msg);
}
}
// find any static ghosts that were active last tick that are no longer active, and send notifications
for (int n = 0; n < _active_sghost_ids_prev->size(); n++) {
int id = (*_active_sghost_ids_prev)[n];
VSStaticGhost &ghost = p_portal_renderer.get_static_ghost(id);
// gone out of view
if (ghost.last_room_tick_hit != _room_tick) {
RenderingServerCallbacks::Message msg;
msg.object_id = ghost.object_id;
msg.type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_EXIT_GAMEPLAY;
callbacks->push_message(msg);
}
}
} // only need to check these if the source rooms changed
// unlock
callbacks->unlock();
// swap the current and previous lists
_swap(source_rooms_changed);
}
void PortalGameplayMonitor::_update_gameplay_room(PortalRenderer &p_portal_renderer, int p_room_id, bool p_source_rooms_changed) {
// get the room
VSRoom &room = p_portal_renderer.get_room(p_room_id);
int num_roamers = room._roamer_pool_ids.size();
RenderingServerCallbacks *callbacks = RSG::scene->get_callbacks();
for (int n = 0; n < num_roamers; n++) {
uint32_t pool_id = room._roamer_pool_ids[n];
PortalRenderer::Moving &moving = p_portal_renderer.get_pool_moving(pool_id);
// done already?
if (moving.last_gameplay_tick_hit == _gameplay_tick)
continue;
// add to the active list
_active_moving_pool_ids_curr->push_back(pool_id);
// if wasn't present in the tick before, add the notification to enter
if (moving.last_gameplay_tick_hit != (_gameplay_tick - 1)) {
RenderingServerCallbacks::Message msg;
msg.object_id = RSG::scene->_instance_get_object_ID(moving.instance);
msg.type = _enter_callback_type;
callbacks->push_message(msg);
}
// mark as done
moving.last_gameplay_tick_hit = _gameplay_tick;
}
// roaming ghosts
int num_rghosts = room._rghost_pool_ids.size();
for (int n = 0; n < num_rghosts; n++) {
uint32_t pool_id = room._rghost_pool_ids[n];
PortalRenderer::RGhost &moving = p_portal_renderer.get_pool_rghost(pool_id);
// done already?
if (moving.last_gameplay_tick_hit == _gameplay_tick)
continue;
// add to the active list
_active_rghost_pool_ids_curr->push_back(pool_id);
// if wasn't present in the tick before, add the notification to enter
if (moving.last_gameplay_tick_hit != (_gameplay_tick - 1)) {
RenderingServerCallbacks::Message msg;
msg.object_id = moving.object_id;
msg.type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_ENTER_GAMEPLAY;
callbacks->push_message(msg);
}
// mark as done
moving.last_gameplay_tick_hit = _gameplay_tick;
}
// no need to progress from here
if (!p_source_rooms_changed) {
return;
}
// has the room come into gameplay?
// later tests only relevant if a room has just come into play
bool room_came_into_play = false;
if (room.last_room_tick_hit != _room_tick) {
room_came_into_play = true;
// add the room to the active list
_active_room_ids_curr->push_back(p_room_id);
// if wasn't present in the tick before, add the notification to enter
if (room.last_room_tick_hit != (_room_tick - 1)) {
RenderingServerCallbacks::Message msg;
msg.object_id = room._pandemonium_instance_ID;
msg.type = _enter_callback_type;
callbacks->push_message(msg);
}
// mark as done
room.last_room_tick_hit = _room_tick;
}
// no need to do later tests
if (!room_came_into_play) {
return;
}
///////////////////////////////////////////////////////////////////
// has the roomgroup come into gameplay?
for (int n = 0; n < room._roomgroup_ids.size(); n++) {
int roomgroup_id = room._roomgroup_ids[n];
VSRoomGroup &roomgroup = p_portal_renderer.get_roomgroup(roomgroup_id);
if (roomgroup.last_room_tick_hit != _room_tick) {
// add the room to the active list
_active_roomgroup_ids_curr->push_back(roomgroup_id);
// if wasn't present in the tick before, add the notification to enter
if (roomgroup.last_room_tick_hit != (_room_tick - 1)) {
RenderingServerCallbacks::Message msg;
msg.object_id = roomgroup._pandemonium_instance_ID;
msg.type = _enter_callback_type;
callbacks->push_message(msg);
}
// mark as done
roomgroup.last_room_tick_hit = _room_tick;
}
} // for through roomgroups
// static ghosts
int num_sghosts = room._static_ghost_ids.size();
for (int n = 0; n < num_sghosts; n++) {
uint32_t id = room._static_ghost_ids[n];
VSStaticGhost &ghost = p_portal_renderer.get_static_ghost(id);
// done already?
if (ghost.last_room_tick_hit == _room_tick)
continue;
// add to the active list
_active_sghost_ids_curr->push_back(id);
// if wasn't present in the tick before, add the notification to enter
if (ghost.last_room_tick_hit != (_room_tick - 1)) {
RenderingServerCallbacks::Message msg;
msg.object_id = ghost.object_id;
msg.type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_ENTER_GAMEPLAY;
callbacks->push_message(msg);
}
// mark as done
ghost.last_room_tick_hit = _room_tick;
}
}
void PortalGameplayMonitor::_swap(bool p_source_rooms_changed) {
LocalVector<uint32_t, int32_t> *temp = _active_moving_pool_ids_curr;
_active_moving_pool_ids_curr = _active_moving_pool_ids_prev;
_active_moving_pool_ids_prev = temp;
_active_moving_pool_ids_curr->clear();
temp = _active_rghost_pool_ids_curr;
_active_rghost_pool_ids_curr = _active_rghost_pool_ids_prev;
_active_rghost_pool_ids_prev = temp;
_active_rghost_pool_ids_curr->clear();
if (p_source_rooms_changed) {
temp = _active_room_ids_curr;
_active_room_ids_curr = _active_room_ids_prev;
_active_room_ids_prev = temp;
_active_room_ids_curr->clear();
temp = _active_roomgroup_ids_curr;
_active_roomgroup_ids_curr = _active_roomgroup_ids_prev;
_active_roomgroup_ids_prev = temp;
_active_roomgroup_ids_curr->clear();
temp = _active_sghost_ids_curr;
_active_sghost_ids_curr = _active_sghost_ids_prev;
_active_sghost_ids_prev = temp;
_active_sghost_ids_curr->clear();
}
}

95
servers/rendering/portals/portal_gameplay_monitor.h
View File

@ -1,95 +0,0 @@
#ifndef PORTAL_GAMEPLAY_MONITOR_H
#define PORTAL_GAMEPLAY_MONITOR_H
/*************************************************************************/
/* portal_gameplay_monitor.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 "core/containers/local_vector.h"
#include "servers/rendering_server_callbacks.h"
#include <stdint.h>
class PortalRenderer;
struct VSRoom;
class PortalGameplayMonitor {
public:
PortalGameplayMonitor();
void unload(PortalRenderer &p_portal_renderer);
// entering and exiting gameplay notifications (requires PVS)
void update_gameplay(PortalRenderer &p_portal_renderer, const int *p_source_room_ids, int p_num_source_rooms);
void set_params(bool p_use_secondary_pvs, bool p_use_signals);
private:
void _update_gameplay_room(PortalRenderer &p_portal_renderer, int p_room_id, bool p_source_rooms_changed);
bool _source_rooms_changed(const int *p_source_room_ids, int p_num_source_rooms);
void _swap(bool p_source_rooms_changed);
// gameplay ticks happen every physics tick
uint32_t _gameplay_tick = 1;
// Room ticks only happen when the rooms the cameras are within change.
// This is an optimization. This tick needs to be maintained separately from _gameplay_tick
// because testing against the previous tick is used to determine whether to send enter or exit
// gameplay notifications, and this must be synchronized differently for rooms, roomgroups and static ghosts.
uint32_t _room_tick = 1;
// we need two version, current and previous
LocalVector<uint32_t, int32_t> _active_moving_pool_ids[2];
LocalVector<uint32_t, int32_t> *_active_moving_pool_ids_curr;
LocalVector<uint32_t, int32_t> *_active_moving_pool_ids_prev;
LocalVector<uint32_t, int32_t> _active_rghost_pool_ids[2];
LocalVector<uint32_t, int32_t> *_active_rghost_pool_ids_curr;
LocalVector<uint32_t, int32_t> *_active_rghost_pool_ids_prev;
LocalVector<uint32_t, int32_t> _active_room_ids[2];
LocalVector<uint32_t, int32_t> *_active_room_ids_curr;
LocalVector<uint32_t, int32_t> *_active_room_ids_prev;
LocalVector<uint32_t, int32_t> _active_roomgroup_ids[2];
LocalVector<uint32_t, int32_t> *_active_roomgroup_ids_curr;
LocalVector<uint32_t, int32_t> *_active_roomgroup_ids_prev;
LocalVector<uint32_t, int32_t> _active_sghost_ids[2];
LocalVector<uint32_t, int32_t> *_active_sghost_ids_curr;
LocalVector<uint32_t, int32_t> *_active_sghost_ids_prev;
LocalVector<uint32_t, int32_t> _source_rooms_prev;
RenderingServerCallbacks::CallbackType _enter_callback_type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_ENTER_GAMEPLAY;
RenderingServerCallbacks::CallbackType _exit_callback_type = RenderingServerCallbacks::CALLBACK_NOTIFICATION_EXIT_GAMEPLAY;
bool _use_secondary_pvs = false;
bool _use_signals = false;
};
#endif

952
servers/rendering/portals/portal_occlusion_culler.cpp
View File

@ -1,952 +0,0 @@
/*************************************************************************/
/* portal_occlusion_culler.cpp */
/*************************************************************************/
/* This file is part of: */
/* PANDEMONIUM 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_occlusion_culler.h"
#include "core/config/engine.h"
#include "core/math/aabb.h"
#include "core/config/project_settings.h"
#include "portal_renderer.h"
#include "servers/rendering/rendering_server_globals.h"
#include "servers/rendering/rendering_server_scene.h"
#define _log(a, b) ;
//#define _log_prepare(a) log(a, 0)
#define _log_prepare(a) ;
bool PortalOcclusionCuller::_debug_log = true;
bool PortalOcclusionCuller::_redraw_gizmo = false;
void PortalOcclusionCuller::Clipper::debug_print_points(String p_string) {
print_line(p_string);
for (int n = 0; n < _pts_in.size(); n++) {
print_line("\t" + itos(n) + " : " + String(Variant(_pts_in[n])));
}
}
Plane PortalOcclusionCuller::Clipper::interpolate(const Plane &p_a, const Plane &p_b, real_t p_t) const {
Vector3 diff = p_b.normal - p_a.normal;
real_t d = p_b.d - p_a.d;
diff *= p_t;
d *= p_t;
return Plane(p_a.normal + diff, p_a.d + d);
}
real_t PortalOcclusionCuller::Clipper::clip_and_find_poly_area(const Plane *p_verts, int p_num_verts) {
_pts_in.clear();
_pts_out.clear();
// seed
for (int n = 0; n < p_num_verts; n++) {
_pts_in.push_back(p_verts[n]);
}
if (!clip_to_plane(-1, 0, 0, 1)) {
return 0.0;
}
if (!clip_to_plane(1, 0, 0, 1)) {
return 0.0;
}
if (!clip_to_plane(0, -1, 0, 1)) {
return 0.0;
}
if (!clip_to_plane(0, 1, 0, 1)) {
return 0.0;
}
if (!clip_to_plane(0, 0, -1, 1)) {
return 0.0;
}
if (!clip_to_plane(0, 0, 1, 1)) {
return 0.0;
}
// perspective divide
_pts_final.resize(_pts_in.size());
for (int n = 0; n < _pts_in.size(); n++) {
_pts_final[n] = _pts_in[n].normal / _pts_in[n].d;
}
return Geometry::find_polygon_area(&_pts_final[0], _pts_final.size());
}
bool PortalOcclusionCuller::Clipper::is_inside(const Plane &p_pt, Boundary p_boundary) {
real_t w = p_pt.d;
switch (p_boundary) {
case B_LEFT: {
return p_pt.normal.x > -w;
} break;
case B_RIGHT: {
return p_pt.normal.x < w;
} break;
case B_TOP: {
return p_pt.normal.y < w;
} break;
case B_BOTTOM: {
return p_pt.normal.y > -w;
} break;
case B_NEAR: {
return p_pt.normal.z < w;
} break;
case B_FAR: {
return p_pt.normal.z > -w;
} break;
default:
break;
}
return false;
}
// a is out, b is in
Plane PortalOcclusionCuller::Clipper::intersect(const Plane &p_a, const Plane &p_b, Boundary p_boundary) {
Plane diff_plane(p_b.normal - p_a.normal, p_b.d - p_a.d);
const Vector3 &diff = diff_plane.normal;
real_t t = 0.0;
const real_t epsilon = 0.001f;
// prevent divide by zero
switch (p_boundary) {
case B_LEFT: {
if (diff.x > epsilon) {
t = (-1.0f - p_a.normal.x) / diff.x;
}
} break;
case B_RIGHT: {
if (-diff.x > epsilon) {
t = (p_a.normal.x - 1.0f) / -diff.x;
}
} break;
case B_TOP: {
if (-diff.y > epsilon) {
t = (p_a.normal.y - 1.0f) / -diff.y;
}
} break;
case B_BOTTOM: {
if (diff.y > epsilon) {
t = (-1.0f - p_a.normal.y) / diff.y;
}
} break;
case B_NEAR: {
if (-diff.z > epsilon) {
t = (p_a.normal.z - 1.0f) / -diff.z;
}
} break;
case B_FAR: {
if (diff.z > epsilon) {
t = (-1.0f - p_a.normal.z) / diff.z;
}
} break;
default:
break;
}
diff_plane.normal *= t;
diff_plane.d *= t;
return Plane(p_a.normal + diff_plane.normal, p_a.d + diff_plane.d);
}
// Clip the poly to the plane given by the formula a * x + b * y + c * z + d * w.
bool PortalOcclusionCuller::Clipper::clip_to_plane(real_t a, real_t b, real_t c, real_t d) {
_pts_out.clear();
// repeat the first
_pts_in.push_back(_pts_in[0]);
Plane vPrev = _pts_in[0];
real_t dpPrev = a * vPrev.normal.x + b * vPrev.normal.y + c * vPrev.normal.z + d * vPrev.d;
for (int i = 1; i < _pts_in.size(); ++i) {
Plane v = _pts_in[i];
real_t dp = a * v.normal.x + b * v.normal.y + c * v.normal.z + d * v.d;
if (dpPrev >= 0) {
_pts_out.push_back(vPrev);
}
if (sgn(dp) != sgn(dpPrev)) {
real_t t = dp < 0 ? dpPrev / (dpPrev - dp) : -dpPrev / (dp - dpPrev);
Plane vOut = interpolate(vPrev, v, t);
_pts_out.push_back(vOut);
}
vPrev = v;
dpPrev = dp;
}
// start again from the output points next time
_pts_in = _pts_out;
return _pts_in.size() > 2;
}
Geometry::MeshData PortalOcclusionCuller::debug_get_current_polys() const {
Geometry::MeshData md;
for (int n = 0; n < _num_polys; n++) {
const Occlusion::PolyPlane &p = _polys[n].poly;
int first_index = md.vertices.size();
Vector3 normal_push = p.plane.normal * 0.001f;
// copy verts
for (int c = 0; c < p.num_verts; c++) {
md.vertices.push_back(p.verts[c] + normal_push);
}
// indices
Geometry::MeshData::Face face;
// triangle fan
face.indices.resize(p.num_verts);
for (int c = 0; c < p.num_verts; c++) {
face.indices.set(c, first_index + c);
}
md.faces.push_back(face);
}
return md;
}
void PortalOcclusionCuller::prepare_generic(PortalRenderer &p_portal_renderer, const LocalVector<uint32_t, uint32_t> &p_occluder_pool_ids, const Vector3 &pt_camera, const LocalVector<Plane> &p_planes) {
_portal_renderer = &p_portal_renderer;
// Bodge to keep settings up to date, until the project settings PR is merged
#ifdef TOOLS_ENABLED
if (Engine::get_singleton()->is_editor_hint() && ((Engine::get_singleton()->get_frames_drawn() % 16) == 0)) {
_max_polys = GLOBAL_GET("rendering/misc/occlusion_culling/max_active_polygons");
}
#endif
_num_spheres = 0;
_pt_camera = pt_camera;
// spheres
_num_spheres = 0;
real_t goodness_of_fit_sphere[MAX_SPHERES];
for (int n = 0; n < _max_spheres; n++) {
goodness_of_fit_sphere[n] = 0.0f;
}
real_t weakest_fit_sphere = FLT_MAX;
int weakest_sphere = 0;
_sphere_closest_dist = FLT_MAX;
// polys
_num_polys = 0;
for (int n = 0; n < _max_polys; n++) {
_polys[n].goodness_of_fit = 0.0f;
}
real_t weakest_fit_poly = FLT_MAX;
int weakest_poly_id = 0;
#ifdef TOOLS_ENABLED
uint32_t polycount = 0;
#endif
const PortalResources &resources = RSG::scene->get_portal_resources();
// find occluders
for (unsigned int o = 0; o < p_occluder_pool_ids.size(); o++) {
int id = p_occluder_pool_ids[o];
VSOccluder_Instance &occ = p_portal_renderer.get_pool_occluder_instance(id);
// is it active?
// in the case of rooms, they will always be active, as inactive
// are removed from rooms. But for whole scene mode, some may be inactive.
if (!occ.active) {
continue;
}
// TODO : occlusion cull spheres AGAINST themselves.
// i.e. a sphere that is occluded by another occluder is no
// use as an occluder...
if (occ.type == VSOccluder_Instance::OT_SPHERE) {
// make sure world space spheres are up to date
p_portal_renderer.occluder_ensure_up_to_date_sphere(resources, occ);
// cull entire AABB
if (is_aabb_culled(occ.aabb, p_planes)) {
continue;
}
// multiple spheres
for (int n = 0; n < occ.list_ids.size(); n++) {
const Occlusion::Sphere &occluder_sphere = p_portal_renderer.get_pool_occluder_world_sphere(occ.list_ids[n]);
// is the occluder sphere culled?
if (is_sphere_culled(occluder_sphere.pos, occluder_sphere.radius, p_planes)) {
continue;
}
real_t dist = (occluder_sphere.pos - pt_camera).length();
// calculate the goodness of fit .. smaller distance better, and larger radius
// calculate adjusted radius at 100.0
real_t fit = 100 / MAX(dist, 0.01f);
fit *= occluder_sphere.radius;
// until we reach the max, just keep recording, and keep track
// of the worst fit
if (_num_spheres < _max_spheres) {
_spheres[_num_spheres] = occluder_sphere;
_sphere_distances[_num_spheres] = dist;
goodness_of_fit_sphere[_num_spheres] = fit;
if (fit < weakest_fit_sphere) {
weakest_fit_sphere = fit;
weakest_sphere = _num_spheres;
}
// keep a record of the closest sphere for quick rejects
if (dist < _sphere_closest_dist) {
_sphere_closest_dist = dist;
}
_num_spheres++;
} else {
// must beat the weakest
if (fit > weakest_fit_sphere) {
_spheres[weakest_sphere] = occluder_sphere;
_sphere_distances[weakest_sphere] = dist;
goodness_of_fit_sphere[weakest_sphere] = fit;
// keep a record of the closest sphere for quick rejects
if (dist < _sphere_closest_dist) {
_sphere_closest_dist = dist;
}
// the weakest may have changed (this could be done more efficiently)
weakest_fit_sphere = FLT_MAX;
for (int s = 0; s < _max_spheres; s++) {
if (goodness_of_fit_sphere[s] < weakest_fit_sphere) {
weakest_fit_sphere = goodness_of_fit_sphere[s];
weakest_sphere = s;
}
}
}
}
}
} // sphere
if (occ.type == VSOccluder_Instance::OT_MESH) {
// make sure world space spheres are up to date
p_portal_renderer.occluder_ensure_up_to_date_polys(resources, occ);
// multiple polys
for (int n = 0; n < occ.list_ids.size(); n++) {
const VSOccluder_Poly &opoly = p_portal_renderer.get_pool_occluder_world_poly(occ.list_ids[n]);
const Occlusion::PolyPlane &poly = opoly.poly;
// backface cull
bool faces_camera = poly.plane.is_point_over(pt_camera);
if (!faces_camera && !opoly.two_way) {
continue;
}
real_t fit;
if (!calculate_poly_goodness_of_fit(opoly, fit)) {
continue;
}
if (_num_polys < _max_polys) {
SortPoly &dest = _polys[_num_polys];
dest.poly = poly;
dest.flags = faces_camera ? SortPoly::SPF_FACES_CAMERA : 0;
if (opoly.num_holes) {
dest.flags |= SortPoly::SPF_HAS_HOLES;
}
#ifdef TOOLS_ENABLED
dest.poly_source_id = polycount++;
#endif
dest.mesh_source_id = occ.list_ids[n];
dest.goodness_of_fit = fit;
if (fit < weakest_fit_poly) {
weakest_fit_poly = fit;
weakest_poly_id = _num_polys;
}
_num_polys++;
} else {
// must beat the weakest
if (fit > weakest_fit_poly) {
SortPoly &dest = _polys[weakest_poly_id];
dest.poly = poly;
//dest.faces_camera = faces_camera;
dest.flags = faces_camera ? SortPoly::SPF_FACES_CAMERA : 0;
if (opoly.num_holes) {
dest.flags |= SortPoly::SPF_HAS_HOLES;
}
#ifdef TOOLS_ENABLED
dest.poly_source_id = polycount++;
#endif
dest.mesh_source_id = occ.list_ids[n];
dest.goodness_of_fit = fit;
// the weakest may have changed (this could be done more efficiently)
weakest_fit_poly = FLT_MAX;
for (int p = 0; p < _max_polys; p++) {
real_t goodness_of_fit = _polys[p].goodness_of_fit;
if (goodness_of_fit < weakest_fit_poly) {
weakest_fit_poly = goodness_of_fit;
weakest_poly_id = p;
}
}
}
} // polys full up, replace
}
}
} // for o
precalc_poly_edge_planes(pt_camera);
// flip polys so always facing camera
for (int n = 0; n < _num_polys; n++) {
if (!(_polys[n].flags & SortPoly::SPF_FACES_CAMERA)) {
_polys[n].poly.flip();
// must flip holes and planes too
_precalced_poly[n].flip();
}
}
// cull polys against each other.
whittle_polys();
// checksum is used only in the editor, to decide
// whether to redraw the gizmo of active polys
#ifdef TOOLS_ENABLED
uint32_t last_checksum = _poly_checksum;
_poly_checksum = 0;
for (int n = 0; n < _num_polys; n++) {
_poly_checksum += _polys[n].poly_source_id;
//_log_prepare("prepfinal : " + itos(_polys[n].poly_source_id) + " fit : " + rtos(_polys[n].goodness_of_fit));
}
if (_poly_checksum != last_checksum) {
_redraw_gizmo = true;
}
#endif
// force the sphere closest distance to above zero to prevent
// divide by zero in the quick reject
_sphere_closest_dist = MAX(_sphere_closest_dist, 0.001);
// sphere self occlusion.
// we could avoid testing the closest sphere, but the complexity isn't worth any speed benefit
for (int n = 0; n < _num_spheres; n++) {
const Occlusion::Sphere &sphere = _spheres[n];
// is it occluded by another sphere?
if (cull_sphere(sphere.pos, sphere.radius, n)) {
// yes, unordered remove
_num_spheres--;
_spheres[n] = _spheres[_num_spheres];
_sphere_distances[n] = _sphere_distances[_num_spheres];
// repeat this n
n--;
}
}
// record whether to do any occlusion culling at all..
_occluders_present = _num_spheres || _num_polys;
}
void PortalOcclusionCuller::precalc_poly_edge_planes(const Vector3 &p_pt_camera) {
for (int n = 0; n < _num_polys; n++) {
const SortPoly &sortpoly = _polys[n];
const Occlusion::PolyPlane &spoly = sortpoly.poly;
PreCalcedPoly &dpoly = _precalced_poly[n];
dpoly.edge_planes.num_planes = spoly.num_verts;
for (int e = 0; e < spoly.num_verts; e++) {
// point a and b of the edge
const Vector3 &pt_a = spoly.verts[e];
const Vector3 &pt_b = spoly.verts[(e + 1) % spoly.num_verts];
// edge plane to camera
dpoly.edge_planes.planes[e] = Plane(p_pt_camera, pt_a, pt_b);
}
dpoly.num_holes = 0;
// holes
if (sortpoly.flags & SortPoly::SPF_HAS_HOLES) {
// get the mesh poly and the holes
const VSOccluder_Poly &mesh = _portal_renderer->get_pool_occluder_world_poly(sortpoly.mesh_source_id);
dpoly.num_holes = mesh.num_holes;
for (int h = 0; h < mesh.num_holes; h++) {
uint32_t hid = mesh.hole_pool_ids[h];
const VSOccluder_Hole &hole = _portal_renderer->get_pool_occluder_world_hole(hid);
// copy the verts to the precalced poly,
// we will need these later for whittling polys.
// We could alternatively link back to the original verts, but that gets messy.
dpoly.hole_polys[h] = hole;
int hole_num_verts = hole.num_verts;
const Vector3 *hverts = hole.verts;
// number of planes equals number of verts forming edges
dpoly.hole_edge_planes[h].num_planes = hole_num_verts;
for (int e = 0; e < hole_num_verts; e++) {
const Vector3 &pt_a = hverts[e];
const Vector3 &pt_b = hverts[(e + 1) % hole_num_verts];
dpoly.hole_edge_planes[h].planes[e] = Plane(p_pt_camera, pt_a, pt_b);
} // for e
} // for h
} // if has holes
}
}
void PortalOcclusionCuller::whittle_polys() {
//#define PANDEMONIUM_OCCLUSION_FLASH_POLYS
#ifdef PANDEMONIUM_OCCLUSION_FLASH_POLYS
if (((Engine::get_singleton()->get_frames_drawn() / 4) % 2) == 0) {
return;
}
#endif
bool repeat = true;
while (repeat) {
repeat = false;
// Check for complete occlusion of polys by a closer poly.
// Such polys can be completely removed from checks.
for (int n = 0; n < _num_polys; n++) {
// ensure we test each occluder once and only once
// (as this routine will repeat each time an occluded poly is found)
SortPoly &sort_poly = _polys[n];
if (!(sort_poly.flags & SortPoly::SPF_TESTED_AS_OCCLUDER)) {
sort_poly.flags |= SortPoly::SPF_TESTED_AS_OCCLUDER;
} else {
continue;
}
const Occlusion::PolyPlane &poly = _polys[n].poly;
const Plane &occluder_plane = poly.plane;
const PreCalcedPoly &pcp = _precalced_poly[n];
// the goodness of fit is the screen space area at the moment,
// so we can use it as a quick reject .. polys behind occluders will always
// be smaller area than the occluder.
real_t occluder_area = _polys[n].goodness_of_fit;
// check each other poly as an occludee
for (int t = 0; t < _num_polys; t++) {
if (n == t) {
continue;
}
// quick reject based on screen space area.
// if the area of the test poly is larger, it can't be completely behind
// the occluder.
bool quick_reject_entire_occludee = _polys[t].goodness_of_fit > occluder_area;
const Occlusion::PolyPlane &test_poly = _polys[t].poly;
PreCalcedPoly &pcp_test = _precalced_poly[t];
// We have two considerations:
// (1) Entire poly is occluded
// (2) If not (1), then maybe a hole is occluded
bool completely_reject = false;
if (!quick_reject_entire_occludee && is_poly_inside_occlusion_volume(test_poly, occluder_plane, pcp.edge_planes)) {
completely_reject = true;
// we must also test against all holes if some are present
for (int h = 0; h < pcp.num_holes; h++) {
if (is_poly_touching_hole(test_poly, pcp.hole_edge_planes[h])) {
completely_reject = false;
break;
}
}
if (completely_reject) {
// yes .. we can remove this poly .. but do not muck up the iteration of the list
//print_line("poly is occluded " + itos(t));
#ifdef TOOLS_ENABLED
// this condition should never happen, we should never be checking occludee against itself
DEV_ASSERT(_polys[t].poly_source_id != _polys[n].poly_source_id);
#endif
// unordered remove
_polys[t] = _polys[_num_polys - 1];
_precalced_poly[t] = _precalced_poly[_num_polys - 1];
_num_polys--;
// no NOT repeat the test poly if it was copied from n, i.e. the occludee would
// be the same as the occluder
if (_num_polys != n) {
// repeat this test poly as it will be the next
t--;
}
// If we end up removing a poly BEFORE n, the replacement poly (from the unordered remove)
// will never get tested as an occluder. So we have to account for this by rerunning the routine.
repeat = true;
} // allow due to holes
} // if poly inside occlusion volume
// if we did not completely reject, there could be holes that could be rejected
if (!completely_reject) {
if (pcp_test.num_holes) {
for (int h = 0; h < pcp_test.num_holes; h++) {
const Occlusion::Poly &hole_poly = pcp_test.hole_polys[h];
// is the hole within the occluder?
if (is_poly_inside_occlusion_volume(hole_poly, occluder_plane, pcp.edge_planes)) {
// if the hole touching a hole in the occluder? if so we can't eliminate it
bool allow = true;
for (int oh = 0; oh < pcp.num_holes; oh++) {
if (is_poly_touching_hole(hole_poly, pcp.hole_edge_planes[oh])) {
allow = false;
break;
}
}
if (allow) {
// Unordered remove the hole. No need to repeat the whole while loop I don't think?
// As this just makes it more efficient at runtime, it doesn't make the further whittling more accurate.
pcp_test.num_holes--;
pcp_test.hole_edge_planes[h] = pcp_test.hole_edge_planes[pcp_test.num_holes];
pcp_test.hole_polys[h] = pcp_test.hole_polys[pcp_test.num_holes];
h--; // repeat this as the unordered remove has placed a new member into h slot
} // allow
} // hole is within
}
} // has holes
} // did not completely reject
} // for t through occludees
} // for n through occluders
} // while repeat
// order polys by distance to camera / area? NYI
}
bool PortalOcclusionCuller::calculate_poly_goodness_of_fit(const VSOccluder_Poly &p_opoly, real_t &r_fit) {
// transform each of the poly points, find the area in screen space
// The points must be homogeneous coordinates, i.e. BEFORE
// the perspective divide, in clip space. They will have the perspective
// divide applied after clipping, to calculate the area.
// We therefore store them as planes to store the w coordinate as d.
Plane xpoints[Occlusion::PolyPlane::MAX_POLY_VERTS];
int num_verts = p_opoly.poly.num_verts;
for (int n = 0; n < num_verts; n++) {
// source and dest in homogeneous coords
Plane source(p_opoly.poly.verts[n], 1.0f);
Plane &dest = xpoints[n];
dest = _matrix_camera.xform(source);
}
// find screen space area
real_t area = _clipper.clip_and_find_poly_area(xpoints, num_verts);
if (area <= 0.0f) {
return false;
}
r_fit = area;
return true;
}
bool PortalOcclusionCuller::_is_poly_of_interest_to_split_plane(const Plane *p_poly_split_plane, int p_poly_id) const {
const Occlusion::PolyPlane &poly = _polys[p_poly_id].poly;
int over = 0;
int under = 0;
// we need an epsilon because adjacent polys that just
// join with a wall may have small floating point error ahead
// of the splitting plane.
const real_t epsilon = 0.005f;
for (int n = 0; n < poly.num_verts; n++) {
// point a and b of the edge
const Vector3 &pt = poly.verts[n];
real_t dist = p_poly_split_plane->distance_to(pt);
if (dist > epsilon) {
over++;
} else {
under++;
}
}
// return whether straddles the plane
return over && under;
}
bool PortalOcclusionCuller::cull_aabb_to_polys_ex(const AABB &p_aabb) const {
_log("\n", 0);
_log("* cull_aabb_to_polys_ex " + String(Variant(p_aabb)), 0);
Plane plane;
for (int n = 0; n < _num_polys; n++) {
_log("\tchecking poly " + itos(n), 0);
const SortPoly &sortpoly = _polys[n];
const Occlusion::PolyPlane &poly = sortpoly.poly;
// occludee must be on opposite side to camera
real_t omin, omax;
p_aabb.project_range_in_plane(poly.plane, omin, omax);
if (omax > -0.2f) {
_log("\t\tAABB is in front of occluder, ignoring", 0);
continue;
}
// test against each edge of the poly, and expand the edge
bool hit = true;
const PreCalcedPoly &pcp = _precalced_poly[n];
for (int e = 0; e < pcp.edge_planes.num_planes; e++) {
// edge plane to camera
plane = pcp.edge_planes.planes[e];
p_aabb.project_range_in_plane(plane, omin, omax);
if (omax > 0.0f) {
hit = false;
break;
}
}
// if it hit, check against holes
if (hit && pcp.num_holes) {
for (int h = 0; h < pcp.num_holes; h++) {
const PlaneSet &hole = pcp.hole_edge_planes[h];
// if the AABB is totally outside any edge, it is safe for a hit
bool safe = false;
for (int e = 0; e < hole.num_planes; e++) {
// edge plane to camera
plane = hole.planes[e];
p_aabb.project_range_in_plane(plane, omin, omax);
// if inside the hole, no longer a hit on this poly
if (omin > 0.0f) {
safe = true;
break;
}
} // for e
if (!safe) {
hit = false;
}
if (!hit) {
break;
}
} // for h
} // if has holes
// hit?
if (hit) {
return true;
}
}
_log("\tno hit", 0);
return false;
}
bool PortalOcclusionCuller::cull_aabb_to_polys(const AABB &p_aabb) const {
if (!_num_polys) {
return false;
}
return cull_aabb_to_polys_ex(p_aabb);
}
bool PortalOcclusionCuller::cull_sphere_to_polys(const Vector3 &p_occludee_center, real_t p_occludee_radius) const {
if (!_num_polys) {
return false;
}
Plane plane;
for (int n = 0; n < _num_polys; n++) {
const Occlusion::PolyPlane &poly = _polys[n].poly;
// test against each edge of the poly, and expand the edge
bool hit = true;
// occludee must be on opposite side to camera
real_t dist = poly.plane.distance_to(p_occludee_center);
if (dist > -p_occludee_radius) {
continue;
}
for (int e = 0; e < poly.num_verts; e++) {
plane = Plane(_pt_camera, poly.verts[e], poly.verts[(e + 1) % poly.num_verts]);
// de-expand
plane.d -= p_occludee_radius;
if (plane.is_point_over(p_occludee_center)) {
hit = false;
break;
}
}
// hit?
if (hit) {
return true;
}
}
return false;
}
bool PortalOcclusionCuller::cull_sphere_to_spheres(const Vector3 &p_occludee_center, real_t p_occludee_radius, const Vector3 &p_ray_dir, real_t p_dist_to_occludee, int p_ignore_sphere) const {
// maybe not required
if (!_num_spheres) {
return false;
}
// prevent divide by zero, and the occludee cannot be occluded if we are WITHIN
// its bounding sphere... so no need to check
if (p_dist_to_occludee < _sphere_closest_dist) {
return false;
}
// this can probably be done cheaper with dot products but the math might be a bit fiddly to get right
for (int s = 0; s < _num_spheres; s++) {
// first get the sphere distance
real_t occluder_dist_to_cam = _sphere_distances[s];
if (p_dist_to_occludee < occluder_dist_to_cam) {
// can't occlude
continue;
}
// the perspective adjusted occludee radius
real_t adjusted_occludee_radius = p_occludee_radius * (occluder_dist_to_cam / p_dist_to_occludee);
const Occlusion::Sphere &occluder_sphere = _spheres[s];
real_t occluder_radius = occluder_sphere.radius - adjusted_occludee_radius;
if (occluder_radius > 0.0) {
occluder_radius = occluder_radius * occluder_radius;
// distance to hit
real_t dist;
if (occluder_sphere.intersect_ray(_pt_camera, p_ray_dir, dist, occluder_radius)) {
if ((dist < p_dist_to_occludee) && (s != p_ignore_sphere)) {
// occluded
return true;
}
}
} // expanded occluder radius is more than 0
}
return false;
}
bool PortalOcclusionCuller::cull_sphere(const Vector3 &p_occludee_center, real_t p_occludee_radius, int p_ignore_sphere, bool p_cull_to_polys) const {
if (!_occluders_present) {
return false;
}
// ray from origin to the occludee
Vector3 ray_dir = p_occludee_center - _pt_camera;
real_t dist_to_occludee_raw = ray_dir.length();
// account for occludee radius
real_t dist_to_occludee = dist_to_occludee_raw - p_occludee_radius;
// ignore occlusion for closeup, and avoid divide by zero
if (dist_to_occludee_raw < 0.1) {
return false;
}
// normalize ray
// hopefully by this point, dist_to_occludee_raw cannot possibly be zero due to above check
ray_dir *= 1.0 / dist_to_occludee_raw;
if (cull_sphere_to_spheres(p_occludee_center, p_occludee_radius, ray_dir, dist_to_occludee, p_ignore_sphere)) {
return true;
}
if (p_cull_to_polys && cull_sphere_to_polys(p_occludee_center, p_occludee_radius)) {
return true;
}
return false;
}
PortalOcclusionCuller::PortalOcclusionCuller() {
_max_spheres = GLOBAL_GET("rendering/misc/occlusion_culling/max_active_spheres");
_max_polys = GLOBAL_GET("rendering/misc/occlusion_culling/max_active_polygons");
}
void PortalOcclusionCuller::log(String p_string, int p_depth) const {
if (_debug_log) {
for (int n = 0; n < p_depth; n++) {
p_string = "\t\t\t" + p_string;
}
print_line(p_string);
}
}
#undef _log
#undef _log_prepare

315
servers/rendering/portals/portal_occlusion_culler.h
View File

@ -1,315 +0,0 @@
#ifndef PORTAL_OCCLUSION_CULLER_H
#define PORTAL_OCCLUSION_CULLER_H
/*************************************************************************/
/* portal_occlusion_culler.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. */
/*************************************************************************/
class PortalRenderer;
#include "core/math/projection.h"
#include "core/math/geometry.h"
#include "portal_types.h"
class PortalOcclusionCuller {
enum {
MAX_SPHERES = 64,
MAX_POLYS = 64,
};
class Clipper {
public:
real_t clip_and_find_poly_area(const Plane *p_verts, int p_num_verts);
private:
enum Boundary {
B_LEFT,
B_RIGHT,
B_TOP,
B_BOTTOM,
B_NEAR,
B_FAR,
};
bool is_inside(const Plane &p_pt, Boundary p_boundary);
Plane intersect(const Plane &p_a, const Plane &p_b, Boundary p_boundary);
void debug_print_points(String p_string);
Plane interpolate(const Plane &p_a, const Plane &p_b, real_t p_t) const;
bool clip_to_plane(real_t a, real_t b, real_t c, real_t d);
LocalVectori<Plane> _pts_in;
LocalVectori<Plane> _pts_out;
// after perspective divide
LocalVectori<Vector3> _pts_final;
template <typename T>
int sgn(T val) {
return (T(0) < val) - (val < T(0));
}
};
public:
PortalOcclusionCuller();
void prepare_camera(const Projection &p_cam_matrix, const Vector3 &p_cam_dir) {
_matrix_camera = p_cam_matrix;
_pt_cam_dir = p_cam_dir;
}
void prepare(PortalRenderer &p_portal_renderer, const VSRoom &p_room, const Vector3 &pt_camera, const LocalVector<Plane> &p_planes, const Plane *p_near_plane) {
if (p_near_plane) {
static LocalVector<Plane> local_planes;
int size_wanted = p_planes.size() + 1;
if ((int)local_planes.size() != size_wanted) {
local_planes.resize(size_wanted);
}
for (int n = 0; n < (int)p_planes.size(); n++) {
local_planes[n] = p_planes[n];
}
local_planes[size_wanted - 1] = *p_near_plane;
prepare_generic(p_portal_renderer, p_room._occluder_pool_ids, pt_camera, local_planes);
} else {
prepare_generic(p_portal_renderer, p_room._occluder_pool_ids, pt_camera, p_planes);
}
}
void prepare_generic(PortalRenderer &p_portal_renderer, const LocalVector<uint32_t, uint32_t> &p_occluder_pool_ids, const Vector3 &pt_camera, const LocalVector<Plane> &p_planes);
bool cull_aabb(const AABB &p_aabb) const {
if (!_occluders_present) {
return false;
}
if (cull_aabb_to_polys(p_aabb)) {
return true;
}
return cull_sphere(p_aabb.get_center(), p_aabb.size.length() * 0.5, -1, false);
}
bool cull_sphere(const Vector3 &p_occludee_center, real_t p_occludee_radius, int p_ignore_sphere = -1, bool p_cull_to_polys = true) const;
Geometry::MeshData debug_get_current_polys() const;
static bool _redraw_gizmo;
private:
bool cull_sphere_to_spheres(const Vector3 &p_occludee_center, real_t p_occludee_radius, const Vector3 &p_ray_dir, real_t p_dist_to_occludee, int p_ignore_sphere) const;
bool cull_sphere_to_polys(const Vector3 &p_occludee_center, real_t p_occludee_radius) const;
bool cull_aabb_to_polys(const AABB &p_aabb) const;
// experimental
bool cull_aabb_to_polys_ex(const AABB &p_aabb) const;
bool _is_poly_of_interest_to_split_plane(const Plane *p_poly_split_plane, int p_poly_id) const;
// if a sphere is entirely in front of any of the culling planes, it can't be seen so returns false
bool is_sphere_culled(const Vector3 &p_pos, real_t p_radius, const LocalVector<Plane> &p_planes) const {
for (unsigned int p = 0; p < p_planes.size(); p++) {
real_t dist = p_planes[p].distance_to(p_pos);
if (dist > p_radius) {
return true;
}
}
return false;
}
bool is_aabb_culled(const AABB &p_aabb, const LocalVector<Plane> &p_planes) const {
const Vector3 &size = p_aabb.size;
Vector3 half_extents = size * 0.5;
Vector3 ofs = p_aabb.position + half_extents;
for (unsigned int i = 0; i < p_planes.size(); i++) {
const Plane &p = p_planes[i];
Vector3 point(
(p.normal.x > 0) ? -half_extents.x : half_extents.x,
(p.normal.y > 0) ? -half_extents.y : half_extents.y,
(p.normal.z > 0) ? -half_extents.z : half_extents.z);
point += ofs;
if (p.is_point_over(point)) {
return true;
}
}
return false;
}
bool calculate_poly_goodness_of_fit(const VSOccluder_Poly &p_opoly, real_t &r_fit);
void whittle_polys();
void precalc_poly_edge_planes(const Vector3 &p_pt_camera);
// If all the points of the poly are beyond one of the planes (e.g. frustum), it is completely culled.
bool is_poly_culled(const Occlusion::PolyPlane &p_opoly, const LocalVector<Plane> &p_planes) const {
for (unsigned int p = 0; p < p_planes.size(); p++) {
const Plane &plane = p_planes[p];
int points_outside = 0;
for (int n = 0; n < p_opoly.num_verts; n++) {
const Vector3 &pt = p_opoly.verts[n];
if (!plane.is_point_over(pt)) {
break;
} else {
points_outside++;
}
}
if (points_outside == p_opoly.num_verts) {
return true;
}
}
return false;
}
// All the points of the poly must be within ALL the planes to return true.
struct PlaneSet;
bool is_poly_inside_occlusion_volume(const Occlusion::Poly &p_test_poly, const Plane &p_occluder_plane, const PlaneSet &p_planeset) const {
// first test against the occluder poly plane
for (int n = 0; n < p_test_poly.num_verts; n++) {
const Vector3 &pt = p_test_poly.verts[n];
if (p_occluder_plane.is_point_over(pt)) {
return false;
}
}
for (int p = 0; p < p_planeset.num_planes; p++) {
const Plane &plane = p_planeset.planes[p];
for (int n = 0; n < p_test_poly.num_verts; n++) {
const Vector3 &pt = p_test_poly.verts[n];
if (plane.is_point_over(pt)) {
return false;
}
}
}
return true;
}
bool is_poly_touching_hole(const Occlusion::Poly &p_opoly, const PlaneSet &p_planeset) const {
if (!p_opoly.num_verts) {
// should not happen?
return false;
}
// find aabb
AABB bb;
bb.position = p_opoly.verts[0];
for (int n = 1; n < p_opoly.num_verts; n++) {
bb.expand_to(p_opoly.verts[n]);
}
// if the AABB is totally outside any edge, it is safe for a hit
real_t omin, omax;
for (int e = 0; e < p_planeset.num_planes; e++) {
// edge plane to camera
const Plane &plane = p_planeset.planes[e];
bb.project_range_in_plane(plane, omin, omax);
// if inside the hole, no longer a hit on this poly
if (omin > 0.0) {
return false;
}
} // for e
return true;
}
void log(String p_string, int p_depth = 0) const;
// only a number of the spheres in the scene will be chosen to be
// active based on their distance to the camera, screen space etc.
Occlusion::Sphere _spheres[MAX_SPHERES];
real_t _sphere_distances[MAX_SPHERES];
real_t _sphere_closest_dist = 0.0;
int _num_spheres = 0;
int _max_spheres = 8;
struct SortPoly {
enum SortPolyFlags {
SPF_FACES_CAMERA = 1,
SPF_DONE = 2,
SPF_TESTED_AS_OCCLUDER = 4,
SPF_HAS_HOLES = 8,
};
Occlusion::PolyPlane poly;
uint32_t flags;
#ifdef TOOLS_ENABLED
uint32_t poly_source_id;
#endif
uint32_t mesh_source_id;
real_t goodness_of_fit;
};
struct PlaneSet {
void flip() {
for (int n = 0; n < num_planes; n++) {
planes[n] = -planes[n];
}
}
// pre-calculated edge planes to the camera
int num_planes = 0;
Plane planes[PortalDefines::OCCLUSION_POLY_MAX_VERTS];
};
struct PreCalcedPoly {
void flip() {
edge_planes.flip();
for (int n = 0; n < num_holes; n++) {
hole_edge_planes[n].flip();
}
}
int num_holes = 0;
PlaneSet edge_planes;
PlaneSet hole_edge_planes[PortalDefines::OCCLUSION_POLY_MAX_HOLES];
Occlusion::Poly hole_polys[PortalDefines::OCCLUSION_POLY_MAX_HOLES];
};
SortPoly _polys[MAX_POLYS];
PreCalcedPoly _precalced_poly[MAX_POLYS];
int _num_polys = 0;
int _max_polys = 8;
#ifdef TOOLS_ENABLED
uint32_t _poly_checksum = 0;
#endif
Vector3 _pt_camera;
Vector3 _pt_cam_dir;
Projection _matrix_camera;
PortalRenderer *_portal_renderer = nullptr;
Clipper _clipper;
bool _occluders_present = false;
static bool _debug_log;
};
#endif // PORTAL_OCCLUSION_CULLER_H

37
servers/rendering/portals/portal_pvs.cpp
View File

@ -1,37 +0,0 @@
/*************************************************************************/
/* portal_pvs.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_pvs.h"
void PVS::clear() {
_room_pvs.clear();
_room_secondary_pvs.clear();
_loaded = false;
}

58
servers/rendering/portals/portal_pvs.h
View File

@ -1,58 +0,0 @@
#ifndef PORTAL_PVS_H
#define PORTAL_PVS_H
/*************************************************************************/
/* portal_pvs.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 "core/containers/local_vector.h"
class PVS {
public:
void clear();
void add_to_pvs(int p_room_id) { _room_pvs.push_back(p_room_id); }
int32_t get_pvs_size() const { return _room_pvs.size(); }
int32_t get_pvs_room_id(int32_t p_entry) const { return _room_pvs[p_entry]; }
void add_to_secondary_pvs(int p_room_id) { _room_secondary_pvs.push_back(p_room_id); }
int32_t get_secondary_pvs_size() const { return _room_secondary_pvs.size(); }
int32_t get_secondary_pvs_room_id(int32_t p_entry) const { return _room_secondary_pvs[p_entry]; }
void set_loaded(bool p_loaded) { _loaded = p_loaded; }
bool is_loaded() const { return _loaded; }
private:
// pvs
LocalVector<uint16_t, int32_t> _room_pvs;
// secondary pvs is primary plus the immediate neighbors of the primary pvs
LocalVector<uint16_t, int32_t> _room_secondary_pvs;
bool _loaded = false;
};
#endif

666
servers/rendering/portals/portal_pvs_builder.cpp
View File

@ -1,666 +0,0 @@
/*************************************************************************/
/* portal_pvs_builder.cpp */
/*************************************************************************/
/* This file is part of: */
/* PANDEMONIUM 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_pvs_builder.h"
#include "core/os/file_access.h"
#include "core/os/os.h"
#include "core/string/print_string.h"
#include "portal_renderer.h"
bool PVSBuilder::_log_active = true;
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 PANDEMONIUM_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, bool p_use_simple_pvs, bool p_log_pvs_generation) {
_portal_renderer = &p_portal_renderer;
_pvs = &p_portal_renderer.get_pvs();
_depth_limit = p_depth_limit;
_log_active = p_log_pvs_generation;
// attempt to load from file rather than create each time
#ifdef PANDEMONIUM_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));
if (p_use_simple_pvs) {
trace_rooms_recursive_simple(0, n, n, -1, false, -1, dummy_planes, bf);
} else {
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 PANDEMONIUM_PVS_SUPPORT_SAVE_FILE
save_pvs(p_filename);
#endif
}
void PVSBuilder::logd(int p_depth, String p_string) {
if (!_log_active) {
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.
// The epsilon should be BEHIND the way we are going through the portal,
// so depends whether it is outgoing or not
if (outgoing) {
_trace_start_point -= portal._plane.normal * 0.1;
} else {
_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 PANDEMONIUM_PVS_EXTRA_REJECT_TEST
#ifdef PANDEMONIUM_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 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++)
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 PANDEMONIUM_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 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++)
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
}
}

73
servers/rendering/portals/portal_pvs_builder.h
View File

@ -1,73 +0,0 @@
#ifndef PORTAL_PVS_BUILDER_H
#define PORTAL_PVS_BUILDER_H
/*************************************************************************/
/* portal_pvs_builder.h */
/*************************************************************************/
/* This file is part of: */
/* PANDEMONIUM 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 "core/containers/bitfield_dynamic.h"
#include "core/containers/local_vector.h"
#include "core/math/plane.h"
//#define PANDEMONIUM_PVS_SUPPORT_SAVE_FILE
class PortalRenderer;
class PVS;
class PVSBuilder {
struct Neighbours {
LocalVector<int32_t, int32_t> room_ids;
};
public:
void calculate_pvs(PortalRenderer &p_portal_renderer, String p_filename, int p_depth_limit, bool p_use_simple_pvs, bool p_log_pvs_generation);
private:
#ifdef PANDEMONIUM_PVS_SUPPORT_SAVE_FILE
bool load_pvs(String p_filename);
void save_pvs(String p_filename);
#endif
void find_neighbors(LocalVector<Neighbours> &r_neighbors);
void logd(int p_depth, String p_string);
void log(String p_string);
void 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 = -1);
void 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);
void create_secondary_pvs(int p_room_id, const LocalVector<Neighbours> &p_neighbors, BitFieldDynamic &r_bitfield_rooms);
PortalRenderer *_portal_renderer = nullptr;
PVS *_pvs = nullptr;
int _depth_limit = 16;
Vector3 _trace_start_point;
static bool _log_active;
};
#endif

1207
servers/rendering/portals/portal_renderer.cpp
View File

File diff suppressed because it is too large Load Diff

525
servers/rendering/portals/portal_renderer.h
View File

@ -1,525 +0,0 @@
#ifndef PORTAL_RENDERER_H
#define PORTAL_RENDERER_H
/*************************************************************************/
/* portal_renderer.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 "core/math/projection.h"
#include "core/math/geometry.h"
#include "core/math/plane.h"
#include "core/containers/pooled_list.h"
#include "core/containers/vector.h"
#include "portal_gameplay_monitor.h"
#include "portal_pvs.h"
#include "portal_resources.h"
#include "portal_rooms_bsp.h"
#include "portal_tracer.h"
#include "portal_types.h"
struct Transform;
struct VSStatic {
// the lifetime of statics is not strictly monitored like moving objects
// therefore we store a RID which could return NULL if the object has been deleted
RID instance;
AABB aabb;
// statics are placed in a room, but they can optionally sprawl to other rooms
// if large (like lights)
uint32_t source_room_id;
// dynamics will request their AABB each frame
// from the visual server in case they have moved.
// But they will NOT update the rooms they are in...
// so this works well for e.g. moving platforms, but not for objects
// that will move between rooms.
uint32_t dynamic;
};
// static / dynamic visibility notifiers.
// ghost objects are not culled, but are present in rooms
// and expect to receive gameplay notifications
struct VSStaticGhost {
ObjectID object_id;
uint32_t last_tick_hit = 0;
uint32_t last_room_tick_hit = 0;
};
class PortalRenderer {
public:
// use most significant bit to store whether an instance is being used in the room system
// in which case, deleting such an instance should deactivate the portal system to prevent
// crashes due to dangling references to instances.
static const uint32_t OCCLUSION_HANDLE_ROOM_BIT = 1 << 31;
static bool use_occlusion_culling;
struct MovingBase {
// when the rooms_and_portals_clear message is sent,
// we want to remove all references to old rooms in the moving
// objects, to prevent dangling references.
void rooms_and_portals_clear() { destroy(); }
void destroy() {
_rooms.clear();
room_id = -1;
last_tick_hit = 0;
last_gameplay_tick_hit = 0;
}
// the expanded aabb allows objects to move on most frames
// without needing to determine a change of room
AABB expanded_aabb;
// exact aabb of the object should be used for culling
AABB exact_aabb;
// which is the primary room this moving object is in
// (it may sprawl into multiple rooms)
int32_t room_id;
// id in the allocation pool
uint32_t pool_id;
uint32_t last_tick_hit = 0;
uint32_t last_gameplay_tick_hit = 0;
// room ids of rooms this moving object is sprawled into
LocalVector<uint32_t, int32_t> _rooms;
};
struct Moving : public MovingBase {
// either roaming or global
bool global;
// in _moving_lists .. not the same as pool ID (handle)
uint32_t list_id;
// a void pointer, but this is ultimately a pointer to a RenderingServerScene::Instance
// (can't have direct pointer because it is a nested class...)
VSInstance *instance;
#ifdef PORTAL_RENDERER_STORE_MOVING_RIDS
// primarily for testing
RID instance_rid;
#endif
};
// So far the only roaming ghosts are VisibilityNotifiers.
// this will always be roaming... statics and dynamics are handled separately,
// and global ghosts do not get created.
struct RGhost : public MovingBase {
ObjectID object_id;
};
PortalHandle portal_create();
void portal_destroy(PortalHandle p_portal);
void portal_set_geometry(PortalHandle p_portal, const Vector<Vector3> &p_points, real_t p_margin);
void portal_link(PortalHandle p_portal, RoomHandle p_room_from, RoomHandle p_room_to, bool p_two_way);
void portal_set_active(PortalHandle p_portal, bool p_active);
RoomGroupHandle roomgroup_create();
void roomgroup_prepare(RoomGroupHandle p_roomgroup, ObjectID p_roomgroup_object_id);
void roomgroup_destroy(RoomGroupHandle p_roomgroup);
void roomgroup_add_room(RoomGroupHandle p_roomgroup, RoomHandle p_room);
// Rooms
RoomHandle room_create();
void room_destroy(RoomHandle p_room);
OcclusionHandle room_add_instance(RoomHandle p_room, RID p_instance, const AABB &p_aabb, bool p_dynamic, const Vector<Vector3> &p_object_pts);
OcclusionHandle room_add_ghost(RoomHandle p_room, ObjectID p_object_id, const AABB &p_aabb);
void room_set_bound(RoomHandle p_room, ObjectID p_room_object_id, const Vector<Plane> &p_convex, const AABB &p_aabb, const Vector<Vector3> &p_verts);
void room_prepare(RoomHandle p_room, int32_t p_priority);
void rooms_and_portals_clear();
void rooms_finalize(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);
void rooms_override_camera(bool p_override, const Vector3 &p_point, const Vector<Plane> *p_convex);
void rooms_set_active(bool p_active) { _active = p_active; }
void rooms_set_params(int p_portal_depth_limit, real_t p_roaming_expansion_margin) {
_tracer.set_depth_limit(p_portal_depth_limit);
_roaming_expansion_margin = p_roaming_expansion_margin;
}
void rooms_set_cull_using_pvs(bool p_enable) { _cull_using_pvs = p_enable; }
void rooms_update_gameplay_monitor(const Vector<Vector3> &p_camera_positions);
// for use in the editor only, to allow a cheap way of turning off portals
// if there has been a change, e.g. moving a room etc.
void rooms_unload(String p_reason) { _ensure_unloaded(p_reason); }
bool rooms_is_loaded() const { return _loaded; }
// debugging
void set_debug_sprawl(bool p_active) { _debug_sprawl = p_active; }
// this section handles moving objects - roaming (change rooms) and globals (not in any room)
OcclusionHandle instance_moving_create(VSInstance *p_instance, RID p_instance_rid, bool p_global, AABB p_aabb);
void instance_moving_update(OcclusionHandle p_handle, const AABB &p_aabb, bool p_force_reinsert = false);
void instance_moving_destroy(OcclusionHandle p_handle);
// spatial derived roamers (non VisualInstances that still need to be portal culled, especially VisibilityNotifiers)
RGhostHandle rghost_create(ObjectID p_object_id, const AABB &p_aabb);
void rghost_update(RGhostHandle p_handle, const AABB &p_aabb, bool p_force_reinsert = false);
void rghost_destroy(RGhostHandle p_handle);
// occluders
OccluderInstanceHandle occluder_instance_create();
void occluder_instance_link(OccluderInstanceHandle p_handle, OccluderResourceHandle p_resource_handle);
void occluder_instance_set_transform(OccluderInstanceHandle p_handle, const Transform &p_xform);
void occluder_instance_set_active(OccluderInstanceHandle p_handle, bool p_active);
void occluder_instance_destroy(OccluderInstanceHandle p_handle, bool p_free = true);
// editor only .. slow
Geometry::MeshData occlusion_debug_get_current_polys() const { return _tracer.get_occlusion_culler().debug_get_current_polys(); }
// note that this relies on a 'frustum' type cull, from a point, and that the planes are specified as in
// Projection, i.e.
// order PLANE_NEAR,PLANE_FAR,PLANE_LEFT,PLANE_TOP,PLANE_RIGHT,PLANE_BOTTOM
int cull_convex(const Transform &p_cam_transform, const Projection &p_cam_projection, const Vector<Plane> &p_convex, VSInstance **p_result_array, int p_result_max, uint32_t p_mask, int32_t &r_previous_room_id_hint) {
// combined camera matrix
Projection cm = Projection(p_cam_transform.affine_inverse());
cm = p_cam_projection * cm;
Vector3 point = p_cam_transform.origin;
Vector3 cam_dir = -p_cam_transform.basis.get_axis(2).normalized();
if (!_override_camera)
return cull_convex_implementation(point, cam_dir, cm, p_convex, p_result_array, p_result_max, p_mask, r_previous_room_id_hint);
// override camera matrix NYI
return cull_convex_implementation(_override_camera_pos, cam_dir, cm, _override_camera_planes, p_result_array, p_result_max, p_mask, r_previous_room_id_hint);
}
int cull_convex_implementation(const Vector3 &p_point, const Vector3 &p_cam_dir, const Projection &p_cam_matrix, const Vector<Plane> &p_convex, VSInstance **p_result_array, int p_result_max, uint32_t p_mask, int32_t &r_previous_room_id_hint);
bool occlusion_is_active() const { return _occluder_instance_pool.active_size() && use_occlusion_culling; }
// special function for occlusion culling only that does not use portals / rooms,
// but allows using occluders with the main scene
int occlusion_cull(const Transform &p_cam_transform, const Projection &p_cam_projection, const Vector<Plane> &p_convex, VSInstance **p_result_array, int p_num_results) {
// inactive?
if (!_occluder_instance_pool.active_size() || !use_occlusion_culling) {
return p_num_results;
}
// combined camera matrix
Projection cm = Projection(p_cam_transform.affine_inverse());
cm = p_cam_projection * cm;
Vector3 point = p_cam_transform.origin;
Vector3 cam_dir = -p_cam_transform.basis.get_axis(2).normalized();
return _tracer.occlusion_cull(*this, point, cam_dir, cm, p_convex, p_result_array, p_num_results);
}
bool is_active() const { return _active && _loaded; }
VSStatic &get_static(int p_id) { return _statics[p_id]; }
const VSStatic &get_static(int p_id) const { return _statics[p_id]; }
int32_t get_num_rooms() const { return _room_pool_ids.size(); }
VSRoom &get_room(int p_id) { return _room_pool[_room_pool_ids[p_id]]; }
const VSRoom &get_room(int p_id) const { return _room_pool[_room_pool_ids[p_id]]; }
int32_t get_num_portals() const { return _portal_pool_ids.size(); }
VSPortal &get_portal(int p_id) { return _portal_pool[_portal_pool_ids[p_id]]; }
const VSPortal &get_portal(int p_id) const { return _portal_pool[_portal_pool_ids[p_id]]; }
int32_t get_num_moving_globals() const { return _moving_list_global.size(); }
const Moving &get_moving_global(uint32_t p_id) const { return _moving_pool[_moving_list_global[p_id]]; }
Moving &get_pool_moving(uint32_t p_pool_id) { return _moving_pool[p_pool_id]; }
const Moving &get_pool_moving(uint32_t p_pool_id) const { return _moving_pool[p_pool_id]; }
RGhost &get_pool_rghost(uint32_t p_pool_id) { return _rghost_pool[p_pool_id]; }
const RGhost &get_pool_rghost(uint32_t p_pool_id) const { return _rghost_pool[p_pool_id]; }
VSStaticGhost &get_static_ghost(uint32_t p_id) { return _static_ghosts[p_id]; }
VSRoomGroup &get_roomgroup(uint32_t p_pool_id) { return _roomgroup_pool[p_pool_id]; }
PVS &get_pvs() { return _pvs; }
const PVS &get_pvs() const { return _pvs; }
bool get_cull_using_pvs() const { return _cull_using_pvs; }
// occluders
const LocalVector<uint32_t, uint32_t> &get_occluders_active_list() const { return _occluder_instance_pool.get_active_list(); }
const VSOccluder_Instance &get_pool_occluder_instance(uint32_t p_pool_id) const { return _occluder_instance_pool[p_pool_id]; }
VSOccluder_Instance &get_pool_occluder_instance(uint32_t p_pool_id) { return _occluder_instance_pool[p_pool_id]; }
const VSOccluder_Sphere &get_pool_occluder_world_sphere(uint32_t p_pool_id) const { return _occluder_world_sphere_pool[p_pool_id]; }
const VSOccluder_Poly &get_pool_occluder_world_poly(uint32_t p_pool_id) const { return _occluder_world_poly_pool[p_pool_id]; }
const VSOccluder_Hole &get_pool_occluder_world_hole(uint32_t p_pool_id) const { return _occluder_world_hole_pool[p_pool_id]; }
VSOccluder_Hole &get_pool_occluder_world_hole(uint32_t p_pool_id) { return _occluder_world_hole_pool[p_pool_id]; }
private:
int find_room_within(const Vector3 &p_pos, int p_previous_room_id = -1) {
return _rooms_lookup_bsp.find_room_within(*this, p_pos, p_previous_room_id);
}
bool sprawl_static(int p_static_id, const VSStatic &p_static, int p_room_id);
bool sprawl_static_geometry(int p_static_id, const VSStatic &p_static, int p_room_id, const Vector<Vector3> &p_object_pts);
bool sprawl_static_ghost(int p_ghost_id, const AABB &p_aabb, int p_room_id);
void _load_finalize_roaming();
void sprawl_roaming(uint32_t p_mover_pool_id, MovingBase &r_moving, int p_room_id, bool p_moving_or_ghost);
void _moving_remove_from_rooms(uint32_t p_moving_pool_id);
void _rghost_remove_from_rooms(uint32_t p_pool_id);
void _occluder_remove_from_rooms(uint32_t p_pool_id);
void _ensure_unloaded(String p_reason = String());
void _rooms_add_portals_to_convex_hulls();
void _add_portal_to_convex_hull(LocalVector<Plane, int32_t> &p_planes, const Plane &p);
void _debug_print_global_list();
bool _occlusion_handle_is_in_room(OcclusionHandle p_h) const {
return p_h == OCCLUSION_HANDLE_ROOM_BIT;
}
void _log(String p_string, int p_priority = 0);
// note this is vulnerable to crashes, we must monitor for deletion of rooms
LocalVector<uint32_t, int32_t> _room_pool_ids;
LocalVector<uint32_t, int32_t> _portal_pool_ids;
LocalVector<VSStatic, int32_t> _statics;
LocalVector<VSStaticGhost, int32_t> _static_ghosts;
// all rooms and portals are allocated from pools.
PooledList<VSPortal> _portal_pool;
PooledList<VSRoom> _room_pool;
PooledList<VSRoomGroup> _roomgroup_pool;
// moving objects, global and roaming
PooledList<Moving> _moving_pool;
TrackedPooledList<RGhost> _rghost_pool;
LocalVector<uint32_t, int32_t> _moving_list_global;
LocalVector<uint32_t, int32_t> _moving_list_roaming;
// occluders
TrackedPooledList<VSOccluder_Instance> _occluder_instance_pool;
TrackedPooledList<VSOccluder_Sphere, uint32_t, true> _occluder_world_sphere_pool;
TrackedPooledList<VSOccluder_Poly, uint32_t, true> _occluder_world_poly_pool;
TrackedPooledList<VSOccluder_Hole, uint32_t, true> _occluder_world_hole_pool;
PVS _pvs;
bool _active = true;
bool _loaded = false;
bool _debug_sprawl = false;
bool _show_debug = true;
// if the pvs is generated, we can either cull using dynamic portals or PVS
bool _cull_using_pvs = false;
PortalTracer _tracer;
PortalTracer::TraceResult _trace_results;
PortalRoomsBSP _rooms_lookup_bsp;
PortalGameplayMonitor _gameplay_monitor;
// when moving roaming objects, we expand their bound
// to prevent too many updates.
real_t _roaming_expansion_margin = 1.0;
// a bitfield to indicate which rooms have been
// visited already in sprawling, to prevent visiting rooms multiple times
BitFieldDynamic _bitfield_rooms;
bool _override_camera = false;
Vector3 _override_camera_pos;
LocalVector<Plane, int32_t> _override_camera_planes;
public:
static String _rid_to_string(RID p_rid);
static String _addr_to_string(const void *p_addr);
void occluder_ensure_up_to_date_sphere(const PortalResources &p_resources, VSOccluder_Instance &r_occluder);
void occluder_ensure_up_to_date_polys(const PortalResources &p_resources, VSOccluder_Instance &r_occluder);
void occluder_refresh_room_within(uint32_t p_occluder_pool_id);
PortalRenderer();
};
inline void PortalRenderer::occluder_ensure_up_to_date_sphere(const PortalResources &p_resources, VSOccluder_Instance &r_occluder) {
// occluder is not bound to a resource, cannot be used
if (r_occluder.resource_pool_id == UINT32_MAX) {
return;
}
// get the resource
const VSOccluder_Resource &res = p_resources.get_pool_occluder_resource(r_occluder.resource_pool_id);
// dirty?
if (r_occluder.revision == res.revision) {
return;
}
r_occluder.revision = res.revision;
// must be same type, if not an error has occurred
ERR_FAIL_COND(res.type != r_occluder.type);
// first make sure the instance has the correct number of world space spheres
if (r_occluder.list_ids.size() != res.list_ids.size()) {
// not the most efficient, but works...
// remove existing
for (int n = 0; n < r_occluder.list_ids.size(); n++) {
uint32_t id = r_occluder.list_ids[n];
_occluder_world_sphere_pool.free(id);
}
r_occluder.list_ids.clear();
// create new
for (int n = 0; n < res.list_ids.size(); n++) {
uint32_t id;
VSOccluder_Sphere *sphere = _occluder_world_sphere_pool.request(id);
sphere->create();
r_occluder.list_ids.push_back(id);
}
}
const Transform &tr = r_occluder.xform;
Vector3 scale3 = tr.basis.get_scale_abs();
real_t scale = (scale3.x + scale3.y + scale3.z) / 3.0;
// update the AABB
Vector3 bb_min = Vector3(FLT_MAX, FLT_MAX, FLT_MAX);
Vector3 bb_max = Vector3(-FLT_MAX, -FLT_MAX, -FLT_MAX);
// transform spheres
for (int n = 0; n < r_occluder.list_ids.size(); n++) {
uint32_t world_pool_id = r_occluder.list_ids[n];
VSOccluder_Sphere &world_osphere = _occluder_world_sphere_pool[world_pool_id];
const VSOccluder_Sphere &local_osphere = p_resources.get_pool_occluder_local_sphere(res.list_ids[n]);
world_osphere.pos = tr.xform(local_osphere.pos);
world_osphere.radius = local_osphere.radius * scale;
Vector3 bradius = Vector3(world_osphere.radius, world_osphere.radius, world_osphere.radius);
Vector3 bmin = world_osphere.pos - bradius;
Vector3 bmax = world_osphere.pos + bradius;
bb_min.x = MIN(bb_min.x, bmin.x);
bb_min.y = MIN(bb_min.y, bmin.y);
bb_min.z = MIN(bb_min.z, bmin.z);
bb_max.x = MAX(bb_max.x, bmax.x);
bb_max.y = MAX(bb_max.y, bmax.y);
bb_max.z = MAX(bb_max.z, bmax.z);
}
r_occluder.aabb.position = bb_min;
r_occluder.aabb.size = bb_max - bb_min;
}
inline void PortalRenderer::occluder_ensure_up_to_date_polys(const PortalResources &p_resources, VSOccluder_Instance &r_occluder) {
// occluder is not bound to a resource, cannot be used
if (r_occluder.resource_pool_id == UINT32_MAX) {
return;
}
// get the resource
const VSOccluder_Resource &res = p_resources.get_pool_occluder_resource(r_occluder.resource_pool_id);
// dirty?
if (r_occluder.revision == res.revision) {
return;
}
r_occluder.revision = res.revision;
// must be same type, if not an error has occurred
ERR_FAIL_COND(res.type != r_occluder.type);
// first make sure the instance has the correct number of world space spheres
if (r_occluder.list_ids.size() != res.list_ids.size()) {
// not the most efficient, but works...
// remove existing
for (int n = 0; n < r_occluder.list_ids.size(); n++) {
uint32_t id = r_occluder.list_ids[n];
_occluder_world_poly_pool.free(id);
}
r_occluder.list_ids.clear();
// create new
for (int n = 0; n < res.list_ids.size(); n++) {
uint32_t id;
VSOccluder_Poly *poly = _occluder_world_poly_pool.request(id);
poly->create();
r_occluder.list_ids.push_back(id);
}
}
const Transform &tr = r_occluder.xform;
for (int n = 0; n < r_occluder.list_ids.size(); n++) {
uint32_t world_pool_id = r_occluder.list_ids[n];
uint32_t local_pool_id = res.list_ids[n];
VSOccluder_Poly &world_opoly = _occluder_world_poly_pool[world_pool_id];
const VSOccluder_Poly &local_opoly = p_resources._occluder_local_poly_pool[local_pool_id];
world_opoly.poly.num_verts = local_opoly.poly.num_verts;
world_opoly.two_way = local_opoly.two_way;
for (int i = 0; i < local_opoly.poly.num_verts; i++) {
world_opoly.poly.verts[i] = tr.xform(local_opoly.poly.verts[i]);
}
world_opoly.poly.plane = tr.xform(local_opoly.poly.plane);
// number of holes must be correct for each poly
if (world_opoly.num_holes != local_opoly.num_holes) {
// remove existing
for (int h = 0; h < world_opoly.num_holes; h++) {
uint32_t id = world_opoly.hole_pool_ids[h];
_occluder_world_hole_pool.free(id);
// not strictly necessary
world_opoly.hole_pool_ids[h] = UINT32_MAX;
}
world_opoly.num_holes = local_opoly.num_holes;
for (int h = 0; h < world_opoly.num_holes; h++) {
uint32_t id;
VSOccluder_Hole *hole = _occluder_world_hole_pool.request(id);
hole->create();
world_opoly.hole_pool_ids[h] = id;
}
}
// holes
for (int h = 0; h < world_opoly.num_holes; h++) {
uint32_t world_hid = world_opoly.hole_pool_ids[h];
uint32_t local_hid = local_opoly.hole_pool_ids[h];
VSOccluder_Hole &world_hole = _occluder_world_hole_pool[world_hid];
const VSOccluder_Hole &local_hole = p_resources._occluder_local_hole_pool[local_hid];
world_hole.num_verts = local_hole.num_verts;
for (int i = 0; i < world_hole.num_verts; i++) {
world_hole.verts[i] = tr.xform(local_hole.verts[i]);
}
}
}
}
#endif // PORTAL_RENDERER_H

216
servers/rendering/portals/portal_resources.cpp
View File

@ -1,216 +0,0 @@
/*************************************************************************/
/* portal_resources.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_resources.h"
OccluderResourceHandle PortalResources::occluder_resource_create() {
uint32_t pool_id = 0;
VSOccluder_Resource *occ = _occluder_resource_pool.request(pool_id);
occ->create();
OccluderResourceHandle handle = pool_id + 1;
return handle;
}
void PortalResources::occluder_resource_destroy(OccluderResourceHandle p_handle) {
p_handle--;
// Depending on the occluder resource type, remove the spheres, polys, holes etc
// We can reuse the update methods for this.
VSOccluder_Resource &occ = _occluder_resource_pool[p_handle];
switch (occ.type) {
case VSOccluder_Instance::OT_SPHERE: {
occluder_resource_update_spheres(p_handle + 1, Vector<Plane>());
} break;
case VSOccluder_Instance::OT_MESH: {
occluder_resource_update_mesh(p_handle + 1, Geometry::OccluderMeshData());
} break;
default: {
} break;
}
// This also clears the occluder
occ.create();
_occluder_resource_pool.free(p_handle);
}
void PortalResources::occluder_resource_prepare(OccluderResourceHandle p_handle, VSOccluder_Instance::Type p_type) {
p_handle--;
// depending on the occluder type, remove the spheres etc
VSOccluder_Resource &occ = _occluder_resource_pool[p_handle];
if (occ.type != VSOccluder_Instance::OT_UNDEFINED) {
ERR_PRINT_ONCE("occluder_resource_prepare should be called only once.");
}
occ.type = p_type;
ERR_FAIL_COND(p_type == VSOccluder_Instance::OT_UNDEFINED);
}
void PortalResources::occluder_resource_update_spheres(OccluderResourceHandle p_handle, const Vector<Plane> &p_spheres) {
p_handle--;
VSOccluder_Resource &occ = _occluder_resource_pool[p_handle];
ERR_FAIL_COND(occ.type != VSOccluder_Resource::OT_SPHERE);
// first deal with the situation where the number of spheres has changed (rare)
if (occ.list_ids.size() != p_spheres.size()) {
// not the most efficient, but works...
// remove existing
for (int n = 0; n < occ.list_ids.size(); n++) {
uint32_t id = occ.list_ids[n];
_occluder_local_sphere_pool.free(id);
}
occ.list_ids.clear();
// create new
for (int n = 0; n < p_spheres.size(); n++) {
uint32_t id;
VSOccluder_Sphere *sphere = _occluder_local_sphere_pool.request(id);
sphere->create();
occ.list_ids.push_back(id);
}
}
// new positions
for (int n = 0; n < occ.list_ids.size(); n++) {
uint32_t id = occ.list_ids[n];
VSOccluder_Sphere &sphere = _occluder_local_sphere_pool[id];
sphere.from_plane(p_spheres[n]);
}
// mark as dirty as the world space spheres will be out of date next time this resource is used
occ.revision += 1;
}
void PortalResources::occluder_resource_update_mesh(OccluderResourceHandle p_handle, const Geometry::OccluderMeshData &p_mesh_data) {
p_handle--;
VSOccluder_Resource &occ = _occluder_resource_pool[p_handle];
ERR_FAIL_COND(occ.type != VSOccluder_Resource::OT_MESH);
// mark as dirty, needs world points updating next time this resource is used
occ.revision += 1;
const LocalVectori<Geometry::OccluderMeshData::Face> &faces = p_mesh_data.faces;
const LocalVectori<Vector3> &vertices = p_mesh_data.vertices;
// first deal with the situation where the number of polys has changed (rare)
if (occ.list_ids.size() != faces.size()) {
// not the most efficient, but works...
// remove existing
for (int n = 0; n < occ.list_ids.size(); n++) {
uint32_t id = occ.list_ids[n];
// must also free the holes
VSOccluder_Poly &opoly = _occluder_local_poly_pool[id];
for (int h = 0; h < opoly.num_holes; h++) {
_occluder_local_hole_pool.free(opoly.hole_pool_ids[h]);
// perhaps debug only
opoly.hole_pool_ids[h] = UINT32_MAX;
}
_occluder_local_poly_pool.free(id);
}
occ.list_ids.clear();
// create new
for (int n = 0; n < faces.size(); n++) {
uint32_t id;
VSOccluder_Poly *poly = _occluder_local_poly_pool.request(id);
poly->create();
occ.list_ids.push_back(id);
}
}
// new data
for (int n = 0; n < occ.list_ids.size(); n++) {
uint32_t id = occ.list_ids[n];
VSOccluder_Poly &opoly = _occluder_local_poly_pool[id];
Occlusion::PolyPlane &poly = opoly.poly;
// source face
const Geometry::OccluderMeshData::Face &face = faces[n];
opoly.two_way = face.two_way;
// make sure the number of holes is correct
if (face.holes.size() != opoly.num_holes) {
// slow but hey ho
// delete existing holes
for (int i = 0; i < opoly.num_holes; i++) {
_occluder_local_hole_pool.free(opoly.hole_pool_ids[i]);
opoly.hole_pool_ids[i] = UINT32_MAX;
}
// create any new holes
opoly.num_holes = face.holes.size();
for (int i = 0; i < opoly.num_holes; i++) {
uint32_t hole_id;
VSOccluder_Hole *hole = _occluder_local_hole_pool.request(hole_id);
opoly.hole_pool_ids[i] = hole_id;
hole->create();
}
}
// set up the poly basics, plane and verts
poly.plane = face.plane;
poly.num_verts = MIN(face.indices.size(), Occlusion::PolyPlane::MAX_POLY_VERTS);
for (int c = 0; c < poly.num_verts; c++) {
int vert_index = face.indices[c];
if (vert_index < vertices.size()) {
poly.verts[c] = vertices[vert_index];
} else {
WARN_PRINT_ONCE("occluder_update_mesh : poly index out of range");
}
}
// set up any holes that are present
for (int h = 0; h < opoly.num_holes; h++) {
VSOccluder_Hole &dhole = get_pool_occluder_local_hole(opoly.hole_pool_ids[h]);
const Geometry::OccluderMeshData::Hole &shole = face.holes[h];
dhole.num_verts = shole.indices.size();
dhole.num_verts = MIN(dhole.num_verts, Occlusion::Poly::MAX_POLY_VERTS);
for (int c = 0; c < dhole.num_verts; c++) {
int vert_index = shole.indices[c];
if (vert_index < vertices.size()) {
dhole.verts[c] = vertices[vert_index];
} else {
WARN_PRINT_ONCE("occluder_update_mesh : hole index out of range");
}
} // for c through hole verts
} // for h through holes
} // for n through occluders
}

67
servers/rendering/portals/portal_resources.h
View File

@ -1,67 +0,0 @@
#ifndef PORTAL_RESOURCES_H
#define PORTAL_RESOURCES_H
/*************************************************************************/
/* portal_resources.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 "core/math/geometry.h"
#include "portal_types.h"
// Although the portal renderer is owned by a scenario,
// resources are not associated with a scenario and can be shared
// potentially across multiple scenarios. They must therefore be held in
// some form of global.
class PortalResources {
friend class PortalRenderer;
public:
OccluderResourceHandle occluder_resource_create();
void occluder_resource_prepare(OccluderResourceHandle p_handle, VSOccluder_Instance::Type p_type);
void occluder_resource_update_spheres(OccluderResourceHandle p_handle, const Vector<Plane> &p_spheres);
void occluder_resource_update_mesh(OccluderResourceHandle p_handle, const Geometry::OccluderMeshData &p_mesh_data);
void occluder_resource_destroy(OccluderResourceHandle p_handle);
const VSOccluder_Resource &get_pool_occluder_resource(uint32_t p_pool_id) const { return _occluder_resource_pool[p_pool_id]; }
VSOccluder_Resource &get_pool_occluder_resource(uint32_t p_pool_id) { return _occluder_resource_pool[p_pool_id]; }
// Local space is shared resources
const VSOccluder_Sphere &get_pool_occluder_local_sphere(uint32_t p_pool_id) const { return _occluder_local_sphere_pool[p_pool_id]; }
const VSOccluder_Poly &get_pool_occluder_local_poly(uint32_t p_pool_id) const { return _occluder_local_poly_pool[p_pool_id]; }
const VSOccluder_Hole &get_pool_occluder_local_hole(uint32_t p_pool_id) const { return _occluder_local_hole_pool[p_pool_id]; }
VSOccluder_Hole &get_pool_occluder_local_hole(uint32_t p_pool_id) { return _occluder_local_hole_pool[p_pool_id]; }
private:
TrackedPooledList<VSOccluder_Resource> _occluder_resource_pool;
TrackedPooledList<VSOccluder_Sphere, uint32_t, true> _occluder_local_sphere_pool;
TrackedPooledList<VSOccluder_Poly, uint32_t, true> _occluder_local_poly_pool;
TrackedPooledList<VSOccluder_Hole, uint32_t, true> _occluder_local_hole_pool;
};
#endif // PORTAL_RESOURCES_H

643
servers/rendering/portals/portal_rooms_bsp.cpp
View File

@ -1,643 +0,0 @@
/*************************************************************************/
/* portal_rooms_bsp.cpp */
/*************************************************************************/
/* This file is part of: */
/* PANDEMONIUM 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_rooms_bsp.h"
#include "core/math/geometry.h"
#include "core/math/plane.h"
#include "core/string/print_string.h"
#include "core/variant/variant.h"
#include "portal_renderer.h"
// #define PANDEMONIUM_VERBOSE_PORTAL_ROOMS_BSP
void PortalRoomsBSP::_log(String p_string) {
#ifdef PANDEMONIUM_VERBOSE_PORTAL_ROOMS_BSP
print_line(p_string);
#endif
}
// rooms which contain internal rooms cannot use the optimization where it terminates the search for
// room within if inside the previous room. We can't use just use the rooms already marked as internal due
// to a portal leading to them, because the internal room network may spread into another room (e.g. terrain)
// which has internal room exit portal. So we need to detect manually all cases of overlap of internal rooms,
// and set the flag.
void PortalRoomsBSP::detect_internal_room_containment(PortalRenderer &r_portal_renderer) {
int num_rooms = r_portal_renderer.get_num_rooms();
for (int n = 0; n < num_rooms; n++) {
VSRoom &room = r_portal_renderer.get_room(n);
if (room._contains_internal_rooms) {
// already established it contains internal rooms, no need to test
continue;
}
// safety
if (!room._planes.size()) {
continue;
}
for (int i = 0; i < num_rooms; i++) {
// don't test against ourself
if (n == i) {
continue;
}
// only interested in rooms with a higher priority, these are potential internal rooms
const VSRoom &other = r_portal_renderer.get_room(i);
if (other._priority <= room._priority) {
continue;
}
// quick aabb check first
if (!room._aabb.intersects(other._aabb)) {
continue;
}
// safety
if (!other._planes.size()) {
continue;
}
if (Geometry::convex_hull_intersects_convex_hull(&room._planes[0], room._planes.size(), &other._planes[0], other._planes.size())) {
// it intersects an internal room
room._contains_internal_rooms = true;
break;
}
}
}
}
int PortalRoomsBSP::find_room_within(const PortalRenderer &p_portal_renderer, const Vector3 &p_pos, int p_previous_room_id) const {
real_t closest = FLT_MAX;
int closest_room_id = -1;
int closest_priority = -10000;
// first try previous room
if (p_previous_room_id != -1) {
if (p_previous_room_id < p_portal_renderer.get_num_rooms()) {
const VSRoom &prev_room = p_portal_renderer.get_room(p_previous_room_id);
// we can only use this shortcut if the room doesn't include internal rooms.
// otherwise the point may be inside more than one room, and we need to find the room of highest priority.
if (!prev_room._contains_internal_rooms) {
closest = prev_room.is_point_within(p_pos);
closest_room_id = p_previous_room_id;
if (closest < 0.0) {
return p_previous_room_id;
}
} else {
// don't mark it as checked later, as we haven't done it because it contains internal rooms
p_previous_room_id = -1;
}
} else {
// previous room was out of range (perhaps due to reconverting room system and the number of rooms decreasing)
p_previous_room_id = -1;
}
}
int num_bsp_rooms = 0;
const int32_t *bsp_rooms = find_shortlist(p_pos, num_bsp_rooms);
if (!num_bsp_rooms) {
return -1;
}
// special case, only 1 room in the shortlist, no need to check further
if (num_bsp_rooms == 1) {
return bsp_rooms[0];
}
for (int n = 0; n < num_bsp_rooms; n++) {
int room_id = bsp_rooms[n];
// the previous room has already been done above, and will be in closest + closest_room_id
if (room_id == p_previous_room_id) {
continue;
}
const VSRoom &room = p_portal_renderer.get_room(room_id);
real_t dist = room.is_point_within(p_pos);
// if we are actually inside a room, unless we are dealing with internal rooms,
// we can terminate early, no need to search more
if (dist < 0.0) {
if (!room._contains_internal_rooms) {
// this will happen in most cases
closest = dist;
closest_room_id = room_id;
break;
} else {
// if we are inside, and there are internal rooms involved we need to be a bit careful.
// higher priority always wins (i.e. the internal room)
// but with equal priority we just choose the regular best fit.
if ((room._priority > closest_priority) || ((room._priority == closest_priority) && (dist < closest))) {
closest = dist;
closest_room_id = room_id;
closest_priority = room._priority;
continue;
}
}
} else {
// if we are outside we just pick the closest room, irrespective of priority
if (dist < closest) {
closest = dist;
closest_room_id = room_id;
// do NOT store the priority, we don't want an room that isn't a true hit
// overriding a hit inside the room
}
}
}
return closest_room_id;
}
const int32_t *PortalRoomsBSP::find_shortlist(const Vector3 &p_pt, int &r_num_rooms) const {
if (!_nodes.size()) {
r_num_rooms = 0;
return nullptr;
}
const Node *node = &_nodes[0];
while (!node->leaf) {
if (node->plane.is_point_over(p_pt)) {
node = &_nodes[node->child[1]];
} else {
node = &_nodes[node->child[0]];
}
}
r_num_rooms = node->num_ids;
return &_room_ids[node->first_id];
}
void PortalRoomsBSP::create(PortalRenderer &r_portal_renderer) {
clear();
_portal_renderer = &r_portal_renderer;
detect_internal_room_containment(r_portal_renderer);
// noop
int num_rooms = r_portal_renderer.get_num_rooms();
if (!num_rooms) {
return;
}
LocalVector<int32_t, int32_t> room_ids;
room_ids.resize(num_rooms);
for (int n = 0; n < num_rooms; n++) {
room_ids[n] = n;
}
_nodes.push_back(Node());
_nodes[0].clear();
build(0, room_ids);
#ifdef PANDEMONIUM_VERBOSE_PORTAL_ROOMS_BSP
debug_print_tree();
#endif
_log("PortalRoomsBSP " + itos(_nodes.size()) + " nodes.");
}
void PortalRoomsBSP::build(int p_start_node_id, LocalVector<int32_t, int32_t> p_orig_room_ids) {
struct Element {
void clear() { room_ids.clear(); }
int node_id;
LocalVector<int32_t, int32_t> room_ids;
};
Element first;
first.node_id = p_start_node_id;
first.room_ids = p_orig_room_ids;
LocalVector<Element, int32_t> stack;
stack.reserve(1024);
stack.push_back(first);
int stack_size = 1;
while (stack_size) {
stack_size--;
Element curr = stack[stack_size];
Node *node = &_nodes[curr.node_id];
int best_fit = 0;
int best_portal_id = -1;
int best_room_a = -1;
int best_room_b = -1;
// find a splitting plane
for (int n = 0; n < curr.room_ids.size(); n++) {
// go through the portals in this room
int rid = curr.room_ids[n];
const VSRoom &room = _portal_renderer->get_room(rid);
for (int p = 0; p < room._portal_ids.size(); p++) {
int pid = room._portal_ids[p];
// only outward portals
const VSPortal &portal = _portal_renderer->get_portal(pid);
if (portal._linkedroom_ID[1] == rid) {
continue;
}
int fit = evaluate_portal(pid, curr.room_ids);
if (fit > best_fit) {
best_fit = fit;
best_portal_id = pid;
}
}
}
bool split_found = false;
Plane split_plane;
// if a splitting portal was found, we are done
if (best_portal_id != -1) {
_log("found splitting portal : " + itos(best_portal_id));
const VSPortal &portal = _portal_renderer->get_portal(best_portal_id);
split_plane = portal._plane;
split_found = true;
} else {
// let's try and find an arbitrary splitting plane
for (int a = 0; a < curr.room_ids.size(); a++) {
for (int b = a + 1; b < curr.room_ids.size(); b++) {
Plane plane;
// note the actual room ids are not the same as a and b!!
int room_a_id = curr.room_ids[a];
int room_b_id = curr.room_ids[b];
int fit = evaluate_room_split_plane(room_a_id, room_b_id, curr.room_ids, plane);
if (fit > best_fit) {
best_fit = fit;
// the room ids, NOT a and b
best_room_a = room_a_id;
best_room_b = room_b_id;
split_plane = plane;
}
} // for b through rooms
} // for a through rooms
if (best_room_a != -1) {
split_found = true;
// print_line("found splitting plane between rooms : " + itos(best_room_a) + " and " + itos(best_room_b));
}
}
// found either a portal plane or arbitrary
if (split_found) {
node->plane = split_plane;
// add to stack
stack_size += 2;
if (stack_size > stack.size()) {
stack.resize(stack_size);
}
stack[stack_size - 2].clear();
stack[stack_size - 1].clear();
LocalVector<int32_t, int32_t> &room_ids_back = stack[stack_size - 2].room_ids;
LocalVector<int32_t, int32_t> &room_ids_front = stack[stack_size - 1].room_ids;
if (best_portal_id != -1) {
evaluate_portal(best_portal_id, curr.room_ids, &room_ids_back, &room_ids_front);
} else {
DEV_ASSERT(best_room_a != -1);
evaluate_room_split_plane(best_room_a, best_room_b, curr.room_ids, split_plane, &room_ids_back, &room_ids_front);
}
DEV_ASSERT(room_ids_back.size() <= curr.room_ids.size());
DEV_ASSERT(room_ids_front.size() <= curr.room_ids.size());
_log("\tback contains : " + itos(room_ids_back.size()) + " rooms");
_log("\tfront contains : " + itos(room_ids_front.size()) + " rooms");
// create child nodes
_nodes.push_back(Node());
_nodes.push_back(Node());
// need to reget the node pointer as we may have resized the vector
node = &_nodes[curr.node_id];
node->child[0] = _nodes.size() - 2;
node->child[1] = _nodes.size() - 1;
stack[stack_size - 2].node_id = node->child[0];
stack[stack_size - 1].node_id = node->child[1];
} else {
// couldn't split any further, is leaf
node->leaf = true;
node->first_id = _room_ids.size();
node->num_ids = curr.room_ids.size();
_log("leaf contains : " + itos(curr.room_ids.size()) + " rooms");
// add to the main list
int start = _room_ids.size();
_room_ids.resize(start + curr.room_ids.size());
for (int n = 0; n < curr.room_ids.size(); n++) {
_room_ids[start + n] = curr.room_ids[n];
}
}
} // while stack not empty
}
void PortalRoomsBSP::debug_print_tree(int p_node_id, int p_depth) {
String string = "";
for (int n = 0; n < p_depth; n++) {
string += "\t";
}
const Node &node = _nodes[p_node_id];
if (node.leaf) {
string += "L ";
for (int n = 0; n < node.num_ids; n++) {
int room_id = _room_ids[node.first_id + n];
string += itos(room_id) + ", ";
}
} else {
string += "N ";
}
print_line(string);
// children
if (!node.leaf) {
debug_print_tree(node.child[0], p_depth + 1);
debug_print_tree(node.child[1], p_depth + 1);
}
}
bool PortalRoomsBSP::find_1d_split_point(real_t p_min_a, real_t p_max_a, real_t p_min_b, real_t p_max_b, real_t &r_split_point) const {
if (p_max_a <= p_min_b) {
r_split_point = p_max_a + ((p_min_b - p_max_a) * 0.5);
return true;
}
if (p_max_b <= p_min_a) {
r_split_point = p_max_b + ((p_min_a - p_max_b) * 0.5);
return true;
}
return false;
}
bool PortalRoomsBSP::test_freeform_plane(const LocalVector<Vector3, int32_t> &p_verts_a, const LocalVector<Vector3, int32_t> &p_verts_b, const Plane &p_plane) const {
// print_line("test_freeform_plane " + String(Variant(p_plane)));
for (int n = 0; n < p_verts_a.size(); n++) {
real_t dist = p_plane.distance_to(p_verts_a[n]);
// print_line("\tdist_a " + String(Variant(dist)));
if (dist > _plane_epsilon) {
return false;
}
}
for (int n = 0; n < p_verts_b.size(); n++) {
real_t dist = p_plane.distance_to(p_verts_b[n]);
// print_line("\tdist_b " + String(Variant(dist)));
if (dist < -_plane_epsilon) {
return false;
}
}
return true;
}
// even if AABBs fail to have a splitting plane, there still may be another orientation that can split rooms (e.g. diagonal)
bool PortalRoomsBSP::calculate_freeform_splitting_plane(const VSRoom &p_room_a, const VSRoom &p_room_b, Plane &r_plane) const {
const LocalVector<Vector3, int32_t> &verts_a = p_room_a._verts;
const LocalVector<Vector3, int32_t> &verts_b = p_room_b._verts;
// test from room a to room b
for (int i = 0; i < verts_a.size(); i++) {
const Vector3 &pt_a = verts_a[i];
for (int j = 0; j < verts_b.size(); j++) {
const Vector3 &pt_b = verts_b[j];
for (int k = j + 1; k < verts_b.size(); k++) {
const Vector3 &pt_c = verts_b[k];
// make a plane
r_plane = Plane(pt_a, pt_b, pt_c);
// test the plane
if (test_freeform_plane(verts_a, verts_b, r_plane)) {
return true;
}
}
}
}
// test from room b to room a
for (int i = 0; i < verts_b.size(); i++) {
const Vector3 &pt_a = verts_b[i];
for (int j = 0; j < verts_a.size(); j++) {
const Vector3 &pt_b = verts_a[j];
for (int k = j + 1; k < verts_a.size(); k++) {
const Vector3 &pt_c = verts_a[k];
// make a plane
r_plane = Plane(pt_a, pt_b, pt_c);
// test the plane
if (test_freeform_plane(verts_b, verts_a, r_plane)) {
return true;
}
}
}
}
return false;
}
bool PortalRoomsBSP::calculate_aabb_splitting_plane(const AABB &p_a, const AABB &p_b, Plane &r_plane) const {
real_t split_point = 0.0;
const Vector3 &min_a = p_a.position;
const Vector3 &min_b = p_b.position;
Vector3 max_a = min_a + p_a.size;
Vector3 max_b = min_b + p_b.size;
if (find_1d_split_point(min_a.x, max_a.x, min_b.x, max_b.x, split_point)) {
r_plane = Plane(Vector3(1, 0, 0), split_point);
return true;
}
if (find_1d_split_point(min_a.y, max_a.y, min_b.y, max_b.y, split_point)) {
r_plane = Plane(Vector3(0, 1, 0), split_point);
return true;
}
if (find_1d_split_point(min_a.z, max_a.z, min_b.z, max_b.z, split_point)) {
r_plane = Plane(Vector3(0, 0, 1), split_point);
return true;
}
return false;
}
int PortalRoomsBSP::evaluate_room_split_plane(int p_room_a_id, int p_room_b_id, const LocalVector<int32_t, int32_t> &p_room_ids, Plane &r_plane, LocalVector<int32_t, int32_t> *r_room_ids_back, LocalVector<int32_t, int32_t> *r_room_ids_front) {
// try and create a splitting plane between room a and b, then evaluate it.
const VSRoom &room_a = _portal_renderer->get_room(p_room_a_id);
const VSRoom &room_b = _portal_renderer->get_room(p_room_b_id);
// easiest case, if the rooms don't overlap AABB, we can create an axis aligned plane between them
if (calculate_aabb_splitting_plane(room_a._aabb, room_b._aabb, r_plane)) {
return evaluate_plane(nullptr, r_plane, p_room_ids, r_room_ids_back, r_room_ids_front);
}
if (calculate_freeform_splitting_plane(room_a, room_b, r_plane)) {
return evaluate_plane(nullptr, r_plane, p_room_ids, r_room_ids_back, r_room_ids_front);
}
return 0;
}
int PortalRoomsBSP::evaluate_plane(const VSPortal *p_portal, const Plane &p_plane, const LocalVector<int32_t, int32_t> &p_room_ids, LocalVector<int32_t, int32_t> *r_room_ids_back, LocalVector<int32_t, int32_t> *r_room_ids_front) {
int rooms_front = 0;
int rooms_back = 0;
if (r_room_ids_back) {
DEV_ASSERT(!r_room_ids_back->size());
}
if (r_room_ids_front) {
DEV_ASSERT(!r_room_ids_front->size());
}
#define PANDEMONIUM_BSP_PUSH_FRONT \
rooms_front++; \
if (r_room_ids_front) { \
r_room_ids_front->push_back(rid); \
}
#define PANDEMONIUM_BSP_PUSH_BACK \
rooms_back++; \
if (r_room_ids_back) { \
r_room_ids_back->push_back(rid); \
}
for (int n = 0; n < p_room_ids.size(); n++) {
int rid = p_room_ids[n];
const VSRoom &room = _portal_renderer->get_room(rid);
// easy cases first
real_t r_min, r_max;
room._aabb.project_range_in_plane(p_plane, r_min, r_max);
if ((r_min <= 0.0) && (r_max <= 0.0)) {
PANDEMONIUM_BSP_PUSH_BACK
continue;
}
if ((r_min >= 0.0) && (r_max >= 0.0)) {
PANDEMONIUM_BSP_PUSH_FRONT
continue;
}
// check if the room uses this portal
// internal portals can link to a room that is both in front and behind,
// so we can only deal with non internal portals here with this cheap test.
if (p_portal && !p_portal->_internal) {
if (p_portal->_linkedroom_ID[0] == rid) {
PANDEMONIUM_BSP_PUSH_BACK
continue;
}
if (p_portal->_linkedroom_ID[1] == rid) {
PANDEMONIUM_BSP_PUSH_FRONT
continue;
}
}
// most expensive test, test the individual points of the room
// This will catch some off axis rooms that aren't caught by the AABB alone
int points_front = 0;
int points_back = 0;
for (int p = 0; p < room._verts.size(); p++) {
const Vector3 &pt = room._verts[p];
real_t dist = p_plane.distance_to(pt);
// don't take account of points in the epsilon zone,
// these are within the margin of error and could be in front OR behind the plane
if (dist > _plane_epsilon) {
points_front++;
if (points_back) {
break;
}
} else if (dist < -_plane_epsilon) {
points_back++;
if (points_front) {
break;
}
}
}
// if all points are in front
if (!points_back) {
PANDEMONIUM_BSP_PUSH_FRONT
continue;
}
// if all points are behind
if (!points_front) {
PANDEMONIUM_BSP_PUSH_BACK
continue;
}
// if split, push to both children
if (r_room_ids_front) {
r_room_ids_front->push_back(rid);
}
if (r_room_ids_back) {
r_room_ids_back->push_back(rid);
}
}
#undef PANDEMONIUM_BSP_PUSH_BACK
#undef PANDEMONIUM_BSP_PUSH_FRONT
// we want the split that splits the most front and back rooms
return rooms_front * rooms_back;
}
int PortalRoomsBSP::evaluate_portal(int p_portal_id, const LocalVector<int32_t, int32_t> &p_room_ids, LocalVector<int32_t, int32_t> *r_room_ids_back, LocalVector<int32_t, int32_t> *r_room_ids_front) {
const VSPortal &portal = _portal_renderer->get_portal(p_portal_id);
const Plane &plane = portal._plane;
return evaluate_plane(&portal, plane, p_room_ids, r_room_ids_back, r_room_ids_front);
}

105
servers/rendering/portals/portal_rooms_bsp.h
View File

@ -1,105 +0,0 @@
#ifndef PORTAL_ROOMS_BSP_H
#define PORTAL_ROOMS_BSP_H
/*************************************************************************/
/* portal_rooms_bsp.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 "core/containers/local_vector.h"
#include "core/math/aabb.h"
#include "core/math/plane.h"
class PortalRenderer;
struct VSPortal;
struct VSRoom;
class PortalRoomsBSP {
struct Node {
Node() { clear(); }
void clear() {
leaf = false;
child[0] = -1;
child[1] = -1;
}
bool leaf;
union {
int32_t child[2];
struct {
int32_t first_id;
int32_t num_ids;
};
};
Plane plane;
};
LocalVector<Node, int32_t> _nodes;
LocalVector<int32_t, int32_t> _room_ids;
PortalRenderer *_portal_renderer = nullptr;
const real_t _plane_epsilon = 0.001;
public:
// build the BSP on level start
void create(PortalRenderer &r_portal_renderer);
// clear data, and ready for a new level
void clear() {
_nodes.reset();
_room_ids.reset();
}
// the main function, returns a shortlist of rooms that are possible for a test point
const int32_t *find_shortlist(const Vector3 &p_pt, int &r_num_rooms) const;
// This is a 'sticky' function, it prefers to stay in the previous room where possible.
// This means there is a hysteresis for room choice that may occur if the user creates
// overlapping rooms...
int find_room_within(const PortalRenderer &p_portal_renderer, const Vector3 &p_pos, int p_previous_room_id) const;
private:
void build(int p_start_node_id, LocalVector<int32_t, int32_t> p_orig_room_ids);
void detect_internal_room_containment(PortalRenderer &r_portal_renderer);
int evaluate_portal(int p_portal_id, const LocalVector<int32_t, int32_t> &p_room_ids, LocalVector<int32_t, int32_t> *r_room_ids_back = nullptr, LocalVector<int32_t, int32_t> *r_room_ids_front = nullptr);
int evaluate_room_split_plane(int p_room_a_id, int p_room_b_id, const LocalVector<int32_t, int32_t> &p_room_ids, Plane &r_plane, LocalVector<int32_t, int32_t> *r_room_ids_back = nullptr, LocalVector<int32_t, int32_t> *r_room_ids_front = nullptr);
int evaluate_plane(const VSPortal *p_portal, const Plane &p_plane, const LocalVector<int32_t, int32_t> &p_room_ids, LocalVector<int32_t, int32_t> *r_room_ids_back = nullptr, LocalVector<int32_t, int32_t> *r_room_ids_front = nullptr);
bool calculate_aabb_splitting_plane(const AABB &p_a, const AABB &p_b, Plane &r_plane) const;
bool calculate_freeform_splitting_plane(const VSRoom &p_room_a, const VSRoom &p_room_b, Plane &r_plane) const;
bool find_1d_split_point(real_t p_min_a, real_t p_max_a, real_t p_min_b, real_t p_max_b, real_t &r_split_point) const;
bool test_freeform_plane(const LocalVector<Vector3, int32_t> &p_verts_a, const LocalVector<Vector3, int32_t> &p_verts_b, const Plane &p_plane) const;
void debug_print_tree(int p_node_id = 0, int p_depth = 0);
void _log(String p_string);
};
#endif

570
servers/rendering/portals/portal_tracer.cpp
View File

@ -1,570 +0,0 @@
/*************************************************************************/
/* 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/rendering/rendering_server_globals.h"
#include "servers/rendering/rendering_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) {
// RSG::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) {
RSG::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 = RSG::scene->_instance_get_from_rid(moving.instance_rid);
if (vss_instance) {
#endif
if (test_cull_inside(moving.exact_aabb, p_planes, false)) {
if (RSG::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 (RSG::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 Projection &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 (RSG::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;
}

175
servers/rendering/portals/portal_tracer.h
View File

@ -1,175 +0,0 @@
#ifndef PORTAL_TRACER_H
#define PORTAL_TRACER_H
/*************************************************************************/
/* portal_tracer.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 "core/containers/bitfield_dynamic.h"
#include "core/containers/local_vector.h"
#include "portal_occlusion_culler.h"
#include "portal_types.h"
#ifdef TOOLS_ENABLED
// use this for checking for instance lifetime errors, disable normally
//#define PORTAL_RENDERER_STORE_MOVING_RIDS
#endif
struct Projection;
class PortalRenderer;
struct VSRoom;
class PortalTracer {
public:
// a bitfield for which statics have been hit this time,
// and a list of showing statics
class TraceResult {
public:
void create(int p_num_statics) {
bf_visible_statics.create(p_num_statics);
}
void clear() {
bf_visible_statics.blank();
visible_static_ids.clear();
visible_roamer_pool_ids.clear();
}
BitFieldDynamic bf_visible_statics;
LocalVector<uint32_t> visible_static_ids;
LocalVector<uint32_t> visible_roamer_pool_ids;
};
struct TraceParams {
bool use_pvs;
uint8_t *decompressed_room_pvs;
};
// The recursive visibility function needs to allocate lists of planes each time a room is traversed.
// Instead of doing this allocation on the fly we will use a pool which should be much faster and nearer
// constant time.
// Note this simple pool isn't super optimal but should be fine for now.
class PlanesPool {
public:
// maximum number of vectors in the pool
const static int POOL_MAX = 32;
void reset();
// request a new vector of planes .. returns the pool id, or -1 if pool is empty
unsigned int request();
// return pool id to the pool
void free(unsigned int ui);
LocalVector<Plane> &get(unsigned int ui) { return _planes[ui]; }
PlanesPool();
private:
LocalVector<Plane> _planes[POOL_MAX];
// list of pool ids that are free and can be allocated
uint8_t _freelist[POOL_MAX];
uint32_t _num_free;
};
// for debugging, instead of doing a normal trace, show the objects that are sprawled from the current room
void trace_debug_sprawl(PortalRenderer &p_portal_renderer, const Vector3 &p_pos, int p_start_room_id, TraceResult &r_result);
// trace statics, dynamics and roaming
void trace(PortalRenderer &p_portal_renderer, const Vector3 &p_pos, const LocalVector<Plane> &p_planes, int p_start_room_id, TraceResult &r_result);
// globals are handled separately as they don't care about the rooms
int 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);
void set_depth_limit(int p_limit) { _depth_limit = p_limit; }
int get_depth_limit() const { return _depth_limit; }
// special function for occlusion culling only that does not use portals / rooms,
// but allows using occluders with the main scene
int occlusion_cull(PortalRenderer &p_portal_renderer, const Vector3 &p_point, const Vector3 &p_cam_dir, const Projection &p_cam_matrix, const Vector<Plane> &p_convex, VSInstance **p_result_array, int p_num_results);
PortalOcclusionCuller &get_occlusion_culler() { return _occlusion_culler; }
const PortalOcclusionCuller &get_occlusion_culler() const { return _occlusion_culler; }
private:
// main tracing function is recursive
void trace_recursive(const TraceParams &p_params, int p_depth, int p_room_id, const LocalVector<Plane> &p_planes, int p_from_external_room_id = -1);
// use pvs to cull instead of dynamically using portals
// this is a faster trace but less accurate. Only possible if PVS has been generated.
void trace_pvs(int p_source_room_id, const LocalVector<Plane> &p_planes);
// debug version
void trace_debug_sprawl_recursive(int p_depth, int p_room_id);
void cull_statics(const VSRoom &p_room, const LocalVector<Plane> &p_planes);
void cull_statics_debug_sprawl(const VSRoom &p_room);
void cull_roamers(const VSRoom &p_room, const LocalVector<Plane> &p_planes);
// if an aabb is in front of any of the culling planes, it can't be seen so returns false
bool test_cull_inside(const AABB &p_aabb, const LocalVector<Plane> &p_planes, bool p_test_explicit_near_plane = true) const {
for (unsigned int p = 0; p < p_planes.size(); p++) {
real_t r_min, r_max;
p_aabb.project_range_in_plane(p_planes[p], r_min, r_max);
if (r_min > 0.0) {
return false;
}
}
if (p_test_explicit_near_plane) {
real_t r_min, r_max;
p_aabb.project_range_in_plane(_near_and_far_planes[0], r_min, r_max);
if (r_min > 0.0) {
return false;
}
}
return true;
}
// local versions to prevent passing around the recursive functions
PortalRenderer *_portal_renderer = nullptr;
Vector3 _trace_start_point;
TraceResult *_result = nullptr;
Plane _near_and_far_planes[2];
PlanesPool _planes_pool;
int _depth_limit = 16;
PortalOcclusionCuller _occlusion_culler;
// keep a tick count for each trace, to avoid adding a visible
// object to the hit list more than once per tick
// (this makes more sense than bitfield for moving objects)
uint32_t _tick = 0;
};
#endif

234
servers/rendering/portals/portal_types.cpp
View File

@ -1,234 +0,0 @@
/*************************************************************************/
/* portal_types.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_types.h"
VSPortal::ClipResult VSPortal::clip_with_plane(const Plane &p) const {
int nOutside = 0;
int nPoints = _pts_world.size();
for (int n = 0; n < nPoints; n++) {
real_t d = p.distance_to(_pts_world[n]);
if (d >= 0.0) {
nOutside++;
}
}
if (nOutside == nPoints) {
return CLIP_OUTSIDE;
}
if (nOutside == 0) {
return CLIP_INSIDE;
}
return CLIP_PARTIAL;
}
void VSPortal::add_pvs_planes(const VSPortal &p_first, bool p_first_outgoing, LocalVector<Plane, int32_t> &r_planes, bool p_outgoing) const {
int num_a = p_first._pts_world.size();
int num_b = _pts_world.size();
// get the world points of both in the correct order based on whether outgoing .. note this isn't very efficient...
Vector3 *pts_a = (Vector3 *)alloca(num_a * sizeof(Vector3));
Vector3 *pts_b = (Vector3 *)alloca(num_b * sizeof(Vector3));
if (p_first_outgoing) {
// straight copy
for (int n = 0; n < num_a; n++) {
pts_a[n] = p_first._pts_world[n];
}
} else {
for (int n = 0; n < num_a; n++) {
pts_a[n] = p_first._pts_world[num_a - 1 - n];
}
}
if (p_outgoing) {
// straight copy
for (int n = 0; n < num_b; n++) {
pts_b[n] = _pts_world[n];
}
} else {
for (int n = 0; n < num_b; n++) {
pts_b[n] = _pts_world[num_b - 1 - n];
}
}
// go through and try every combination of points to form a clipping plane
for (int pvA = 0; pvA < num_a; pvA++) {
for (int pvB = 0; pvB < num_b; pvB++) {
int pvC = (pvB + 1) % num_b;
// three verts
const Vector3 &va = pts_a[pvA];
const Vector3 &vb = pts_b[pvB];
const Vector3 &vc = pts_b[pvC];
// create plane
Plane plane = Plane(va, vc, vb);
// already exists similar plane, so ignore
if (_is_plane_duplicate(plane, r_planes)) {
continue;
}
if (_test_pvs_plane(-plane, pts_a, num_a, pts_b, num_b)) {
// add the plane
r_planes.push_back(plane);
}
} // for pvB
} // for pvA
}
// typically we will end up with a bunch of duplicate planes being trying to be added for a portal.
// we can remove any that are too similar
bool VSPortal::_is_plane_duplicate(const Plane &p_plane, const LocalVector<Plane, int32_t> &p_planes) const {
const real_t epsilon_d = 0.001;
const real_t epsilon_dot = 0.98;
for (int n = 0; n < p_planes.size(); n++) {
const Plane &p = p_planes[n];
if (Math::absf(p_plane.d - p.d) > epsilon_d) {
continue;
}
real_t dot = p_plane.normal.dot(p.normal);
if (dot < epsilon_dot) {
continue;
}
// match
return true;
}
return false;
}
bool VSPortal::_pvs_is_outside_planes(const LocalVector<Plane, int32_t> &p_planes) const {
// short version
const Vector<Vector3> &pts = _pts_world;
int nPoints = pts.size();
const real_t epsilon = 0.1;
for (int p = 0; p < p_planes.size(); p++) {
for (int n = 0; n < nPoints; n++) {
const Vector3 &pt = pts[n];
real_t dist = p_planes[p].distance_to(pt);
if (dist < -epsilon) {
return false;
}
}
}
return true;
}
bool VSPortal::_test_pvs_plane(const Plane &p_plane, const Vector3 *pts_a, int num_a, const Vector3 *pts_b, int num_b) const {
const real_t epsilon = 0.1;
for (int n = 0; n < num_a; n++) {
real_t dist = p_plane.distance_to(pts_a[n]);
if (dist > epsilon) {
return false;
}
}
for (int n = 0; n < num_b; n++) {
real_t dist = p_plane.distance_to(pts_b[n]);
if (dist < -epsilon) {
return false;
}
}
return true;
}
// add clipping planes to the vector formed by each portal edge and the camera
void VSPortal::add_planes(const Vector3 &p_cam, LocalVector<Plane> &r_planes, bool p_outgoing) const {
// short version
const Vector<Vector3> &pts = _pts_world;
int nPoints = pts.size();
ERR_FAIL_COND(nPoints < 3);
Plane p;
int offset_a, offset_b;
if (p_outgoing) {
offset_a = 0;
offset_b = -1;
} else {
offset_a = -1;
offset_b = 0;
}
for (int n = 1; n < nPoints; n++) {
p = Plane(p_cam, pts[n + offset_a], pts[n + offset_b]);
// detect null plane
// if (p.normal.length_squared() < 0.1)
// {
// print("NULL plane detected from points : ");
// print(ptCam + pts[n] + pts[n-1]);
// }
r_planes.push_back(p);
debug_check_plane_validity(p);
}
// first and last
if (p_outgoing) {
p = Plane(p_cam, pts[0], pts[nPoints - 1]);
} else {
p = Plane(p_cam, pts[nPoints - 1], pts[0]);
}
r_planes.push_back(p);
debug_check_plane_validity(p);
// debug
// if (!manager.m_bDebugPlanes)
// return;
// for (int n=0; n<nPoints; n++)
// {
// manager.m_DebugPlanes.push_back(pts[n]);
// }
}
void VSPortal::debug_check_plane_validity(const Plane &p) const {
// DEV_ASSERT(p.distance_to(center) < 0.0);
}

514
servers/rendering/portals/portal_types.h
View File

@ -1,514 +0,0 @@
#ifndef PORTAL_TYPES_H
#define PORTAL_TYPES_H
/*************************************************************************/
/* portal_types.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 "core/containers/local_vector.h"
#include "core/math/aabb.h"
#include "core/math/plane.h"
#include "core/math/quaternion.h"
#include "core/math/transform.h"
#include "core/math/vector3.h"
#include "core/object/object_id.h"
#include "core/containers/rid.h"
#include "portal_defines.h"
// visual server scene instance.
// we can't have a pointer to nested class outside of visual server scene...
// so rather than use a void * straight we can use this for some semblance
// of safety
typedef void VSInstance;
typedef void VSGhost;
// the handles are just IDs, but nicer to be specific on what they are in the code.
// Also - the handles are plus one based (i.e. 0 is unset, 1 is id 0, 2 is id 1 etc.
typedef uint32_t PortalHandle;
typedef uint32_t RoomHandle;
typedef uint32_t RoomGroupHandle;
typedef uint32_t OcclusionHandle;
typedef uint32_t RGhostHandle;
typedef uint32_t OccluderInstanceHandle;
typedef uint32_t OccluderResourceHandle;
struct VSPortal {
enum ClipResult {
CLIP_OUTSIDE,
CLIP_PARTIAL,
CLIP_INSIDE,
};
// explicit create and destroy rather than constructors / destructors
// because we are using a pool so objects may be reused
void create() {
_linkedroom_ID[0] = -1;
_linkedroom_ID[1] = -1;
_active = true;
_plane = Plane();
_portal_id = -1;
_aabb = AABB();
}
void destroy() {
_pts_world.reset();
}
void rooms_and_portals_clear() {
_linkedroom_ID[0] = -1;
_linkedroom_ID[1] = -1;
_active = true;
_plane = Plane();
_aabb = AABB();
_pts_world.reset();
}
VSPortal::ClipResult clip_with_plane(const Plane &p) const;
void add_planes(const Vector3 &p_cam, LocalVector<Plane> &r_planes, bool p_outgoing) const;
void debug_check_plane_validity(const Plane &p) const;
void add_pvs_planes(const VSPortal &p_first, bool p_first_outgoing, LocalVector<Plane, int32_t> &r_planes, bool p_outgoing) const;
bool _pvs_is_outside_planes(const LocalVector<Plane, int32_t> &p_planes) const;
private:
bool _test_pvs_plane(const Plane &p_plane, const Vector3 *pts_a, int num_a, const Vector3 *pts_b, int num_b) const;
bool _is_plane_duplicate(const Plane &p_plane, const LocalVector<Plane, int32_t> &p_planes) const;
public:
// returns the room to if if crosses, or else returns -1
int geometry_crosses_portal(int p_room_from, const AABB &p_aabb, const Vector<Vector3> &p_pts) const {
// first aabb check
if (!p_aabb.intersects(_aabb)) {
return -1;
}
// disallow sprawling from outer to inner rooms.
// This is a convenience feature that stops e.g. terrain sprawling into
// a building. If you want geometry to feature in the inner room and the outer,
// simply place it in the inner room.
if (_internal && (_linkedroom_ID[0] != p_room_from)) {
return -1;
}
// accurate check use portal triangles
// NYI
const real_t epsilon = _margin;
if (p_room_from == _linkedroom_ID[0]) {
// outward
// how far do points project over the portal
for (int n = 0; n < p_pts.size(); n++) {
real_t dist = _plane.distance_to(p_pts[n]);
if (dist > epsilon) {
return _linkedroom_ID[1];
}
}
} else {
// inward
DEV_ASSERT(p_room_from == _linkedroom_ID[1]);
for (int n = 0; n < p_pts.size(); n++) {
real_t dist = _plane.distance_to(p_pts[n]);
if (dist < -epsilon) {
return _linkedroom_ID[0];
}
}
}
// no points crossed the portal
return -1;
}
// returns the room to if if crosses, or else returns -1
int crosses_portal(int p_room_from, const AABB &p_aabb, bool p_disallow_crossing_internal = false, bool p_accurate_check = false) const {
// first aabb check
if (!p_aabb.intersects(_aabb)) {
return -1;
}
// disallow sprawling from outer to inner rooms.
// This is a convenience feature that stops e.g. terrain sprawling into
// a building. If you want geometry to feature in the inner room and the outer,
// simply place it in the inner room.
if (p_disallow_crossing_internal && _internal && (_linkedroom_ID[0] != p_room_from)) {
return -1;
}
// accurate check use portal triangles
// NYI
real_t r_min, r_max;
p_aabb.project_range_in_plane(_plane, r_min, r_max);
const real_t epsilon = _margin; //10.0;
if (p_room_from == _linkedroom_ID[0]) {
if (r_max > epsilon) {
return _linkedroom_ID[1];
} else {
return -1;
}
}
DEV_ASSERT(p_room_from == _linkedroom_ID[1]);
if (r_min < -epsilon) {
return _linkedroom_ID[0];
}
return -1;
}
// the portal needs a list of unique world points (in order, clockwise?)
LocalVector<Vector3> _pts_world;
// used in PVS calculation
Vector3 _pt_center;
// used for occlusion culling with occluders
real_t _bounding_sphere_radius = 0.0;
// portal plane
Plane _plane;
// aabb for quick bounds checks
AABB _aabb;
uint32_t _portal_id = -1;
// in order to detect objects crossing portals,
// an extension margin can be used to prevent objects
// that *just* cross the portal extending into the next room
real_t _margin = 1.0;
// these are room IDs, or -1 if unset
int _linkedroom_ID[2];
// can be turned on and off by the user
bool _active = true;
// internal portals have slightly different behaviour
bool _internal = false;
VSPortal() {
_linkedroom_ID[0] = -1;
_linkedroom_ID[1] = -1;
}
};
struct VSRoomGroup {
void create() {
}
void destroy() {
_room_ids.reset();
}
// used for calculating gameplay notifications
uint32_t last_room_tick_hit = 0;
ObjectID _pandemonium_instance_ID = 0;
LocalVector<uint32_t, int32_t> _room_ids;
};
struct VSRoom {
// explicit create and destroy rather than constructors / destructors
// because we are using a pool so objects may be reused
void create() {
_room_ID = -1;
_aabb = AABB();
}
void destroy() {
_static_ids.reset();
_static_ghost_ids.reset();
_planes.reset();
_verts.reset();
_portal_ids.reset();
_roamer_pool_ids.reset();
_rghost_pool_ids.reset();
_roomgroup_ids.reset();
_pvs_first = 0;
_pvs_size = 0;
_secondary_pvs_first = 0;
_secondary_pvs_size = 0;
_priority = 0;
_contains_internal_rooms = false;
last_room_tick_hit = 0;
}
void cleanup_after_conversion() {
_verts.reset();
}
void rooms_and_portals_clear() {
destroy();
_aabb = AABB();
// don't unset the room_ID here, because rooms may be accessed after this is called
}
// this isn't just useful for checking whether a point is within (i.e. returned value is 0 or less)
// it is useful for finding the CLOSEST room to a point (by plane distance, doesn't take into account corners etc)
real_t is_point_within(const Vector3 &p_pos) const {
// inside by default
real_t closest_dist = -FLT_MAX;
for (int n = 0; n < _planes.size(); n++) {
real_t dist = _planes[n].distance_to(p_pos);
if (dist > closest_dist) {
closest_dist = dist;
}
}
return closest_dist;
}
// not super fast, but there shouldn't be that many roamers per room
bool remove_roamer(uint32_t p_pool_id) {
for (int n = 0; n < _roamer_pool_ids.size(); n++) {
if (_roamer_pool_ids[n] == p_pool_id) {
_roamer_pool_ids.remove_unordered(n);
return true;
}
}
return false;
}
bool remove_rghost(uint32_t p_pool_id) {
for (int n = 0; n < _rghost_pool_ids.size(); n++) {
if (_rghost_pool_ids[n] == p_pool_id) {
_rghost_pool_ids.remove_unordered(n);
return true;
}
}
return false;
}
bool remove_occluder(uint32_t p_pool_id) {
for (unsigned int n = 0; n < _occluder_pool_ids.size(); n++) {
if (_occluder_pool_ids[n] == p_pool_id) {
_occluder_pool_ids.remove_unordered(n);
return true;
}
}
return false;
}
void add_roamer(uint32_t p_pool_id) {
_roamer_pool_ids.push_back(p_pool_id);
}
void add_rghost(uint32_t p_pool_id) {
_rghost_pool_ids.push_back(p_pool_id);
}
void add_occluder(uint32_t p_pool_id) {
_occluder_pool_ids.push_back(p_pool_id);
}
// keep a list of statics in the room .. statics may appear
// in more than one room due to sprawling!
LocalVector<uint32_t, int32_t> _static_ids;
LocalVector<uint32_t, int32_t> _static_ghost_ids;
// very rough
AABB _aabb;
int32_t _room_ID = -1;
ObjectID _pandemonium_instance_ID = 0;
// rooms with a higher priority are internal rooms ..
// rooms within a room. These will be chosen in preference
// when finding the room within, when within more than one room.
// Example, house in a terrain room.
int32_t _priority = 0;
bool _contains_internal_rooms = false;
int32_t _pvs_first = 0;
int32_t _secondary_pvs_first = 0;
uint16_t _pvs_size = 0;
uint16_t _secondary_pvs_size = 0;
// used for calculating gameplay notifications
uint32_t last_room_tick_hit = 0;
// convex hull of the room, either determined by geometry or manual bound
LocalVector<Plane, int32_t> _planes;
// vertices of the corners of the hull, passed from the scene tree
// (note these don't take account of any final portal planes adjusted by the portal renderer)
LocalVector<Vector3, int32_t> _verts;
// which portals are in the room (ingoing and outgoing)
LocalVector<uint32_t, int32_t> _portal_ids;
// roaming movers currently in the room
LocalVector<uint32_t, int32_t> _roamer_pool_ids;
LocalVector<uint32_t, int32_t> _rghost_pool_ids;
// only using uint here for compatibility with TrackedPoolList,
// as we will use either this or TrackedPoolList for occlusion testing
LocalVector<uint32_t, uint32_t> _occluder_pool_ids;
// keep track of which roomgroups the room is in, that
// way we can switch on and off roomgroups as they enter / exit view
LocalVector<uint32_t, int32_t> _roomgroup_ids;
};
// Possibly shared data, in local space
struct VSOccluder_Resource {
void create() {
type = OT_UNDEFINED;
revision = 0;
list_ids.clear();
}
// these should match the values in RenderingServer::OccluderType
enum Type : uint32_t {
OT_UNDEFINED,
OT_SPHERE,
OT_MESH,
OT_NUM_TYPES,
} type;
// If the revision of the instance and the resource don't match,
// then the local versions have been updated and need transforming
// to world space in the instance (i.e. it is dirty)
uint32_t revision;
// ids of multiple objects in the appropriate occluder pool:
// local space for resources, and world space for occluder instances
LocalVector<uint32_t, int32_t> list_ids;
};
struct VSOccluder_Instance : public VSOccluder_Resource {
void create() {
VSOccluder_Resource::create();
room_id = -1;
active = true;
resource_pool_id = UINT32_MAX;
}
// Occluder instance can be bound to one resource (which will include data in local space)
// This should be set back to NULL if the resource is deleted
uint32_t resource_pool_id;
// which is the primary room this group of occluders is in
// (it may sprawl into multiple rooms)
int32_t room_id;
// location for finding the room
Vector3 pt_center;
// world space aabb, only updated when dirty
AABB aabb;
// global xform
Transform xform;
// controlled by the visible flag on the occluder
bool active;
};
namespace Occlusion {
struct Sphere {
Vector3 pos;
real_t radius;
void create() { radius = 0.0; }
void from_plane(const Plane &p_plane) {
pos = p_plane.normal;
// Disallow negative radius. Even zero radius should not really be sent.
radius = MAX(p_plane.d, 0.0);
}
bool intersect_ray(const Vector3 &p_ray_origin, const Vector3 &p_ray_dir, real_t &r_dist, real_t radius_squared) const {
Vector3 offset = pos - p_ray_origin;
real_t c2 = offset.length_squared();
real_t v = offset.dot(p_ray_dir);
real_t d = radius_squared - (c2 - (v * v));
if (d < 0.0) {
return false;
}
r_dist = (v - Math::sqrt(d));
return true;
}
};
struct Poly {
static const int MAX_POLY_VERTS = PortalDefines::OCCLUSION_POLY_MAX_VERTS;
void create() {
num_verts = 0;
}
void flip() {
for (int n = 0; n < num_verts / 2; n++) {
SWAP(verts[n], verts[num_verts - n - 1]);
}
}
int num_verts;
Vector3 verts[MAX_POLY_VERTS];
};
struct PolyPlane : public Poly {
void flip() {
plane = -plane;
Poly::flip();
}
Plane plane;
};
} // namespace Occlusion
struct VSOccluder_Sphere : public Occlusion::Sphere {
};
struct VSOccluder_Poly {
static const int MAX_POLY_HOLES = PortalDefines::OCCLUSION_POLY_MAX_HOLES;
void create() {
poly.create();
num_holes = 0;
two_way = false;
for (int n = 0; n < MAX_POLY_HOLES; n++) {
hole_pool_ids[n] = UINT32_MAX;
}
}
Occlusion::PolyPlane poly;
bool two_way;
int num_holes;
uint32_t hole_pool_ids[MAX_POLY_HOLES];
};
struct VSOccluder_Hole : public Occlusion::Poly {
};
#endif

58
servers/rendering/rendering_server_raster.h
View File

@ -45,8 +45,6 @@ class RenderingServerRaster : public RenderingServer {
MAX_INSTANCE_LIGHTS = 4,
LIGHT_CACHE_DIRTY = -1,
MAX_LIGHTS_CULLED = 256,
MAX_ROOM_CULL = 32,
MAX_EXTERIOR_PORTALS = 128,
MAX_LIGHT_SAMPLERS = 256,
INSTANCE_ROOMLESS_MASK = (1 << 20)
@ -493,62 +491,6 @@ public:
BIND2(instance_set_extra_visibility_margin, RID, real_t)
/* PORTALS */
BIND2(instance_set_portal_mode, RID, InstancePortalMode)
BIND0R(RID, ghost_create)
BIND4(ghost_set_scenario, RID, RID, ObjectID, const AABB &)
BIND2(ghost_update, RID, const AABB &)
BIND0R(RID, portal_create)
BIND2(portal_set_scenario, RID, RID)
BIND3(portal_set_geometry, RID, const Vector<Vector3> &, real_t)
BIND4(portal_link, RID, RID, RID, bool)
BIND2(portal_set_active, RID, bool)
/* ROOMGROUPS */
BIND0R(RID, roomgroup_create)
BIND2(roomgroup_prepare, RID, ObjectID)
BIND2(roomgroup_set_scenario, RID, RID)
BIND2(roomgroup_add_room, RID, RID)
/* OCCLUDERS */
BIND0R(RID, occluder_instance_create)
BIND2(occluder_instance_set_scenario, RID, RID)
BIND2(occluder_instance_link_resource, RID, RID)
BIND2(occluder_instance_set_transform, RID, const Transform &)
BIND2(occluder_instance_set_active, RID, bool)
BIND0R(RID, occluder_resource_create)
BIND2(occluder_resource_prepare, RID, OccluderType)
BIND2(occluder_resource_spheres_update, RID, const Vector<Plane> &)
BIND2(occluder_resource_mesh_update, RID, const Geometry::OccluderMeshData &)
BIND1(set_use_occlusion_culling, bool)
BIND1RC(Geometry::MeshData, occlusion_debug_get_current_polys, RID)
/* ROOMS */
BIND0R(RID, room_create)
BIND2(room_set_scenario, RID, RID)
BIND4(room_add_instance, RID, RID, const AABB &, const Vector<Vector3> &)
BIND3(room_add_ghost, RID, ObjectID, const AABB &)
BIND5(room_set_bound, RID, ObjectID, const Vector<Plane> &, const AABB &, const Vector<Vector3> &)
BIND2(room_prepare, RID, int32_t)
BIND1(rooms_and_portals_clear, RID)
BIND2(rooms_unload, RID, String)
BIND8(rooms_finalize, RID, bool, bool, bool, bool, String, bool, bool)
BIND4(rooms_override_camera, RID, bool, const Vector3 &, const Vector<Plane> *)
BIND2(rooms_set_active, RID, bool)
BIND3(rooms_set_params, RID, int, real_t)
BIND3(rooms_set_debug_feature, RID, RoomsDebugFeature, bool)
BIND2(rooms_update_gameplay_monitor, RID, const Vector<Vector3> &)
// don't use this in a game
BIND1RC(bool, rooms_is_loaded, RID)
// Callbacks
BIND1(callbacks_register, RenderingServerCallbacks *)

622
servers/rendering/rendering_server_scene.cpp
View File

@ -580,11 +580,6 @@ void RenderingServerScene::instance_set_scenario(RID p_instance, RID p_scenario)
instance->spatial_partition_id = 0;
}
// handle occlusion changes
if (instance->occlusion_handle) {
_instance_destroy_occlusion_rep(instance);
}
// remove any interpolation data associated with the instance in this scenario
_interpolation_data.notify_free_instance(p_instance, *instance);
@ -628,9 +623,6 @@ void RenderingServerScene::instance_set_scenario(RID p_instance, RID p_scenario)
}
}
// handle occlusion changes if necessary
_instance_create_occlusion_rep(instance);
_instance_queue_update(instance, true, true);
}
}
@ -1107,518 +1099,11 @@ void RenderingServerScene::instance_set_extra_visibility_margin(RID p_instance,
_instance_queue_update(instance, true, false);
}
// Portals
void RenderingServerScene::instance_set_portal_mode(RID p_instance, RenderingServer::InstancePortalMode p_mode) {
Instance *instance = instance_owner.get(p_instance);
ERR_FAIL_COND(!instance);
// no change?
if (instance->portal_mode == p_mode) {
return;
}
// should this happen?
if (!instance->scenario) {
instance->portal_mode = p_mode;
return;
}
// destroy previous occlusion instance?
_instance_destroy_occlusion_rep(instance);
instance->portal_mode = p_mode;
_instance_create_occlusion_rep(instance);
}
void RenderingServerScene::_instance_create_occlusion_rep(Instance *p_instance) {
ERR_FAIL_COND(!p_instance);
ERR_FAIL_COND(!p_instance->scenario);
switch (p_instance->portal_mode) {
default: {
p_instance->occlusion_handle = 0;
} break;
case RenderingServer::InstancePortalMode::INSTANCE_PORTAL_MODE_ROAMING: {
p_instance->occlusion_handle = p_instance->scenario->_portal_renderer.instance_moving_create(p_instance, p_instance->self, false, p_instance->transformed_aabb);
} break;
case RenderingServer::InstancePortalMode::INSTANCE_PORTAL_MODE_GLOBAL: {
p_instance->occlusion_handle = p_instance->scenario->_portal_renderer.instance_moving_create(p_instance, p_instance->self, true, p_instance->transformed_aabb);
} break;
}
}
void RenderingServerScene::_instance_destroy_occlusion_rep(Instance *p_instance) {
ERR_FAIL_COND(!p_instance);
ERR_FAIL_COND(!p_instance->scenario);
// not an error, can occur
if (!p_instance->occlusion_handle) {
return;
}
p_instance->scenario->_portal_renderer.instance_moving_destroy(p_instance->occlusion_handle);
// unset
p_instance->occlusion_handle = 0;
}
void *RenderingServerScene::_instance_get_from_rid(RID p_instance) {
Instance *instance = instance_owner.get(p_instance);
return instance;
}
bool RenderingServerScene::_instance_get_transformed_aabb(RID p_instance, AABB &r_aabb) {
Instance *instance = instance_owner.get(p_instance);
ERR_FAIL_NULL_V(instance, false);
r_aabb = instance->transformed_aabb;
return true;
}
// the portal has to be associated with a scenario, this is assumed to be
// the same scenario as the portal node
RID RenderingServerScene::portal_create() {
Portal *portal = memnew(Portal);
ERR_FAIL_COND_V(!portal, RID());
RID portal_rid = portal_owner.make_rid(portal);
return portal_rid;
}
// should not be called multiple times, different scenarios etc, but just in case, we will support this
void RenderingServerScene::portal_set_scenario(RID p_portal, RID p_scenario) {
Portal *portal = portal_owner.getornull(p_portal);
ERR_FAIL_COND(!portal);
Scenario *scenario = scenario_owner.getornull(p_scenario);
// noop?
if (portal->scenario == scenario) {
return;
}
// if the portal is in a scenario already, remove it
if (portal->scenario) {
portal->scenario->_portal_renderer.portal_destroy(portal->scenario_portal_id);
portal->scenario = nullptr;
portal->scenario_portal_id = 0;
}
// create when entering the world
if (scenario) {
portal->scenario = scenario;
// defer the actual creation to here
portal->scenario_portal_id = scenario->_portal_renderer.portal_create();
}
}
void RenderingServerScene::portal_set_geometry(RID p_portal, const Vector<Vector3> &p_points, real_t p_margin) {
Portal *portal = portal_owner.getornull(p_portal);
ERR_FAIL_COND(!portal);
ERR_FAIL_COND(!portal->scenario);
portal->scenario->_portal_renderer.portal_set_geometry(portal->scenario_portal_id, p_points, p_margin);
}
void RenderingServerScene::portal_link(RID p_portal, RID p_room_from, RID p_room_to, bool p_two_way) {
Portal *portal = portal_owner.getornull(p_portal);
ERR_FAIL_COND(!portal);
ERR_FAIL_COND(!portal->scenario);
Room *room_from = room_owner.getornull(p_room_from);
ERR_FAIL_COND(!room_from);
Room *room_to = room_owner.getornull(p_room_to);
ERR_FAIL_COND(!room_to);
portal->scenario->_portal_renderer.portal_link(portal->scenario_portal_id, room_from->scenario_room_id, room_to->scenario_room_id, p_two_way);
}
void RenderingServerScene::portal_set_active(RID p_portal, bool p_active) {
Portal *portal = portal_owner.getornull(p_portal);
ERR_FAIL_COND(!portal);
ERR_FAIL_COND(!portal->scenario);
portal->scenario->_portal_renderer.portal_set_active(portal->scenario_portal_id, p_active);
}
RID RenderingServerScene::ghost_create() {
Ghost *ci = memnew(Ghost);
ERR_FAIL_COND_V(!ci, RID());
RID ci_rid = ghost_owner.make_rid(ci);
return ci_rid;
}
void RenderingServerScene::ghost_set_scenario(RID p_ghost, RID p_scenario, ObjectID p_id, const AABB &p_aabb) {
Ghost *ci = ghost_owner.getornull(p_ghost);
ERR_FAIL_COND(!ci);
ci->aabb = p_aabb;
ci->object_id = p_id;
Scenario *scenario = scenario_owner.getornull(p_scenario);
// noop?
if (ci->scenario == scenario) {
return;
}
// if the portal is in a scenario already, remove it
if (ci->scenario) {
_ghost_destroy_occlusion_rep(ci);
ci->scenario = nullptr;
}
// create when entering the world
if (scenario) {
ci->scenario = scenario;
// defer the actual creation to here
_ghost_create_occlusion_rep(ci);
}
}
void RenderingServerScene::ghost_update(RID p_ghost, const AABB &p_aabb) {
Ghost *ci = ghost_owner.getornull(p_ghost);
ERR_FAIL_COND(!ci);
ERR_FAIL_COND(!ci->scenario);
ci->aabb = p_aabb;
if (ci->rghost_handle) {
ci->scenario->_portal_renderer.rghost_update(ci->rghost_handle, p_aabb);
}
}
void RenderingServerScene::_ghost_create_occlusion_rep(Ghost *p_ghost) {
ERR_FAIL_COND(!p_ghost);
ERR_FAIL_COND(!p_ghost->scenario);
if (!p_ghost->rghost_handle) {
p_ghost->rghost_handle = p_ghost->scenario->_portal_renderer.rghost_create(p_ghost->object_id, p_ghost->aabb);
}
}
void RenderingServerScene::_ghost_destroy_occlusion_rep(Ghost *p_ghost) {
ERR_FAIL_COND(!p_ghost);
ERR_FAIL_COND(!p_ghost->scenario);
// not an error, can occur
if (!p_ghost->rghost_handle) {
return;
}
p_ghost->scenario->_portal_renderer.rghost_destroy(p_ghost->rghost_handle);
p_ghost->rghost_handle = 0;
}
RID RenderingServerScene::roomgroup_create() {
RoomGroup *rg = memnew(RoomGroup);
ERR_FAIL_COND_V(!rg, RID());
RID roomgroup_rid = roomgroup_owner.make_rid(rg);
return roomgroup_rid;
}
void RenderingServerScene::roomgroup_prepare(RID p_roomgroup, ObjectID p_roomgroup_object_id) {
RoomGroup *roomgroup = roomgroup_owner.getornull(p_roomgroup);
ERR_FAIL_COND(!roomgroup);
ERR_FAIL_COND(!roomgroup->scenario);
roomgroup->scenario->_portal_renderer.roomgroup_prepare(roomgroup->scenario_roomgroup_id, p_roomgroup_object_id);
}
void RenderingServerScene::roomgroup_set_scenario(RID p_roomgroup, RID p_scenario) {
RoomGroup *rg = roomgroup_owner.getornull(p_roomgroup);
ERR_FAIL_COND(!rg);
Scenario *scenario = scenario_owner.getornull(p_scenario);
// noop?
if (rg->scenario == scenario) {
return;
}
// if the portal is in a scenario already, remove it
if (rg->scenario) {
rg->scenario->_portal_renderer.roomgroup_destroy(rg->scenario_roomgroup_id);
rg->scenario = nullptr;
rg->scenario_roomgroup_id = 0;
}
// create when entering the world
if (scenario) {
rg->scenario = scenario;
// defer the actual creation to here
rg->scenario_roomgroup_id = scenario->_portal_renderer.roomgroup_create();
}
}
void RenderingServerScene::roomgroup_add_room(RID p_roomgroup, RID p_room) {
RoomGroup *roomgroup = roomgroup_owner.getornull(p_roomgroup);
ERR_FAIL_COND(!roomgroup);
ERR_FAIL_COND(!roomgroup->scenario);
Room *room = room_owner.getornull(p_room);
ERR_FAIL_COND(!room);
ERR_FAIL_COND(!room->scenario);
ERR_FAIL_COND(roomgroup->scenario != room->scenario);
roomgroup->scenario->_portal_renderer.roomgroup_add_room(roomgroup->scenario_roomgroup_id, room->scenario_room_id);
}
// Occluders
RID RenderingServerScene::occluder_instance_create() {
OccluderInstance *ro = memnew(OccluderInstance);
ERR_FAIL_COND_V(!ro, RID());
RID occluder_rid = occluder_instance_owner.make_rid(ro);
return occluder_rid;
}
void RenderingServerScene::occluder_instance_link_resource(RID p_occluder_instance, RID p_occluder_resource) {
OccluderInstance *oi = occluder_instance_owner.getornull(p_occluder_instance);
ERR_FAIL_COND(!oi);
ERR_FAIL_COND(!oi->scenario);
OccluderResource *res = occluder_resource_owner.getornull(p_occluder_resource);
ERR_FAIL_COND(!res);
oi->scenario->_portal_renderer.occluder_instance_link(oi->scenario_occluder_id, res->occluder_resource_id);
}
void RenderingServerScene::occluder_instance_set_scenario(RID p_occluder_instance, RID p_scenario) {
OccluderInstance *oi = occluder_instance_owner.getornull(p_occluder_instance);
ERR_FAIL_COND(!oi);
Scenario *scenario = scenario_owner.getornull(p_scenario);
// noop?
if (oi->scenario == scenario) {
return;
}
// if the portal is in a scenario already, remove it
if (oi->scenario) {
oi->scenario->_portal_renderer.occluder_instance_destroy(oi->scenario_occluder_id);
oi->scenario = nullptr;
oi->scenario_occluder_id = 0;
}
// create when entering the world
if (scenario) {
oi->scenario = scenario;
oi->scenario_occluder_id = scenario->_portal_renderer.occluder_instance_create();
}
}
void RenderingServerScene::occluder_instance_set_active(RID p_occluder_instance, bool p_active) {
OccluderInstance *oi = occluder_instance_owner.getornull(p_occluder_instance);
ERR_FAIL_COND(!oi);
ERR_FAIL_COND(!oi->scenario);
oi->scenario->_portal_renderer.occluder_instance_set_active(oi->scenario_occluder_id, p_active);
}
void RenderingServerScene::occluder_instance_set_transform(RID p_occluder_instance, const Transform &p_xform) {
OccluderInstance *oi = occluder_instance_owner.getornull(p_occluder_instance);
ERR_FAIL_COND(!oi);
ERR_FAIL_COND(!oi->scenario);
oi->scenario->_portal_renderer.occluder_instance_set_transform(oi->scenario_occluder_id, p_xform);
}
RID RenderingServerScene::occluder_resource_create() {
OccluderResource *res = memnew(OccluderResource);
ERR_FAIL_COND_V(!res, RID());
res->occluder_resource_id = _portal_resources.occluder_resource_create();
RID occluder_resource_rid = occluder_resource_owner.make_rid(res);
return occluder_resource_rid;
}
void RenderingServerScene::occluder_resource_prepare(RID p_occluder_resource, RenderingServer::OccluderType p_type) {
OccluderResource *res = occluder_resource_owner.getornull(p_occluder_resource);
ERR_FAIL_COND(!res);
_portal_resources.occluder_resource_prepare(res->occluder_resource_id, (VSOccluder_Instance::Type)p_type);
}
void RenderingServerScene::occluder_resource_spheres_update(RID p_occluder_resource, const Vector<Plane> &p_spheres) {
OccluderResource *res = occluder_resource_owner.getornull(p_occluder_resource);
ERR_FAIL_COND(!res);
_portal_resources.occluder_resource_update_spheres(res->occluder_resource_id, p_spheres);
}
void RenderingServerScene::occluder_resource_mesh_update(RID p_occluder_resource, const Geometry::OccluderMeshData &p_mesh_data) {
OccluderResource *res = occluder_resource_owner.getornull(p_occluder_resource);
ERR_FAIL_COND(!res);
_portal_resources.occluder_resource_update_mesh(res->occluder_resource_id, p_mesh_data);
}
void RenderingServerScene::set_use_occlusion_culling(bool p_enable) {
// this is not scenario specific, and is global
// (mainly for debugging)
PortalRenderer::use_occlusion_culling = p_enable;
}
Geometry::MeshData RenderingServerScene::occlusion_debug_get_current_polys(RID p_scenario) const {
Scenario *scenario = scenario_owner.getornull(p_scenario);
if (!scenario) {
return Geometry::MeshData();
}
return scenario->_portal_renderer.occlusion_debug_get_current_polys();
}
// Rooms
void RenderingServerScene::callbacks_register(RenderingServerCallbacks *p_callbacks) {
_rendering_server_callbacks = p_callbacks;
}
// the room has to be associated with a scenario, this is assumed to be
// the same scenario as the room node
RID RenderingServerScene::room_create() {
Room *room = memnew(Room);
ERR_FAIL_COND_V(!room, RID());
RID room_rid = room_owner.make_rid(room);
return room_rid;
}
// should not be called multiple times, different scenarios etc, but just in case, we will support this
void RenderingServerScene::room_set_scenario(RID p_room, RID p_scenario) {
Room *room = room_owner.getornull(p_room);
ERR_FAIL_COND(!room);
Scenario *scenario = scenario_owner.getornull(p_scenario);
// no change?
if (room->scenario == scenario) {
return;
}
// if the room has an existing scenario, remove from it
if (room->scenario) {
room->scenario->_portal_renderer.room_destroy(room->scenario_room_id);
room->scenario = nullptr;
room->scenario_room_id = 0;
}
// create when entering the world
if (scenario) {
room->scenario = scenario;
// defer the actual creation to here
room->scenario_room_id = scenario->_portal_renderer.room_create();
}
}
void RenderingServerScene::room_add_ghost(RID p_room, ObjectID p_object_id, const AABB &p_aabb) {
Room *room = room_owner.getornull(p_room);
ERR_FAIL_COND(!room);
ERR_FAIL_COND(!room->scenario);
room->scenario->_portal_renderer.room_add_ghost(room->scenario_room_id, p_object_id, p_aabb);
}
void RenderingServerScene::room_add_instance(RID p_room, RID p_instance, const AABB &p_aabb, const Vector<Vector3> &p_object_pts) {
Room *room = room_owner.getornull(p_room);
ERR_FAIL_COND(!room);
ERR_FAIL_COND(!room->scenario);
Instance *instance = instance_owner.getornull(p_instance);
ERR_FAIL_COND(!instance);
AABB bb = p_aabb;
// the aabb passed from the client takes no account of the extra cull margin,
// so we need to add this manually.
// It is assumed it is in world space.
if (instance->extra_margin != 0.0) {
bb.grow_by(instance->extra_margin);
}
bool dynamic = false;
// don't add if portal mode is not static or dynamic
switch (instance->portal_mode) {
default: {
return; // this should be taken care of by the calling function, but just in case
} break;
case RenderingServer::InstancePortalMode::INSTANCE_PORTAL_MODE_DYNAMIC: {
dynamic = true;
} break;
case RenderingServer::InstancePortalMode::INSTANCE_PORTAL_MODE_STATIC: {
dynamic = false;
} break;
}
instance->occlusion_handle = room->scenario->_portal_renderer.room_add_instance(room->scenario_room_id, p_instance, bb, dynamic, p_object_pts);
}
void RenderingServerScene::room_prepare(RID p_room, int32_t p_priority) {
Room *room = room_owner.getornull(p_room);
ERR_FAIL_COND(!room);
ERR_FAIL_COND(!room->scenario);
room->scenario->_portal_renderer.room_prepare(room->scenario_room_id, p_priority);
}
void RenderingServerScene::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) {
Room *room = room_owner.getornull(p_room);
ERR_FAIL_COND(!room);
ERR_FAIL_COND(!room->scenario);
room->scenario->_portal_renderer.room_set_bound(room->scenario_room_id, p_room_object_id, p_convex, p_aabb, p_verts);
}
void RenderingServerScene::rooms_unload(RID p_scenario, String p_reason) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->_portal_renderer.rooms_unload(p_reason);
}
void RenderingServerScene::rooms_and_portals_clear(RID p_scenario) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->_portal_renderer.rooms_and_portals_clear();
}
void RenderingServerScene::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) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->_portal_renderer.rooms_finalize(p_generate_pvs, p_cull_using_pvs, p_use_secondary_pvs, p_use_signals, p_pvs_filename, p_use_simple_pvs, p_log_pvs_generation);
}
void RenderingServerScene::rooms_override_camera(RID p_scenario, bool p_override, const Vector3 &p_point, const Vector<Plane> *p_convex) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->_portal_renderer.rooms_override_camera(p_override, p_point, p_convex);
}
void RenderingServerScene::rooms_set_active(RID p_scenario, bool p_active) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->_portal_renderer.rooms_set_active(p_active);
}
void RenderingServerScene::rooms_set_params(RID p_scenario, int p_portal_depth_limit, real_t p_roaming_expansion_margin) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->_portal_renderer.rooms_set_params(p_portal_depth_limit, p_roaming_expansion_margin);
}
void RenderingServerScene::rooms_set_debug_feature(RID p_scenario, RenderingServer::RoomsDebugFeature p_feature, bool p_active) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
switch (p_feature) {
default: {
} break;
case RenderingServer::ROOMS_DEBUG_SPRAWL: {
scenario->_portal_renderer.set_debug_sprawl(p_active);
} break;
}
}
void RenderingServerScene::rooms_update_gameplay_monitor(RID p_scenario, const Vector<Vector3> &p_camera_positions) {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND(!scenario);
scenario->_portal_renderer.rooms_update_gameplay_monitor(p_camera_positions);
}
bool RenderingServerScene::rooms_is_loaded(RID p_scenario) const {
Scenario *scenario = scenario_owner.getornull(p_scenario);
ERR_FAIL_COND_V(!scenario, false);
return scenario->_portal_renderer.rooms_is_loaded();
}
Vector<ObjectID> RenderingServerScene::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const {
Vector<ObjectID> instances;
Scenario *scenario = scenario_owner.get(p_scenario);
@ -1688,45 +1173,6 @@ Vector<ObjectID> RenderingServerScene::instances_cull_convex(const Vector<Plane>
return instances;
}
// thin wrapper to allow rooms / portals to take over culling if active
int RenderingServerScene::_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) {
int res = -1;
if (p_scenario->_portal_renderer.is_active()) {
// Note that the portal renderer ASSUMES that the planes exactly match the convention in
// Projection of enum Planes (6 planes, in order, near, far etc)
// If this is not the case, it should not be used.
res = p_scenario->_portal_renderer.cull_convex(p_cam_transform, p_cam_projection, p_convex, (VSInstance **)p_result_array, p_result_max, p_mask, r_previous_room_id_hint);
}
// fallback to BVH / octree if portals not active
if (res == -1) {
res = p_scenario->sps->cull_convex(p_convex, p_result_array, p_result_max, p_mask);
// Opportunity for occlusion culling on the main scene. This will be a noop if no occluders.
if (p_scenario->_portal_renderer.occlusion_is_active()) {
res = p_scenario->_portal_renderer.occlusion_cull(p_cam_transform, p_cam_projection, p_convex, (VSInstance **)p_result_array, res);
}
}
return res;
}
void RenderingServerScene::_rooms_instance_update(Instance *p_instance, const AABB &p_aabb) {
// magic number for instances in the room / portal system, but not requiring an update
// (due to being a STATIC or DYNAMIC object within a room)
// Must match the value in PortalRenderer in RenderingServer
const uint32_t OCCLUSION_HANDLE_ROOM_BIT = 1 << 31;
// if the instance is a moving object in the room / portal system, update it
// Note that if rooms and portals is not in use, occlusion_handle should be zero in all cases unless the portal_mode
// has been set to global or roaming. (which is unlikely as the default is static).
// The exception is editor user interface elements.
// These are always set to global and will always keep their aabb up to date in the portal renderer unnecessarily.
// There is no easy way around this, but it should be very cheap, and have no impact outside the editor.
if (p_instance->occlusion_handle && (p_instance->occlusion_handle != OCCLUSION_HANDLE_ROOM_BIT)) {
p_instance->scenario->_portal_renderer.instance_moving_update(p_instance->occlusion_handle, p_aabb);
}
}
void RenderingServerScene::instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) {
Instance *instance = instance_owner.get(p_instance);
ERR_FAIL_COND(!instance);
@ -1859,8 +1305,6 @@ void RenderingServerScene::_update_instance(Instance *p_instance) {
p_instance->scenario->sps->move(p_instance->spatial_partition_id, new_aabb);
}
// keep rooms and portals instance up to date if present
_rooms_instance_update(p_instance, new_aabb);
}
void RenderingServerScene::_update_instance_aabb(Instance *p_instance) {
@ -2389,26 +1833,8 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
Vector<Plane> planes = cm.get_projection_planes(xform);
int cull_count = _cull_convex_from_point(p_scenario, light_transform, cm, planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, light->previous_room_id_hint, RS::INSTANCE_GEOMETRY_MASK);
Plane near_plane(xform.origin, -xform.basis.get_axis(2));
for (int j = 0; j < cull_count; j++) {
Instance *instance = instance_shadow_cull_result[j];
if (!instance->visible || !((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) || !static_cast<InstanceGeometryData *>(instance->base_data)->can_cast_shadows || !(p_visible_layers & instance->layer_mask)) {
cull_count--;
SWAP(instance_shadow_cull_result[j], instance_shadow_cull_result[cull_count]);
j--;
} else {
if (static_cast<InstanceGeometryData *>(instance->base_data)->material_is_animated) {
animated_material_found = true;
}
instance->depth = near_plane.distance_to(instance->transform.origin);
instance->depth_layer = 0;
}
}
RSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, xform, radius, 0, i);
RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, i, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, 0);
}
//restore the regular DP matrix
@ -2424,26 +1850,9 @@ bool RenderingServerScene::_light_instance_update_shadow(Instance *p_instance, c
cm.set_perspective(angle * 2.0, 1.0, 0.01, radius);
Vector<Plane> planes = cm.get_projection_planes(light_transform);
int cull_count = _cull_convex_from_point(p_scenario, light_transform, cm, planes, instance_shadow_cull_result, MAX_INSTANCE_CULL, light->previous_room_id_hint, RS::INSTANCE_GEOMETRY_MASK);
Plane near_plane(light_transform.origin, -light_transform.basis.get_axis(2));
for (int j = 0; j < cull_count; j++) {
Instance *instance = instance_shadow_cull_result[j];
if (!instance->visible || !((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) || !static_cast<InstanceGeometryData *>(instance->base_data)->can_cast_shadows || !(p_visible_layers & instance->layer_mask)) {
cull_count--;
SWAP(instance_shadow_cull_result[j], instance_shadow_cull_result[cull_count]);
j--;
} else {
if (static_cast<InstanceGeometryData *>(instance->base_data)->material_is_animated) {
animated_material_found = true;
}
instance->depth = near_plane.distance_to(instance->transform.origin);
instance->depth_layer = 0;
}
}
RSG::scene_render->light_instance_set_shadow_transform(light->instance, cm, light_transform, radius, 0, 0);
RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, 0, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, cull_count);
RSG::scene_render->render_shadow(light->instance, p_shadow_atlas, 0, (RasterizerScene::InstanceBase **)instance_shadow_cull_result, 0);
} break;
}
@ -2521,7 +1930,7 @@ void RenderingServerScene::_prepare_scene(const Transform p_cam_transform, const
float z_far = p_cam_projection.get_z_far();
/* STEP 2 - CULL */
instance_cull_count = _cull_convex_from_point(scenario, p_cam_transform, p_cam_projection, planes, instance_cull_result, MAX_INSTANCE_CULL, r_previous_room_id_hint);
instance_cull_count = 0;
light_cull_count = 0;
reflection_probe_cull_count = 0;
@ -2884,31 +2293,6 @@ bool RenderingServerScene::free(RID p_rid) {
instance_owner.free(p_rid);
memdelete(instance);
} else if (room_owner.owns(p_rid)) {
Room *room = room_owner.get(p_rid);
room_owner.free(p_rid);
memdelete(room);
} else if (portal_owner.owns(p_rid)) {
Portal *portal = portal_owner.get(p_rid);
portal_owner.free(p_rid);
memdelete(portal);
} else if (ghost_owner.owns(p_rid)) {
Ghost *ghost = ghost_owner.get(p_rid);
ghost_owner.free(p_rid);
memdelete(ghost);
} else if (roomgroup_owner.owns(p_rid)) {
RoomGroup *roomgroup = roomgroup_owner.get(p_rid);
roomgroup_owner.free(p_rid);
memdelete(roomgroup);
} else if (occluder_instance_owner.owns(p_rid)) {
OccluderInstance *occ_inst = occluder_instance_owner.get(p_rid);
occluder_instance_owner.free(p_rid);
memdelete(occ_inst);
} else if (occluder_resource_owner.owns(p_rid)) {
OccluderResource *occ_res = occluder_resource_owner.get(p_rid);
occ_res->destroy(_portal_resources);
occluder_resource_owner.free(p_rid);
memdelete(occ_res);
} else {
return false;
}

191
servers/rendering/rendering_server_scene.h
View File

@ -39,7 +39,6 @@
#include "core/os/safe_refcount.h"
#include "core/os/semaphore.h"
#include "core/os/thread.h"
#include "portals/portal_renderer.h"
class RenderingServerScene {
public:
@ -48,8 +47,6 @@ public:
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;
@ -272,7 +269,6 @@ public:
RID self;
SpatialPartitioningScene *sps;
PortalRenderer _portal_renderer;
List<Instance *> directional_lights;
RID environment;
@ -309,10 +305,6 @@ public:
//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;
@ -370,9 +362,6 @@ public:
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;
@ -525,182 +514,7 @@ public:
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;
@ -711,10 +525,6 @@ public:
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);
@ -745,7 +555,6 @@ public:
private:
bool _use_bvh;
RenderingServerCallbacks *_rendering_server_callbacks;
PortalResources _portal_resources;
public:
RenderingServerScene();

6
servers/rendering/rendering_server_wrap_mt.cpp
View File

@ -161,12 +161,6 @@ void RenderingServerWrapMT::finish() {
canvas_item_free_cached_ids();
canvas_light_occluder_free_cached_ids();
canvas_occluder_polygon_free_cached_ids();
room_free_cached_ids();
roomgroup_free_cached_ids();
portal_free_cached_ids();
ghost_free_cached_ids();
occluder_instance_free_cached_ids();
occluder_resource_free_cached_ids();
}
void RenderingServerWrapMT::set_use_vsync_callback(bool p_enable) {

56
servers/rendering/rendering_server_wrap_mt.h
View File

@ -405,62 +405,6 @@ public:
FUNC2(instance_set_extra_visibility_margin, RID, real_t)
/* PORTALS API */
FUNC2(instance_set_portal_mode, RID, InstancePortalMode)
FUNCRID(ghost)
FUNC4(ghost_set_scenario, RID, RID, ObjectID, const AABB &)
FUNC2(ghost_update, RID, const AABB &)
FUNCRID(portal)
FUNC2(portal_set_scenario, RID, RID)
FUNC3(portal_set_geometry, RID, const Vector<Vector3> &, real_t)
FUNC4(portal_link, RID, RID, RID, bool)
FUNC2(portal_set_active, RID, bool)
/* ROOMGROUPS API */
FUNCRID(roomgroup)
FUNC2(roomgroup_prepare, RID, ObjectID)
FUNC2(roomgroup_set_scenario, RID, RID)
FUNC2(roomgroup_add_room, RID, RID)
/* OCCLUDERS API */
FUNCRID(occluder_instance)
FUNC2(occluder_instance_set_scenario, RID, RID)
FUNC2(occluder_instance_link_resource, RID, RID)
FUNC2(occluder_instance_set_transform, RID, const Transform &)
FUNC2(occluder_instance_set_active, RID, bool)
FUNCRID(occluder_resource)
FUNC2(occluder_resource_prepare, RID, OccluderType)
FUNC2(occluder_resource_spheres_update, RID, const Vector<Plane> &)
FUNC2(occluder_resource_mesh_update, RID, const Geometry::OccluderMeshData &)
FUNC1(set_use_occlusion_culling, bool)
FUNC1RC(Geometry::MeshData, occlusion_debug_get_current_polys, RID)
/* ROOMS API */
FUNCRID(room)
FUNC2(room_set_scenario, RID, RID)
FUNC4(room_add_instance, RID, RID, const AABB &, const Vector<Vector3> &)
FUNC3(room_add_ghost, RID, ObjectID, const AABB &)
FUNC5(room_set_bound, RID, ObjectID, const Vector<Plane> &, const AABB &, const Vector<Vector3> &)
FUNC2(room_prepare, RID, int32_t)
FUNC1(rooms_and_portals_clear, RID)
FUNC2(rooms_unload, RID, String)
FUNC8(rooms_finalize, RID, bool, bool, bool, bool, String, bool, bool)
FUNC4(rooms_override_camera, RID, bool, const Vector3 &, const Vector<Plane> *)
FUNC2(rooms_set_active, RID, bool)
FUNC3(rooms_set_params, RID, int, real_t)
FUNC3(rooms_set_debug_feature, RID, RoomsDebugFeature, bool)
FUNC2(rooms_update_gameplay_monitor, RID, const Vector<Vector3> &)
// don't use this in a game
FUNC1RC(bool, rooms_is_loaded, RID)
// Callbacks
FUNC1(callbacks_register, RenderingServerCallbacks *)

5
servers/rendering_server.cpp
View File

@ -2205,7 +2205,6 @@ void RenderingServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("has_feature", "feature"), &RenderingServer::has_feature);
ClassDB::bind_method(D_METHOD("has_os_feature", "feature"), &RenderingServer::has_os_feature);
ClassDB::bind_method(D_METHOD("set_debug_generate_wireframes", "generate"), &RenderingServer::set_debug_generate_wireframes);
ClassDB::bind_method(D_METHOD("set_use_occlusion_culling", "enable"), &RenderingServer::set_use_occlusion_culling);
ClassDB::bind_method(D_METHOD("is_render_loop_enabled"), &RenderingServer::is_render_loop_enabled);
ClassDB::bind_method(D_METHOD("set_render_loop_enabled", "enabled"), &RenderingServer::set_render_loop_enabled);
@ -2524,10 +2523,6 @@ RID RenderingServer::instance_create2(RID p_base, RID p_scenario) {
instance_set_base(instance, p_base);
instance_set_scenario(instance, p_scenario);
// instance_create2 is used mainly by editor instances.
// These should not be culled by the portal system when it is active, so we set their mode to global,
// for frustum culling only.
instance_set_portal_mode(instance, RenderingServer::INSTANCE_PORTAL_MODE_GLOBAL);
return instance;
}

77
servers/rendering_server.h
View File

@ -782,82 +782,6 @@ public:
virtual void instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) = 0;
/* PORTALS API */
enum InstancePortalMode {
INSTANCE_PORTAL_MODE_STATIC, // not moving within a room
INSTANCE_PORTAL_MODE_DYNAMIC, // moving within room
INSTANCE_PORTAL_MODE_ROAMING, // moving between rooms
INSTANCE_PORTAL_MODE_GLOBAL, // frustum culled only
INSTANCE_PORTAL_MODE_IGNORE, // don't show at all - e.g. manual bounds, hidden portals
};
virtual void instance_set_portal_mode(RID p_instance, InstancePortalMode p_mode) = 0;
virtual RID ghost_create() = 0;
virtual void ghost_set_scenario(RID p_ghost, RID p_scenario, ObjectID p_id, const AABB &p_aabb) = 0;
virtual void ghost_update(RID p_ghost, const AABB &p_aabb) = 0;
virtual RID portal_create() = 0;
virtual void portal_set_scenario(RID p_portal, RID p_scenario) = 0;
virtual void portal_set_geometry(RID p_portal, const Vector<Vector3> &p_points, real_t p_margin) = 0;
virtual void portal_link(RID p_portal, RID p_room_from, RID p_room_to, bool p_two_way) = 0;
virtual void portal_set_active(RID p_portal, bool p_active) = 0;
/* ROOMGROUPS API */
virtual RID roomgroup_create() = 0;
virtual void roomgroup_prepare(RID p_roomgroup, ObjectID p_roomgroup_object_id) = 0;
virtual void roomgroup_set_scenario(RID p_roomgroup, RID p_scenario) = 0;
virtual void roomgroup_add_room(RID p_roomgroup, RID p_room) = 0;
/* OCCLUDERS API */
enum OccluderType {
OCCLUDER_TYPE_UNDEFINED,
OCCLUDER_TYPE_SPHERE,
OCCLUDER_TYPE_MESH,
OCCLUDER_TYPE_NUM_TYPES,
};
virtual RID occluder_instance_create() = 0;
virtual void occluder_instance_set_scenario(RID p_occluder_instance, RID p_scenario) = 0;
virtual void occluder_instance_link_resource(RID p_occluder_instance, RID p_occluder_resource) = 0;
virtual void occluder_instance_set_transform(RID p_occluder_instance, const Transform &p_xform) = 0;
virtual void occluder_instance_set_active(RID p_occluder_instance, bool p_active) = 0;
virtual RID occluder_resource_create() = 0;
virtual void occluder_resource_prepare(RID p_occluder_resource, RenderingServer::OccluderType p_type) = 0;
virtual void occluder_resource_spheres_update(RID p_occluder_resource, const Vector<Plane> &p_spheres) = 0;
virtual void occluder_resource_mesh_update(RID p_occluder_resource, const Geometry::OccluderMeshData &p_mesh_data) = 0;
virtual void set_use_occlusion_culling(bool p_enable) = 0;
virtual Geometry::MeshData occlusion_debug_get_current_polys(RID p_scenario) const = 0;
/* ROOMS API */
enum RoomsDebugFeature {
ROOMS_DEBUG_SPRAWL,
};
virtual RID room_create() = 0;
virtual void room_set_scenario(RID p_room, RID p_scenario) = 0;
virtual void room_add_instance(RID p_room, RID p_instance, const AABB &p_aabb, const Vector<Vector3> &p_object_pts) = 0;
virtual void room_add_ghost(RID p_room, ObjectID p_object_id, const AABB &p_aabb) = 0;
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) = 0;
virtual void room_prepare(RID p_room, int32_t p_priority) = 0;
virtual void rooms_and_portals_clear(RID p_scenario) = 0;
virtual void rooms_unload(RID p_scenario, String p_reason) = 0;
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) = 0;
virtual void rooms_override_camera(RID p_scenario, bool p_override, const Vector3 &p_point, const Vector<Plane> *p_convex) = 0;
virtual void rooms_set_active(RID p_scenario, bool p_active) = 0;
virtual void rooms_set_params(RID p_scenario, int p_portal_depth_limit, real_t p_roaming_expansion_margin) = 0;
virtual void rooms_set_debug_feature(RID p_scenario, RoomsDebugFeature p_feature, bool p_active) = 0;
virtual void rooms_update_gameplay_monitor(RID p_scenario, const Vector<Vector3> &p_camera_positions) = 0;
// don't use this in a game!
virtual bool rooms_is_loaded(RID p_scenario) const = 0;
// callbacks are used to send messages back from the visual server to scene tree in thread friendly manner
virtual void callbacks_register(RenderingServerCallbacks *p_callbacks) = 0;
@ -1146,7 +1070,6 @@ VARIANT_ENUM_CAST(RenderingServer::ViewportRenderInfo);
VARIANT_ENUM_CAST(RenderingServer::ViewportDebugDraw);
VARIANT_ENUM_CAST(RenderingServer::ScenarioDebugMode);
VARIANT_ENUM_CAST(RenderingServer::InstanceType);
VARIANT_ENUM_CAST(RenderingServer::InstancePortalMode);
VARIANT_ENUM_CAST(RenderingServer::NinePatchAxisMode);
VARIANT_ENUM_CAST(RenderingServer::CanvasLightMode);
VARIANT_ENUM_CAST(RenderingServer::CanvasLightShadowFilter);