AVA2 builds with ENABLE_MAP_OBJECT_OPTIMIZATION: CArea:: __UpdateLoadedObjectInstances unloads objects whose 2D distance from the main actor is at least max(OBJECT_DIST, 5000). CPythonBackground::Update now takes the main actor position (as CPythonApplication passes it) and sets that loading center on MapObjectManager, which skips farther objects before their frustum test. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
435 lines
17 KiB
C++
435 lines
17 KiB
C++
#include "MapObjectManager.h"
|
|
#include <limits>
|
|
#include "src/eter_render/SpeedTreeForest.h"
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
|
|
namespace ava2 {
|
|
|
|
static void ComputeObjectOBB(MapObjectInstance& obj);
|
|
|
|
namespace {
|
|
|
|
inline void MakeFullTransformMatrix(float yawDeg, float pitchDeg, float rollDeg,
|
|
float tx, float ty, float tz, float scale, float* out) {
|
|
float ry = yawDeg * 3.14159265358979323846f / 180.0f;
|
|
float rx = pitchDeg * 3.14159265358979323846f / 180.0f;
|
|
float rz = rollDeg * 3.14159265358979323846f / 180.0f;
|
|
|
|
float cy = std::cos(ry), sy = std::sin(ry);
|
|
float cx = std::cos(rx), sx = std::sin(rx);
|
|
float cz = std::cos(rz), sz = std::sin(rz);
|
|
|
|
// Composite Euler rotation matrix (YXZ / YawPitchRoll)
|
|
out[0] = (cy * cz + sy * sx * sz) * scale;
|
|
out[1] = (cx * sz) * scale;
|
|
out[2] = (-sy * cz + cy * sx * sz) * scale;
|
|
out[3] = 0.0f;
|
|
|
|
out[4] = (-cy * sz + sy * sx * cz) * scale;
|
|
out[5] = (cx * cz) * scale;
|
|
out[6] = (sy * sz + cy * sx * cz) * scale;
|
|
out[7] = 0.0f;
|
|
|
|
out[8] = (sy * cx) * scale;
|
|
out[9] = (-sx) * scale;
|
|
out[10] = (cy * cx) * scale;
|
|
out[11] = 0.0f;
|
|
|
|
out[12] = tx;
|
|
out[13] = ty;
|
|
out[14] = tz;
|
|
out[15] = 1.0f;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
MapObjectManager::MapObjectManager() = default;
|
|
|
|
std::string MapObjectManager::NormalizePath(const std::string& path) {
|
|
std::string p = path;
|
|
std::replace(p.begin(), p.end(), '\\', '/');
|
|
|
|
// Strip drive letter if present (e.g., "d:/", "D:/")
|
|
if (p.size() >= 3 && (p[1] == ':' && p[2] == '/')) {
|
|
p = p.substr(3);
|
|
}
|
|
while (!p.empty() && p.front() == '/') {
|
|
p.erase(p.begin());
|
|
}
|
|
|
|
if (std::filesystem::exists(p)) return p;
|
|
if (std::filesystem::exists("build/dev/" + p)) return "build/dev/" + p;
|
|
if (std::filesystem::exists("../" + p)) return "../" + p;
|
|
return p;
|
|
}
|
|
|
|
void MapObjectManager::RegisterProperty(uint32_t crc, const std::string& model_path) {
|
|
m_property_map[crc] = model_path;
|
|
}
|
|
|
|
size_t MapObjectManager::ScanPropertyDirectory(const std::string& prop_dir) {
|
|
if (!std::filesystem::exists(prop_dir)) return 0;
|
|
|
|
size_t count = 0;
|
|
for (const auto& entry : std::filesystem::recursive_directory_iterator(prop_dir, std::filesystem::directory_options::skip_permission_denied)) {
|
|
if (!entry.is_regular_file()) continue;
|
|
auto ext = entry.path().extension().string();
|
|
if (ext != ".prb" && ext != ".prt") continue;
|
|
|
|
std::ifstream file(entry.path());
|
|
if (!file.is_open()) continue;
|
|
|
|
std::string line;
|
|
if (!std::getline(file, line) || line.find("YPRT") == std::string::npos) continue;
|
|
|
|
std::string crc_line;
|
|
if (!std::getline(file, crc_line)) continue;
|
|
|
|
try {
|
|
uint32_t crc = static_cast<uint32_t>(std::stoul(crc_line));
|
|
std::string model_file;
|
|
while (std::getline(file, line)) {
|
|
if (line.find("file") != std::string::npos) {
|
|
size_t first = line.find('"');
|
|
size_t last = line.rfind('"');
|
|
if (first != std::string::npos && last != std::string::npos && last > first) {
|
|
model_file = line.substr(first + 1, last - first - 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (!model_file.empty()) {
|
|
m_property_map[crc] = model_file;
|
|
count++;
|
|
}
|
|
} catch (...) {
|
|
continue;
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
std::shared_ptr<Gr2ModelInstance> MapObjectManager::GetOrLoadModel(const std::string& path) {
|
|
std::string norm = NormalizePath(path);
|
|
auto it = m_model_cache.find(norm);
|
|
if (it != m_model_cache.end()) return it->second;
|
|
|
|
if (!std::filesystem::exists(norm)) {
|
|
return nullptr;
|
|
}
|
|
|
|
auto inst = Gr2ModelInstance::Load(norm);
|
|
if (inst) {
|
|
m_model_cache[norm] = std::move(inst);
|
|
return m_model_cache[norm];
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
bool MapObjectManager::LoadAreaData(const std::string& areadata_path, float coord_scale, SpeedTreeForest* forest, bool native_y) {
|
|
std::ifstream file(areadata_path);
|
|
if (!file.is_open()) {
|
|
std::cerr << "MapObjectManager::LoadAreaData failed to open: " << areadata_path << std::endl;
|
|
return false;
|
|
}
|
|
|
|
std::string line;
|
|
bool in_object = false;
|
|
std::vector<std::string> block_lines;
|
|
size_t loaded_count = 0;
|
|
|
|
while (std::getline(file, line)) {
|
|
// Strip trailing CR
|
|
if (!line.empty() && line.back() == '\r') line.pop_back();
|
|
|
|
if (line.find("Start Object") != std::string::npos) {
|
|
in_object = true;
|
|
block_lines.clear();
|
|
continue;
|
|
}
|
|
|
|
if (line.find("End Object") != std::string::npos) {
|
|
in_object = false;
|
|
if (block_lines.size() >= 2) {
|
|
// Line 0: X Y Z
|
|
// Line 1: CRC
|
|
// Line 2 (optional): pitch#roll#yaw or yaw
|
|
// Line 3 (optional): height bias
|
|
float px = 0.0f, py = 0.0f, pz = 0.0f;
|
|
uint32_t crc = 0;
|
|
float yaw = 0.0f, pitch = 0.0f, roll = 0.0f;
|
|
float bias = 0.0f;
|
|
|
|
std::istringstream iss(block_lines[0]);
|
|
iss >> px >> py >> pz;
|
|
// AVA2 areadata stores the render-space Y sign; packets use positive map Y.
|
|
if (native_y) py = -py;
|
|
|
|
try {
|
|
crc = static_cast<uint32_t>(std::stoul(block_lines[1]));
|
|
} catch (...) {
|
|
continue;
|
|
}
|
|
|
|
if (block_lines.size() > 2) {
|
|
std::string rot_str = block_lines[2];
|
|
size_t s1 = rot_str.find('#');
|
|
if (s1 != std::string::npos) {
|
|
yaw = std::stof(rot_str.substr(0, s1));
|
|
size_t s2 = rot_str.find('#', s1 + 1);
|
|
if (s2 != std::string::npos) {
|
|
pitch = std::stof(rot_str.substr(s1 + 1, s2 - s1 - 1));
|
|
roll = std::stof(rot_str.substr(s2 + 1));
|
|
if (native_y) {
|
|
// Native roll rotates about Z (up); that is engine Y yaw.
|
|
const float nativeYaw = yaw;
|
|
yaw = roll;
|
|
roll = -nativeYaw;
|
|
}
|
|
}
|
|
} else {
|
|
try { yaw = std::stof(rot_str); } catch (...) {}
|
|
}
|
|
}
|
|
|
|
if (block_lines.size() > 3) {
|
|
try { bias = std::stof(block_lines[3]); } catch (...) {}
|
|
}
|
|
|
|
if (forest && forest->HasMainTree(crc)) {
|
|
forest->CreateInstance(px * coord_scale, (pz + bias) * coord_scale, py * coord_scale, crc, yaw, coord_scale);
|
|
loaded_count++;
|
|
continue;
|
|
}
|
|
|
|
auto prop_it = m_property_map.find(crc);
|
|
if (prop_it != m_property_map.end()) {
|
|
const std::string& mfile = prop_it->second;
|
|
if (forest && (mfile.find(".spt") != std::string::npos || mfile.find(".SPT") != std::string::npos)) {
|
|
forest->CreateInstance(px * coord_scale, (pz + bias) * coord_scale, py * coord_scale, crc, yaw, coord_scale, mfile.c_str());
|
|
loaded_count++;
|
|
continue;
|
|
}
|
|
|
|
auto model = GetOrLoadModel(mfile);
|
|
if (model) {
|
|
MapObjectInstance obj;
|
|
obj.model_path = mfile;
|
|
obj.property_crc = crc;
|
|
obj.x = px * coord_scale;
|
|
obj.y = (pz + bias) * coord_scale;
|
|
obj.z = py * coord_scale;
|
|
obj.yaw = yaw;
|
|
obj.pitch = pitch;
|
|
obj.roll = roll;
|
|
obj.scale = coord_scale;
|
|
obj.model = model;
|
|
ComputeObjectOBB(obj);
|
|
m_objects.push_back(std::move(obj));
|
|
loaded_count++;
|
|
}
|
|
}
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (in_object) {
|
|
// Trim leading spaces
|
|
size_t start = line.find_first_not_of(" \t");
|
|
if (start != std::string::npos) {
|
|
block_lines.push_back(line.substr(start));
|
|
}
|
|
}
|
|
}
|
|
|
|
return loaded_count > 0 || !m_objects.empty();
|
|
}
|
|
|
|
static void ComputeObjectOBB(MapObjectInstance& obj) {
|
|
if (!obj.model) {
|
|
obj.has_collision = false;
|
|
return;
|
|
}
|
|
float minX = 0, minY = 0, minZ = 0, maxX = 0, maxY = 0, maxZ = 0;
|
|
if (obj.model->GetLocalBounds(minX, minY, minZ, maxX, maxY, maxZ)) {
|
|
float scale = obj.scale;
|
|
float hx = (maxX - minX) * 0.5f * scale;
|
|
float hy = (maxY - minY) * 0.5f * scale;
|
|
float hz = (maxZ - minZ) * 0.5f * scale;
|
|
if (hx < 10.0f && hz < 10.0f) {
|
|
obj.has_collision = false;
|
|
return;
|
|
}
|
|
obj.obb.halfExtents[0] = hx;
|
|
obj.obb.halfExtents[1] = hy;
|
|
obj.obb.halfExtents[2] = hz;
|
|
float cxLocal = (minX + maxX) * 0.5f * scale;
|
|
float cyLocal = (minY + maxY) * 0.5f * scale;
|
|
float czLocal = (minZ + maxZ) * 0.5f * scale;
|
|
|
|
float yawRad = obj.yaw * (3.14159265f / 180.0f);
|
|
obj.obb.yawRad = yawRad;
|
|
float cosY = std::cos(yawRad);
|
|
float sinY = std::sin(yawRad);
|
|
obj.obb.centerX = obj.x + (cxLocal * cosY - czLocal * sinY);
|
|
obj.obb.centerY = obj.y + cyLocal;
|
|
obj.obb.centerZ = obj.z + (cxLocal * sinY + czLocal * cosY);
|
|
obj.has_collision = true;
|
|
} else {
|
|
obj.has_collision = false;
|
|
}
|
|
}
|
|
|
|
bool MapObjectManager::AddObject(const std::string& model_path, float x, float y, float z,
|
|
float yaw, float pitch, float roll, float scale) {
|
|
auto model = GetOrLoadModel(model_path);
|
|
if (!model) return false;
|
|
|
|
MapObjectInstance obj;
|
|
obj.model_path = model_path;
|
|
obj.x = x;
|
|
obj.y = y;
|
|
obj.z = z;
|
|
obj.yaw = yaw;
|
|
obj.pitch = pitch;
|
|
obj.roll = roll;
|
|
obj.scale = scale;
|
|
obj.model = model;
|
|
ComputeObjectOBB(obj);
|
|
m_objects.push_back(std::move(obj));
|
|
return true;
|
|
}
|
|
|
|
const std::vector<size_t>& MapObjectManager::CollisionCandidates(float x,float z,float radius) const {
|
|
constexpr double cell=512;
|
|
if(m_collisionCount!=m_objects.size()) {
|
|
m_collisionCells.clear();m_largeCollisionObjects.clear();m_allCollisionObjects.clear();
|
|
for(size_t i=0;i<m_objects.size();++i) {
|
|
const auto& obj=m_objects[i];if(!obj.has_collision)continue;
|
|
m_allCollisionObjects.push_back(i);
|
|
const double r=std::max(std::abs(obj.obb.halfExtents[0]),std::abs(obj.obb.halfExtents[2]))*1.5;
|
|
const double cx=obj.obb.centerX,cz=obj.obb.centerZ;
|
|
if(!std::isfinite(r) || !std::isfinite(cx) || !std::isfinite(cz) || std::abs(cx)+r>1e9 || std::abs(cz)+r>1e9 || r>4096) {
|
|
m_largeCollisionObjects.push_back(i);continue;
|
|
}
|
|
const auto x0=int64_t(std::floor((cx-r)/cell)),x1=int64_t(std::floor((cx+r)/cell));
|
|
const auto z0=int64_t(std::floor((cz-r)/cell)),z1=int64_t(std::floor((cz+r)/cell));
|
|
if((x1-x0+1)*(z1-z0+1)>256){m_largeCollisionObjects.push_back(i);continue;}
|
|
for(auto gx=x0;gx<=x1;++gx)for(auto gz=z0;gz<=z1;++gz)m_collisionCells[{gx,gz}].push_back(i);
|
|
}
|
|
m_collisionCount=m_objects.size();
|
|
}
|
|
m_collisionCandidates.clear();
|
|
if(!std::isfinite(x) || !std::isfinite(z) || !std::isfinite(radius) || radius<0 || radius>4096 || std::abs(double(x))+radius>1e9 || std::abs(double(z))+radius>1e9) {
|
|
m_collisionCandidates=m_allCollisionObjects;return m_collisionCandidates;
|
|
}
|
|
m_collisionCandidates.insert(m_collisionCandidates.end(),m_largeCollisionObjects.begin(),m_largeCollisionObjects.end());
|
|
const auto x0=int64_t(std::floor((double(x)-radius)/cell)),x1=int64_t(std::floor((double(x)+radius)/cell));
|
|
const auto z0=int64_t(std::floor((double(z)-radius)/cell)),z1=int64_t(std::floor((double(z)+radius)/cell));
|
|
for(auto gx=x0;gx<=x1;++gx)for(auto gz=z0;gz<=z1;++gz) {
|
|
auto it=m_collisionCells.find({gx,gz});if(it!=m_collisionCells.end())m_collisionCandidates.insert(m_collisionCandidates.end(),it->second.begin(),it->second.end());
|
|
}
|
|
// Preserve the original first-hit normal when OBBs overlap, independent of cell order.
|
|
std::sort(m_collisionCandidates.begin(),m_collisionCandidates.end());
|
|
m_collisionCandidates.erase(std::unique(m_collisionCandidates.begin(),m_collisionCandidates.end()),m_collisionCandidates.end());
|
|
return m_collisionCandidates;
|
|
}
|
|
|
|
bool MapObjectManager::CheckCollision(float worldX, float worldZ, float actorRadius) const {
|
|
for (auto index : CollisionCandidates(worldX,worldZ,actorRadius)) {
|
|
const auto& obj=m_objects[index];
|
|
if (!obj.has_collision) continue;
|
|
float maxR = std::max(obj.obb.halfExtents[0], obj.obb.halfExtents[2]) * 1.5f + actorRadius;
|
|
float dx = worldX - obj.obb.centerX;
|
|
float dz = worldZ - obj.obb.centerZ;
|
|
if (dx * dx + dz * dz > maxR * maxR) continue;
|
|
|
|
if (obj.obb.IntersectsCircle2D(worldX, worldZ, actorRadius)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool MapObjectManager::CheckCollisionNormal(float worldX, float worldZ, float actorRadius, float& outNx, float& outNz) const {
|
|
for (auto index : CollisionCandidates(worldX,worldZ,actorRadius)) {
|
|
const auto& obj=m_objects[index];
|
|
if (!obj.has_collision) continue;
|
|
float maxR = std::max(obj.obb.halfExtents[0], obj.obb.halfExtents[2]) * 1.5f + actorRadius;
|
|
float dx = worldX - obj.obb.centerX;
|
|
float dz = worldZ - obj.obb.centerZ;
|
|
if (dx * dx + dz * dz > maxR * maxR) continue;
|
|
|
|
float pen = 0.0f;
|
|
if (obj.obb.GetPenetrationAndNormal(worldX, worldZ, actorRadius, outNx, outNz, pen)) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::vector<Render3DDraw> MapObjectManager::BuildDrawCommands(const float* view, const float* proj) const {
|
|
std::vector<Render3DDrawRef> refs;
|
|
AppendDrawRefs(view, proj, 0, refs);
|
|
std::vector<Render3DDraw> all_draws;
|
|
all_draws.reserve(refs.size());
|
|
for (const auto& ref : refs) all_draws.push_back(*ref.draw);
|
|
return all_draws;
|
|
}
|
|
|
|
void MapObjectManager::AppendDrawRefs(const float* view, const float* proj, std::size_t before, std::vector<Render3DDrawRef>& out,
|
|
const float* light_direction, const float* light_ambient) const {
|
|
for (const auto& obj : m_objects) {
|
|
if (!obj.model) continue;
|
|
if (m_maxDistanceSq > 0.0f) {
|
|
const float dx = obj.x - m_centerX, dz = obj.z - m_centerZ;
|
|
if (dx * dx + dz * dz >= m_maxDistanceSq) continue;
|
|
}
|
|
|
|
float world[16];
|
|
MakeFullTransformMatrix(obj.yaw, obj.pitch, obj.roll, obj.x, obj.y, obj.z, obj.scale, world);
|
|
if (!obj.draws_cached) {
|
|
obj.cached_draws = obj.model->BuildDrawCommands(-1.0f, world, true);
|
|
std::fill_n(obj.bounds_min, 3, std::numeric_limits<float>::max());
|
|
std::fill_n(obj.bounds_max, 3, std::numeric_limits<float>::lowest());
|
|
for (const auto& draw : obj.cached_draws) {
|
|
for (size_t i=0; i+2<draw.positions.size(); i+=3) {
|
|
for (int axis=0; axis<3; ++axis) {
|
|
float v = draw.positions[i]*draw.world[axis] + draw.positions[i+1]*draw.world[4+axis] +
|
|
draw.positions[i+2]*draw.world[8+axis] + draw.world[12+axis];
|
|
obj.bounds_min[axis] = std::min(obj.bounds_min[axis], v);
|
|
obj.bounds_max[axis] = std::max(obj.bounds_max[axis], v);
|
|
}
|
|
}
|
|
}
|
|
auto& streams=m_meshStreams[obj.model.get()];
|
|
for (size_t i=0;i<obj.cached_draws.size();++i) {
|
|
auto& draw=obj.cached_draws[i];
|
|
draw=Render3DDraw::ShareGeometry(std::move(draw));
|
|
if(i<streams.size()) draw.geometry=streams[i];
|
|
else streams.push_back(draw.geometry);
|
|
}
|
|
obj.draws_cached = true;
|
|
}
|
|
if (!IsBoundsVisible(obj.bounds_min, obj.bounds_max, view, proj)) continue;
|
|
for (auto& draw : obj.cached_draws) {
|
|
if (light_direction) std::copy_n(light_direction, 3, draw.light_direction);
|
|
if (light_ambient) std::copy_n(light_ambient, 3, draw.light_ambient);
|
|
out.push_back({before, &draw});
|
|
}
|
|
}
|
|
}
|
|
|
|
void MapObjectManager::ClearObjects() {
|
|
m_objects.clear();
|
|
m_collisionCount=std::numeric_limits<size_t>::max();
|
|
m_collisionCells.clear();m_allCollisionObjects.clear();m_largeCollisionObjects.clear();m_collisionCandidates.clear();
|
|
}
|
|
|
|
} // namespace ava2
|