mirror of
https://github.com/Relintai/godot-lportal.git
synced 2024-11-11 10:52:09 +01:00
1605 lines
38 KiB
C++
1605 lines
38 KiB
C++
// Copyright (c) 2019 Lawnjelly
|
|
|
|
// 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 "lroom_converter.h"
|
|
#include "lroom_manager.h"
|
|
#include "lportal.h"
|
|
#include "scene/3d/mesh_instance.h"
|
|
#include "core/math/quick_hull.h"
|
|
#include "ldebug.h"
|
|
#include "scene/3d/light.h"
|
|
|
|
// save typing, I am lazy
|
|
#define LMAN m_pManager
|
|
#define LROOMLIST m_pRoomList
|
|
|
|
|
|
|
|
void LRoomConverter::Convert(LRoomManager &manager, bool bVerbose, bool bPreparationRun, bool bDeleteLights, bool bSingleRoomMode)
|
|
{
|
|
m_bFinalRun = (bPreparationRun == false);
|
|
m_bDeleteLights = bDeleteLights;
|
|
m_bSingleRoomMode = bSingleRoomMode;
|
|
|
|
// This just is simply used to set how much debugging output .. more during conversion, less during running
|
|
// except when requested by explicitly clearing this flag.
|
|
Lawn::LDebug::m_bRunning = (bVerbose == false);
|
|
|
|
if (!m_bFinalRun)
|
|
{
|
|
LPRINT(5, "running convert PREPARATION RUN");
|
|
}
|
|
else
|
|
{
|
|
LPRINT(5, "running convert");
|
|
}
|
|
|
|
|
|
|
|
LMAN = &manager;
|
|
LROOMLIST = manager.GetRoomList();
|
|
|
|
// force clear all arrays
|
|
manager.ReleaseResources(true);
|
|
|
|
int count = CountRooms();
|
|
|
|
//int num_global_lights = LMAN->m_Lights.size();
|
|
|
|
// make sure bitfield is right size for number of rooms
|
|
LMAN->m_BF_visible_rooms.Create(count);
|
|
LMAN->m_LightRender.m_BF_Temp_Visible_Rooms.Create(count);
|
|
|
|
LMAN->m_Rooms.resize(count);
|
|
|
|
m_TempRooms.clear(true);
|
|
m_TempRooms.resize(count);
|
|
|
|
|
|
Convert_Rooms();
|
|
Convert_Portals();
|
|
Convert_Bounds();
|
|
|
|
// make sure manager bitfields are the correct size for number of objects
|
|
int num_sobs = LMAN->m_SOBs.size();
|
|
LPRINT(5,"Total SOBs " + itos(num_sobs));
|
|
LMAN->m_BF_caster_SOBs.Create(num_sobs);
|
|
LMAN->m_BF_visible_SOBs.Create(num_sobs);
|
|
LMAN->m_BF_master_SOBs.Create(num_sobs);
|
|
LMAN->m_BF_master_SOBs_prev.Create(num_sobs);
|
|
|
|
LMAN->m_LightRender.m_BF_Temp_SOBs.Create(num_sobs);
|
|
|
|
LMAN->m_BF_ActiveLights.Create(LMAN->m_Lights.size());
|
|
LMAN->m_BF_ActiveLights_prev.Create(LMAN->m_Lights.size());
|
|
LMAN->m_BF_ProcessedLights.Create(LMAN->m_Lights.size());
|
|
|
|
// must be done after the bitfields
|
|
Convert_Lights();
|
|
Convert_ShadowCasters();
|
|
Convert_AreaLights();
|
|
|
|
// hide all in preparation for first frame
|
|
//LMAN->ShowAll(false);
|
|
|
|
// temp rooms no longer needed
|
|
m_TempRooms.clear(true);
|
|
|
|
// clear out the local room lights, leave only global lights
|
|
//LMAN->m_Lights.resize(num_global_lights);
|
|
Lawn::LDebug::m_bRunning = true;
|
|
}
|
|
|
|
|
|
|
|
int LRoomConverter::Convert_Rooms_Recursive(Node * pParent, int count, int area)
|
|
{
|
|
for (int n=0; n<pParent->get_child_count(); n++)
|
|
{
|
|
Node * pChild = pParent->get_child(n);
|
|
|
|
if (Node_IsRoom(pChild))
|
|
{
|
|
Spatial * pSpat = Object::cast_to<Spatial>(pChild);
|
|
assert (pSpat);
|
|
|
|
Convert_Room(pSpat, count++, area);
|
|
}
|
|
else if (Node_IsArea(pChild))
|
|
{
|
|
// get the area name
|
|
String szArea = LPortal::FindNameAfter(pChild, "area_");
|
|
|
|
// find or create an area with this name
|
|
int area_child = Area_FindOrCreate(szArea);
|
|
count = Convert_Rooms_Recursive(pChild, count, area_child);
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
void LRoomConverter::Convert_Rooms()
|
|
{
|
|
LPRINT(5,"Convert_Rooms");
|
|
|
|
// allow faking a single room in single room mode
|
|
if (m_bSingleRoomMode)
|
|
{
|
|
Spatial * pSpat = Object::cast_to<Spatial>(LROOMLIST);
|
|
if (!pSpat)
|
|
return;
|
|
|
|
// add a default area
|
|
int area = Area_FindOrCreate("default");
|
|
|
|
Convert_Room(pSpat, 0, area);
|
|
return;
|
|
}
|
|
|
|
|
|
// first find all room empties and convert to LRooms
|
|
int count = 0;
|
|
int area = -1;
|
|
|
|
count = Convert_Rooms_Recursive(LROOMLIST, count, area);
|
|
}
|
|
|
|
int LRoomConverter::Area_FindOrCreate(String szName)
|
|
{
|
|
for (int n=0; n<LMAN->m_Areas.size(); n++)
|
|
{
|
|
if (LMAN->m_Areas[n].m_szName == szName)
|
|
return n;
|
|
}
|
|
|
|
// create
|
|
LArea area;
|
|
area.Create(szName);
|
|
LMAN->m_Areas.push_back(area);
|
|
return LMAN->m_Areas.size() - 1;
|
|
}
|
|
|
|
|
|
int LRoomConverter::FindRoom_ByName(String szName) const
|
|
{
|
|
for (int n=0; n<LMAN->m_Rooms.size(); n++)
|
|
{
|
|
if (LMAN->m_Rooms[n].m_szName == szName)
|
|
return n;
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
void LRoomConverter::Convert_Room_SetDefaultCullMask_Recursive(Node * pParent)
|
|
{
|
|
int nChildren = pParent->get_child_count();
|
|
for (int n=0; n<nChildren; n++)
|
|
{
|
|
Node * pChild = pParent->get_child(n);
|
|
|
|
// default cull mask should always be visible to camera and lights
|
|
VisualInstance * pVI = Object::cast_to<VisualInstance>(pChild);
|
|
if (pVI)
|
|
{
|
|
// LRoom::SoftShow(pVI, LRoom::LAYER_MASK_CAMERA | LRoom::LAYER_MASK_LIGHT);
|
|
}
|
|
|
|
Convert_Room_SetDefaultCullMask_Recursive(pChild);
|
|
}
|
|
}
|
|
|
|
|
|
void LRoomConverter::Convert_Room_FindObjects_Recursive(Node * pParent, LRoom &lroom, LAABB &bb_room)
|
|
{
|
|
int nChildren = pParent->get_child_count();
|
|
for (int n=0; n<nChildren; n++)
|
|
{
|
|
Node * pChild = pParent->get_child(n);
|
|
|
|
// ignore invisible
|
|
Spatial * pSpatialChild = Object::cast_to<Spatial>(pChild);
|
|
if (pSpatialChild && (Convert_IsVisibleInRooms(pSpatialChild) == false))
|
|
{
|
|
pSpatialChild->queue_delete();
|
|
continue;
|
|
}
|
|
|
|
// we are not interested in portal meshes, as they will be deleted later in conversion
|
|
if (Node_IsPortal(pChild))
|
|
continue;
|
|
// we can optionally ignore nodes (they will still be shown / hidden with the room though)
|
|
if (Node_IsIgnore(pChild))
|
|
continue;
|
|
// not interested in bounds
|
|
if (Node_IsBound(pChild))
|
|
continue;
|
|
|
|
// lights
|
|
if (Node_IsLight(pChild))
|
|
{
|
|
LRoom_DetectedLight(lroom, pChild);
|
|
continue;
|
|
}
|
|
|
|
// area
|
|
if (Node_IsArea(pChild))
|
|
{
|
|
LRoom_DetectedArea(lroom, pChild);
|
|
continue;
|
|
}
|
|
|
|
VisualInstance * pVI = Object::cast_to<VisualInstance>(pChild);
|
|
if (pVI)
|
|
{
|
|
|
|
|
|
LPRINT(2, "\t\tFound VI : " + pVI->get_name());
|
|
|
|
|
|
// update bound to find centre of room roughly
|
|
AABB bb = pVI->get_transformed_aabb();
|
|
bb_room.ExpandToEnclose(bb);
|
|
|
|
// store some info about the static object for use at runtime
|
|
LSob sob;
|
|
sob.m_ID = pVI->get_instance_id();
|
|
sob.m_aabb = bb;
|
|
sob.Hidable_Create(pChild);
|
|
|
|
//lroom.m_SOBs.push_back(sob);
|
|
LRoom_PushBackSOB(lroom, sob);
|
|
|
|
// take away layer 0 from the sob, so it can be culled effectively
|
|
if (m_bFinalRun)
|
|
{
|
|
pVI->set_layer_mask(0);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// not visual instances
|
|
}
|
|
|
|
// does it have further children?
|
|
Convert_Room_FindObjects_Recursive(pChild, lroom, bb_room);
|
|
}
|
|
|
|
}
|
|
|
|
bool LRoomConverter::Convert_IsVisibleInRooms(const Node * pNode) const
|
|
{
|
|
const Spatial * pS = Object::cast_to<Spatial>(pNode);
|
|
const Spatial * pRoomList = Object::cast_to<Spatial>(LROOMLIST);
|
|
|
|
while (pS)
|
|
{
|
|
if (!pS->is_visible())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
pS = pS->get_parent_spatial();
|
|
|
|
// terminate
|
|
if (pS == pRoomList)
|
|
return true;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// areaID could be -1 if unset
|
|
bool LRoomConverter::Convert_Room(Spatial * pNode, int lroomID, int areaID)
|
|
{
|
|
// get the room part of the name
|
|
String szFullName = pNode->get_name();
|
|
String szRoom = LPortal::FindNameAfter(pNode, "room_");
|
|
|
|
if (areaID == -1)
|
|
{
|
|
LPRINT(4, "Convert_Room : " + szFullName);
|
|
}
|
|
else
|
|
{
|
|
LPRINT(4, "Convert_Room : " + szFullName + " area_id " + itos(areaID));
|
|
}
|
|
|
|
// get a reference to the lroom we are writing to
|
|
LRoom &lroom = LMAN->m_Rooms[lroomID];
|
|
|
|
// store the godot room
|
|
lroom.m_GodotID = pNode->get_instance_id();
|
|
lroom.m_RoomID = lroomID;
|
|
|
|
// save the room ID on the godot room metadata
|
|
// This is used when registering DOBs and teleporting them with hints
|
|
// i.e. the Godot room is used to lookup the room ID of the startroom.
|
|
LMAN->Meta_SetRoomNum(pNode, lroomID);
|
|
|
|
// create a new LRoom to exchange the children over to, and delete the original empty
|
|
lroom.m_szName = szRoom;
|
|
|
|
// area
|
|
if (areaID != -1)
|
|
lroom.m_Areas.push_back(areaID);
|
|
|
|
// keep a running bounding volume as we go through the visual instances
|
|
// to determine the overall bound of the room
|
|
LAABB bb_room;
|
|
bb_room.SetToMaxOpposite();
|
|
|
|
// set default cull masks
|
|
Convert_Room_SetDefaultCullMask_Recursive(pNode);
|
|
|
|
// recursively find statics
|
|
Convert_Room_FindObjects_Recursive(pNode, lroom, bb_room);
|
|
|
|
// store the lroom centre and bound
|
|
lroom.m_ptCentre = bb_room.FindCentre();
|
|
|
|
// bound (untested)
|
|
lroom.m_AABB.position = bb_room.m_ptMins;
|
|
lroom.m_AABB.size = bb_room.m_ptMaxs - bb_room.m_ptMins;
|
|
|
|
LPRINT(2, "\t\t\t" + String(lroom.m_szName) + " centre " + lroom.m_ptCentre);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool LRoomConverter::Bound_AddPlaneIfUnique(LVector<Plane> &planes, const Plane &p)
|
|
{
|
|
for (int n=0; n<planes.size(); n++)
|
|
{
|
|
const Plane &o = planes[n];
|
|
|
|
// this is a fudge factor for how close planes can be to be considered the same ...
|
|
// to prevent ridiculous amounts of planes
|
|
const float d = 0.08f;
|
|
|
|
if (fabs(p.d - o.d) > d) continue;
|
|
|
|
float dot = p.normal.dot(o.normal);
|
|
if (dot < 0.98f) continue;
|
|
|
|
// match!
|
|
return false;
|
|
}
|
|
|
|
// test
|
|
// Vector3 va(1, 0, 0);
|
|
// Vector3 vb(1, 0.2, 0);
|
|
// vb.normalize();
|
|
// float dot = va.dot(vb);
|
|
// print("va dot vb is " + String(Variant(dot)));
|
|
|
|
// is unique
|
|
// print("\t\t\t\tAdding bound plane : " + p);
|
|
|
|
planes.push_back(p);
|
|
return true;
|
|
}
|
|
|
|
bool LRoomConverter::Convert_Bound_FromPoints(LRoom &lroom, const Vector<Vector3> &points)
|
|
{
|
|
if (points.size() > 3)
|
|
{
|
|
Geometry::MeshData md;
|
|
Error err = QuickHull::build(points, md);
|
|
if (err == OK)
|
|
{
|
|
// get the planes
|
|
for (int n=0; n<md.faces.size(); n++)
|
|
{
|
|
const Plane &p = md.faces[n].plane;
|
|
Bound_AddPlaneIfUnique(lroom.m_Bound.m_Planes, p);
|
|
}
|
|
|
|
LPRINT(2, "\t\t\tcontained " + itos(lroom.m_Bound.m_Planes.size()) + " planes.");
|
|
|
|
// make a copy of the mesh data for debugging
|
|
// note this could be avoided in release builds? NYI
|
|
lroom.m_Bound_MeshData = md;
|
|
|
|
// for (int f=0; f<md.faces.size(); f++)
|
|
// {
|
|
// String sz;
|
|
// sz = "face " + itos (f) + ", indices ";
|
|
// for (int i=0; i<md.faces[f].indices.size(); i++)
|
|
// {
|
|
// sz += itos(md.faces[f].indices[i]) + ", ";
|
|
// }
|
|
// LPRINT(2, sz);
|
|
// }
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
void LRoomConverter::GetWorldVertsFromMesh(const MeshInstance &mi, Vector<Vector3> &pts) const
|
|
{
|
|
// some godot jiggery pokery to get the mesh verts in local space
|
|
Ref<Mesh> rmesh = mi.get_mesh();
|
|
Array arrays = rmesh->surface_get_arrays(0);
|
|
|
|
// possible to have a meshinstance with no geometry .. don't want to crash
|
|
if (!arrays.size())
|
|
{
|
|
WARN_PRINT_ONCE("Warning : LRoomConverter::GetWorldVertsFromMesh MeshInstance with no mesh, ignoring");
|
|
return;
|
|
}
|
|
|
|
PoolVector<Vector3> p_vertices = arrays[VS::ARRAY_VERTEX];
|
|
|
|
// convert to world space
|
|
Transform trans = mi.get_global_transform();
|
|
|
|
for (int n=0; n<p_vertices.size(); n++)
|
|
{
|
|
Vector3 ptWorld = trans.xform(p_vertices[n]);
|
|
pts.push_back(ptWorld);
|
|
}
|
|
}
|
|
|
|
bool LRoomConverter::Convert_ManualBound(LRoom &lroom, MeshInstance * pMI)
|
|
{
|
|
LPRINT(2, "\tCONVERT_MANUAL_BOUND : '" + pMI->get_name() + "' for room '" + lroom.get_name() + "'");
|
|
|
|
Vector<Vector3> points;
|
|
GetWorldVertsFromMesh(*pMI, points);
|
|
for (int n=0; n<points.size(); n++)
|
|
{
|
|
// expand the room AABB to make sure it encompasses the bound
|
|
lroom.m_AABB.expand_to(points[n]);
|
|
}
|
|
|
|
return Convert_Bound_FromPoints(lroom, points);
|
|
}
|
|
|
|
// hide all in preparation for first frame
|
|
//void LRoomConverter::Convert_HideAll()
|
|
//{
|
|
// for (int n=0; n<LMAN->m_SOBs.size(); n++)
|
|
// {
|
|
// LSob &sob = LMAN->m_SOBs[n];
|
|
// sob.Show(false);
|
|
// }
|
|
|
|
// // hide all lights that are non global
|
|
// for (int n=0; n<LMAN->m_Lights.size(); n++)
|
|
// {
|
|
// LLight &light = LMAN->m_Lights[n];
|
|
// if (!light.IsGlobal())
|
|
// light.Show(false);
|
|
// }
|
|
|
|
//}
|
|
|
|
void LRoomConverter::Convert_AreaLights()
|
|
{
|
|
// list the rooms in each area
|
|
for (int a=0; a<LMAN->m_Areas.size(); a++)
|
|
{
|
|
LArea &area = LMAN->m_Areas[a];
|
|
|
|
// add every room in this area to the light affected rooms list
|
|
for (int r=0; r<LMAN->m_Rooms.size(); r++)
|
|
{
|
|
LRoom &room = LMAN->m_Rooms[r];
|
|
if (room.IsInArea(a))
|
|
{
|
|
// add the room to the area room list
|
|
if (area.m_iNumRooms == 0)
|
|
area.m_iFirstRoom = LMAN->m_AreaRooms.size();
|
|
|
|
area.m_iNumRooms += 1;
|
|
LMAN->m_AreaRooms.push_back(r);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// first identify which lights are area lights, and match area strings to area IDs
|
|
for (int n=0; n<LMAN->m_Lights.size(); n++)
|
|
{
|
|
LLight &l = LMAN->m_Lights[n];
|
|
|
|
// global area light?
|
|
if (!l.m_Source.IsGlobal())
|
|
continue;
|
|
|
|
assert (l.m_iArea == -1);
|
|
|
|
// match area string to area
|
|
// find the area
|
|
for (int n=0; n<LMAN->m_Areas.size(); n++)
|
|
{
|
|
if (LMAN->m_Areas[n].m_szName == l.m_szArea)
|
|
{
|
|
l.m_iArea = n;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// area not found?
|
|
if (l.m_iArea == -1)
|
|
{
|
|
LWARN(2, "Convert_AreaLights area not found : " + l.m_szArea);
|
|
}
|
|
else
|
|
{
|
|
LPRINT(5,"Area light " + itos (n) + " area " + l.m_szArea + " found area_id " + itos(l.m_iArea));
|
|
}
|
|
}
|
|
|
|
|
|
// add each light within an area to the area light list
|
|
for (int a=0; a<LMAN->m_Areas.size(); a++)
|
|
{
|
|
LArea &area = LMAN->m_Areas[a];
|
|
|
|
for (int n=0; n<LMAN->m_Lights.size(); n++)
|
|
{
|
|
LLight &l = LMAN->m_Lights[n];
|
|
|
|
int areaID = l.m_iArea;
|
|
if (areaID != a)
|
|
continue;
|
|
|
|
// this light affects this area
|
|
if (area.m_iNumLights == 0)
|
|
area.m_iFirstLight = LMAN->m_AreaLights.size();
|
|
|
|
LMAN->m_AreaLights.push_back(n);
|
|
area.m_iNumLights++;
|
|
|
|
|
|
} // for n
|
|
} // for a
|
|
|
|
// for each global light we can calculate the affected rooms
|
|
for (int n=0; n<LMAN->m_Lights.size(); n++)
|
|
{
|
|
LLight &l = LMAN->m_Lights[n];
|
|
|
|
int areaID = l.m_iArea;
|
|
|
|
// not a global light
|
|
if (areaID == -1)
|
|
continue;
|
|
|
|
LPRINT(5,"Area light " + itos (n) + " affected rooms:");
|
|
|
|
// add every room in this area to the light affected rooms list
|
|
for (int r=0; r<LMAN->m_Rooms.size(); r++)
|
|
{
|
|
LRoom &room = LMAN->m_Rooms[r];
|
|
if (room.IsInArea(areaID))
|
|
{
|
|
//l.AddAffectedRoom(r); // no need as this is now done by area
|
|
LPRINT(5,"\t" + itos (r));
|
|
|
|
// store the global lights on the room
|
|
room.m_GlobalLights.push_back(n);
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void LRoomConverter::Convert_Lights()
|
|
{
|
|
// trace local lights out from rooms and add to each room the light affects
|
|
for (int n=0; n<LMAN->m_Lights.size(); n++)
|
|
{
|
|
LLight &l = LMAN->m_Lights[n];
|
|
if (l.m_Source.IsGlobal())
|
|
continue; // ignore globals .. affect all rooms
|
|
|
|
Light_Trace(n);
|
|
}
|
|
}
|
|
|
|
|
|
void LRoomConverter::Light_Trace(int iLightID)
|
|
{
|
|
// get the light
|
|
LLight &l = LMAN->m_Lights[iLightID];
|
|
LPRINT(5,"_____________________________________________________________");
|
|
LPRINT(5,"\nLight_Trace " + itos (iLightID));
|
|
|
|
LMAN->m_Trace.Trace_Light(*LMAN, l, LTrace::LR_CONVERT);
|
|
|
|
// now save the data from the trace
|
|
LRoomManager::LLightRender &lr = LMAN->m_LightRender;
|
|
|
|
// visible rooms
|
|
for (int n=0; n<lr.m_Temp_Visible_Rooms.size(); n++)
|
|
{
|
|
int room_id = lr.m_Temp_Visible_Rooms[n];
|
|
LRoom &room = *LMAN->GetRoom(room_id);
|
|
|
|
room.AddLocalLight(iLightID);
|
|
|
|
// store the affected room on the light
|
|
l.AddAffectedRoom(room_id);
|
|
}
|
|
|
|
|
|
// sobs
|
|
for (int n=0; n<lr.m_Temp_Visible_SOBs.size(); n++)
|
|
{
|
|
int sob_id = lr.m_Temp_Visible_SOBs[n];
|
|
|
|
// first?
|
|
if (!l.m_NumCasters)
|
|
l.m_FirstCaster = LMAN->m_LightCasters_SOB.size();
|
|
|
|
LMAN->m_LightCasters_SOB.push_back(sob_id);
|
|
l.m_NumCasters++;
|
|
}
|
|
|
|
LPRINT(5, itos(lr.m_Temp_Visible_Rooms.size()) + " visible rooms, " + itos (lr.m_Temp_Visible_SOBs.size()) + " visible SOBs.\n");
|
|
|
|
/*
|
|
// blank this each time as it is used to create the list of casters
|
|
LMAN->m_BF_caster_SOBs.Blank();
|
|
|
|
// reset the planes pool for each render out from the source room
|
|
LMAN->m_Pool.Reset();
|
|
|
|
// the first set of planes are blank
|
|
unsigned int pool_member = LMAN->m_Pool.Request();
|
|
assert (pool_member != -1);
|
|
|
|
LVector<Plane> &planes = LMAN->m_Pool.Get(pool_member);
|
|
planes.clear();
|
|
|
|
Lawn::LDebug::m_iTabDepth = 0;
|
|
|
|
Light_TraceRecursive(0, LMAN->m_Rooms[l.m_Source.m_RoomID], l, iLightID, planes);
|
|
*/
|
|
}
|
|
|
|
/*
|
|
void LRoomConverter::Light_TraceRecursive(int depth, LRoom &lroom, LLight &light, int iLightID, const LVector<Plane> &planes)
|
|
{
|
|
// prevent too much depth
|
|
if (depth > 8)
|
|
{
|
|
LPRINT_RUN(2, "\t\t\tLight_TraceRecursive DEPTH LIMIT REACHED");
|
|
return;
|
|
}
|
|
|
|
Lawn::LDebug::m_iTabDepth = depth;
|
|
LPRINT_RUN(2, "ROOM " + lroom.get_name() + " affected by local light");
|
|
|
|
|
|
// add to the local lights affecting this room
|
|
// already in list?
|
|
bool bAlreadyInList = false;
|
|
for (int n=0; n<lroom.m_LocalLights.size(); n++)
|
|
{
|
|
if (lroom.m_LocalLights[n] == iLightID)
|
|
{
|
|
bAlreadyInList = true;
|
|
break;
|
|
}
|
|
}
|
|
// add to local lights if not already in list
|
|
if (!bAlreadyInList)
|
|
{
|
|
lroom.m_LocalLights.push_back(iLightID);
|
|
|
|
// store the affected room on the light
|
|
light.AddAffectedRoom(lroom.m_RoomID);
|
|
}
|
|
|
|
// add each light caster that is within the planes to the light caster list
|
|
// clip all objects in this room to the clipping planes
|
|
int last_sob = lroom.m_iFirstSOB + lroom.m_iNumSOBs;
|
|
for (int n=lroom.m_iFirstSOB; n<last_sob; n++)
|
|
{
|
|
LSob &sob = LMAN->m_SOBs[n];
|
|
|
|
//LPRINT_RUN(2, "sob " + itos(n) + " " + sob.GetSpatial()->get_name());
|
|
// already determined to be visible through another portal
|
|
// if (LMAN->m_BF_caster_SOBs.GetBit(n))
|
|
// {
|
|
// //LPRINT_RUN(2, "\talready visible");
|
|
// continue;
|
|
// }
|
|
|
|
bool bShow = true;
|
|
|
|
|
|
// estimate the radius .. for now
|
|
const AABB &bb = sob.m_aabb;
|
|
|
|
// print("\t\t\tculling object " + pObj->get_name());
|
|
|
|
for (int p=0; p<planes.size(); p++)
|
|
{
|
|
// float dist = planes[p].distance_to(pt);
|
|
// print("\t\t\t\t" + itos(p) + " : dist " + String(Variant(dist)));
|
|
|
|
float r_min, r_max;
|
|
bb.project_range_in_plane(planes[p], r_min, r_max);
|
|
|
|
// print("\t\t\t\t" + itos(p) + " : r_min " + String(Variant(r_min)) + ", r_max " + String(Variant(r_max)));
|
|
|
|
|
|
if (r_min > 0.0f)
|
|
{
|
|
bShow = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bShow)
|
|
{
|
|
Light_AddCaster_SOB(light, n);
|
|
}
|
|
|
|
} // for through sobs
|
|
|
|
|
|
|
|
// look through every portal out
|
|
for (int n=0; n<lroom.m_iNumPortals; n++)
|
|
{
|
|
int portalID = lroom.m_iFirstPortal + n;
|
|
|
|
const LPortal &port = LMAN->m_Portals[portalID];
|
|
|
|
LPRINT_RUN(2, "\tPORTAL " + itos (n) + " (" + itos(portalID) + ") " + port.get_name() + " normal " + port.m_Plane.normal);
|
|
|
|
float dot = port.m_Plane.normal.dot(light.m_Source.m_ptDir);
|
|
|
|
if (dot <= 0.0f)
|
|
{
|
|
LPRINT_RUN(2, "\t\tCULLED (wrong direction)");
|
|
continue;
|
|
}
|
|
|
|
// is it culled by the planes?
|
|
LPortal::eClipResult overall_res = LPortal::eClipResult::CLIP_INSIDE;
|
|
|
|
// cull portal with planes
|
|
for (int l=0; l<planes.size(); l++)
|
|
{
|
|
LPortal::eClipResult res = port.ClipWithPlane(planes[l]);
|
|
|
|
switch (res)
|
|
{
|
|
case LPortal::eClipResult::CLIP_OUTSIDE:
|
|
overall_res = res;
|
|
break;
|
|
case LPortal::eClipResult::CLIP_PARTIAL:
|
|
overall_res = res;
|
|
break;
|
|
default: // suppress warning
|
|
break;
|
|
}
|
|
|
|
if (overall_res == LPortal::eClipResult::CLIP_OUTSIDE)
|
|
break;
|
|
}
|
|
|
|
// this portal is culled
|
|
if (overall_res == LPortal::eClipResult::CLIP_OUTSIDE)
|
|
{
|
|
LPRINT_RUN(2, "\t\tCULLED (outside planes)");
|
|
continue;
|
|
}
|
|
|
|
|
|
LRoom &linked_room = LMAN->Portal_GetLinkedRoom(port);
|
|
|
|
|
|
// recurse into that portal
|
|
unsigned int uiPoolMem = LMAN->m_Pool.Request();
|
|
if (uiPoolMem != -1)
|
|
{
|
|
// get a vector of planes from the pool
|
|
LVector<Plane> &new_planes = LMAN->m_Pool.Get(uiPoolMem);
|
|
|
|
// copy the existing planes
|
|
new_planes.copy_from(planes);
|
|
|
|
// add the planes for the portal
|
|
port.AddLightPlanes(*LMAN, light, new_planes, false);
|
|
|
|
Light_TraceRecursive(depth + 1, linked_room, light, iLightID, new_planes);
|
|
// for debugging need to reset tab depth
|
|
Lawn::LDebug::m_iTabDepth = depth;
|
|
|
|
// we no longer need these planes
|
|
LMAN->m_Pool.Free(uiPoolMem);
|
|
}
|
|
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 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("LRoom_FindShadowCasters_Recursive : Planes pool is empty");
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
*/
|
|
|
|
void LRoomConverter::Convert_ShadowCasters()
|
|
{
|
|
int nLights = LMAN->m_Lights.size();
|
|
LPRINT(5,"\nConvert_ShadowCasters ... numlights " + itos (nLights));
|
|
|
|
|
|
for (int l=0; l<nLights; l++)
|
|
{
|
|
const LLight &light = LMAN->m_Lights[l];
|
|
String sz = "Light " + itos (l);
|
|
if (light.m_Source.IsGlobal())
|
|
sz += " GLOBAL";
|
|
else
|
|
sz += " LOCAL from room " + itos(light.m_Source.m_RoomID);
|
|
|
|
LPRINT(5, sz + " direction " + light.m_Source.m_ptDir);
|
|
|
|
for (int n=0; n<LMAN->m_Rooms.size(); n++)
|
|
{
|
|
LRoom &lroom = LMAN->m_Rooms[n];
|
|
|
|
// global lights affect every room
|
|
bool bAffectsRoom = false; // true
|
|
|
|
// if the light is local, does it affect this room?
|
|
if (!light.m_Source.IsGlobal())
|
|
{
|
|
// a local light .. does it affect this room?
|
|
bAffectsRoom = false;
|
|
for (int i=0; i<lroom.m_LocalLights.size(); i++)
|
|
{
|
|
// if the light id is found among the local lights for this room
|
|
if (lroom.m_LocalLights[i] == l)
|
|
{
|
|
bAffectsRoom = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bAffectsRoom)
|
|
{
|
|
LPRINT(2,"\n\tAFFECTS room " + itos(n) + ", " + lroom.get_name());
|
|
LRoom_FindShadowCasters_FromLight(lroom, light);
|
|
//LRoom_FindShadowCasters(lroom, l, light);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void LRoomConverter::Convert_Bounds()
|
|
{
|
|
for (int n=0; n<LMAN->m_Rooms.size(); n++)
|
|
{
|
|
LRoom &lroom = LMAN->m_Rooms[n];
|
|
|
|
//print("DetectBounds from room " + lroom.get_name());
|
|
|
|
Spatial * pGRoom = lroom.GetGodotRoom();
|
|
assert (pGRoom);
|
|
|
|
|
|
for (int n=0; n<pGRoom->get_child_count(); n++)
|
|
{
|
|
Node * pChild = pGRoom->get_child(n);
|
|
|
|
if (Node_IsBound(pChild))
|
|
{
|
|
MeshInstance * pMesh = Object::cast_to<MeshInstance>(pChild);
|
|
assert (pMesh);
|
|
Convert_ManualBound(lroom, pMesh);
|
|
|
|
// delete the mesh
|
|
pGRoom->remove_child(pChild);
|
|
pChild->queue_delete();
|
|
break;
|
|
}
|
|
}
|
|
|
|
// if no manual bound is found, we will create one by using qhull on all the points
|
|
if (!lroom.m_Bound.IsActive())
|
|
{
|
|
Vector<Vector3> pts;
|
|
Bound_FindPoints_Recursive(pGRoom, pts);
|
|
|
|
LPRINT(2, "\tCONVERT_AUTO_BOUND room : '" + lroom.get_name() + "' (" + itos(pts.size()) + " verts)");
|
|
|
|
// use qhull
|
|
Convert_Bound_FromPoints(lroom, pts);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void LRoomConverter::Bound_FindPoints_Recursive(Node * pNode, Vector<Vector3> &pts)
|
|
{
|
|
// is it a mesh instance?
|
|
MeshInstance * pMI = Object::cast_to<MeshInstance>(pNode);
|
|
if (pMI)
|
|
{
|
|
// get the points in world space
|
|
GetWorldVertsFromMesh(*pMI, pts);
|
|
}
|
|
|
|
for (int n=0; n<pNode->get_child_count(); n++)
|
|
{
|
|
Node * pChild = pNode->get_child(n);
|
|
Bound_FindPoints_Recursive(pChild, pts);
|
|
}
|
|
}
|
|
|
|
void LRoomConverter::Convert_Portals()
|
|
{
|
|
for (int pass=0; pass<3; pass++)
|
|
{
|
|
LPRINT(2, "Convert_Portals pass " + itos(pass));
|
|
LPRINT(2, "");
|
|
|
|
for (int n=0; n<LMAN->m_Rooms.size(); n++)
|
|
{
|
|
LRoom &lroom = LMAN->m_Rooms[n];
|
|
LTempRoom &troom = m_TempRooms[n];
|
|
|
|
switch (pass)
|
|
{
|
|
case 0:
|
|
LRoom_DetectPortalMeshes(lroom, troom);
|
|
break;
|
|
case 1:
|
|
LRoom_MakePortalsTwoWay(lroom, troom, n);
|
|
break;
|
|
case 2:
|
|
LRoom_MakePortalFinalList(lroom, troom);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
int LRoomConverter::CountRooms()
|
|
{
|
|
if (m_bSingleRoomMode)
|
|
return 1; // hard coded
|
|
|
|
int nChildren = LROOMLIST->get_child_count();
|
|
int count = 0;
|
|
|
|
for (int n=0; n<nChildren; n++)
|
|
{
|
|
Node * pChild = LROOMLIST->get_child(n);
|
|
if (Node_IsRoom(pChild))
|
|
count++;
|
|
else
|
|
{
|
|
// also check the children if this is an area
|
|
if (Node_IsArea(pChild))
|
|
{
|
|
for (int c=0; c<pChild->get_child_count(); c++)
|
|
{
|
|
Node * pChild2 = pChild->get_child(c);
|
|
if (Node_IsRoom(pChild2))
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
|
|
// find all objects that cast shadows onto the objects in this room
|
|
//void LRoomConverter::LRoom_FindShadowCasters(LRoom &lroom, int lightID, const LLight &light)
|
|
//{
|
|
// // each global light, and each light affecting this room
|
|
// for (int n=0; n<LMAN->m_Lights.size(); n++)
|
|
// {
|
|
// // if the light is not a global light, we are only interested if it emits from this room
|
|
// const LLight &l = LMAN->m_Lights[n];
|
|
|
|
// bool bAffectsRoom = true;
|
|
// if (l.m_RoomID != -1)
|
|
// {
|
|
// // a local light .. does it affect this room?
|
|
// bAffectsRoom = false;
|
|
// for (int i=0; i<lroom.m_LocalLights.size(); i++)
|
|
// {
|
|
// // if the light id is found among the local lights for this room
|
|
// if (lroom.m_LocalLights[i] == n)
|
|
// {
|
|
// bAffectsRoom = true;
|
|
// break;
|
|
// }
|
|
// }
|
|
// }
|
|
|
|
// if (bAffectsRoom)
|
|
// LRoom_FindShadowCasters_FromLight(lroom, l);
|
|
// }
|
|
|
|
|
|
// return;
|
|
//}
|
|
|
|
/*
|
|
void LRoomConverter::Light_AddCaster_SOB(LLight &light, int sobID)
|
|
{
|
|
// we will reuse the rendering bitflags for shadow casters for this ... to check for double entries (fnaa fnaa)
|
|
if (LMAN->m_BF_caster_SOBs.GetBit(sobID))
|
|
return;
|
|
|
|
|
|
LPRINT_RUN(2, "\t\t\tLightCaster " + itos(sobID));
|
|
|
|
LMAN->m_BF_caster_SOBs.SetBit(sobID, true);
|
|
|
|
|
|
// first?
|
|
if (!light.m_NumCasters)
|
|
light.m_FirstCaster = LMAN->m_LightCasters_SOB.size();
|
|
|
|
LMAN->m_LightCasters_SOB.push_back(sobID);
|
|
light.m_NumCasters++;
|
|
}
|
|
*/
|
|
|
|
void LRoomConverter::LRoom_AddShadowCaster_SOB(LRoom &lroom, int sobID)
|
|
{
|
|
// we will reuse the rendering bitflags for shadow casters for this ... to check for double entries (fnaa fnaa)
|
|
if (LMAN->m_BF_caster_SOBs.GetBit(sobID))
|
|
return;
|
|
|
|
LMAN->m_BF_caster_SOBs.SetBit(sobID, true);
|
|
|
|
// first?
|
|
if (!lroom.m_iNumShadowCasters_SOB)
|
|
lroom.m_iFirstShadowCaster_SOB = LMAN->m_ShadowCasters_SOB.size();
|
|
|
|
LMAN->m_ShadowCasters_SOB.push_back(sobID);
|
|
lroom.m_iNumShadowCasters_SOB++;
|
|
}
|
|
|
|
|
|
void LRoomConverter::LRoom_FindShadowCasters_FromLight(LRoom &lroom, const LLight &light)
|
|
{
|
|
// blank this each time as it is used to create the list of casters
|
|
LMAN->m_BF_caster_SOBs.Blank();
|
|
|
|
// first add all objects in this room as casters
|
|
// int last_sob = lroom.m_iFirstSOB + lroom.m_iNumSOBs;
|
|
// for (int n=lroom.m_iFirstSOB; n<last_sob; n++)
|
|
// {
|
|
// //LSob &sob = manager.m_SOBs[n];
|
|
// LRoom_AddShadowCaster_SOB(lroom, n);
|
|
// }
|
|
|
|
|
|
// just a constant light direction for now
|
|
// LLight light;
|
|
// light.m_ptDir = Vector3(1.0f, -1.0f, 0.0f);
|
|
// light.m_ptDir.normalize();
|
|
|
|
// reset the planes pool for each render out from the source room
|
|
LMAN->m_Pool.Reset();
|
|
|
|
|
|
// the first set of planes are blank
|
|
unsigned int pool_member = LMAN->m_Pool.Request();
|
|
assert (pool_member != -1);
|
|
|
|
LVector<Plane> &planes = LMAN->m_Pool.Get(pool_member);
|
|
planes.clear();
|
|
|
|
Lawn::LDebug::m_iTabDepth = 0;
|
|
LRoom_FindShadowCasters_Recursive(lroom, 1, lroom, light, planes);
|
|
|
|
}
|
|
|
|
|
|
void LRoomConverter::LRoom_FindShadowCasters_Recursive(LRoom &source_lroom, int depth, LRoom &lroom, const LLight &light, const LVector<Plane> &planes)
|
|
{
|
|
// prevent too much depth
|
|
if (depth > 8)
|
|
{
|
|
LPRINT_RUN(2, "\t\t\tLRoom_FindShadowCasters_Recursive DEPTH LIMIT REACHED");
|
|
// WARN_PRINT_ONCE("LPortal Depth Limit reached (seeing through > 8 portals)");
|
|
return;
|
|
}
|
|
|
|
Lawn::LDebug::m_iTabDepth = depth;
|
|
LPRINT_RUN(2, "ROOM " + lroom.get_name());
|
|
|
|
|
|
// every object in this room is added that is within the planes
|
|
int last_sob = lroom.m_iFirstSOB + lroom.m_iNumSOBs;
|
|
for (int n=lroom.m_iFirstSOB; n<last_sob; n++)
|
|
{
|
|
LSob &sob = LMAN->m_SOBs[n];
|
|
|
|
// not a shadow caster? don't add to the list
|
|
if (!sob.IsShadowCaster())
|
|
continue;
|
|
|
|
bool bShow = true;
|
|
const AABB &bb = sob.m_aabb;
|
|
|
|
// print("\t\t\tculling object " + pObj->get_name());
|
|
|
|
for (int p=0; p<planes.size(); p++)
|
|
{
|
|
// float dist = planes[p].distance_to(pt);
|
|
// print("\t\t\t\t" + itos(p) + " : dist " + String(Variant(dist)));
|
|
|
|
float r_min, r_max;
|
|
bb.project_range_in_plane(planes[p], r_min, r_max);
|
|
|
|
// print("\t\t\t\t" + itos(p) + " : r_min " + String(Variant(r_min)) + ", r_max " + String(Variant(r_max)));
|
|
|
|
|
|
if (r_min > 0.0f)
|
|
// if (r_max < 0.0f)
|
|
{
|
|
//LPRINT_RUN(2, "\tR_MIN is " + String(Variant(r_min)) + " R_MAX is " + String(Variant(r_max))+ ", for plane " + itos(p));
|
|
|
|
bShow = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bShow)
|
|
{
|
|
LPRINT_RUN(2, "\tcaster " + itos(n) + ", " + sob.GetSpatial()->get_name());
|
|
LRoom_AddShadowCaster_SOB(source_lroom, n);
|
|
}
|
|
else
|
|
{
|
|
//LPRINT_RUN(2, "\tculled " + itos(n) + ", " + sob.GetSpatial()->get_name());
|
|
}
|
|
}
|
|
|
|
// look through every portal out
|
|
for (int n=0; n<lroom.m_iNumPortals; n++)
|
|
{
|
|
int portalID = lroom.m_iFirstPortal + n;
|
|
|
|
const LPortal &port = LMAN->m_Portals[portalID];
|
|
|
|
LPRINT_RUN(2, "\tPORTAL " + itos (n) + " (" + itos(portalID) + ") " + port.get_name() + " normal " + port.m_Plane.normal);
|
|
|
|
// cull with light direction
|
|
float dot;
|
|
if (light.m_Source.m_eType == LSource::ST_DIRECTIONAL)
|
|
{
|
|
dot = port.m_Plane.normal.dot(light.m_Source.m_ptDir);
|
|
}
|
|
else
|
|
{
|
|
// cull with light direction to portal
|
|
Vector3 ptLightToPort = port.m_ptCentre - light.m_Source.m_ptPos;
|
|
dot = port.m_Plane.normal.dot(ptLightToPort);
|
|
}
|
|
|
|
|
|
// float dot = port.m_Plane.normal.dot(light.m_ptDir);
|
|
if (dot >= 0.0f)
|
|
{
|
|
LPRINT_RUN(2, "\t\tCULLED (wrong direction)");
|
|
continue;
|
|
}
|
|
|
|
// is it culled by the planes?
|
|
LPortal::eClipResult overall_res = LPortal::eClipResult::CLIP_INSIDE;
|
|
|
|
// cull portal with planes
|
|
for (int l=0; l<planes.size(); l++)
|
|
{
|
|
LPortal::eClipResult res = port.ClipWithPlane(planes[l]);
|
|
|
|
switch (res)
|
|
{
|
|
case LPortal::eClipResult::CLIP_OUTSIDE:
|
|
overall_res = res;
|
|
break;
|
|
case LPortal::eClipResult::CLIP_PARTIAL:
|
|
overall_res = res;
|
|
break;
|
|
default: // suppress warning
|
|
break;
|
|
}
|
|
|
|
if (overall_res == LPortal::eClipResult::CLIP_OUTSIDE)
|
|
break;
|
|
}
|
|
|
|
// this portal is culled
|
|
if (overall_res == LPortal::eClipResult::CLIP_OUTSIDE)
|
|
{
|
|
LPRINT_RUN(2, "\t\tCULLED (outside planes)");
|
|
continue;
|
|
}
|
|
|
|
|
|
LRoom &linked_room = LMAN->Portal_GetLinkedRoom(port);
|
|
|
|
|
|
// recurse into that portal
|
|
unsigned int uiPoolMem = LMAN->m_Pool.Request();
|
|
if (uiPoolMem != -1)
|
|
{
|
|
// get a vector of planes from the pool
|
|
LVector<Plane> &new_planes = LMAN->m_Pool.Get(uiPoolMem);
|
|
|
|
// copy the existing planes
|
|
new_planes.copy_from(planes);
|
|
|
|
// add the planes for the portal
|
|
port.AddLightPlanes(*LMAN, light, new_planes, true);
|
|
|
|
LRoom_FindShadowCasters_Recursive(source_lroom, depth + 1, linked_room, light, new_planes);
|
|
// for debugging need to reset tab depth
|
|
Lawn::LDebug::m_iTabDepth = depth;
|
|
|
|
// we no longer need these planes
|
|
LMAN->m_Pool.Free(uiPoolMem);
|
|
}
|
|
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 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("LRoom_FindShadowCasters_Recursive : Planes pool is empty");
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// go through the nodes hanging off the room looking for those that are meshes to mark portal locations
|
|
void LRoomConverter::LRoom_DetectPortalMeshes(LRoom &lroom, LTempRoom &troom)
|
|
{
|
|
LPRINT(2, "DETECT_PORTALS from room " + lroom.get_name());
|
|
|
|
Spatial * pGRoom = lroom.GetGodotRoom();
|
|
assert (pGRoom);
|
|
|
|
|
|
for (int n=0; n<pGRoom->get_child_count(); n++)
|
|
{
|
|
Node * pChild = pGRoom->get_child(n);
|
|
|
|
if (Node_IsPortal(pChild))
|
|
{
|
|
|
|
MeshInstance * pMesh = Object::cast_to<MeshInstance>(pChild);
|
|
assert (pMesh);
|
|
|
|
// name must start with 'portal_'
|
|
// and ends with the name of the room we want to link to (without the 'room_')
|
|
String szLinkRoom = LPortal::FindNameAfter(pMesh, "portal_");
|
|
LRoom_DetectedPortalMesh(lroom, troom, pMesh, szLinkRoom);
|
|
}
|
|
}
|
|
|
|
// delete portal meshes
|
|
if (m_bFinalRun)
|
|
// if (true)
|
|
{
|
|
// we need an enclosing while loop because we might be deleting children and mucking up the iterator
|
|
bool bDetectedOne = true;
|
|
|
|
while (bDetectedOne)
|
|
{
|
|
bDetectedOne = false;
|
|
|
|
for (int n=0; n<pGRoom->get_child_count(); n++)
|
|
{
|
|
Node * pChild = pGRoom->get_child(n);
|
|
|
|
if (Node_IsPortal(pChild))
|
|
{
|
|
// delete the original child, as it is no longer needed at runtime (except maybe for debugging .. NYI?)
|
|
// pMeshInstance->hide();
|
|
pChild->get_parent()->remove_child(pChild);
|
|
pChild->queue_delete();
|
|
bDetectedOne = true;
|
|
}
|
|
|
|
if (bDetectedOne)
|
|
break;
|
|
} // for loop
|
|
|
|
} // while
|
|
} // if we want to delete portal meshes
|
|
|
|
}
|
|
|
|
void LRoomConverter::LRoom_PushBackSOB(LRoom &lroom, const LSob &sob)
|
|
{
|
|
// first added for this room?
|
|
if (lroom.m_iNumSOBs == 0)
|
|
lroom.m_iFirstSOB = LMAN->m_SOBs.size();
|
|
|
|
LMAN->m_SOBs.push_back(sob);
|
|
lroom.m_iNumSOBs++;
|
|
}
|
|
|
|
|
|
// handles the slight faff involved in getting a new portal in the manager contiguous list of portals
|
|
LPortal * LRoomConverter::LRoom_RequestNewPortal(LRoom &lroom)
|
|
{
|
|
// is this the first portal?
|
|
if (lroom.m_iNumPortals == 0)
|
|
lroom.m_iFirstPortal = LMAN->m_Portals.size();
|
|
|
|
lroom.m_iNumPortals++;
|
|
|
|
return LMAN->m_Portals.request();
|
|
}
|
|
|
|
// convert the list on each room to a single contiguous list in the manager
|
|
void LRoomConverter::LRoom_MakePortalFinalList(LRoom &lroom, LTempRoom &troom)
|
|
{
|
|
for (int n=0; n<troom.m_Portals.size(); n++)
|
|
{
|
|
LPortal &lport_final = *LRoom_RequestNewPortal(lroom);
|
|
lport_final = troom.m_Portals[n];
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void LRoomConverter::LRoom_DetectedArea(LRoom &lroom, Node * pNode)
|
|
{
|
|
// find the area name
|
|
String szArea = LPortal::FindNameAfter(pNode, "area_");
|
|
|
|
// find or create an area with this name
|
|
int area = Area_FindOrCreate(szArea);
|
|
|
|
// check for duplicates? maybe a level design mistake?
|
|
if (lroom.m_Areas.find(area) != -1)
|
|
{
|
|
LWARN(2, "LRoom_DetectedArea : duplicate area in room, ignoring : " + szArea);
|
|
return;
|
|
}
|
|
|
|
// add it to the lroom
|
|
lroom.m_Areas.push_back(area);
|
|
}
|
|
|
|
void LRoomConverter::LRoom_DetectedLight(LRoom &lroom, Node * pNode)
|
|
{
|
|
Light * pLight = Object::cast_to<Light>(pNode);
|
|
assert (pLight);
|
|
|
|
if (m_bDeleteLights)
|
|
{
|
|
LPRINT(2, "Deleting Light : " + pLight->get_name());
|
|
// delete light now we are using lightmaps for test
|
|
pLight->queue_delete();
|
|
}
|
|
else
|
|
{
|
|
LPRINT(2, "Detected Light : " + pLight->get_name());
|
|
LMAN->LightCreate(pLight, lroom.m_RoomID);
|
|
}
|
|
}
|
|
|
|
// found a portal mesh! create a matching LPortal
|
|
void LRoomConverter::LRoom_DetectedPortalMesh(LRoom &lroom, LTempRoom &troom, MeshInstance * pMeshInstance, String szLinkRoom)
|
|
{
|
|
LPRINT(2, "\tdetected to " + szLinkRoom);
|
|
|
|
// which room does this portal want to link to?
|
|
int iLinkRoom = FindRoom_ByName(szLinkRoom);
|
|
if (iLinkRoom == -1)
|
|
{
|
|
LWARN(5, "portal to room " + szLinkRoom + ", room not found");
|
|
//WARN_PRINTS("portal to room " + szLinkRoom + ", room not found");
|
|
return;
|
|
}
|
|
|
|
// some godot jiggery pokery to get the mesh verts in local space
|
|
Ref<Mesh> rmesh = pMeshInstance->get_mesh();
|
|
Array arrays = rmesh->surface_get_arrays(0);
|
|
PoolVector<Vector3> p_vertices = arrays[VS::ARRAY_VERTEX];
|
|
|
|
|
|
// create a new LPortal to fill with this wonderful info
|
|
LPortal &lport = *troom.m_Portals.request();
|
|
lport.m_szName = szLinkRoom;
|
|
lport.m_iRoomNum = iLinkRoom;
|
|
|
|
// create the portal geometry
|
|
lport.CreateGeometry(p_vertices, pMeshInstance->get_global_transform(), LMAN->m_bPortalPlane_Convention);
|
|
|
|
|
|
// LPRINT(2, "\t\t\tnum portals now " + itos(troom.m_Portals.size()));
|
|
}
|
|
|
|
|
|
// This aims to make life easier for level designers. They only need to make a portal facing one way and LPortal
|
|
// will automatically create a mirror portal the other way.
|
|
void LRoomConverter::LRoom_MakePortalsTwoWay(LRoom &lroom, LTempRoom &troom, int iRoomNum)
|
|
{
|
|
LPRINT(2, "MAKE_PORTALS_TWOWAY from room " + lroom.get_name());
|
|
LPRINT(2, "\tcontains " + itos (troom.m_Portals.size()) + " portals");
|
|
for (int n=0; n<troom.m_Portals.size(); n++)
|
|
{
|
|
const LPortal &portal_orig = troom.m_Portals[n];
|
|
LPRINT(2, "\tconsidering portal " + portal_orig.get_name());
|
|
|
|
// only make original portals into mirror portals, to prevent infinite recursion
|
|
if (portal_orig.m_bMirror)
|
|
{
|
|
LPRINT (2, "\t\tis MIRROR, ignoring");
|
|
continue;
|
|
}
|
|
|
|
LPRINT(2, "\t\tcreating opposite portal");
|
|
|
|
// get the temproom this portal is linking to
|
|
//LTempRoom &nroom = m_TempRooms[portal_orig.m_iRoomNum];
|
|
|
|
// does a portal already exist back to the orig room?
|
|
// NOTE this doesn't cope with multiple portals between pairs of rooms yet.
|
|
// bool bAlreadyLinked =false;
|
|
|
|
// for (int p=0; p<nroom.m_Portals.size(); p++)
|
|
// {
|
|
// if (nroom.m_Portals[p].m_iRoomNum == n)
|
|
// {
|
|
// bAlreadyLinked = true;
|
|
// break;
|
|
// }
|
|
// }
|
|
|
|
// if (bAlreadyLinked)
|
|
// continue;
|
|
|
|
// needs a new reverse link if got to here
|
|
TRoom_MakeOppositePortal(portal_orig, iRoomNum);
|
|
}
|
|
}
|
|
|
|
// There is a need for a mirror portal, let's make one!
|
|
void LRoomConverter::TRoom_MakeOppositePortal(const LPortal &port, int iRoomOrig)
|
|
{
|
|
LTempRoom &nroom = m_TempRooms[port.m_iRoomNum];
|
|
const LRoom &orig_lroom = LMAN->m_Rooms[iRoomOrig];
|
|
|
|
// the new portal should have the name of the room the original came from
|
|
LPortal &new_port = *nroom.m_Portals.request();
|
|
new_port.m_szName = orig_lroom.m_szName;
|
|
new_port.m_iRoomNum = iRoomOrig;
|
|
new_port.m_bMirror = true;
|
|
|
|
// the portal vertices should be the same but reversed (to flip the normal)
|
|
new_port.CopyReversedGeometry(port);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////
|
|
|
|
// helper
|
|
bool LRoomConverter::Node_IsLight(Node * pNode) const
|
|
{
|
|
Light * pLight = Object::cast_to<Light>(pNode);
|
|
if (!pLight)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool LRoomConverter::Node_IsArea(Node * pNode) const
|
|
{
|
|
Spatial * pSpat = Object::cast_to<Spatial>(pNode);
|
|
if (!pSpat)
|
|
return false;
|
|
|
|
if (LPortal::NameStartsWith(pSpat, "area_"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool LRoomConverter::Node_IsRoom(Node * pNode) const
|
|
{
|
|
Spatial * pSpat = Object::cast_to<Spatial>(pNode);
|
|
if (!pSpat)
|
|
return false;
|
|
|
|
if (LPortal::NameStartsWith(pSpat, "room_"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LRoomConverter::Node_IsIgnore(Node * pNode) const
|
|
{
|
|
if (LPortal::NameStartsWith(pNode, "ignore_"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LRoomConverter::Node_IsBound(Node * pNode) const
|
|
{
|
|
MeshInstance * pMI = Object::cast_to<MeshInstance>(pNode);
|
|
if (!pMI)
|
|
return false;
|
|
|
|
if (LPortal::NameStartsWith(pMI, "bound_"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LRoomConverter::Node_IsPortal(Node * pNode) const
|
|
{
|
|
MeshInstance * pMI = Object::cast_to<MeshInstance>(pNode);
|
|
if (!pMI)
|
|
return false;
|
|
|
|
if (LPortal::NameStartsWith(pMI, "portal_"))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
// keep the global namespace clean
|
|
#undef LMAN
|