Mirrored_Repos/DarkflameServer
1
0
Fork 0
mirror of https://github.com/DarkflameUniverse/DarkflameServer.git synced 2025-12-11 18:48:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

better algo for finding what scene we are in

Browse Source
This commit is contained in:
Aaron Kimbrell
2025-10-16 01:19:05 -05:00
parent 09ca19383c
commit ae20974c36
2 changed files with 140 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

104
dGame/dUtilities/SlashCommands/DEVGMCommands.cpp
View File

@@ -1951,21 +1951,49 @@ namespace DEVGMCommands {
return;
}
// Get the pre-generated terrain mesh
const auto& terrainMesh = zone->GetTerrainMesh();
if (terrainMesh.vertices.empty()) {
ChatPackets::SendSystemMessage(sysAddr, u"Zone does not have valid terrain mesh data.");
// Get the Raw terrain data
const auto& raw = zone->GetZoneRaw();
if (raw.chunks.empty()) {
ChatPackets::SendSystemMessage(sysAddr, u"Zone does not have valid terrain data.");
return;
}
// Spawn at ALL vertices in the current scene without any filtering or spacing
// Spawn at all sceneMap points in the current scene
uint32_t spawnedCount = 0;
for (const auto& vertex : terrainMesh.vertices) {
// Check if this vertex belongs to the current scene
if (LWOSCENEID(vertex.sceneID) == currentSceneID) {
// Use the vertex position
NiPoint3 spawnPos = vertex.position;
for (const auto& chunk : raw.chunks) {
if (chunk.sceneMap.empty() || chunk.colorMapResolution == 0 || chunk.heightMap.empty()) continue;
// Iterate through the heightmap (same as GenerateTerrainMesh)
for (uint32_t i = 0; i < chunk.width; ++i) {
for (uint32_t j = 0; j < chunk.height; ++j) {
// Get height at this position
const uint32_t heightIndex = chunk.width * i + j;
if (heightIndex >= chunk.heightMap.size()) continue;
const float y = chunk.heightMap[heightIndex];
// Map heightmap position to scene map position (same as GenerateTerrainMesh)
const float sceneMapI = (static_cast<float>(i) / static_cast<float>(chunk.width - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
const float sceneMapJ = (static_cast<float>(j) / static_cast<float>(chunk.height - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
const uint32_t sceneI = std::min(static_cast<uint32_t>(sceneMapI), chunk.colorMapResolution - 1);
const uint32_t sceneJ = std::min(static_cast<uint32_t>(sceneMapJ), chunk.colorMapResolution - 1);
const uint32_t sceneIndex = sceneI * chunk.colorMapResolution + sceneJ;
uint8_t sceneID = 0;
if (sceneIndex < chunk.sceneMap.size()) {
sceneID = chunk.sceneMap[sceneIndex];
}
// Check if this point belongs to the current scene
if (sceneID == currentSceneID.GetSceneID()) {
// Calculate world position (same as GenerateTerrainMesh)
const float worldX = (static_cast<float>(i) + (chunk.offsetWorldX / chunk.scaleFactor)) * chunk.scaleFactor;
const float worldY = (y / chunk.scaleFactor) * chunk.scaleFactor;
const float worldZ = (static_cast<float>(j) + (chunk.offsetWorldZ / chunk.scaleFactor)) * chunk.scaleFactor;
NiPoint3 spawnPos(worldX, worldY, worldZ);
EntityInfo info;
info.lot = lot + currentSceneID.GetSceneID(); // to differentiate scenes
@@ -1983,6 +2011,8 @@ namespace DEVGMCommands {
}
}
}
}
}
if (spawnedCount == 0) {
std::ostringstream feedback;
@@ -2011,23 +2041,55 @@ namespace DEVGMCommands {
return;
}
// Get the pre-generated terrain mesh
const auto& terrainMesh = zone->GetTerrainMesh();
if (terrainMesh.vertices.empty()) {
ChatPackets::SendSystemMessage(sysAddr, u"Zone does not have valid terrain mesh data.");
// Get the Raw terrain data
const auto& raw = zone->GetZoneRaw();
if (raw.chunks.empty()) {
ChatPackets::SendSystemMessage(sysAddr, u"Zone does not have valid terrain data.");
return;
}
// Spawn at ALL vertices without any filtering or spacing restrictions for maximum accuracy
// Spawn at all sceneMap points across all scenes
uint32_t spawnedCount = 0;
std::map<uint8_t, uint32_t> sceneSpawnCounts; // Track spawns per scene
for (const auto& vertex : terrainMesh.vertices) {
for (const auto& chunk : raw.chunks) {
if (chunk.sceneMap.empty() || chunk.colorMapResolution == 0 || chunk.heightMap.empty()) continue;
// Iterate through the heightmap (same as GenerateTerrainMesh)
for (uint32_t i = 0; i < chunk.width; ++i) {
for (uint32_t j = 0; j < chunk.height; ++j) {
// Get height at this position
const uint32_t heightIndex = chunk.width * i + j;
if (heightIndex >= chunk.heightMap.size()) continue;
const float y = chunk.heightMap[heightIndex];
// Map heightmap position to scene map position (same as GenerateTerrainMesh)
const float sceneMapI = (static_cast<float>(i) / static_cast<float>(chunk.width - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
const float sceneMapJ = (static_cast<float>(j) / static_cast<float>(chunk.height - 1)) * static_cast<float>(chunk.colorMapResolution - 1);
const uint32_t sceneI = std::min(static_cast<uint32_t>(sceneMapI), chunk.colorMapResolution - 1);
const uint32_t sceneJ = std::min(static_cast<uint32_t>(sceneMapJ), chunk.colorMapResolution - 1);
const uint32_t sceneIndex = sceneI * chunk.colorMapResolution + sceneJ;
uint8_t sceneID = 0;
if (sceneIndex < chunk.sceneMap.size()) {
sceneID = chunk.sceneMap[sceneIndex];
}
// Skip invalid scenes (scene ID 0 typically means no scene)
if (vertex.sceneID == 0) continue;
if (sceneID == 0) continue;
// Calculate world position (same as GenerateTerrainMesh)
const float worldX = (static_cast<float>(i) + (chunk.offsetWorldX / chunk.scaleFactor)) * chunk.scaleFactor;
const float worldY = (y / chunk.scaleFactor) * chunk.scaleFactor;
const float worldZ = (static_cast<float>(j) + (chunk.offsetWorldZ / chunk.scaleFactor)) * chunk.scaleFactor;
NiPoint3 spawnPos(worldX, worldY, worldZ);
EntityInfo info;
info.lot = lot + vertex.sceneID; // to show different scenes
info.pos = vertex.position;
info.lot = lot + sceneID; // to show different scenes
info.pos = spawnPos;
info.rot = QuatUtils::IDENTITY;
info.spawner = nullptr;
info.spawnerID = entity->GetObjectID();
@@ -2038,7 +2100,9 @@ namespace DEVGMCommands {
if (newEntity != nullptr) {
Game::entityManager->ConstructEntity(newEntity);
spawnedCount++;
sceneSpawnCounts[vertex.sceneID]++;
sceneSpawnCounts[sceneID]++;
}
}
}
}

61
dZoneManager/dZoneManager.cpp
View File

@@ -308,46 +308,49 @@ LWOSCENEID dZoneManager::GetSceneIDFromPosition(const NiPoint3& position) const
const auto& terrainMesh = m_pZone->GetTerrainMesh();
// If mesh is empty, no scene data available
if (terrainMesh.vertices.empty() || terrainMesh.triangles.empty()) {
// If no chunks, no scene data available
if (raw.chunks.empty()) {
return LWOSCENEID_INVALID;
}
// Find the triangle containing this position (ignoring Y coordinate for scene lookup)
// We iterate through all triangles and find the one that contains the point in 2D (XZ plane)
for (size_t i = 0; i < terrainMesh.triangles.size(); i += 3) {
const auto& v0 = terrainMesh.vertices[terrainMesh.triangles[i]];
const auto& v1 = terrainMesh.vertices[terrainMesh.triangles[i + 1]];
const auto& v2 = terrainMesh.vertices[terrainMesh.triangles[i + 2]];
// Find the chunk containing this position
// Reverse the world position calculation from GenerateTerrainMesh
for (const auto& chunk : raw.chunks) {
if (chunk.sceneMap.empty()) continue;
// Check if position is inside this triangle using 2D (XZ) coordinates
// Using barycentric coordinates / cross product method
const float x = position.x;
const float z = position.z;
// Reverse: worldX = (i + offsetWorldX/scaleFactor) * scaleFactor
// Therefore: i = worldX/scaleFactor - offsetWorldX/scaleFactor
const float heightI = position.x / chunk.scaleFactor - (chunk.offsetWorldX / chunk.scaleFactor);
const float heightJ = position.z / chunk.scaleFactor - (chunk.offsetWorldZ / chunk.scaleFactor);
const float x0 = v0.position.x;
const float z0 = v0.position.z;
const float x1 = v1.position.x;
const float z1 = v1.position.z;
const float x2 = v2.position.x;
const float z2 = v2.position.z;
// Check if position is within this chunk's heightmap bounds
if (heightI >= 0.0f && heightI < chunk.width &&
heightJ >= 0.0f && heightJ < chunk.height) {
// Calculate barycentric coordinates
const float denom = (z1 - z2) * (x0 - x2) + (x2 - x1) * (z0 - z2);
if (std::abs(denom) < 0.0001f) continue; // Degenerate triangle
// Map heightmap position to scene map position (same as GenerateTerrainMesh)
const float sceneMapI = (heightI / (chunk.width - 1)) * (chunk.colorMapResolution - 1);
const float sceneMapJ = (heightJ / (chunk.height - 1)) * (chunk.colorMapResolution - 1);
const float a = ((z1 - z2) * (x - x2) + (x2 - x1) * (z - z2)) / denom;
const float b = ((z2 - z0) * (x - x2) + (x0 - x2) * (z - z2)) / denom;
const float c = 1.0f - a - b;
const uint32_t sceneI = std::min(static_cast<uint32_t>(sceneMapI), chunk.colorMapResolution - 1);
const uint32_t sceneJ = std::min(static_cast<uint32_t>(sceneMapJ), chunk.colorMapResolution - 1);
// Point is inside triangle if all barycentric coordinates are non-negative
if (a >= 0.0f && b >= 0.0f && c >= 0.0f) {
// Return the scene ID from the first vertex (all vertices in a triangle should have the same scene ID)
return LWOSCENEID(v0.sceneID);
// Scene map uses the same indexing pattern as heightmap: row * width + col
const uint32_t sceneIndex = sceneI * chunk.colorMapResolution + sceneJ;
// Bounds check
if (sceneIndex >= chunk.sceneMap.size()) {
return LWOSCENEID_INVALID;
}
// Get scene ID from sceneMap
const uint8_t sceneID = chunk.sceneMap[sceneIndex];
// Return the scene ID
return LWOSCENEID(sceneID, 0);
}
}
// Position not found in any triangle
// Position not found in any chunk
return LWOSCENEID_INVALID;
}