Orkuncakilkaya
b368912c78
The user's walk showed the footprint rising outside the Ludic heap. Jolt's bytes were already counted; the navmesh's were not, so nothing could see them. Now: - ludic.nav nav_heap_test: fifty crossings of a four-tile map by the resident index hold the tiles in and the native bytes to the first crossing's; a thousand crowd walkers in and out grow nothing; a reset gives back every byte the mesh took. - ludic.physics cross_heap_test: a 1 km map of 64 m chunks kept to a ring round a player crossing corner to corner and back, each chunk a heightfield, twelve owned posts and six owned scaled hulls as the game makes them: six more crossings hold the bodies, the shapes and Jolt's bytes and peak exactly. (A post made as an offset of a cylinder, with only the offset owned, leaked the cylinder every time: the game's solid_pillar owns its cylinder directly.) lib/macos-arm64 rebuilt; lib/windows-x64 needs native/build.sh run on the PC for the new exports. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
95 lines
3.4 KiB
C++
95 lines
3.4 KiB
C++
// nav_shim.cpp - ludic.nav's door into Recast & Detour (phase 17). The shim rules of
|
|
// packages/README.md: int, float and opaque handles cross; no struct by value, no callback into
|
|
// Ludic; what a query finds is written into a buffer the package owns; errors are return codes.
|
|
#include <Recast.h>
|
|
#include <DetourNavMesh.h>
|
|
#include <DetourNavMeshBuilder.h>
|
|
#include <DetourNavMeshQuery.h>
|
|
#include <DetourCommon.h>
|
|
#include <DetourCrowd.h>
|
|
#include <RecastAlloc.h>
|
|
#include <DetourAlloc.h>
|
|
#include <cstring>
|
|
#include <cstdlib>
|
|
#include <cmath>
|
|
#include <vector>
|
|
|
|
#if defined(_WIN32)
|
|
#define NAV_SHIM extern "C" __declspec(dllexport)
|
|
#else
|
|
#define NAV_SHIM extern "C" __attribute__((visibility("default")))
|
|
#endif
|
|
|
|
#include "nav_alloc.inl"
|
|
|
|
#ifdef _WIN32
|
|
extern "C" __declspec(dllimport) int __stdcall QueryPerformanceCounter(long long *);
|
|
extern "C" __declspec(dllimport) int __stdcall QueryPerformanceFrequency(long long *);
|
|
#else
|
|
#include <time.h>
|
|
#endif
|
|
|
|
namespace {
|
|
// a monotonic clock in nanoseconds, from the OS alone (KERNEL32 on Windows: no C++ runtime to ship)
|
|
long long nav_now_ns() {
|
|
#ifdef _WIN32
|
|
long long c = 0, f = 1;
|
|
QueryPerformanceCounter(&c);
|
|
QueryPerformanceFrequency(&f);
|
|
return (long long)((double)c * 1e9 / (double)f);
|
|
#else
|
|
struct timespec t;
|
|
clock_gettime(CLOCK_MONOTONIC, &t);
|
|
return (long long)t.tv_sec * 1000000000LL + t.tv_nsec;
|
|
#endif
|
|
}
|
|
const int NAV_MAX_POLYS = 512; // polygons a path may cross; a longer one is cut there
|
|
const int NAV_MAX_NODES = 4096; // the search's open list
|
|
const int NAV_FILTERS = 8; // costs per kind of ground: one set per kind of walker's taste
|
|
|
|
// one tile of a file-backed mesh (nav_resident.inl): its cell, where its bytes are, whether it is in
|
|
struct NavTileRec {
|
|
int x = 0, y = 0, size = 0;
|
|
long long offset = 0;
|
|
unsigned long long ref = 0;
|
|
bool in = false;
|
|
};
|
|
|
|
// a navmesh and the one query that walks it, with the scratch a path needs
|
|
struct Nav {
|
|
dtNavMesh *mesh = nullptr;
|
|
dtNavMeshQuery *query = nullptr;
|
|
dtQueryFilter filters[NAV_FILTERS];
|
|
float ext[3] = {2.0f, 4.0f, 2.0f}; // how far to look for the mesh around a point
|
|
dtPolyRef polys[NAV_MAX_POLYS];
|
|
int partial = 0; // the last path stopped short of its end
|
|
long long ns = 0; // time spent finding paths, for the measure (17.10)
|
|
std::vector<NavTileRec> tiles; // a file-backed mesh's index; empty for a built or loaded one
|
|
};
|
|
|
|
// a navmesh with its query, from params (a set of tiles) or from one tile's data
|
|
Nav *nav_open(dtNavMesh *mesh) {
|
|
Nav *n = new Nav();
|
|
n->mesh = mesh;
|
|
n->query = dtAllocNavMeshQuery();
|
|
if (!n->query || dtStatusFailed(n->query->init(n->mesh, NAV_MAX_NODES))) { dtFreeNavMeshQuery(n->query); dtFreeNavMesh(n->mesh); delete n; return nullptr; }
|
|
for (int f = 0; f < NAV_FILTERS; ++f) {
|
|
n->filters[f].setIncludeFlags(0xffff);
|
|
n->filters[f].setExcludeFlags(0);
|
|
}
|
|
return n;
|
|
}
|
|
Nav *nav_from(unsigned char *data, int size) {
|
|
dtNavMesh *mesh = dtAllocNavMesh();
|
|
if (!mesh || dtStatusFailed(mesh->init(data, size, DT_TILE_FREE_DATA))) { dtFree(data); dtFreeNavMesh(mesh); return nullptr; }
|
|
return nav_open(mesh);
|
|
}
|
|
// filter f, the first when f is out of range
|
|
const dtQueryFilter *nav_filter(Nav *n, int f) { return &n->filters[f >= 0 && f < NAV_FILTERS ? f : 0]; }
|
|
} // namespace
|
|
|
|
#include "nav_build.inl"
|
|
#include "nav_tiles.inl"
|
|
#include "nav_query.inl"
|
|
#include "nav_crowd.inl"
|
|
#include "nav_resident.inl"
|