bit
/
DotRecastNetSim
forked from mirror/DotRecast
40
0
Fork 1
Code Pull Requests Releases Activity

Changed `DtTileCacheBuilder` to a static class

This commit is contained in:
ikpil 2024-05-21 00:10:24 +09:00
parent ec9ebe28b9
commit 8f8db51542
6 changed files with 64 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CHANGELOG.md
View File

@ -15,6 +15,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
### Changed ### Changed
- Changed `IDtPolyQuery` interface to make `Process()` more versatile - Changed `IDtPolyQuery` interface to make `Process()` more versatile
- Changed `PolyQueryInvoker` to `DtActionPolyQuery` - Changed `PolyQueryInvoker` to `DtActionPolyQuery`
- Changed `DtTileCacheBuilder` to a static class
- Changed `DtTileCacheLayerHeaderReader` to a static class
### Removed ### Removed
- Nothing - Nothing

19
src/DotRecast.Detour.TileCache/DtTileCache.cs
View File

@ -54,7 +54,6 @@ namespace DotRecast.Detour.TileCache
private readonly List<long> m_update = new List<long>(); private readonly List<long> m_update = new List<long>();
private readonly DtTileCacheBuilder builder = new DtTileCacheBuilder(); private readonly DtTileCacheBuilder builder = new DtTileCacheBuilder();
private readonly DtTileCacheLayerHeaderReader tileReader = new DtTileCacheLayerHeaderReader();
public DtTileCache(DtTileCacheParams option, DtTileCacheStorageParams storageParams, DtNavMesh navmesh, IRcCompressor tcomp, IDtTileCacheMeshProcess tmprocs) public DtTileCache(DtTileCacheParams option, DtTileCacheStorageParams storageParams, DtNavMesh navmesh, IRcCompressor tcomp, IDtTileCacheMeshProcess tmprocs)
{ {
@ -245,7 +244,7 @@ namespace DotRecast.Detour.TileCache
// Make sure the data is in right format. // Make sure the data is in right format.
RcByteBuffer buf = new RcByteBuffer(data); RcByteBuffer buf = new RcByteBuffer(data);
buf.Order(m_storageParams.Order); buf.Order(m_storageParams.Order);
DtTileCacheLayerHeader header = tileReader.Read(buf, m_storageParams.Compatibility); DtTileCacheLayerHeader header = DtTileCacheLayerHeaderReader.Read(buf, m_storageParams.Compatibility);
// Make sure the location is free. // Make sure the location is free.
if (GetTileAt(header.tx, header.ty, header.tlayer) != null) if (GetTileAt(header.tx, header.ty, header.tlayer) != null)
{ {
@ -617,24 +616,24 @@ namespace DotRecast.Detour.TileCache
{ {
if (ob.type == DtTileCacheObstacleType.CYLINDER) if (ob.type == DtTileCacheObstacleType.CYLINDER)
{ {
builder.MarkCylinderArea(layer, tile.header.bmin, m_params.cs, m_params.ch, ob.pos, ob.radius, ob.height, 0); DtTileCacheBuilder.MarkCylinderArea(layer, tile.header.bmin, m_params.cs, m_params.ch, ob.pos, ob.radius, ob.height, 0);
} }
else if (ob.type == DtTileCacheObstacleType.BOX) else if (ob.type == DtTileCacheObstacleType.BOX)
{ {
builder.MarkBoxArea(layer, tile.header.bmin, m_params.cs, m_params.ch, ob.bmin, ob.bmax, 0); DtTileCacheBuilder.MarkBoxArea(layer, tile.header.bmin, m_params.cs, m_params.ch, ob.bmin, ob.bmax, 0);
} }
else if (ob.type == DtTileCacheObstacleType.ORIENTED_BOX) else if (ob.type == DtTileCacheObstacleType.ORIENTED_BOX)
{ {
builder.MarkBoxArea(layer, tile.header.bmin, m_params.cs, m_params.ch, ob.center, ob.extents, ob.rotAux, 0); DtTileCacheBuilder.MarkBoxArea(layer, tile.header.bmin, m_params.cs, m_params.ch, ob.center, ob.extents, ob.rotAux, 0);
} }
} }
} }
// Build navmesh // Build navmesh
builder.BuildTileCacheRegions(layer, walkableClimbVx); DtTileCacheBuilder.BuildTileCacheRegions(layer, walkableClimbVx);
DtTileCacheContourSet lcset = builder.BuildTileCacheContours(layer, walkableClimbVx, DtTileCacheContourSet lcset = DtTileCacheBuilder.BuildTileCacheContours(layer, walkableClimbVx, m_params.maxSimplificationError);
m_params.maxSimplificationError); DtTileCachePolyMesh polyMesh = DtTileCacheBuilder.BuildTileCachePolyMesh(lcset, m_navmesh.GetMaxVertsPerPoly());
DtTileCachePolyMesh polyMesh = builder.BuildTileCachePolyMesh(lcset, m_navmesh.GetMaxVertsPerPoly());
// Early out if the mesh tile is empty. // Early out if the mesh tile is empty.
if (polyMesh.npolys == 0) if (polyMesh.npolys == 0)
{ {
@ -678,7 +677,7 @@ namespace DotRecast.Detour.TileCache
public DtTileCacheLayer DecompressTile(DtCompressedTile tile) public DtTileCacheLayer DecompressTile(DtCompressedTile tile)
{ {
DtTileCacheLayer layer = builder.DecompressTileCacheLayer(m_tcomp, tile.data, m_storageParams.Order, m_storageParams.Compatibility); DtTileCacheLayer layer = DtTileCacheBuilder.DecompressTileCacheLayer(m_tcomp, tile.data, m_storageParams.Order, m_storageParams.Compatibility);
return layer; return layer;
} }

96
src/DotRecast.Detour.TileCache/DtTileCacheBuilder.cs
View File

@ -37,9 +37,7 @@ namespace DotRecast.Detour.TileCache
private static readonly int[] DirOffsetX = { -1, 0, 1, 0, }; private static readonly int[] DirOffsetX = { -1, 0, 1, 0, };
private static readonly int[] DirOffsetY = { 0, 1, 0, -1 }; private static readonly int[] DirOffsetY = { 0, 1, 0, -1 };
private readonly DtTileCacheLayerHeaderReader reader = new DtTileCacheLayerHeaderReader(); public static void BuildTileCacheRegions(DtTileCacheLayer layer, int walkableClimb)
public void BuildTileCacheRegions(DtTileCacheLayer layer, int walkableClimb)
{ {
int w = layer.header.width; int w = layer.header.width;
int h = layer.header.height; int h = layer.header.height;
@ -247,7 +245,7 @@ namespace DotRecast.Detour.TileCache
} }
} }
void AddUniqueLast(List<int> a, int v) public static void AddUniqueLast(List<int> a, int v)
{ {
int n = a.Count; int n = a.Count;
if (n > 0 && a[n - 1] == v) if (n > 0 && a[n - 1] == v)
@ -255,7 +253,7 @@ namespace DotRecast.Detour.TileCache
a.Add(v); a.Add(v);
} }
bool IsConnected(DtTileCacheLayer layer, int ia, int ib, int walkableClimb) public static bool IsConnected(DtTileCacheLayer layer, int ia, int ib, int walkableClimb)
{ {
if (layer.areas[ia] != layer.areas[ib]) if (layer.areas[ia] != layer.areas[ib])
return false; return false;
@ -264,7 +262,7 @@ namespace DotRecast.Detour.TileCache
return true; return true;
} }
bool CanMerge(int oldRegId, int newRegId, DtLayerMonotoneRegion[] regs, int nregs) public static bool CanMerge(int oldRegId, int newRegId, DtLayerMonotoneRegion[] regs, int nregs)
{ {
int count = 0; int count = 0;
for (int i = 0; i < nregs; ++i) for (int i = 0; i < nregs; ++i)
@ -282,7 +280,7 @@ namespace DotRecast.Detour.TileCache
return count == 1; return count == 1;
} }
private void AppendVertex(DtTempContour cont, int x, int y, int z, int r) public static void AppendVertex(DtTempContour cont, int x, int y, int z, int r)
{ {
// Try to merge with existing segments. // Try to merge with existing segments.
if (cont.nverts > 1) if (cont.nverts > 1)
@ -316,7 +314,7 @@ namespace DotRecast.Detour.TileCache
cont.nverts++; cont.nverts++;
} }
private int GetNeighbourReg(DtTileCacheLayer layer, int ax, int ay, int dir) public static int GetNeighbourReg(DtTileCacheLayer layer, int ax, int ay, int dir)
{ {
int w = layer.header.width; int w = layer.header.width;
int ia = ax + ay * w; int ia = ax + ay * w;
@ -339,17 +337,17 @@ namespace DotRecast.Detour.TileCache
return layer.regs[ib]; return layer.regs[ib];
} }
private int GetDirOffsetX(int dir) public static int GetDirOffsetX(int dir)
{ {
return DirOffsetX[dir & 0x03]; return DirOffsetX[dir & 0x03];
} }
private int GetDirOffsetY(int dir) public static int GetDirOffsetY(int dir)
{ {
return DirOffsetY[dir & 0x03]; return DirOffsetY[dir & 0x03];
} }
private void WalkContour(DtTileCacheLayer layer, int x, int y, DtTempContour cont) public static void WalkContour(DtTileCacheLayer layer, int x, int y, DtTempContour cont)
{ {
int w = layer.header.width; int w = layer.header.width;
int h = layer.header.height; int h = layer.header.height;
@ -434,7 +432,7 @@ namespace DotRecast.Detour.TileCache
cont.nverts--; cont.nverts--;
} }
private float DistancePtSeg(int x, int z, int px, int pz, int qx, int qz) public static float DistancePtSeg(int x, int z, int px, int pz, int qx, int qz)
{ {
float pqx = qx - px; float pqx = qx - px;
float pqz = qz - pz; float pqz = qz - pz;
@ -455,7 +453,7 @@ namespace DotRecast.Detour.TileCache
return dx * dx + dz * dz; return dx * dx + dz * dz;
} }
private void SimplifyContour(DtTempContour cont, float maxError) public static void SimplifyContour(DtTempContour cont, float maxError)
{ {
cont.poly.Clear(); cont.poly.Clear();
@ -584,7 +582,7 @@ namespace DotRecast.Detour.TileCache
} }
} }
static int GetCornerHeight(DtTileCacheLayer layer, int x, int y, int z, int walkableClimb, out bool shouldRemove) public static int GetCornerHeight(DtTileCacheLayer layer, int x, int y, int z, int walkableClimb, out bool shouldRemove)
{ {
int w = layer.header.width; int w = layer.header.width;
int h = layer.header.height; int h = layer.header.height;
@ -634,7 +632,7 @@ namespace DotRecast.Detour.TileCache
} }
// TODO: move this somewhere else, once the layer meshing is done. // TODO: move this somewhere else, once the layer meshing is done.
public DtTileCacheContourSet BuildTileCacheContours(DtTileCacheLayer layer, int walkableClimb, float maxError) public static DtTileCacheContourSet BuildTileCacheContours(DtTileCacheLayer layer, int walkableClimb, float maxError)
{ {
int w = layer.header.width; int w = layer.header.width;
int h = layer.header.height; int h = layer.header.height;
@ -711,7 +709,7 @@ namespace DotRecast.Detour.TileCache
const uint VERTEX_BUCKET_COUNT2 = (1 << 8); const uint VERTEX_BUCKET_COUNT2 = (1 << 8);
private int ComputeVertexHash2(int x, int y, int z) public static int ComputeVertexHash2(int x, int y, int z)
{ {
uint h1 = 0x8da6b343; // Large multiplicative constants; uint h1 = 0x8da6b343; // Large multiplicative constants;
uint h2 = 0xd8163841; // here arbitrarily chosen primes uint h2 = 0xd8163841; // here arbitrarily chosen primes
@ -720,7 +718,7 @@ namespace DotRecast.Detour.TileCache
return (int)(n & (VERTEX_BUCKET_COUNT2 - 1)); return (int)(n & (VERTEX_BUCKET_COUNT2 - 1));
} }
private int AddVertex(int x, int y, int z, int[] verts, int[] firstVert, int[] nextVert, int nv) public static int AddVertex(int x, int y, int z, int[] verts, int[] firstVert, int[] nextVert, int nv)
{ {
int bucket = ComputeVertexHash2(x, 0, z); int bucket = ComputeVertexHash2(x, 0, z);
int i = firstVert[bucket]; int i = firstVert[bucket];
@ -743,7 +741,7 @@ namespace DotRecast.Detour.TileCache
return i; return i;
} }
private void BuildMeshAdjacency(int[] polys, int npolys, int[] verts, int nverts, DtTileCacheContourSet lcset, public static void BuildMeshAdjacency(int[] polys, int npolys, int[] verts, int nverts, DtTileCacheContourSet lcset,
int maxVertsPerPoly) int maxVertsPerPoly)
{ {
// Based on code by Eric Lengyel from: // Based on code by Eric Lengyel from:
@ -954,22 +952,22 @@ namespace DotRecast.Detour.TileCache
} }
} }
private bool OverlapRangeExl(int amin, int amax, int bmin, int bmax) public static bool OverlapRangeExl(int amin, int amax, int bmin, int bmax)
{ {
return (amin >= bmax || amax <= bmin) ? false : true; return (amin >= bmax || amax <= bmin) ? false : true;
} }
private int Prev(int i, int n) public static int Prev(int i, int n)
{ {
return i - 1 >= 0 ? i - 1 : n - 1; return i - 1 >= 0 ? i - 1 : n - 1;
} }
private int Next(int i, int n) public static int Next(int i, int n)
{ {
return i + 1 < n ? i + 1 : 0; return i + 1 < n ? i + 1 : 0;
} }
private int Area2(int[] verts, int a, int b, int c) public static int Area2(int[] verts, int a, int b, int c)
{ {
return (verts[b] - verts[a]) * (verts[c + 2] - verts[a + 2]) return (verts[b] - verts[a]) * (verts[c + 2] - verts[a + 2])
- (verts[c] - verts[a]) * (verts[b + 2] - verts[a + 2]); - (verts[c] - verts[a]) * (verts[b + 2] - verts[a + 2]);
@ -977,17 +975,17 @@ namespace DotRecast.Detour.TileCache
// Returns true iff c is strictly to the left of the directed // Returns true iff c is strictly to the left of the directed
// line through a to b. // line through a to b.
private bool Left(int[] verts, int a, int b, int c) public static bool Left(int[] verts, int a, int b, int c)
{ {
return Area2(verts, a, b, c) < 0; return Area2(verts, a, b, c) < 0;
} }
private bool LeftOn(int[] verts, int a, int b, int c) public static bool LeftOn(int[] verts, int a, int b, int c)
{ {
return Area2(verts, a, b, c) <= 0; return Area2(verts, a, b, c) <= 0;
} }
private bool Collinear(int[] verts, int a, int b, int c) public static bool Collinear(int[] verts, int a, int b, int c)
{ {
return Area2(verts, a, b, c) == 0; return Area2(verts, a, b, c) == 0;
} }
@ -995,7 +993,7 @@ namespace DotRecast.Detour.TileCache
// Returns true iff ab properly intersects cd: they share // Returns true iff ab properly intersects cd: they share
// a point interior to both segments. The properness of the // a point interior to both segments. The properness of the
// intersection is ensured by using strict leftness. // intersection is ensured by using strict leftness.
private bool IntersectProp(int[] verts, int a, int b, int c, int d) public static bool IntersectProp(int[] verts, int a, int b, int c, int d)
{ {
// Eliminate improper cases. // Eliminate improper cases.
if (Collinear(verts, a, b, c) || Collinear(verts, a, b, d) || Collinear(verts, c, d, a) if (Collinear(verts, a, b, c) || Collinear(verts, a, b, d) || Collinear(verts, c, d, a)
@ -1007,7 +1005,7 @@ namespace DotRecast.Detour.TileCache
// Returns T iff (a,b,c) are collinear and point c lies // Returns T iff (a,b,c) are collinear and point c lies
// on the closed segment ab. // on the closed segment ab.
private bool Between(int[] verts, int a, int b, int c) public static bool Between(int[] verts, int a, int b, int c)
{ {
if (!Collinear(verts, a, b, c)) if (!Collinear(verts, a, b, c))
return false; return false;
@ -1021,7 +1019,7 @@ namespace DotRecast.Detour.TileCache
} }
// Returns true iff segments ab and cd intersect, properly or improperly. // Returns true iff segments ab and cd intersect, properly or improperly.
private bool Intersect(int[] verts, int a, int b, int c, int d) public static bool Intersect(int[] verts, int a, int b, int c, int d)
{ {
if (IntersectProp(verts, a, b, c, d)) if (IntersectProp(verts, a, b, c, d))
return true; return true;
@ -1032,14 +1030,14 @@ namespace DotRecast.Detour.TileCache
return false; return false;
} }
private bool Vequal(int[] verts, int a, int b) public static bool Vequal(int[] verts, int a, int b)
{ {
return verts[a] == verts[b] && verts[a + 2] == verts[b + 2]; return verts[a] == verts[b] && verts[a + 2] == verts[b + 2];
} }
// Returns T iff (v_i, v_j) is a proper internal *or* external // Returns T iff (v_i, v_j) is a proper internal *or* external
// diagonal of P, *ignoring edges incident to v_i and v_j*. // diagonal of P, *ignoring edges incident to v_i and v_j*.
private bool Diagonalie(int i, int j, int n, int[] verts, int[] indices) public static bool Diagonalie(int i, int j, int n, int[] verts, int[] indices)
{ {
int d0 = (indices[i] & 0x7fff) * 4; int d0 = (indices[i] & 0x7fff) * 4;
int d1 = (indices[j] & 0x7fff) * 4; int d1 = (indices[j] & 0x7fff) * 4;
@ -1067,7 +1065,7 @@ namespace DotRecast.Detour.TileCache
// Returns true iff the diagonal (i,j) is strictly internal to the // Returns true iff the diagonal (i,j) is strictly internal to the
// polygon P in the neighborhood of the i endpoint. // polygon P in the neighborhood of the i endpoint.
private bool InCone(int i, int j, int n, int[] verts, int[] indices) public static bool InCone(int i, int j, int n, int[] verts, int[] indices)
{ {
int pi = (indices[i] & 0x7fff) * 4; int pi = (indices[i] & 0x7fff) * 4;
int pj = (indices[j] & 0x7fff) * 4; int pj = (indices[j] & 0x7fff) * 4;
@ -1084,12 +1082,12 @@ namespace DotRecast.Detour.TileCache
// Returns T iff (v_i, v_j) is a proper internal // Returns T iff (v_i, v_j) is a proper internal
// diagonal of P. // diagonal of P.
private bool Diagonal(int i, int j, int n, int[] verts, int[] indices) public static bool Diagonal(int i, int j, int n, int[] verts, int[] indices)
{ {
return InCone(i, j, n, verts, indices) && Diagonalie(i, j, n, verts, indices); return InCone(i, j, n, verts, indices) && Diagonalie(i, j, n, verts, indices);
} }
private int Triangulate(int n, int[] verts, int[] indices, int[] tris) public static int Triangulate(int n, int[] verts, int[] indices, int[] tris)
{ {
int ntris = 0; int ntris = 0;
int dst = 0; // tris; int dst = 0; // tris;
@ -1174,7 +1172,7 @@ namespace DotRecast.Detour.TileCache
return ntris; return ntris;
} }
private int CountPolyVerts(int[] polys, int p, int maxVertsPerPoly) public static int CountPolyVerts(int[] polys, int p, int maxVertsPerPoly)
{ {
for (int i = 0; i < maxVertsPerPoly; ++i) for (int i = 0; i < maxVertsPerPoly; ++i)
if (polys[p + i] == DT_TILECACHE_NULL_IDX) if (polys[p + i] == DT_TILECACHE_NULL_IDX)
@ -1182,13 +1180,13 @@ namespace DotRecast.Detour.TileCache
return maxVertsPerPoly; return maxVertsPerPoly;
} }
private bool Uleft(int[] verts, int a, int b, int c) public static bool Uleft(int[] verts, int a, int b, int c)
{ {
return (verts[b] - verts[a]) * (verts[c + 2] - verts[a + 2]) return (verts[b] - verts[a]) * (verts[c + 2] - verts[a + 2])
- (verts[c] - verts[a]) * (verts[b + 2] - verts[a + 2]) < 0; - (verts[c] - verts[a]) * (verts[b + 2] - verts[a + 2]) < 0;
} }
private int GetPolyMergeValue(int[] polys, int pa, int pb, int[] verts, out int ea, out int eb, int maxVertsPerPoly) public static int GetPolyMergeValue(int[] polys, int pa, int pb, int[] verts, out int ea, out int eb, int maxVertsPerPoly)
{ {
ea = 0; ea = 0;
eb = 0; eb = 0;
@ -1259,7 +1257,7 @@ namespace DotRecast.Detour.TileCache
return (dx * dx) + (dy * dy); return (dx * dx) + (dy * dy);
} }
private void MergePolys(int[] polys, int pa, int pb, int ea, int eb, int maxVertsPerPoly) public static void MergePolys(int[] polys, int pa, int pb, int ea, int eb, int maxVertsPerPoly)
{ {
int[] tmp = new int[maxVertsPerPoly * 2]; int[] tmp = new int[maxVertsPerPoly * 2];
@ -1278,19 +1276,19 @@ namespace DotRecast.Detour.TileCache
RcArrays.Copy(tmp, 0, polys, pa, maxVertsPerPoly); RcArrays.Copy(tmp, 0, polys, pa, maxVertsPerPoly);
} }
private int PushFront(int v, List<int> arr) public static int PushFront(int v, List<int> arr)
{ {
arr.Insert(0, v); arr.Insert(0, v);
return arr.Count; return arr.Count;
} }
private int PushBack(int v, List<int> arr) public static int PushBack(int v, List<int> arr)
{ {
arr.Add(v); arr.Add(v);
return arr.Count; return arr.Count;
} }
private bool CanRemoveVertex(DtTileCachePolyMesh mesh, int rem) public static bool CanRemoveVertex(DtTileCachePolyMesh mesh, int rem)
{ {
// Count number of polygons to remove. // Count number of polygons to remove.
int maxVertsPerPoly = mesh.nvp; int maxVertsPerPoly = mesh.nvp;
@ -1388,7 +1386,7 @@ namespace DotRecast.Detour.TileCache
return true; return true;
} }
private void RemoveVertex(DtTileCachePolyMesh mesh, int rem, int maxTris) public static void RemoveVertex(DtTileCachePolyMesh mesh, int rem, int maxTris)
{ {
// Count number of polygons to remove. // Count number of polygons to remove.
int maxVertsPerPoly = mesh.nvp; int maxVertsPerPoly = mesh.nvp;
@ -1627,7 +1625,7 @@ namespace DotRecast.Detour.TileCache
} }
} }
public DtTileCachePolyMesh BuildTileCachePolyMesh(DtTileCacheContourSet lcset, int maxVertsPerPoly) public static DtTileCachePolyMesh BuildTileCachePolyMesh(DtTileCacheContourSet lcset, int maxVertsPerPoly)
{ {
int maxVertices = 0; int maxVertices = 0;
int maxTris = 0; int maxTris = 0;
@ -1801,7 +1799,7 @@ namespace DotRecast.Detour.TileCache
return mesh; return mesh;
} }
public void MarkCylinderArea(DtTileCacheLayer layer, RcVec3f orig, float cs, float ch, RcVec3f pos, float radius, float height, int areaId) public static void MarkCylinderArea(DtTileCacheLayer layer, RcVec3f orig, float cs, float ch, RcVec3f pos, float radius, float height, int areaId)
{ {
RcVec3f bmin = new RcVec3f(); RcVec3f bmin = new RcVec3f();
RcVec3f bmax = new RcVec3f(); RcVec3f bmax = new RcVec3f();
@ -1862,7 +1860,7 @@ namespace DotRecast.Detour.TileCache
} }
} }
public void MarkBoxArea(DtTileCacheLayer layer, RcVec3f orig, float cs, float ch, RcVec3f bmin, RcVec3f bmax, int areaId) public static void MarkBoxArea(DtTileCacheLayer layer, RcVec3f orig, float cs, float ch, RcVec3f bmin, RcVec3f bmax, int areaId)
{ {
int w = layer.header.width; int w = layer.header.width;
int h = layer.header.height; int h = layer.header.height;
@ -1906,7 +1904,7 @@ namespace DotRecast.Detour.TileCache
} }
} }
public byte[] CompressTileCacheLayer(IRcCompressor comp, DtTileCacheLayer layer, RcByteOrder order, bool cCompatibility) public static byte[] CompressTileCacheLayer(IRcCompressor comp, DtTileCacheLayer layer, RcByteOrder order, bool cCompatibility)
{ {
using var ms = new MemoryStream(); using var ms = new MemoryStream();
using var bw = new BinaryWriter(ms); using var bw = new BinaryWriter(ms);
@ -1933,7 +1931,7 @@ namespace DotRecast.Detour.TileCache
} }
} }
public byte[] CompressTileCacheLayer(DtTileCacheLayerHeader header, int[] heights, int[] areas, int[] cons, RcByteOrder order, bool cCompatibility, IRcCompressor comp) public static byte[] CompressTileCacheLayer(DtTileCacheLayerHeader header, int[] heights, int[] areas, int[] cons, RcByteOrder order, bool cCompatibility, IRcCompressor comp)
{ {
using var ms = new MemoryStream(); using var ms = new MemoryStream();
using var bw = new BinaryWriter(ms); using var bw = new BinaryWriter(ms);
@ -1960,14 +1958,14 @@ namespace DotRecast.Detour.TileCache
} }
} }
public DtTileCacheLayer DecompressTileCacheLayer(IRcCompressor comp, byte[] compressed, RcByteOrder order, bool cCompatibility) public static DtTileCacheLayer DecompressTileCacheLayer(IRcCompressor comp, byte[] compressed, RcByteOrder order, bool cCompatibility)
{ {
RcByteBuffer buf = new RcByteBuffer(compressed); RcByteBuffer buf = new RcByteBuffer(compressed);
buf.Order(order); buf.Order(order);
DtTileCacheLayer layer = new DtTileCacheLayer(); DtTileCacheLayer layer = new DtTileCacheLayer();
try try
{ {
layer.header = reader.Read(buf, cCompatibility); layer.header = DtTileCacheLayerHeaderReader.Read(buf, cCompatibility);
} }
catch (IOException e) catch (IOException e)
{ {
@ -1990,7 +1988,7 @@ namespace DotRecast.Detour.TileCache
return layer; return layer;
} }
public void MarkBoxArea(DtTileCacheLayer layer, RcVec3f orig, float cs, float ch, RcVec3f center, RcVec3f extents, public static void MarkBoxArea(DtTileCacheLayer layer, RcVec3f orig, float cs, float ch, RcVec3f center, RcVec3f extents,
float[] rotAux, int areaId) float[] rotAux, int areaId)
{ {
int w = layer.header.width; int w = layer.header.width;

2
src/DotRecast.Detour.TileCache/DtTileCacheLayerBuilder.cs
View File

@ -128,7 +128,7 @@ namespace DotRecast.Detour.TileCache
header.hmax = layer.hmax; header.hmax = layer.hmax;
var comp = _compFactory.Create(storageParams.Compatibility ? 0 : 1); var comp = _compFactory.Create(storageParams.Compatibility ? 0 : 1);
var bytes = builder.CompressTileCacheLayer(header, layer.heights, layer.areas, layer.cons, storageParams.Order, storageParams.Compatibility, comp); var bytes = DtTileCacheBuilder.CompressTileCacheLayer(header, layer.heights, layer.areas, layer.cons, storageParams.Order, storageParams.Compatibility, comp);
result.Add(bytes); result.Add(bytes);
} }
} }

4
src/DotRecast.Detour.TileCache/Io/DtTileCacheLayerHeaderReader.cs
View File

@ -23,9 +23,9 @@ using DotRecast.Core;
namespace DotRecast.Detour.TileCache.Io namespace DotRecast.Detour.TileCache.Io
{ {
public class DtTileCacheLayerHeaderReader public static class DtTileCacheLayerHeaderReader
{ {
public DtTileCacheLayerHeader Read(RcByteBuffer data, bool cCompatibility) public static DtTileCacheLayerHeader Read(RcByteBuffer data, bool cCompatibility)
{ {
DtTileCacheLayerHeader header = new DtTileCacheLayerHeader(); DtTileCacheLayerHeader header = new DtTileCacheLayerHeader();
header.magic = data.GetInt(); header.magic = data.GetInt();

2
src/DotRecast.Detour.TileCache/Io/DtTileCacheWriter.cs
View File

@ -64,7 +64,7 @@ namespace DotRecast.Detour.TileCache.Io
byte[] data = tile.data; byte[] data = tile.data;
DtTileCacheLayer layer = cache.DecompressTile(tile); DtTileCacheLayer layer = cache.DecompressTile(tile);
var comp = _compFactory.Create(cCompatibility ? 0 : 1); var comp = _compFactory.Create(cCompatibility ? 0 : 1);
data = builder.CompressTileCacheLayer(comp, layer, order, cCompatibility); data = DtTileCacheBuilder.CompressTileCacheLayer(comp, layer, order, cCompatibility);
Write(stream, data.Length, order); Write(stream, data.Length, order);
stream.Write(data); stream.Write(data);
} }