psst
This commit is contained in:
Jan Racek
522
Runtime/PSXNavRegionBuilder.cs
Normal file
522
Runtime/PSXNavRegionBuilder.cs
Normal file
@@ -0,0 +1,522 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using UnityEngine;
|
||||
using DotRecast.Core;
|
||||
using DotRecast.Core.Numerics;
|
||||
using DotRecast.Recast;
|
||||
|
||||
namespace SplashEdit.RuntimeCode
|
||||
{
|
||||
public enum NavSurfaceType : byte { Flat = 0, Ramp = 1, Stairs = 2 }
|
||||
|
||||
/// <summary>
|
||||
/// PS1 nav mesh builder using DotRecast (C# port of Recast).
|
||||
/// Runs the full Recast voxelization pipeline on scene geometry,
|
||||
/// then extracts convex polygons with accurate heights from the detail mesh.
|
||||
/// </summary>
|
||||
public class PSXNavRegionBuilder
|
||||
{
|
||||
public float AgentHeight = 1.8f;
|
||||
public float AgentRadius = 0.3f;
|
||||
public float MaxStepHeight = 0.35f;
|
||||
public float WalkableSlopeAngle = 46.0f;
|
||||
public float CellSize = 0.05f;
|
||||
public float CellHeight = 0.025f;
|
||||
public float MergePlaneError = 0.1f;
|
||||
public const int MaxVertsPerRegion = 8;
|
||||
|
||||
private List<NavRegionExport> _regions = new();
|
||||
private List<NavPortalExport> _portals = new();
|
||||
private int _startRegion;
|
||||
|
||||
public int RegionCount => _regions.Count;
|
||||
public int PortalCount => _portals.Count;
|
||||
public IReadOnlyList<NavRegionExport> Regions => _regions;
|
||||
public IReadOnlyList<NavPortalExport> Portals => _portals;
|
||||
public VoxelCell[] DebugCells => null;
|
||||
public int DebugGridW => 0;
|
||||
public int DebugGridH => 0;
|
||||
public float DebugOriginX => 0;
|
||||
public float DebugOriginZ => 0;
|
||||
public float DebugVoxelSize => 0;
|
||||
|
||||
public class NavRegionExport
|
||||
{
|
||||
public List<Vector2> vertsXZ = new();
|
||||
public float planeA, planeB, planeD;
|
||||
public int portalStart, portalCount;
|
||||
public NavSurfaceType surfaceType;
|
||||
public byte roomIndex;
|
||||
public Plane floorPlane;
|
||||
public List<Vector3> worldTris = new();
|
||||
public List<int> sourceTriIndices = new();
|
||||
}
|
||||
|
||||
public struct NavPortalExport
|
||||
{
|
||||
public Vector2 a, b;
|
||||
public int neighborRegion;
|
||||
public float heightDelta;
|
||||
}
|
||||
|
||||
public struct VoxelCell
|
||||
{
|
||||
public float worldY, slopeAngle;
|
||||
public bool occupied, blocked;
|
||||
public int regionId;
|
||||
}
|
||||
|
||||
/// <summary>PSXRoom volumes for spatial room assignment. Set before Build().</summary>
|
||||
public PSXRoom[] PSXRooms { get; set; }
|
||||
|
||||
public void Build(PSXObjectExporter[] exporters, Vector3 spawn)
|
||||
{
|
||||
_regions.Clear(); _portals.Clear(); _startRegion = 0;
|
||||
|
||||
// 1. Collect world-space geometry from all exporters
|
||||
var allVerts = new List<float>();
|
||||
var allTris = new List<int>();
|
||||
CollectGeometry(exporters, allVerts, allTris);
|
||||
|
||||
if (allVerts.Count < 9 || allTris.Count < 3)
|
||||
{
|
||||
Debug.LogWarning("[Nav] No geometry to build navmesh from.");
|
||||
return;
|
||||
}
|
||||
|
||||
float[] verts = allVerts.ToArray();
|
||||
int[] tris = allTris.ToArray();
|
||||
int nverts = allVerts.Count / 3;
|
||||
int ntris = allTris.Count / 3;
|
||||
|
||||
// 2. Recast parameters (convert to voxel units)
|
||||
float cs = CellSize;
|
||||
float ch = CellHeight;
|
||||
int walkableHeight = (int)Math.Ceiling(AgentHeight / ch);
|
||||
int walkableClimb = (int)Math.Floor(MaxStepHeight / ch);
|
||||
int walkableRadius = (int)Math.Ceiling(AgentRadius / cs);
|
||||
int maxEdgeLen = (int)(12.0f / cs);
|
||||
float maxSimplificationError = 1.3f;
|
||||
int minRegionArea = 8;
|
||||
int mergeRegionArea = 20;
|
||||
int maxVertsPerPoly = 6;
|
||||
float detailSampleDist = cs * 6;
|
||||
float detailSampleMaxError = ch * 1;
|
||||
|
||||
// 3. Compute bounds with border padding
|
||||
float bminX = float.MaxValue, bminY = float.MaxValue, bminZ = float.MaxValue;
|
||||
float bmaxX = float.MinValue, bmaxY = float.MinValue, bmaxZ = float.MinValue;
|
||||
for (int i = 0; i < verts.Length; i += 3)
|
||||
{
|
||||
bminX = Math.Min(bminX, verts[i]); bmaxX = Math.Max(bmaxX, verts[i]);
|
||||
bminY = Math.Min(bminY, verts[i+1]); bmaxY = Math.Max(bmaxY, verts[i+1]);
|
||||
bminZ = Math.Min(bminZ, verts[i+2]); bmaxZ = Math.Max(bmaxZ, verts[i+2]);
|
||||
}
|
||||
|
||||
float borderPad = walkableRadius * cs;
|
||||
bminX -= borderPad; bminZ -= borderPad;
|
||||
bmaxX += borderPad; bmaxZ += borderPad;
|
||||
|
||||
var bmin = new RcVec3f(bminX, bminY, bminZ);
|
||||
var bmax = new RcVec3f(bmaxX, bmaxY, bmaxZ);
|
||||
|
||||
int gw = (int)((bmaxX - bminX) / cs + 0.5f);
|
||||
int gh = (int)((bmaxZ - bminZ) / cs + 0.5f);
|
||||
|
||||
// 4. Run Recast pipeline
|
||||
var ctx = new RcContext();
|
||||
|
||||
// Create heightfield
|
||||
var solid = new RcHeightfield(gw, gh, bmin, bmax, cs, ch, 0);
|
||||
|
||||
// Mark walkable triangles
|
||||
int[] areas = RcRecast.MarkWalkableTriangles(ctx, WalkableSlopeAngle, verts, tris, ntris,
|
||||
new RcAreaModification(RcRecast.RC_WALKABLE_AREA));
|
||||
|
||||
// Rasterize
|
||||
RcRasterizations.RasterizeTriangles(ctx, verts, tris, areas, ntris, solid, walkableClimb);
|
||||
|
||||
// Filter
|
||||
RcFilters.FilterLowHangingWalkableObstacles(ctx, walkableClimb, solid);
|
||||
RcFilters.FilterLedgeSpans(ctx, walkableHeight, walkableClimb, solid);
|
||||
RcFilters.FilterWalkableLowHeightSpans(ctx, walkableHeight, solid);
|
||||
|
||||
// Build compact heightfield
|
||||
var chf = RcCompacts.BuildCompactHeightfield(ctx, walkableHeight, walkableClimb, solid);
|
||||
|
||||
// Erode walkable area
|
||||
RcAreas.ErodeWalkableArea(ctx, walkableRadius, chf);
|
||||
|
||||
// Build distance field and regions
|
||||
RcRegions.BuildDistanceField(ctx, chf);
|
||||
RcRegions.BuildRegions(ctx, chf, minRegionArea, mergeRegionArea);
|
||||
|
||||
// Build contours
|
||||
var cset = RcContours.BuildContours(ctx, chf, maxSimplificationError, maxEdgeLen,
|
||||
(int)RcBuildContoursFlags.RC_CONTOUR_TESS_WALL_EDGES);
|
||||
|
||||
// Build polygon mesh
|
||||
var pmesh = RcMeshs.BuildPolyMesh(ctx, cset, maxVertsPerPoly);
|
||||
|
||||
// Build detail mesh for accurate heights
|
||||
var dmesh = RcMeshDetails.BuildPolyMeshDetail(ctx, pmesh, chf, detailSampleDist, detailSampleMaxError);
|
||||
|
||||
// 5. Extract polygons as NavRegions
|
||||
int nvp = pmesh.nvp;
|
||||
int RC_MESH_NULL_IDX = 0xffff;
|
||||
|
||||
for (int i = 0; i < pmesh.npolys; i++)
|
||||
{
|
||||
// Count valid vertices in this polygon
|
||||
int nv = 0;
|
||||
for (int j = 0; j < nvp; j++)
|
||||
{
|
||||
if (pmesh.polys[i * 2 * nvp + j] == RC_MESH_NULL_IDX) break;
|
||||
nv++;
|
||||
}
|
||||
if (nv < 3) continue;
|
||||
|
||||
var region = new NavRegionExport();
|
||||
var pts3d = new List<Vector3>();
|
||||
|
||||
for (int j = 0; j < nv; j++)
|
||||
{
|
||||
int vi = pmesh.polys[i * 2 * nvp + j];
|
||||
|
||||
// Get XZ from poly mesh (cell coords -> world)
|
||||
float wx = pmesh.bmin.X + pmesh.verts[vi * 3 + 0] * pmesh.cs;
|
||||
float wz = pmesh.bmin.Z + pmesh.verts[vi * 3 + 2] * pmesh.cs;
|
||||
|
||||
// Get accurate Y from detail mesh
|
||||
float wy;
|
||||
if (dmesh != null && i < dmesh.nmeshes)
|
||||
{
|
||||
int vbase = dmesh.meshes[i * 4 + 0];
|
||||
// Detail mesh stores polygon verts first, in order
|
||||
wy = dmesh.verts[(vbase + j) * 3 + 1];
|
||||
}
|
||||
else
|
||||
{
|
||||
// Fallback: coarse Y from poly mesh
|
||||
wy = pmesh.bmin.Y + pmesh.verts[vi * 3 + 1] * pmesh.ch;
|
||||
}
|
||||
|
||||
region.vertsXZ.Add(new Vector2(wx, wz));
|
||||
pts3d.Add(new Vector3(wx, wy, wz));
|
||||
}
|
||||
|
||||
// Ensure CCW winding
|
||||
float signedArea = 0;
|
||||
for (int j = 0; j < region.vertsXZ.Count; j++)
|
||||
{
|
||||
var a = region.vertsXZ[j];
|
||||
var b = region.vertsXZ[(j + 1) % region.vertsXZ.Count];
|
||||
signedArea += a.x * b.y - b.x * a.y;
|
||||
}
|
||||
if (signedArea < 0)
|
||||
{
|
||||
region.vertsXZ.Reverse();
|
||||
pts3d.Reverse();
|
||||
}
|
||||
|
||||
FitPlane(region, pts3d);
|
||||
_regions.Add(region);
|
||||
}
|
||||
|
||||
// 6. Build portals from Recast neighbor connectivity
|
||||
var perRegion = new Dictionary<int, List<NavPortalExport>>();
|
||||
for (int i = 0; i < _regions.Count; i++)
|
||||
perRegion[i] = new List<NavPortalExport>();
|
||||
|
||||
// Build mapping: pmesh poly index -> region index
|
||||
// (some polys may be skipped if nv < 3, so we need this mapping)
|
||||
var polyToRegion = new Dictionary<int, int>();
|
||||
int regionIdx = 0;
|
||||
for (int i = 0; i < pmesh.npolys; i++)
|
||||
{
|
||||
int nv = 0;
|
||||
for (int j = 0; j < nvp; j++)
|
||||
{
|
||||
if (pmesh.polys[i * 2 * nvp + j] == RC_MESH_NULL_IDX) break;
|
||||
nv++;
|
||||
}
|
||||
if (nv < 3) continue;
|
||||
polyToRegion[i] = regionIdx++;
|
||||
}
|
||||
|
||||
for (int i = 0; i < pmesh.npolys; i++)
|
||||
{
|
||||
if (!polyToRegion.TryGetValue(i, out int srcRegion)) continue;
|
||||
|
||||
int nv = 0;
|
||||
for (int j = 0; j < nvp; j++)
|
||||
{
|
||||
if (pmesh.polys[i * 2 * nvp + j] == RC_MESH_NULL_IDX) break;
|
||||
nv++;
|
||||
}
|
||||
|
||||
for (int j = 0; j < nv; j++)
|
||||
{
|
||||
int neighbor = pmesh.polys[i * 2 * nvp + nvp + j];
|
||||
if (neighbor == RC_MESH_NULL_IDX || (neighbor & 0x8000) != 0) continue;
|
||||
if (!polyToRegion.TryGetValue(neighbor, out int dstRegion)) continue;
|
||||
|
||||
// Portal edge vertices from pmesh directly (NOT from region,
|
||||
// which may have been reversed for CCW winding)
|
||||
int vi0 = pmesh.polys[i * 2 * nvp + j];
|
||||
int vi1 = pmesh.polys[i * 2 * nvp + (j + 1) % nv];
|
||||
|
||||
float ax = pmesh.bmin.X + pmesh.verts[vi0 * 3 + 0] * pmesh.cs;
|
||||
float az = pmesh.bmin.Z + pmesh.verts[vi0 * 3 + 2] * pmesh.cs;
|
||||
float bx = pmesh.bmin.X + pmesh.verts[vi1 * 3 + 0] * pmesh.cs;
|
||||
float bz = pmesh.bmin.Z + pmesh.verts[vi1 * 3 + 2] * pmesh.cs;
|
||||
|
||||
var a2 = new Vector2(ax, az);
|
||||
var b2 = new Vector2(bx, bz);
|
||||
|
||||
// Height delta at midpoint of portal edge
|
||||
var mid = new Vector2((ax + bx) / 2, (az + bz) / 2);
|
||||
float yHere = EvalY(_regions[srcRegion], mid);
|
||||
float yThere = EvalY(_regions[dstRegion], mid);
|
||||
|
||||
perRegion[srcRegion].Add(new NavPortalExport
|
||||
{
|
||||
a = a2,
|
||||
b = b2,
|
||||
neighborRegion = dstRegion,
|
||||
heightDelta = yThere - yHere
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Assign portals
|
||||
foreach (var kvp in perRegion)
|
||||
{
|
||||
_regions[kvp.Key].portalStart = _portals.Count;
|
||||
_regions[kvp.Key].portalCount = kvp.Value.Count;
|
||||
_portals.AddRange(kvp.Value);
|
||||
}
|
||||
|
||||
// 7. Assign rooms: spatial containment if PSXRooms provided, BFS fallback
|
||||
if (PSXRooms != null && PSXRooms.Length > 0)
|
||||
AssignRoomsFromPSXRooms(PSXRooms);
|
||||
else
|
||||
AssignRoomsByBFS();
|
||||
|
||||
// 8. Find start region closest to spawn
|
||||
_startRegion = FindClosestRegion(spawn);
|
||||
}
|
||||
|
||||
void CollectGeometry(PSXObjectExporter[] exporters, List<float> outVerts, List<int> outTris)
|
||||
{
|
||||
foreach (var exporter in exporters)
|
||||
{
|
||||
|
||||
MeshFilter mf = exporter.GetComponent<MeshFilter>();
|
||||
Mesh mesh = mf?.sharedMesh;
|
||||
if (mesh == null) continue;
|
||||
|
||||
Matrix4x4 worldMatrix = exporter.transform.localToWorldMatrix;
|
||||
Vector3[] vertices = mesh.vertices;
|
||||
int[] indices = mesh.triangles;
|
||||
|
||||
int baseVert = outVerts.Count / 3;
|
||||
foreach (var v in vertices)
|
||||
{
|
||||
Vector3 w = worldMatrix.MultiplyPoint3x4(v);
|
||||
outVerts.Add(w.x);
|
||||
outVerts.Add(w.y);
|
||||
outVerts.Add(w.z);
|
||||
}
|
||||
|
||||
// Filter triangles: reject downward-facing normals
|
||||
// (ceilings, roofs, undersides) which should never be walkable.
|
||||
for (int i = 0; i < indices.Length; i += 3)
|
||||
{
|
||||
Vector3 v0 = worldMatrix.MultiplyPoint3x4(vertices[indices[i]]);
|
||||
Vector3 v1 = worldMatrix.MultiplyPoint3x4(vertices[indices[i + 1]]);
|
||||
Vector3 v2 = worldMatrix.MultiplyPoint3x4(vertices[indices[i + 2]]);
|
||||
|
||||
Vector3 normal = Vector3.Cross(v1 - v0, v2 - v0);
|
||||
// Skip triangles whose world-space normal points downward (y < 0)
|
||||
// This eliminates ceilings/roofs that Recast might incorrectly voxelize
|
||||
if (normal.y < 0f) continue;
|
||||
|
||||
outTris.Add(indices[i] + baseVert);
|
||||
outTris.Add(indices[i + 1] + baseVert);
|
||||
outTris.Add(indices[i + 2] + baseVert);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
int FindClosestRegion(Vector3 spawn)
|
||||
{
|
||||
int best = 0;
|
||||
float bestDist = float.MaxValue;
|
||||
for (int i = 0; i < _regions.Count; i++)
|
||||
{
|
||||
var r = _regions[i];
|
||||
// Compute centroid
|
||||
float cx = 0, cz = 0;
|
||||
foreach (var v in r.vertsXZ) { cx += v.x; cz += v.y; }
|
||||
cx /= r.vertsXZ.Count; cz /= r.vertsXZ.Count;
|
||||
float cy = EvalY(r, new Vector2(cx, cz));
|
||||
|
||||
float dx = spawn.x - cx, dy = spawn.y - cy, dz = spawn.z - cz;
|
||||
float dist = dx * dx + dy * dy + dz * dz;
|
||||
if (dist < bestDist) { bestDist = dist; best = i; }
|
||||
}
|
||||
return best;
|
||||
}
|
||||
|
||||
float EvalY(NavRegionExport r, Vector2 xz) => r.planeA * xz.x + r.planeB * xz.y + r.planeD;
|
||||
|
||||
void FitPlane(NavRegionExport r, List<Vector3> pts)
|
||||
{
|
||||
int n = pts.Count;
|
||||
if (n < 3) { r.planeA = 0; r.planeB = 0; r.planeD = n > 0 ? pts[0].y : 0; r.surfaceType = NavSurfaceType.Flat; return; }
|
||||
|
||||
if (n == 3)
|
||||
{
|
||||
// Exact 3-point solve: Y = A*X + B*Z + D
|
||||
double x0 = pts[0].x, z0 = pts[0].z, y0 = pts[0].y;
|
||||
double x1 = pts[1].x, z1 = pts[1].z, y1 = pts[1].y;
|
||||
double x2 = pts[2].x, z2 = pts[2].z, y2 = pts[2].y;
|
||||
double det = (x0 - x2) * (z1 - z2) - (x1 - x2) * (z0 - z2);
|
||||
if (Math.Abs(det) < 1e-12) { r.planeA = 0; r.planeB = 0; r.planeD = (float)((y0 + y1 + y2) / 3); }
|
||||
else
|
||||
{
|
||||
double inv = 1.0 / det;
|
||||
r.planeA = (float)(((y0 - y2) * (z1 - z2) - (y1 - y2) * (z0 - z2)) * inv);
|
||||
r.planeB = (float)(((x0 - x2) * (y1 - y2) - (x1 - x2) * (y0 - y2)) * inv);
|
||||
r.planeD = (float)(y0 - r.planeA * x0 - r.planeB * z0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Least-squares: Y = A*X + B*Z + D
|
||||
double sX = 0, sZ = 0, sY = 0, sXX = 0, sXZ = 0, sZZ = 0, sXY = 0, sZY = 0;
|
||||
foreach (var p in pts) { sX += p.x; sZ += p.z; sY += p.y; sXX += p.x * p.x; sXZ += p.x * p.z; sZZ += p.z * p.z; sXY += p.x * p.y; sZY += p.z * p.y; }
|
||||
double det = sXX * (sZZ * n - sZ * sZ) - sXZ * (sXZ * n - sZ * sX) + sX * (sXZ * sZ - sZZ * sX);
|
||||
if (Math.Abs(det) < 1e-12) { r.planeA = 0; r.planeB = 0; r.planeD = (float)(sY / n); }
|
||||
else
|
||||
{
|
||||
double inv = 1.0 / det;
|
||||
r.planeA = (float)((sXY * (sZZ * n - sZ * sZ) - sXZ * (sZY * n - sZ * sY) + sX * (sZY * sZ - sZZ * sY)) * inv);
|
||||
r.planeB = (float)((sXX * (sZY * n - sZ * sY) - sXY * (sXZ * n - sZ * sX) + sX * (sXZ * sY - sZY * sX)) * inv);
|
||||
r.planeD = (float)((sXX * (sZZ * sY - sZ * sZY) - sXZ * (sXZ * sY - sZY * sX) + sXY * (sXZ * sZ - sZZ * sX)) * inv);
|
||||
}
|
||||
}
|
||||
|
||||
float slope = Mathf.Atan(Mathf.Sqrt(r.planeA * r.planeA + r.planeB * r.planeB)) * Mathf.Rad2Deg;
|
||||
r.surfaceType = slope < 3f ? NavSurfaceType.Flat : slope < 25f ? NavSurfaceType.Ramp : NavSurfaceType.Stairs;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Assign room indices to nav regions using PSXRoom spatial containment.
|
||||
/// Each region's centroid is tested against all PSXRoom volumes. The smallest
|
||||
/// containing room wins (most specific). Regions outside all rooms get 0xFF.
|
||||
/// This ensures nav region room indices match the PSXRoomBuilder room indices
|
||||
/// used by the rendering portal system.
|
||||
/// </summary>
|
||||
void AssignRoomsFromPSXRooms(PSXRoom[] psxRooms)
|
||||
{
|
||||
const float MARGIN = 0.5f;
|
||||
Bounds[] roomBounds = new Bounds[psxRooms.Length];
|
||||
for (int r = 0; r < psxRooms.Length; r++)
|
||||
{
|
||||
roomBounds[r] = psxRooms[r].GetWorldBounds();
|
||||
roomBounds[r].Expand(MARGIN * 2f);
|
||||
}
|
||||
|
||||
for (int i = 0; i < _regions.Count; i++)
|
||||
{
|
||||
var reg = _regions[i];
|
||||
// Compute region centroid from polygon vertices
|
||||
float cx = 0, cz = 0;
|
||||
foreach (var v in reg.vertsXZ) { cx += v.x; cz += v.y; }
|
||||
cx /= reg.vertsXZ.Count; cz /= reg.vertsXZ.Count;
|
||||
float cy = EvalY(reg, new Vector2(cx, cz));
|
||||
Vector3 centroid = new Vector3(cx, cy, cz);
|
||||
|
||||
byte bestRoom = 0xFF;
|
||||
float bestVolume = float.MaxValue;
|
||||
for (int r = 0; r < psxRooms.Length; r++)
|
||||
{
|
||||
if (roomBounds[r].Contains(centroid))
|
||||
{
|
||||
float vol = roomBounds[r].size.x * roomBounds[r].size.y * roomBounds[r].size.z;
|
||||
if (vol < bestVolume)
|
||||
{
|
||||
bestVolume = vol;
|
||||
bestRoom = (byte)r;
|
||||
}
|
||||
}
|
||||
}
|
||||
reg.roomIndex = bestRoom;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Fallback room assignment via BFS over nav portal connectivity.
|
||||
/// Used when no PSXRoom volumes exist (exterior scenes).
|
||||
/// </summary>
|
||||
void AssignRoomsByBFS()
|
||||
{
|
||||
byte room = 0;
|
||||
var vis = new bool[_regions.Count];
|
||||
for (int i = 0; i < _regions.Count; i++)
|
||||
{
|
||||
if (vis[i]) continue;
|
||||
byte rm = room++;
|
||||
var q = new Queue<int>(); q.Enqueue(i); vis[i] = true;
|
||||
while (q.Count > 0)
|
||||
{
|
||||
int ri = q.Dequeue(); _regions[ri].roomIndex = rm;
|
||||
for (int p = _regions[ri].portalStart; p < _regions[ri].portalStart + _regions[ri].portalCount; p++)
|
||||
{
|
||||
int nb = _portals[p].neighborRegion;
|
||||
if (nb >= 0 && nb < _regions.Count && !vis[nb]) { vis[nb] = true; q.Enqueue(nb); }
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public void WriteToBinary(BinaryWriter writer, float gteScaling)
|
||||
{
|
||||
writer.Write((ushort)_regions.Count);
|
||||
writer.Write((ushort)_portals.Count);
|
||||
writer.Write((ushort)_startRegion);
|
||||
writer.Write((ushort)0);
|
||||
foreach (var r in _regions)
|
||||
{
|
||||
for (int v = 0; v < MaxVertsPerRegion; v++)
|
||||
writer.Write(v < r.vertsXZ.Count ? PSXTrig.ConvertWorldToFixed12(r.vertsXZ[v].x / gteScaling) : 0);
|
||||
for (int v = 0; v < MaxVertsPerRegion; v++)
|
||||
writer.Write(v < r.vertsXZ.Count ? PSXTrig.ConvertWorldToFixed12(r.vertsXZ[v].y / gteScaling) : 0);
|
||||
writer.Write(PSXTrig.ConvertWorldToFixed12(-r.planeA));
|
||||
writer.Write(PSXTrig.ConvertWorldToFixed12(-r.planeB));
|
||||
writer.Write(PSXTrig.ConvertWorldToFixed12(-r.planeD / gteScaling));
|
||||
writer.Write((ushort)r.portalStart);
|
||||
writer.Write((byte)r.portalCount);
|
||||
writer.Write((byte)r.vertsXZ.Count);
|
||||
writer.Write((byte)r.surfaceType);
|
||||
writer.Write(r.roomIndex);
|
||||
writer.Write((byte)0);
|
||||
writer.Write((byte)0);
|
||||
}
|
||||
foreach (var p in _portals)
|
||||
{
|
||||
writer.Write(PSXTrig.ConvertWorldToFixed12(p.a.x / gteScaling));
|
||||
writer.Write(PSXTrig.ConvertWorldToFixed12(p.a.y / gteScaling));
|
||||
writer.Write(PSXTrig.ConvertWorldToFixed12(p.b.x / gteScaling));
|
||||
writer.Write(PSXTrig.ConvertWorldToFixed12(p.b.y / gteScaling));
|
||||
writer.Write((ushort)p.neighborRegion);
|
||||
writer.Write((short)PSXTrig.ConvertToFixed12(p.heightDelta / gteScaling));
|
||||
}
|
||||
}
|
||||
|
||||
public int GetBinarySize() => 8 + _regions.Count * 84 + _portals.Count * 20;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user