zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-11-22 21:02:07 +00:00
Code Activity

chore: adjust method naming to PascalCase

Browse Source
This commit is contained in:
Jan Laupetin
2025-11-04 22:52:34 +00:00
parent 4b1e81056c
commit 3d1fa7c6d9
19 changed files with 148 additions and 148 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/ObjLoading/Game/T6/BSP/BSPCalculation.cpp
View File

@@ -18,17 +18,17 @@ namespace BSP
partitionIndex = objPartitionIndex; partitionIndex = objPartitionIndex;
} }
void BSPLeaf::addObject(std::shared_ptr<BSPObject> object) void BSPLeaf::AddObject(std::shared_ptr<BSPObject> object)
{ {
objectList.emplace_back(std::move(object)); objectList.emplace_back(std::move(object));
} }
BSPObject* BSPLeaf::getObject(const size_t index) const BSPObject* BSPLeaf::GetObject(const size_t index) const
{ {
return objectList.at(index).get(); return objectList.at(index).get();
} }
size_t BSPLeaf::getObjectCount() const size_t BSPLeaf::GetObjectCount() const
{ {
return objectList.size(); return objectList.size();
} }
@@ -41,7 +41,7 @@ namespace BSP
distance = nodeDistance; distance = nodeDistance;
} }
PlaneSide BSPNode::objectIsInFront(const BSPObject& object) const PlaneSide BSPNode::ObjectIsInFront(const BSPObject& object) const
{ {
float minCoord, maxCoord; float minCoord, maxCoord;
@@ -89,10 +89,10 @@ namespace BSP
max.z = zMax; max.z = zMax;
level = treeLevel; level = treeLevel;
splitTree(); SplitTree();
} }
void BSPTree::splitTree() void BSPTree::SplitTree()
{ {
std::unique_ptr<BSPTree> front; std::unique_ptr<BSPTree> front;
std::unique_ptr<BSPTree> back; std::unique_ptr<BSPTree> back;
@@ -139,28 +139,28 @@ namespace BSP
} }
} }
void BSPTree::addObjectToTree(std::shared_ptr<BSPObject> object) const void BSPTree::AddObjectToTree(std::shared_ptr<BSPObject> object) const
{ {
if (isLeaf) if (isLeaf)
{ {
leaf->addObject(std::move(object)); leaf->AddObject(std::move(object));
} }
else else
{ {
const auto side = node->objectIsInFront(*object); const auto side = node->ObjectIsInFront(*object);
if (side == PlaneSide::SIDE_FRONT) if (side == PlaneSide::SIDE_FRONT)
{ {
node->front->addObjectToTree(std::move(object)); node->front->AddObjectToTree(std::move(object));
} }
else if (side == PlaneSide::SIDE_BACK) else if (side == PlaneSide::SIDE_BACK)
{ {
node->back->addObjectToTree(std::move(object)); node->back->AddObjectToTree(std::move(object));
} }
else // intersects else // intersects
{ {
node->front->addObjectToTree(object); node->front->AddObjectToTree(object);
node->back->addObjectToTree(object); node->back->AddObjectToTree(object);
} }
} }
} }

12
src/ObjLoading/Game/T6/BSP/BSPCalculation.h
View File

@@ -34,9 +34,9 @@ namespace BSP
class BSPLeaf class BSPLeaf
{ {
public: public:
void addObject(std::shared_ptr<BSPObject> object); void AddObject(std::shared_ptr<BSPObject> object);
[[nodiscard]] BSPObject* getObject(size_t index) const; [[nodiscard]] BSPObject* GetObject(size_t index) const;
[[nodiscard]] size_t getObjectCount() const; [[nodiscard]] size_t GetObjectCount() const;
std::vector<std::shared_ptr<BSPObject>> objectList; std::vector<std::shared_ptr<BSPObject>> objectList;
}; };
@@ -47,7 +47,7 @@ namespace BSP
{ {
public: public:
BSPNode(std::unique_ptr<BSPTree> frontTree, std::unique_ptr<BSPTree> backTree, PlaneAxis nodeAxis, float nodeDistance); BSPNode(std::unique_ptr<BSPTree> frontTree, std::unique_ptr<BSPTree> backTree, PlaneAxis nodeAxis, float nodeDistance);
[[nodiscard]] PlaneSide objectIsInFront(const BSPObject& object) const; [[nodiscard]] PlaneSide ObjectIsInFront(const BSPObject& object) const;
std::unique_ptr<BSPTree> front; std::unique_ptr<BSPTree> front;
std::unique_ptr<BSPTree> back; std::unique_ptr<BSPTree> back;
@@ -61,8 +61,8 @@ namespace BSP
public: public:
BSPTree(float xMin, float yMin, float zMin, float xMax, float yMax, float zMax, int treeLevel); BSPTree(float xMin, float yMin, float zMin, float xMax, float yMax, float zMax, int treeLevel);
void splitTree(); void SplitTree();
void addObjectToTree(std::shared_ptr<BSPObject> object) const; void AddObjectToTree(std::shared_ptr<BSPObject> object) const;
bool isLeaf; bool isLeaf;
std::unique_ptr<BSPLeaf> leaf; std::unique_ptr<BSPLeaf> leaf;

14
src/ObjLoading/Game/T6/BSP/BSPCreator.cpp
View File

@@ -11,7 +11,7 @@ using namespace BSP;
namespace namespace
{ {
void addFBXMeshToWorld( void AddFBXMeshToWorld(
ufbx_node* node, std::vector<BSPSurface>& surfaceVec, std::vector<BSPVertex>& vertexVec, std::vector<uint16_t>& indexVec, bool& hasTangentSpace) ufbx_node* node, std::vector<BSPSurface>& surfaceVec, std::vector<BSPVertex>& vertexVec, std::vector<uint16_t>& indexVec, bool& hasTangentSpace)
{ {
ufbx_mesh* mesh = node->mesh; ufbx_mesh* mesh = node->mesh;
@@ -176,7 +176,7 @@ namespace
} }
} }
void loadWorldData(const ufbx_scene& scene, BSPData& bsp, const bool isGfxData) void LoadWorldData(const ufbx_scene& scene, BSPData& bsp, const bool isGfxData)
{ {
bool hasTangentSpace = true; bool hasTangentSpace = true;
for (ufbx_node* node : scene.nodes) for (ufbx_node* node : scene.nodes)
@@ -184,9 +184,9 @@ namespace
if (node->attrib_type == UFBX_ELEMENT_MESH) if (node->attrib_type == UFBX_ELEMENT_MESH)
{ {
if (isGfxData) if (isGfxData)
addFBXMeshToWorld(node, bsp.gfxWorld.surfaces, bsp.gfxWorld.vertices, bsp.gfxWorld.indices, hasTangentSpace); AddFBXMeshToWorld(node, bsp.gfxWorld.surfaces, bsp.gfxWorld.vertices, bsp.gfxWorld.indices, hasTangentSpace);
else else
addFBXMeshToWorld(node, bsp.colWorld.surfaces, bsp.colWorld.vertices, bsp.colWorld.indices, hasTangentSpace); AddFBXMeshToWorld(node, bsp.colWorld.surfaces, bsp.colWorld.vertices, bsp.colWorld.indices, hasTangentSpace);
} }
else else
{ {
@@ -201,7 +201,7 @@ namespace
namespace BSP namespace BSP
{ {
std::unique_ptr<BSPData> createBSPData(const std::string& mapName, ISearchPath& searchPath) std::unique_ptr<BSPData> CreateBSPData(const std::string& mapName, ISearchPath& searchPath)
{ {
const auto gfxFbxPath = GetFileNameForBSPAsset("map_gfx.fbx"); const auto gfxFbxPath = GetFileNameForBSPAsset("map_gfx.fbx");
const auto gfxFile = searchPath.Open(gfxFbxPath); const auto gfxFile = searchPath.Open(gfxFbxPath);
@@ -268,8 +268,8 @@ namespace BSP
bsp->name = mapName; bsp->name = mapName;
bsp->bspName = std::format("maps/mp/{}.d3dbsp", mapName); bsp->bspName = std::format("maps/mp/{}.d3dbsp", mapName);
loadWorldData(*gfxScene, *bsp, true); LoadWorldData(*gfxScene, *bsp, true);
loadWorldData(*colScene, *bsp, false); LoadWorldData(*colScene, *bsp, false);
ufbx_free_scene(gfxScene); ufbx_free_scene(gfxScene);
if (gfxScene != colScene) if (gfxScene != colScene)

2
src/ObjLoading/Game/T6/BSP/BSPCreator.h
View File

@@ -5,5 +5,5 @@
namespace BSP namespace BSP
{ {
std::unique_ptr<BSPData> createBSPData(const std::string& mapName, ISearchPath& searchPath); std::unique_ptr<BSPData> CreateBSPData(const std::string& mapName, ISearchPath& searchPath);
}; // namespace BSP }; // namespace BSP

32
src/ObjLoading/Game/T6/BSP/Linker/BSPLinker.cpp
View File

@@ -14,7 +14,7 @@ using namespace T6;
namespace BSP namespace BSP
{ {
void BSPLinker::addEmptyFootstepTableAsset(const std::string& assetName) const void BSPLinker::AddEmptyFootstepTableAsset(const std::string& assetName) const
{ {
if (assetName.empty()) if (assetName.empty())
return; return;
@@ -26,7 +26,7 @@ namespace BSP
m_context.AddAsset<AssetFootstepTable>(assetName, footstepTable); m_context.AddAsset<AssetFootstepTable>(assetName, footstepTable);
} }
bool BSPLinker::addDefaultRequiredAssets(const BSPData& bsp) const bool BSPLinker::AddDefaultRequiredAssets(const BSPData& bsp) const
{ {
if (!m_context.LoadDependency<AssetScript>(std::format("maps/mp/{}.gsc", bsp.name))) if (!m_context.LoadDependency<AssetScript>(std::format("maps/mp/{}.gsc", bsp.name)))
return false; return false;
@@ -42,12 +42,12 @@ namespace BSP
if (!m_context.LoadDependency<AssetScript>(std::format("clientscripts/mp/{}_fx.csc", bsp.name))) if (!m_context.LoadDependency<AssetScript>(std::format("clientscripts/mp/{}_fx.csc", bsp.name)))
return false; return false;
addEmptyFootstepTableAsset("default_1st_person"); AddEmptyFootstepTableAsset("default_1st_person");
addEmptyFootstepTableAsset("default_3rd_person"); AddEmptyFootstepTableAsset("default_3rd_person");
addEmptyFootstepTableAsset("default_1st_person_quiet"); AddEmptyFootstepTableAsset("default_1st_person_quiet");
addEmptyFootstepTableAsset("default_3rd_person_quiet"); AddEmptyFootstepTableAsset("default_3rd_person_quiet");
addEmptyFootstepTableAsset("default_3rd_person_loud"); AddEmptyFootstepTableAsset("default_3rd_person_loud");
addEmptyFootstepTableAsset("default_ai"); AddEmptyFootstepTableAsset("default_ai");
if (!m_context.LoadDependency<AssetRawFile>("animtrees/fxanim_props.atr")) if (!m_context.LoadDependency<AssetRawFile>("animtrees/fxanim_props.atr"))
return false; return false;
@@ -62,9 +62,9 @@ namespace BSP
{ {
} }
bool BSPLinker::linkBSP(const BSPData& bsp) const bool BSPLinker::LinkBSP(const BSPData& bsp) const
{ {
if (!addDefaultRequiredAssets(bsp)) if (!AddDefaultRequiredAssets(bsp))
return false; return false;
ComWorldLinker comWorldLinker(m_memory, m_search_path, m_context); ComWorldLinker comWorldLinker(m_memory, m_search_path, m_context);
@@ -74,32 +74,32 @@ namespace BSP
MapEntsLinker mapEntsLinker(m_memory, m_search_path, m_context); MapEntsLinker mapEntsLinker(m_memory, m_search_path, m_context);
SkinnedVertsLinker skinnedVertsLinker(m_memory, m_search_path, m_context); SkinnedVertsLinker skinnedVertsLinker(m_memory, m_search_path, m_context);
auto* comWorld = comWorldLinker.linkComWorld(bsp); auto* comWorld = comWorldLinker.LinkComWorld(bsp);
if (!comWorld) if (!comWorld)
return false; return false;
m_context.AddAsset<AssetComWorld>(comWorld->name, comWorld); m_context.AddAsset<AssetComWorld>(comWorld->name, comWorld);
auto* mapEnts = mapEntsLinker.linkMapEnts(bsp); auto* mapEnts = mapEntsLinker.LinkMapEnts(bsp);
if (!mapEnts) if (!mapEnts)
return false; return false;
m_context.AddAsset<AssetMapEnts>(mapEnts->name, mapEnts); m_context.AddAsset<AssetMapEnts>(mapEnts->name, mapEnts);
auto* gameWorldMp = gameWorldMpLinker.linkGameWorldMp(bsp); auto* gameWorldMp = gameWorldMpLinker.LinkGameWorldMp(bsp);
if (!gameWorldMp) if (!gameWorldMp)
return false; return false;
m_context.AddAsset<AssetGameWorldMp>(gameWorldMp->name, gameWorldMp); m_context.AddAsset<AssetGameWorldMp>(gameWorldMp->name, gameWorldMp);
auto* skinnedVerts = skinnedVertsLinker.linkSkinnedVerts(bsp); auto* skinnedVerts = skinnedVertsLinker.LinkSkinnedVerts(bsp);
if (!skinnedVerts) if (!skinnedVerts)
return false; return false;
m_context.AddAsset<AssetSkinnedVerts>(skinnedVerts->name, skinnedVerts); m_context.AddAsset<AssetSkinnedVerts>(skinnedVerts->name, skinnedVerts);
auto* gfxWorld = gfxWorldLinker.linkGfxWorld(bsp); // requires mapents asset auto* gfxWorld = gfxWorldLinker.LinkGfxWorld(bsp); // requires mapents asset
if (!gfxWorld) if (!gfxWorld)
return false; return false;
m_context.AddAsset<AssetGfxWorld>(gfxWorld->name, gfxWorld); m_context.AddAsset<AssetGfxWorld>(gfxWorld->name, gfxWorld);
auto* clipMap = clipMapLinker.linkClipMap(bsp); // requires gfxworld and mapents asset auto* clipMap = clipMapLinker.LinkClipMap(bsp); // requires gfxworld and mapents asset
if (!clipMap) if (!clipMap)
return false; return false;
m_context.AddAsset<AssetClipMap>(clipMap->name, clipMap); m_context.AddAsset<AssetClipMap>(clipMap->name, clipMap);

6
src/ObjLoading/Game/T6/BSP/Linker/BSPLinker.h
View File

@@ -12,11 +12,11 @@ namespace BSP
public: public:
BSPLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context); BSPLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context);
[[nodiscard]] bool linkBSP(const BSPData& bsp) const; [[nodiscard]] bool LinkBSP(const BSPData& bsp) const;
private: private:
void addEmptyFootstepTableAsset(const std::string& assetName) const; void AddEmptyFootstepTableAsset(const std::string& assetName) const;
[[nodiscard]] bool addDefaultRequiredAssets(const BSPData& bsp) const; [[nodiscard]] bool AddDefaultRequiredAssets(const BSPData& bsp) const;
MemoryManager& m_memory; MemoryManager& m_memory;
ISearchPath& m_search_path; ISearchPath& m_search_path;

62
src/ObjLoading/Game/T6/BSP/Linker/ClipMapLinker.cpp
View File

@@ -17,7 +17,7 @@ namespace BSP
{ {
} }
void ClipMapLinker::loadDynEnts(clipMap_t& clipMap) const void ClipMapLinker::LoadDynEnts(clipMap_t& clipMap) const
{ {
uint16_t dynEntCount = 0; uint16_t dynEntCount = 0;
clipMap.originalDynEntCount = dynEntCount; clipMap.originalDynEntCount = dynEntCount;
@@ -44,7 +44,7 @@ namespace BSP
clipMap.dynEntDefList[1] = nullptr; clipMap.dynEntDefList[1] = nullptr;
} }
void ClipMapLinker::loadVisibility(clipMap_t& clipMap) const void ClipMapLinker::LoadVisibility(clipMap_t& clipMap) const
{ {
// Only use one visbility cluster for the entire map // Only use one visbility cluster for the entire map
clipMap.numClusters = 1; clipMap.numClusters = 1;
@@ -55,7 +55,7 @@ namespace BSP
memset(clipMap.visibility, 0xFF, clipMap.clusterBytes); memset(clipMap.visibility, 0xFF, clipMap.clusterBytes);
} }
void ClipMapLinker::loadBoxData(clipMap_t& clipMap) const void ClipMapLinker::LoadBoxData(clipMap_t& clipMap) const
{ {
// box_model and box_brush are what are used by game traces as "temporary" collision when // box_model and box_brush are what are used by game traces as "temporary" collision when
// no brush or model is specified to do the trace with. // no brush or model is specified to do the trace with.
@@ -116,7 +116,7 @@ namespace BSP
clipMap.box_brush->verts = nullptr; clipMap.box_brush->verts = nullptr;
} }
void ClipMapLinker::loadRopesAndConstraints(clipMap_t& clipMap) const void ClipMapLinker::LoadRopesAndConstraints(clipMap_t& clipMap) const
{ {
clipMap.num_constraints = 0; // max 511 clipMap.num_constraints = 0; // max 511
clipMap.constraints = nullptr; clipMap.constraints = nullptr;
@@ -126,7 +126,7 @@ namespace BSP
clipMap.ropes = m_memory.Alloc<rope_t>(clipMap.max_ropes); clipMap.ropes = m_memory.Alloc<rope_t>(clipMap.max_ropes);
} }
void ClipMapLinker::loadSubModelCollision(clipMap_t& clipMap, const BSPData& bsp) const void ClipMapLinker::LoadSubModelCollision(clipMap_t& clipMap, const BSPData& bsp) const
{ {
// Submodels are used for the world and map ent collision (triggers, bomb zones, etc) // Submodels are used for the world and map ent collision (triggers, bomb zones, etc)
auto gfxWorldAsset = m_context.LoadDependency<AssetGfxWorld>(bsp.bspName); auto gfxWorldAsset = m_context.LoadDependency<AssetGfxWorld>(bsp.bspName);
@@ -165,7 +165,7 @@ namespace BSP
clipMap.cmodels[0].info = nullptr; // always set to 0 clipMap.cmodels[0].info = nullptr; // always set to 0
} }
void ClipMapLinker::loadXModelCollision(clipMap_t& clipMap) const void ClipMapLinker::LoadXModelCollision(clipMap_t& clipMap) const
{ {
// Right now XModels aren't supported // Right now XModels aren't supported
clipMap.numStaticModels = 0; clipMap.numStaticModels = 0;
@@ -215,11 +215,11 @@ namespace BSP
*/ */
} }
void ClipMapLinker::addAABBTreeFromLeaf(clipMap_t& clipMap, const BSPTree& tree, size_t& outParentCount, size_t& outParentStartIndex) void ClipMapLinker::AddAABBTreeFromLeaf(clipMap_t& clipMap, const BSPTree& tree, size_t& outParentCount, size_t& outParentStartIndex)
{ {
assert(tree.isLeaf); assert(tree.isLeaf);
size_t leafObjectCount = tree.leaf->getObjectCount(); size_t leafObjectCount = tree.leaf->GetObjectCount();
assert(leafObjectCount > 0); assert(leafObjectCount > 0);
highestLeafObjectCount = std::max(leafObjectCount, highestLeafObjectCount); highestLeafObjectCount = std::max(leafObjectCount, highestLeafObjectCount);
@@ -248,7 +248,7 @@ namespace BSP
vec3_t parentMaxs; vec3_t parentMaxs;
for (size_t objectIdx = 0; objectIdx < childObjectCount; objectIdx++) for (size_t objectIdx = 0; objectIdx < childObjectCount; objectIdx++)
{ {
int partitionIndex = tree.leaf->getObject(addedObjectCount + objectIdx)->partitionIndex; int partitionIndex = tree.leaf->GetObject(addedObjectCount + objectIdx)->partitionIndex;
CollisionPartition* partition = &clipMap.partitions[partitionIndex]; CollisionPartition* partition = &clipMap.partitions[partitionIndex];
for (int uindIdx = 0; uindIdx < partition->nuinds; uindIdx++) for (int uindIdx = 0; uindIdx < partition->nuinds; uindIdx++)
{ {
@@ -278,7 +278,7 @@ namespace BSP
// add child AABBs // add child AABBs
for (size_t objectIdx = 0; objectIdx < childObjectCount; objectIdx++) for (size_t objectIdx = 0; objectIdx < childObjectCount; objectIdx++)
{ {
int partitionIndex = tree.leaf->getObject(addedObjectCount + objectIdx)->partitionIndex; int partitionIndex = tree.leaf->GetObject(addedObjectCount + objectIdx)->partitionIndex;
CollisionPartition* partition = &clipMap.partitions[partitionIndex]; CollisionPartition* partition = &clipMap.partitions[partitionIndex];
vec3_t childMins; vec3_t childMins;
vec3_t childMaxs; vec3_t childMaxs;
@@ -327,7 +327,7 @@ namespace BSP
// Nodes are indexed by their index in the node array // Nodes are indexed by their index in the node array
// Leafs are indexed by (-1 - <leaf index>) // Leafs are indexed by (-1 - <leaf index>)
// See https://developer.valvesoftware.com/wiki/BSP_(Source) // See https://developer.valvesoftware.com/wiki/BSP_(Source)
int16_t ClipMapLinker::loadBSPNode(clipMap_t& clipMap, const BSPTree& tree) int16_t ClipMapLinker::LoadBSPNode(clipMap_t& clipMap, const BSPTree& tree)
{ {
if (tree.isLeaf) if (tree.isLeaf)
{ {
@@ -346,11 +346,11 @@ namespace BSP
leaf.maxs.z = 0.0f; leaf.maxs.z = 0.0f;
leaf.leafBrushNode = 0; leaf.leafBrushNode = 0;
if (tree.leaf->getObjectCount() > 0) if (tree.leaf->GetObjectCount() > 0)
{ {
size_t parentCount = 0; size_t parentCount = 0;
size_t parentStartIndex = 0; size_t parentStartIndex = 0;
addAABBTreeFromLeaf(clipMap, tree, parentCount, parentStartIndex); AddAABBTreeFromLeaf(clipMap, tree, parentCount, parentStartIndex);
leaf.collAabbCount = static_cast<uint16_t>(parentCount); leaf.collAabbCount = static_cast<uint16_t>(parentCount);
leaf.firstCollAabbIndex = static_cast<uint16_t>(parentStartIndex); leaf.firstCollAabbIndex = static_cast<uint16_t>(parentStartIndex);
} }
@@ -400,14 +400,14 @@ namespace BSP
planeVec.emplace_back(plane); planeVec.emplace_back(plane);
// The recursion of adding the children through loadBSPNode means the parent node needs to be added before the chilren are loaded // The recursion of adding the children through LoadBSPNode means the parent node needs to be added before the children are loaded
size_t nodeIndex = nodeVec.size(); size_t nodeIndex = nodeVec.size();
nodeVec.emplace_back(); nodeVec.emplace_back();
cNode_t node; cNode_t node;
node.plane = nullptr; // initialised after the BSP tree has been loaded node.plane = nullptr; // initialised after the BSP tree has been loaded
node.children[0] = loadBSPNode(clipMap, *tree.node->front); node.children[0] = LoadBSPNode(clipMap, *tree.node->front);
node.children[1] = loadBSPNode(clipMap, *tree.node->back); node.children[1] = LoadBSPNode(clipMap, *tree.node->back);
nodeVec.at(nodeIndex) = node; nodeVec.at(nodeIndex) = node;
@@ -415,7 +415,7 @@ namespace BSP
} }
} }
void ClipMapLinker::loadBSPTree(clipMap_t& clipMap, const BSPData& bsp) void ClipMapLinker::LoadBSPTree(clipMap_t& clipMap, const BSPData& bsp)
{ {
vec3_t worldMins; vec3_t worldMins;
vec3_t worldMaxs; vec3_t worldMaxs;
@@ -452,11 +452,11 @@ namespace BSP
} }
auto currObject = auto currObject =
std::make_shared<BSPObject>(partitionMins.x, partitionMins.y, partitionMins.z, partitionMaxs.x, partitionMaxs.y, partitionMaxs.z, partitionIdx); std::make_shared<BSPObject>(partitionMins.x, partitionMins.y, partitionMins.z, partitionMaxs.x, partitionMaxs.y, partitionMaxs.z, partitionIdx);
tree->addObjectToTree(std::move(currObject)); tree->AddObjectToTree(std::move(currObject));
} }
// load planes, nodes, leafs, and AABB trees // load planes, nodes, leafs, and AABB trees
loadBSPNode(clipMap, *tree); LoadBSPNode(clipMap, *tree);
clipMap.info.planeCount = static_cast<int>(planeVec.size()); clipMap.info.planeCount = static_cast<int>(planeVec.size());
clipMap.info.planes = m_memory.Alloc<cplane_s>(planeVec.size()); clipMap.info.planes = m_memory.Alloc<cplane_s>(planeVec.size());
@@ -481,7 +481,7 @@ namespace BSP
con::info("Highest leaf object count: {}", highestLeafObjectCount); con::info("Highest leaf object count: {}", highestLeafObjectCount);
} }
bool ClipMapLinker::loadPartitions(clipMap_t& clipMap, const BSPData& bsp) const bool ClipMapLinker::LoadPartitions(clipMap_t& clipMap, const BSPData& bsp) const
{ {
// due to tris using uint16_t as the type for indexing the vert array, // due to tris using uint16_t as the type for indexing the vert array,
// any vertex count over the uint16_t max means the vertices above the uint16_t max can't be indexed // any vertex count over the uint16_t max means the vertices above the uint16_t max can't be indexed
@@ -592,7 +592,7 @@ namespace BSP
*/ */
} }
bool ClipMapLinker::loadWorldCollision(clipMap_t& clipMap, const BSPData& bsp) bool ClipMapLinker::LoadWorldCollision(clipMap_t& clipMap, const BSPData& bsp)
{ {
// No support for brushes, only tris right now // No support for brushes, only tris right now
clipMap.info.numBrushSides = 0; clipMap.info.numBrushSides = 0;
@@ -609,15 +609,15 @@ namespace BSP
clipMap.info.brushContents = nullptr; clipMap.info.brushContents = nullptr;
// load verts, tris, uinds and partitions // load verts, tris, uinds and partitions
if (!loadPartitions(clipMap, bsp)) if (!LoadPartitions(clipMap, bsp))
return false; return false;
loadBSPTree(clipMap, bsp); LoadBSPTree(clipMap, bsp);
return true; return true;
} }
clipMap_t* ClipMapLinker::linkClipMap(const BSPData& bsp) clipMap_t* ClipMapLinker::LinkClipMap(const BSPData& bsp)
{ {
clipMap_t* clipMap = m_memory.Alloc<clipMap_t>(); clipMap_t* clipMap = m_memory.Alloc<clipMap_t>();
clipMap->name = m_memory.Dup(bsp.bspName.c_str()); clipMap->name = m_memory.Dup(bsp.bspName.c_str());
@@ -631,17 +631,17 @@ namespace BSP
assert(mapEntsAsset != nullptr); assert(mapEntsAsset != nullptr);
clipMap->mapEnts = mapEntsAsset->Asset(); clipMap->mapEnts = mapEntsAsset->Asset();
loadBoxData(*clipMap); LoadBoxData(*clipMap);
loadVisibility(*clipMap); LoadVisibility(*clipMap);
loadRopesAndConstraints(*clipMap); LoadRopesAndConstraints(*clipMap);
loadSubModelCollision(*clipMap, bsp); LoadSubModelCollision(*clipMap, bsp);
loadDynEnts(*clipMap); LoadDynEnts(*clipMap);
loadXModelCollision(*clipMap); LoadXModelCollision(*clipMap);
// Clipmap materials define the properties of a material (bullet penetration, no collision, water, etc) // Clipmap materials define the properties of a material (bullet penetration, no collision, water, etc)
// Right now there is no way to define properties per material so only one material is used // Right now there is no way to define properties per material so only one material is used
@@ -657,7 +657,7 @@ namespace BSP
clipMap->triEdgeIsWalkable = new char[walkableEdgeSize]; clipMap->triEdgeIsWalkable = new char[walkableEdgeSize];
memset(clipMap->triEdgeIsWalkable, 1, walkableEdgeSize * sizeof(char)); memset(clipMap->triEdgeIsWalkable, 1, walkableEdgeSize * sizeof(char));
if (!loadWorldCollision(*clipMap, bsp)) if (!LoadWorldCollision(*clipMap, bsp))
return nullptr; return nullptr;
return clipMap; return clipMap;

24
src/ObjLoading/Game/T6/BSP/Linker/ClipMapLinker.h
View File

@@ -13,21 +13,21 @@ namespace BSP
public: public:
ClipMapLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context); ClipMapLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context);
[[nodiscard]] T6::clipMap_t* linkClipMap(const BSPData& bsp); [[nodiscard]] T6::clipMap_t* LinkClipMap(const BSPData& bsp);
private: private:
void loadBoxData(T6::clipMap_t& clipMap) const; void LoadBoxData(T6::clipMap_t& clipMap) const;
void loadVisibility(T6::clipMap_t& clipMap) const; void LoadVisibility(T6::clipMap_t& clipMap) const;
void loadDynEnts(T6::clipMap_t& clipMap) const; void LoadDynEnts(T6::clipMap_t& clipMap) const;
void loadRopesAndConstraints(T6::clipMap_t& clipMap) const; void LoadRopesAndConstraints(T6::clipMap_t& clipMap) const;
void loadSubModelCollision(T6::clipMap_t& clipMap, const BSPData& bsp) const; void LoadSubModelCollision(T6::clipMap_t& clipMap, const BSPData& bsp) const;
void loadXModelCollision(T6::clipMap_t& clipMap) const; void LoadXModelCollision(T6::clipMap_t& clipMap) const;
void addAABBTreeFromLeaf(T6::clipMap_t& clipMap, const BSPTree& tree, size_t& out_parentCount, size_t& out_parentStartIndex); void AddAABBTreeFromLeaf(T6::clipMap_t& clipMap, const BSPTree& tree, size_t& outParentCount, size_t& outParentStartIndex);
int16_t loadBSPNode(T6::clipMap_t& clipMap, const BSPTree& tree); int16_t LoadBSPNode(T6::clipMap_t& clipMap, const BSPTree& tree);
void loadBSPTree(T6::clipMap_t& clipMap, const BSPData& bsp); void LoadBSPTree(T6::clipMap_t& clipMap, const BSPData& bsp);
bool loadPartitions(T6::clipMap_t& clipMap, const BSPData& bsp) const; bool LoadPartitions(T6::clipMap_t& clipMap, const BSPData& bsp) const;
bool loadWorldCollision(T6::clipMap_t& clipMap, const BSPData& bsp); bool LoadWorldCollision(T6::clipMap_t& clipMap, const BSPData& bsp);
MemoryManager& m_memory; MemoryManager& m_memory;
ISearchPath& m_search_path; ISearchPath& m_search_path;

2
src/ObjLoading/Game/T6/BSP/Linker/ComWorldLinker.cpp
View File

@@ -11,7 +11,7 @@ namespace BSP
{ {
} }
ComWorld* ComWorldLinker::linkComWorld(const BSPData& bsp) const ComWorld* ComWorldLinker::LinkComWorld(const BSPData& bsp) const
{ {
// all lights that aren't the sunlight or default light need their own GfxLightDef asset // all lights that aren't the sunlight or default light need their own GfxLightDef asset
ComWorld* comWorld = m_memory.Alloc<ComWorld>(); ComWorld* comWorld = m_memory.Alloc<ComWorld>();

2
src/ObjLoading/Game/T6/BSP/Linker/ComWorldLinker.h
View File

@@ -12,7 +12,7 @@ namespace BSP
public: public:
ComWorldLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context); ComWorldLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context);
[[nodiscard]] T6::ComWorld* linkComWorld(const BSPData& bsp) const; [[nodiscard]] T6::ComWorld* LinkComWorld(const BSPData& bsp) const;
private: private:
MemoryManager& m_memory; MemoryManager& m_memory;

2
src/ObjLoading/Game/T6/BSP/Linker/GameWorldMpLinker.cpp
View File

@@ -11,7 +11,7 @@ namespace BSP
{ {
} }
GameWorldMp* GameWorldMpLinker::linkGameWorldMp(const BSPData& bsp) const GameWorldMp* GameWorldMpLinker::LinkGameWorldMp(const BSPData& bsp) const
{ {
GameWorldMp* gameWorldMp = m_memory.Alloc<GameWorldMp>(); GameWorldMp* gameWorldMp = m_memory.Alloc<GameWorldMp>();

2
src/ObjLoading/Game/T6/BSP/Linker/GameWorldMpLinker.h
View File

@@ -12,7 +12,7 @@ namespace BSP
public: public:
GameWorldMpLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context); GameWorldMpLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context);
[[nodiscard]] T6::GameWorldMp* linkGameWorldMp(const BSPData& bsp) const; [[nodiscard]] T6::GameWorldMp* LinkGameWorldMp(const BSPData& bsp) const;
private: private:
MemoryManager& m_memory; MemoryManager& m_memory;

66
src/ObjLoading/Game/T6/BSP/Linker/GfxWorldLinker.cpp
View File

@@ -19,7 +19,7 @@ namespace BSP
{ {
} }
void GfxWorldLinker::loadDrawData(const BSPData& bsp, GfxWorld& gfxWorld) const void GfxWorldLinker::LoadDrawData(const BSPData& bsp, GfxWorld& gfxWorld) const
{ {
size_t vertexCount = bsp.gfxWorld.vertices.size(); size_t vertexCount = bsp.gfxWorld.vertices.size();
gfxWorld.draw.vertexCount = static_cast<unsigned int>(vertexCount); gfxWorld.draw.vertexCount = static_cast<unsigned int>(vertexCount);
@@ -57,9 +57,9 @@ namespace BSP
} }
} }
bool GfxWorldLinker::loadMapSurfaces(const BSPData& bsp, GfxWorld& gfxWorld) const bool GfxWorldLinker::LoadMapSurfaces(const BSPData& bsp, GfxWorld& gfxWorld) const
{ {
loadDrawData(bsp, gfxWorld); LoadDrawData(bsp, gfxWorld);
size_t surfaceCount = bsp.gfxWorld.surfaces.size(); size_t surfaceCount = bsp.gfxWorld.surfaces.size();
gfxWorld.surfaceCount = static_cast<int>(surfaceCount); gfxWorld.surfaceCount = static_cast<int>(surfaceCount);
@@ -157,7 +157,7 @@ namespace BSP
return true; return true;
} }
void GfxWorldLinker::loadXModels(const BSPData& bsp, GfxWorld& gfxWorld) const void GfxWorldLinker::LoadXModels(const BSPData& bsp, GfxWorld& gfxWorld) const
{ {
/* /*
Models are unsupported right now Models are unsupported right now
@@ -186,10 +186,10 @@ namespace BSP
currModel->placement.origin.x = inModel->origin.x; currModel->placement.origin.x = inModel->origin.x;
currModel->placement.origin.y = inModel->origin.y; currModel->placement.origin.y = inModel->origin.y;
currModel->placement.origin.z = inModel->origin.z; currModel->placement.origin.z = inModel->origin.z;
currModel->placement.origin = BSPUtil::convertToBO2Coords(currModel->placement.origin); currModel->placement.origin = ConvertToBO2Coords(currModel->placement.origin);
currModel->placement.scale = inModel->scale; currModel->placement.scale = inModel->scale;
BSPUtil::convertAnglesToAxis(&inModel->rotation, currModel->placement.axis); ConvertAnglesToAxis(&inModel->rotation, currModel->placement.axis);
// mins and maxs are calculated in world space not local space // mins and maxs are calculated in world space not local space
// TODO: this does not account for model rotation or scale // TODO: this does not account for model rotation or scale
@@ -252,7 +252,7 @@ namespace BSP
gfxWorld.dpvs.usageCount = 0; gfxWorld.dpvs.usageCount = 0;
} }
void GfxWorldLinker::cleanGfxWorld(GfxWorld& gfxWorld) const void GfxWorldLinker::CleanGfxWorld(GfxWorld& gfxWorld) const
{ {
// checksum is generated by the game // checksum is generated by the game
gfxWorld.checksum = 0; gfxWorld.checksum = 0;
@@ -338,7 +338,7 @@ namespace BSP
gfxWorld.sunLight = m_memory.Alloc<GfxLight>(); gfxWorld.sunLight = m_memory.Alloc<GfxLight>();
} }
void GfxWorldLinker::loadGfxLights(GfxWorld& gfxWorld) const void GfxWorldLinker::LoadGfxLights(GfxWorld& gfxWorld) const
{ {
// there must be 2 or more lights, first is the static light and second is the sun light // there must be 2 or more lights, first is the static light and second is the sun light
gfxWorld.primaryLightCount = BSPGameConstants::BSP_DEFAULT_LIGHT_COUNT; gfxWorld.primaryLightCount = BSPGameConstants::BSP_DEFAULT_LIGHT_COUNT;
@@ -367,7 +367,7 @@ namespace BSP
gfxWorld.primaryLightEntityShadowVis = nullptr; gfxWorld.primaryLightEntityShadowVis = nullptr;
} }
void GfxWorldLinker::loadLightGrid(GfxWorld& gfxWorld) const void GfxWorldLinker::LoadLightGrid(GfxWorld& gfxWorld) const
{ {
// there is almost no basis for the values in this code, they were chosen based on what looks correct when reverse engineering. // there is almost no basis for the values in this code, they were chosen based on what looks correct when reverse engineering.
@@ -425,7 +425,7 @@ namespace BSP
gfxWorld.lightGrid.skyGridVolumes = nullptr; gfxWorld.lightGrid.skyGridVolumes = nullptr;
} }
void GfxWorldLinker::loadGfxCells(GfxWorld& gfxWorld) const void GfxWorldLinker::LoadGfxCells(GfxWorld& gfxWorld) const
{ {
// Cells are basically data used to determine what can be seen and what cant be seen // Cells are basically data used to determine what can be seen and what cant be seen
// Right now custom maps have no optimisation so there is only 1 cell // Right now custom maps have no optimisation so there is only 1 cell
@@ -489,7 +489,7 @@ namespace BSP
gfxWorld.dpvsPlanes.planes = nullptr; gfxWorld.dpvsPlanes.planes = nullptr;
} }
void GfxWorldLinker::loadWorldBounds(GfxWorld& gfxWorld) const void GfxWorldLinker::LoadWorldBounds(GfxWorld& gfxWorld) const
{ {
gfxWorld.mins.x = 0.0f; gfxWorld.mins.x = 0.0f;
gfxWorld.mins.y = 0.0f; gfxWorld.mins.y = 0.0f;
@@ -504,7 +504,7 @@ namespace BSP
} }
} }
void GfxWorldLinker::loadModels(GfxWorld& gfxWorld) const void GfxWorldLinker::LoadModels(GfxWorld& gfxWorld) const
{ {
// Models (Submodels in the clipmap code) are used for the world and map ent collision (triggers, bomb zones, etc) // Models (Submodels in the clipmap code) are used for the world and map ent collision (triggers, bomb zones, etc)
// Right now there is only one submodel, the world sub model // Right now there is only one submodel, the world sub model
@@ -541,7 +541,7 @@ namespace BSP
//} //}
} }
void GfxWorldLinker::loadSunData(GfxWorld& gfxWorld) const void GfxWorldLinker::LoadSunData(GfxWorld& gfxWorld) const
{ {
// default values taken from mp_dig // default values taken from mp_dig
gfxWorld.sunParse.fogTransitionTime = 0.001f; gfxWorld.sunParse.fogTransitionTime = 0.001f;
@@ -587,7 +587,7 @@ namespace BSP
gfxWorld.sunParse.initWorldFog->sunFogYaw = 254.0f; gfxWorld.sunParse.initWorldFog->sunFogYaw = 254.0f;
} }
bool GfxWorldLinker::loadReflectionProbeData(GfxWorld& gfxWorld) const bool GfxWorldLinker::LoadReflectionProbeData(GfxWorld& gfxWorld) const
{ {
gfxWorld.draw.reflectionProbeCount = 1; gfxWorld.draw.reflectionProbeCount = 1;
@@ -627,7 +627,7 @@ namespace BSP
return true; return true;
} }
bool GfxWorldLinker::loadLightmapData(GfxWorld& gfxWorld) const bool GfxWorldLinker::LoadLightmapData(GfxWorld& gfxWorld) const
{ {
gfxWorld.draw.lightmapCount = 1; gfxWorld.draw.lightmapCount = 1;
@@ -648,7 +648,7 @@ namespace BSP
return true; return true;
} }
void GfxWorldLinker::loadSkyBox(const BSPData& projInfo, GfxWorld& gfxWorld) const void GfxWorldLinker::LoadSkyBox(const BSPData& projInfo, GfxWorld& gfxWorld) const
{ {
const auto skyBoxName = std::format("skybox_{}", projInfo.name); const auto skyBoxName = std::format("skybox_{}", projInfo.name);
gfxWorld.skyBoxModel = m_memory.Dup(skyBoxName.c_str()); gfxWorld.skyBoxModel = m_memory.Dup(skyBoxName.c_str());
@@ -665,7 +665,7 @@ namespace BSP
gfxWorld.skyDynIntensity.factor1 = 1.0f; gfxWorld.skyDynIntensity.factor1 = 1.0f;
} }
void GfxWorldLinker::loadDynEntData(GfxWorld& gfxWorld) const void GfxWorldLinker::LoadDynEntData(GfxWorld& gfxWorld) const
{ {
unsigned dynEntCount = 0u; unsigned dynEntCount = 0u;
gfxWorld.dpvsDyn.dynEntClientCount[0] = dynEntCount + 256; // the game allocs 256 empty dynents, as they may be used ingame gfxWorld.dpvsDyn.dynEntClientCount[0] = dynEntCount + 256; // the game allocs 256 empty dynents, as they may be used ingame
@@ -697,7 +697,7 @@ namespace BSP
gfxWorld.sceneDynBrush = nullptr; gfxWorld.sceneDynBrush = nullptr;
} }
bool GfxWorldLinker::loadOutdoors(GfxWorld& gfxWorld) const bool GfxWorldLinker::LoadOutdoors(GfxWorld& gfxWorld) const
{ {
const auto xRecip = 1.0f / (gfxWorld.maxs.x - gfxWorld.mins.x); const auto xRecip = 1.0f / (gfxWorld.maxs.x - gfxWorld.mins.x);
const auto xScale = -(xRecip * gfxWorld.mins.x); const auto xScale = -(xRecip * gfxWorld.mins.x);
@@ -729,7 +729,7 @@ namespace BSP
return true; return true;
} }
GfxWorld* GfxWorldLinker::linkGfxWorld(const BSPData& bsp) const GfxWorld* GfxWorldLinker::LinkGfxWorld(const BSPData& bsp) const
{ {
GfxWorld* gfxWorld = m_memory.Alloc<GfxWorld>(); GfxWorld* gfxWorld = m_memory.Alloc<GfxWorld>();
gfxWorld->baseName = m_memory.Dup(bsp.name.c_str()); gfxWorld->baseName = m_memory.Dup(bsp.name.c_str());
@@ -739,39 +739,39 @@ namespace BSP
gfxWorld->lightingFlags = 0; gfxWorld->lightingFlags = 0;
gfxWorld->lightingQuality = 4096; gfxWorld->lightingQuality = 4096;
cleanGfxWorld(*gfxWorld); CleanGfxWorld(*gfxWorld);
if (!loadMapSurfaces(bsp, *gfxWorld)) if (!LoadMapSurfaces(bsp, *gfxWorld))
return nullptr; return nullptr;
loadXModels(bsp, *gfxWorld); LoadXModels(bsp, *gfxWorld);
if (!loadLightmapData(*gfxWorld)) if (!LoadLightmapData(*gfxWorld))
return nullptr; return nullptr;
loadSkyBox(bsp, *gfxWorld); LoadSkyBox(bsp, *gfxWorld);
if (!loadReflectionProbeData(*gfxWorld)) if (!LoadReflectionProbeData(*gfxWorld))
return nullptr; return nullptr;
// world bounds are based on loaded surface mins/maxs // world bounds are based on loaded surface mins/maxs
loadWorldBounds(*gfxWorld); LoadWorldBounds(*gfxWorld);
if (!loadOutdoors(*gfxWorld)) if (!LoadOutdoors(*gfxWorld))
return nullptr; return nullptr;
// gfx cells depend on surface/smodel count // gfx cells depend on surface/smodel count
loadGfxCells(*gfxWorld); LoadGfxCells(*gfxWorld);
loadLightGrid(*gfxWorld); LoadLightGrid(*gfxWorld);
loadGfxLights(*gfxWorld); LoadGfxLights(*gfxWorld);
loadModels(*gfxWorld); LoadModels(*gfxWorld);
loadSunData(*gfxWorld); LoadSunData(*gfxWorld);
loadDynEntData(*gfxWorld); LoadDynEntData(*gfxWorld);
return gfxWorld; return gfxWorld;
} }

32
src/ObjLoading/Game/T6/BSP/Linker/GfxWorldLinker.h
View File

@@ -12,24 +12,24 @@ namespace BSP
public: public:
GfxWorldLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context); GfxWorldLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context);
[[nodiscard]] T6::GfxWorld* linkGfxWorld(const BSPData& bsp) const; [[nodiscard]] T6::GfxWorld* LinkGfxWorld(const BSPData& bsp) const;
private: private:
void loadDrawData(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const; void LoadDrawData(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const;
bool loadMapSurfaces(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const; bool LoadMapSurfaces(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const;
void loadXModels(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const; void LoadXModels(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const;
void cleanGfxWorld(T6::GfxWorld& gfxWorld) const; void CleanGfxWorld(T6::GfxWorld& gfxWorld) const;
void loadGfxLights(T6::GfxWorld& gfxWorld) const; void LoadGfxLights(T6::GfxWorld& gfxWorld) const;
void loadLightGrid(T6::GfxWorld& gfxWorld) const; void LoadLightGrid(T6::GfxWorld& gfxWorld) const;
void loadGfxCells(T6::GfxWorld& gfxWorld) const; void LoadGfxCells(T6::GfxWorld& gfxWorld) const;
void loadModels(T6::GfxWorld& gfxWorld) const; void LoadModels(T6::GfxWorld& gfxWorld) const;
bool loadReflectionProbeData(T6::GfxWorld& gfxWorld) const; bool LoadReflectionProbeData(T6::GfxWorld& gfxWorld) const;
bool loadLightmapData(T6::GfxWorld& gfxWorld) const; bool LoadLightmapData(T6::GfxWorld& gfxWorld) const;
void loadSkyBox(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const; void LoadSkyBox(const BSPData& projInfo, T6::GfxWorld& gfxWorld) const;
void loadDynEntData(T6::GfxWorld& gfxWorld) const; void LoadDynEntData(T6::GfxWorld& gfxWorld) const;
bool loadOutdoors(T6::GfxWorld& gfxWorld) const; bool LoadOutdoors(T6::GfxWorld& gfxWorld) const;
void loadSunData(T6::GfxWorld& gfxWorld) const; void LoadSunData(T6::GfxWorld& gfxWorld) const;
void loadWorldBounds(T6::GfxWorld& gfxWorld) const; void LoadWorldBounds(T6::GfxWorld& gfxWorld) const;
MemoryManager& m_memory; MemoryManager& m_memory;
ISearchPath& m_search_path; ISearchPath& m_search_path;

2
src/ObjLoading/Game/T6/BSP/Linker/MapEntsLinker.cpp
View File

@@ -72,7 +72,7 @@ namespace BSP
{ {
} }
MapEnts* MapEntsLinker::linkMapEnts(const BSPData& bsp) const MapEnts* MapEntsLinker::LinkMapEnts(const BSPData& bsp) const
{ {
try try
{ {

2
src/ObjLoading/Game/T6/BSP/Linker/MapEntsLinker.h
View File

@@ -12,7 +12,7 @@ namespace BSP
public: public:
MapEntsLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context); MapEntsLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context);
[[nodiscard]] T6::MapEnts* linkMapEnts(const BSPData& bsp) const; [[nodiscard]] T6::MapEnts* LinkMapEnts(const BSPData& bsp) const;
private: private:
MemoryManager& m_memory; MemoryManager& m_memory;

2
src/ObjLoading/Game/T6/BSP/Linker/SkinnedVertsLinker.cpp
View File

@@ -9,7 +9,7 @@ namespace BSP
{ {
} }
T6::SkinnedVertsDef* SkinnedVertsLinker::linkSkinnedVerts(const BSPData& bsp) const T6::SkinnedVertsDef* SkinnedVertsLinker::LinkSkinnedVerts(const BSPData& bsp) const
{ {
// Pretty sure maxSkinnedVerts relates to the max amount of xmodel skinned verts a map will have // Pretty sure maxSkinnedVerts relates to the max amount of xmodel skinned verts a map will have
// But setting it to the world vertex count seems to work // But setting it to the world vertex count seems to work

2
src/ObjLoading/Game/T6/BSP/Linker/SkinnedVertsLinker.h
View File

@@ -12,7 +12,7 @@ namespace BSP
public: public:
SkinnedVertsLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context); SkinnedVertsLinker(MemoryManager& memory, ISearchPath& searchPath, AssetCreationContext& context);
[[nodiscard]] T6::SkinnedVertsDef* linkSkinnedVerts(const BSPData& bsp) const; [[nodiscard]] T6::SkinnedVertsDef* LinkSkinnedVerts(const BSPData& bsp) const;
private: private:
MemoryManager& m_memory; MemoryManager& m_memory;

4
src/ObjLoading/Game/T6/BSP/LoaderBSP_T6.cpp
View File

@@ -32,12 +32,12 @@ namespace
bool FinalizeZone(AssetCreationContext& context) override bool FinalizeZone(AssetCreationContext& context) override
{ {
const auto bsp = BSP::createBSPData(m_zone.m_name, m_search_path); const auto bsp = CreateBSPData(m_zone.m_name, m_search_path);
if (!bsp) if (!bsp)
return false; return false;
BSPLinker linker(m_memory, m_search_path, context); BSPLinker linker(m_memory, m_search_path, context);
const auto result = linker.linkBSP(*bsp); const auto result = linker.LinkBSP(*bsp);
if (!result) if (!result)
con::error("BSP link has failed."); con::error("BSP link has failed.");