zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2026-06-06 00:32:34 +00:00
Code Activity

feat: zone volumes now use brushes instead of terrain to define their boundaries

Browse Source
This commit is contained in:
LJW-Dev
2026-04-13 20:21:05 +08:00
committed by Jan Laupetin
parent 2ea3db4adf
commit 5dcbb03f18
5 changed files with 243 additions and 80 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/ObjLoading/Game/T6/BSP/BSP.h
+14 -1
View File
@@ -62,9 +62,17 @@ namespace BSP
bool doesCastShadow;
};
struct BSPBoxBrush
{
vec3_t localMins;
vec3_t localMaxs;
int surfaceFlags;
int contentFlags;
};
struct BSPWorld
{
std::vector<BSPSurface> staticSurfaces;
std::vector<BSPSurface> scriptSurfaces;
@@ -72,6 +80,8 @@ namespace BSP
std::vector<uint16_t> indices;
std::vector<BSPMaterial> materials;
std::vector<BSPXModel> xmodels;
std::vector<BSPBoxBrush> scriptBoxBrushes;
};
enum BSPLightType
@@ -145,6 +155,9 @@ namespace BSP
size_t surfaceIndex;
size_t surfaceCount;
bool hasBrush;
size_t brushIndex;
};
struct BSPData
src/ObjLoading/Game/T6/BSP/BSPCreator.cpp
+91 -2
View File
@@ -665,7 +665,94 @@ namespace
return true;
}
size_t addScriptModel(const JsonRoot& jRoot, const gltf::JsonNode& node)
size_t addScriptBrushModel(const JsonRoot& jRoot, const gltf::JsonNode& node)
{
if (!node.mesh || !jRoot.meshes)
throw new GltfLoadException("Script model created with no mesh data");
Eigen::Matrix4f nodeMatrix = createNodeMatrix(node);
const auto& mesh = jRoot.meshes.value()[node.mesh.value()];
if (mesh.primitives.size() == 0)
throw new GltfLoadException("Script model created with no mesh data");
BSPModel model;
model.isGfxModel = m_is_world_gfx;
model.surfaceIndex = 0;
model.surfaceCount = 0;
model.hasBrush = true;
model.brushIndex = m_curr_bsp_world->scriptBoxBrushes.size();
m_bsp->models.emplace_back(model);
BSPBoxBrush boxBrush;
boxBrush.contentFlags = 1;
boxBrush.surfaceFlags = 1;
vec3_t worldMins;
vec3_t worldMaxs;
for (size_t primIdx = 0; primIdx < mesh.primitives.size(); primIdx++)
{
const auto& primitive = mesh.primitives.at(primIdx);
if (!primitive.attributes.POSITION)
throw GltfLoadException("Requires primitives attribute POSITION");
// clang-format off
const auto* positionAccessor = GetAccessorForIndex(
"POSITION",
primitive.attributes.POSITION,
{ JsonAccessorType::VEC3 },
{ JsonAccessorComponentType::FLOAT }
).value_or(nullptr);
// clang-format on
assert(positionAccessor != nullptr);
if (positionAccessor->GetCount() == 0)
throw GltfLoadException("positionAccessor has count of 0");
for (size_t vertexIndex = 0u; vertexIndex < positionAccessor->GetCount(); vertexIndex++)
{
vec3_t vertex;
if (!positionAccessor->GetFloatVec3(vertexIndex, vertex.v))
assert(false);
Eigen::Vector4f position(vertex.x, vertex.y, vertex.z, 1.0f);
Eigen::Vector4f transformedPosition = nodeMatrix * position;
vertex.x = transformedPosition.x();
vertex.y = transformedPosition.y();
vertex.z = transformedPosition.z();
RhcToLhcCoordinates(vertex.v);
if (vertexIndex == 0 && primIdx == 0)
{
worldMins = vertex;
worldMaxs = vertex;
}
else
BSPUtil::updateAABBWithPoint(vertex, worldMins, worldMaxs);
}
}
// convert world position to local position
Eigen::Vector4f position(0, 0, 0, 1.0f);
Eigen::Vector4f transformedPosition = nodeMatrix * position;
vec3_t origin;
origin.x = transformedPosition.x();
origin.y = transformedPosition.y();
origin.z = transformedPosition.z();
RhcToLhcCoordinates(origin.v);
boxBrush.localMins.x = worldMins.x - origin.x;
boxBrush.localMins.y = worldMins.y - origin.y;
boxBrush.localMins.z = worldMins.z - origin.z;
boxBrush.localMaxs.x = worldMaxs.x - origin.x;
boxBrush.localMaxs.y = worldMaxs.y - origin.y;
boxBrush.localMaxs.z = worldMaxs.z - origin.z;
m_curr_bsp_world->scriptBoxBrushes.emplace_back(boxBrush);
return m_bsp->models.size(); // script model index starts at 1
}
size_t addScriptTerrainModel(const JsonRoot& jRoot, const gltf::JsonNode& node)
{
if (!node.mesh || !jRoot.meshes)
throw new GltfLoadException("Script model created with no mesh data");
@@ -680,6 +767,8 @@ namespace
model.isGfxModel = m_is_world_gfx;
model.surfaceIndex = m_curr_bsp_world->scriptSurfaces.size();
model.surfaceCount = mesh.primitives.size();
model.hasBrush = false;
model.brushIndex = 0;
m_bsp->models.emplace_back(model);
for (const auto& primitive : mesh.primitives)
@@ -735,7 +824,7 @@ namespace
zone.zoneName = *node.extras->zone;
zone.zSpawnerGroupName = node.extras->zspawner_group.value_or("");
zone.spawnpointGroupName = node.extras->spawnpoint_group.value_or("");
zone.modelIndex = addScriptModel(jRoot, node);
zone.modelIndex = addScriptBrushModel(jRoot, node);
m_bsp->zZones.emplace_back(zone);
return true;
src/ObjLoading/Game/T6/BSP/Linker/ClipMapLinker.cpp
+134 -76
View File
@@ -243,17 +243,98 @@ namespace BSP
for (size_t modelIdx = 0; modelIdx < bsp->models.size(); modelIdx++)
{
auto clipModel = &clipMap->cmodels[modelIdx + 1];
auto& bspMpdel = bsp->models.at(modelIdx);
auto& bspModel = bsp->models.at(modelIdx);
if (bspMpdel.isGfxModel)
if (bspModel.isGfxModel)
{
memset(clipModel, 0, sizeof(cmodel_t));
continue;
}
if (bspModel.surfaceCount != 0)
{
std::vector<int> partitionIndexes;
for (size_t surfIdx = 0; surfIdx < bspModel.surfaceCount; surfIdx++)
{
ColSurface& surf = collisionSurfaceVec.at(bsp->colWorld.staticSurfaces.size() + bspModel.surfaceIndex + surfIdx);
for (size_t partitionIdx = 0; partitionIdx < surf.partitionCount; partitionIdx++)
{
size_t clipMapPartitionIndex = surf.partitionStartIndex + partitionIdx;
partitionIndexes.emplace_back(clipMapPartitionIndex);
vec3_t mins;
vec3_t maxs;
calculatePartitionAABB(clipMap, &clipMap->partitions[clipMapPartitionIndex], mins, maxs);
if (surfIdx == 0 && partitionIdx == 0)
{
clipModel->mins = mins;
clipModel->maxs = maxs;
}
else
BSPUtil::updateAABB(mins, maxs, clipModel->mins, clipModel->maxs);
}
}
int terrainContents = 0;
size_t firstCollAabbIndex = 0;
size_t collAabbCount = 0;
addAABBTreeFromPartitions(clipMap, partitionIndexes, &collAabbCount, &firstCollAabbIndex, &terrainContents);
clipModel->leaf.terrainContents = terrainContents;
clipModel->leaf.firstCollAabbIndex = static_cast<uint16_t>(firstCollAabbIndex);
clipModel->leaf.collAabbCount = static_cast<uint16_t>(collAabbCount);
}
else
{
clipModel->leaf.terrainContents = 0;
clipModel->leaf.firstCollAabbIndex = 0;
clipModel->leaf.collAabbCount = 0;
}
if (bspModel.hasBrush)
{
BSPBoxBrush& bspBrush = bsp->colWorld.scriptBoxBrushes.at(bspModel.brushIndex);
clipModel->leaf.mins = bspBrush.localMins;
clipModel->leaf.maxs = bspBrush.localMaxs;
clipModel->leaf.brushContents = bspBrush.contentFlags;
clipModel->leaf.leafBrushNode = static_cast<int>(brushNodeVec.size());
assert(clipModel->leaf.leafBrushNode != 0);
cLeafBrushNode_s brushNode;
brushNode.axis = 0;
brushNode.contents = bspBrush.contentFlags;
brushNode.leafBrushCount = 1;
brushNode.data.leaf.brushes = m_memory.Alloc<LeafBrush>(1);
brushNode.data.leaf.brushes[0] = static_cast<unsigned short>(brushVec.size());
brushNodeVec.emplace_back(brushNode);
cbrush_array_t brush;
memset(&brush, 0, sizeof(cbrush_array_t)); // if not sides or verts are given, the mins/maxs are used instead
brush.contents = bspBrush.contentFlags;
brush.mins = bspBrush.localMins;
brush.maxs = bspBrush.localMaxs;
brush.axial_cflags[0][0] = bspBrush.contentFlags;
brush.axial_cflags[0][1] = bspBrush.contentFlags;
brush.axial_cflags[0][2] = bspBrush.contentFlags;
brush.axial_cflags[1][0] = bspBrush.contentFlags;
brush.axial_cflags[1][1] = bspBrush.contentFlags;
brush.axial_cflags[1][2] = bspBrush.contentFlags;
brush.axial_sflags[0][0] = bspBrush.surfaceFlags;
brush.axial_sflags[0][1] = bspBrush.surfaceFlags;
brush.axial_sflags[0][2] = bspBrush.surfaceFlags;
brush.axial_sflags[1][0] = bspBrush.surfaceFlags;
brush.axial_sflags[1][1] = bspBrush.surfaceFlags;
brush.axial_sflags[1][2] = bspBrush.surfaceFlags;
brushVec.emplace_back(brush);
if (bspModel.surfaceCount != 0)
BSPUtil::updateAABB(bspBrush.localMins, bspBrush.localMaxs, clipModel->mins, clipModel->maxs);
else
{
clipModel->mins = bspBrush.localMins;
clipModel->maxs = bspBrush.localMaxs;
}
}
else
{
clipModel->mins.x = 0.0f;
clipModel->mins.y = 0.0f;
clipModel->mins.z = 0.0f;
clipModel->maxs.x = 0.0f;
clipModel->maxs.y = 0.0f;
clipModel->maxs.z = 0.0f;
clipModel->radius = 0.0f;
clipModel->leaf.brushContents = 0;
clipModel->leaf.mins.x = 0.0f;
clipModel->leaf.mins.y = 0.0f;
@@ -262,50 +343,16 @@ namespace BSP
clipModel->leaf.maxs.y = 0.0f;
clipModel->leaf.maxs.z = 0.0f;
clipModel->leaf.leafBrushNode = 0;
clipModel->leaf.cluster = 0;
clipModel->info = nullptr;
continue;
}
std::vector<int> partitionIndexes;
for (size_t surfIdx = 0; surfIdx < bspMpdel.surfaceCount; surfIdx++)
if (bspModel.surfaceCount == 0 && !bspModel.hasBrush)
{
ColSurface& surf = collisionSurfaceVec.at(bsp->colWorld.staticSurfaces.size() + bspMpdel.surfaceIndex + surfIdx);
for (size_t partitionIdx = 0; partitionIdx < surf.partitionCount; partitionIdx++)
{
size_t clipMapPartitionIndex = surf.partitionStartIndex + partitionIdx;
partitionIndexes.emplace_back(clipMapPartitionIndex);
vec3_t mins;
vec3_t maxs;
calculatePartitionAABB(clipMap, &clipMap->partitions[clipMapPartitionIndex], mins, maxs);
if (surfIdx == 0 && partitionIdx == 0)
{
clipModel->mins = mins;
clipModel->maxs = maxs;
}
else
BSPUtil::updateAABB(mins, maxs, clipModel->mins, clipModel->maxs);
}
clipModel->mins = {0.0f, 0.0f, 0.0f};
clipModel->maxs = {0.0f, 0.0f, 0.0f};
clipModel->radius = 0.0f;
}
clipModel->radius = BSPUtil::distBetweenPoints(clipModel->mins, clipModel->maxs) / 2;
int terrainContents = 0;
size_t firstCollAabbIndex = 0;
size_t collAabbCount = 0;
addAABBTreeFromPartitions(clipMap, partitionIndexes, &collAabbCount, &firstCollAabbIndex, &terrainContents);
clipModel->leaf.terrainContents = terrainContents;
clipModel->leaf.firstCollAabbIndex = static_cast<uint16_t>(firstCollAabbIndex);
clipModel->leaf.collAabbCount = static_cast<uint16_t>(collAabbCount);
// no brush
clipModel->leaf.brushContents = 0;
clipModel->leaf.mins.x = 0.0f;
clipModel->leaf.mins.y = 0.0f;
clipModel->leaf.mins.z = 0.0f;
clipModel->leaf.maxs.x = 0.0f;
clipModel->leaf.maxs.y = 0.0f;
clipModel->leaf.maxs.z = 0.0f;
clipModel->leaf.leafBrushNode = 0;
else
clipModel->radius = BSPUtil::distBetweenPoints(clipModel->mins, clipModel->maxs) / 2;
clipModel->leaf.cluster = 0;
clipModel->info = nullptr;
}
@@ -607,22 +654,6 @@ namespace BSP
// load planes, nodes, leafs, and AABB trees
loadBSPNode(clipMap, tree.get(), true);
clipMap->info.planeCount = static_cast<int>(planeVec.size());
clipMap->info.planes = m_memory.Alloc<cplane_s>(planeVec.size());
memcpy(clipMap->info.planes, planeVec.data(), sizeof(cplane_s) * planeVec.size());
clipMap->numNodes = static_cast<unsigned int>(nodeVec.size());
clipMap->nodes = m_memory.Alloc<cNode_t>(nodeVec.size());
memcpy(clipMap->nodes, nodeVec.data(), sizeof(cNode_t) * nodeVec.size());
clipMap->numLeafs = static_cast<unsigned int>(leafVec.size());
clipMap->leafs = m_memory.Alloc<cLeaf_s>(leafVec.size());
memcpy(clipMap->leafs, leafVec.data(), sizeof(cLeaf_s) * leafVec.size());
// The plane of each node have the same index
for (size_t nodeIdx = 0; nodeIdx < nodeVec.size(); nodeIdx++)
clipMap->nodes[nodeIdx].plane = &clipMap->info.planes[nodeIdx];
con::info("Highest AABB tree partition count: {}", highestPartitionCountForAABB);
return true;
@@ -724,17 +755,21 @@ namespace BSP
// No support for brushes, only tris right now
clipMap->info.numBrushSides = 0;
clipMap->info.brushsides = nullptr;
clipMap->info.leafbrushNodesCount = 0;
clipMap->info.leafbrushNodes = nullptr;
clipMap->info.numLeafBrushes = 0;
clipMap->info.leafbrushes = nullptr;
clipMap->info.numBrushVerts = 0;
clipMap->info.brushVerts = nullptr;
clipMap->info.numBrushes = 0;
clipMap->info.brushes = nullptr;
clipMap->info.brushBounds = nullptr;
clipMap->info.brushContents = nullptr;
// first brush node is always empty
cLeafBrushNode_s tempNode;
memset(&tempNode, 0, sizeof(cLeafBrushNode_s));
brushNodeVec.emplace_back(tempNode);
clipMap->info.numBrushes = 0;
clipMap->info.brushes = nullptr;
// load verts, tris, uinds and partitions
if (!loadPartitions(clipMap, bsp))
return false;
@@ -742,6 +777,36 @@ namespace BSP
if (!loadBSPTree(clipMap, bsp))
return false;
loadSubModelCollision(clipMap, bsp); // requires tri verts
clipMap->info.planeCount = static_cast<int>(planeVec.size());
clipMap->info.planes = m_memory.Alloc<cplane_s>(planeVec.size());
memcpy(clipMap->info.planes, planeVec.data(), sizeof(cplane_s) * planeVec.size());
clipMap->numNodes = static_cast<unsigned int>(nodeVec.size());
clipMap->nodes = m_memory.Alloc<cNode_t>(nodeVec.size());
memcpy(clipMap->nodes, nodeVec.data(), sizeof(cNode_t) * nodeVec.size());
clipMap->numLeafs = static_cast<unsigned int>(leafVec.size());
clipMap->leafs = m_memory.Alloc<cLeaf_s>(leafVec.size());
memcpy(clipMap->leafs, leafVec.data(), sizeof(cLeaf_s) * leafVec.size());
clipMap->aabbTreeCount = static_cast<unsigned int>(AABBTreeVec.size());
clipMap->aabbTrees = m_memory.Alloc<CollisionAabbTree>(AABBTreeVec.size());
memcpy(clipMap->aabbTrees, AABBTreeVec.data(), sizeof(CollisionAabbTree) * AABBTreeVec.size());
clipMap->info.leafbrushNodesCount = static_cast<unsigned int>(brushNodeVec.size());
clipMap->info.leafbrushNodes = m_memory.Alloc<cLeafBrushNode_s>(brushNodeVec.size());
memcpy(clipMap->info.leafbrushNodes, brushNodeVec.data(), sizeof(cLeafBrushNode_s) * brushNodeVec.size());
clipMap->info.numBrushes = static_cast<uint16_t>(brushVec.size());
clipMap->info.brushes = m_memory.Alloc<cbrush_array_t>(brushVec.size());
memcpy(clipMap->info.brushes, brushVec.data(), sizeof(cbrush_array_t) * brushVec.size());
// The plane of each node have the same index
for (size_t nodeIdx = 0; nodeIdx < nodeVec.size(); nodeIdx++)
clipMap->nodes[nodeIdx].plane = &clipMap->info.planes[nodeIdx];
return true;
}
@@ -801,19 +866,12 @@ namespace BSP
if (!loadWorldCollision(clipMap, bsp)) // requires materials
return nullptr;
loadSubModelCollision(clipMap, bsp); // requires tri verts
// set all edges to walkable
// might do weird stuff on walls, but from testing doesnt seem to do anything
int walkableEdgeSize = (3 * clipMap->triCount + 31) / 32 * 4;
clipMap->triEdgeIsWalkable = m_memory.Alloc<char>(walkableEdgeSize);
memset(clipMap->triEdgeIsWalkable, 1, walkableEdgeSize * sizeof(char));
// multiple functions add to AABBTreeVec, so it is added to the clipmap last
clipMap->aabbTreeCount = static_cast<unsigned int>(AABBTreeVec.size());
clipMap->aabbTrees = m_memory.Alloc<CollisionAabbTree>(AABBTreeVec.size());
memcpy(clipMap->aabbTrees, AABBTreeVec.data(), sizeof(CollisionAabbTree) * AABBTreeVec.size());
return clipMap;
}
} // namespace BSP
src/ObjLoading/Game/T6/BSP/Linker/ClipMapLinker.h
+3
View File
@@ -39,6 +39,9 @@ namespace BSP
std::vector<CollisionAabbTree> AABBTreeVec;
size_t highestPartitionCountForAABB = 0;
std::vector<cLeafBrushNode_s> brushNodeVec;
std::vector<cbrush_array_t> brushVec;
std::vector<ColSurface> collisionSurfaceVec;
std::vector<size_t> partitionToColSurfaceMap;
src/ObjLoading/Game/T6/BSP/Linker/GfxWorldLinker.cpp
+1 -1
View File
@@ -587,7 +587,7 @@ namespace BSP
auto currEntModel = &gfxWorld->models[modelIdx + 1];
auto& bspModel = bsp->models.at(modelIdx);
if (bspModel.isGfxModel)
if (bspModel.isGfxModel && bspModel.surfaceCount != 0)
{
currEntModel->startSurfIndex = bsp->gfxWorld.staticSurfaces.size() + bspModel.surfaceIndex;
currEntModel->surfaceCount = bspModel.surfaceCount;