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

123 -> xyz

This commit is contained in:
ikpil 2023-04-29 13:00:19 +09:00
parent 096cfec536
commit d108c56a29
19 changed files with 232 additions and 232 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/DotRecast.Recast/Geom/SimpleInputGeomProvider.cs
View File

@ -129,9 +129,9 @@ namespace DotRecast.Recast.Geom
e1.y = vertices[v2 + 1] - vertices[v0 + 1]; e1.y = vertices[v2 + 1] - vertices[v0 + 1];
e1.z = vertices[v2 + 2] - vertices[v0 + 2]; e1.z = vertices[v2 + 2] - vertices[v0 + 2];
normals[i] = e0[1] * e1[2] - e0[2] * e1[1]; normals[i] = e0.y * e1.z - e0.z * e1.y;
normals[i + 1] = e0[2] * e1[0] - e0[0] * e1[2]; normals[i + 1] = e0.z * e1.x - e0.x * e1.z;
normals[i + 2] = e0[0] * e1[1] - e0[1] * e1[0]; normals[i + 2] = e0.x * e1.y - e0.y * e1.x;
float d = (float)Math.Sqrt(normals[i] * normals[i] + normals[i + 1] * normals[i + 1] + normals[i + 2] * normals[i + 2]); float d = (float)Math.Sqrt(normals[i] * normals[i] + normals[i + 1] * normals[i + 1] + normals[i + 2] * normals[i + 2]);
if (d > 0) if (d > 0)
{ {

4
src/DotRecast.Recast/PolyUtils.cs
View File

@ -32,8 +32,8 @@ namespace DotRecast.Recast
{ {
Vector3f vi = Vector3f.Of(verts[i * 3], verts[i * 3 + 1], verts[i * 3 + 2]); Vector3f vi = Vector3f.Of(verts[i * 3], verts[i * 3 + 1], verts[i * 3 + 2]);
Vector3f vj = Vector3f.Of(verts[j * 3], verts[j * 3 + 1], verts[j * 3 + 2]); Vector3f vj = Vector3f.Of(verts[j * 3], verts[j * 3 + 1], verts[j * 3 + 2]);
if (((vi[2] > p[2]) != (vj[2] > p[2])) if (((vi.z > p.z) != (vj.z > p.z))
&& (p[0] < (vj[0] - vi[0]) * (p[2] - vi[2]) / (vj[2] - vi[2]) + vi[0])) && (p.x < (vj.x - vi.x) * (p.z - vi.z) / (vj.z - vi.z) + vi.x))
{ {
c = !c; c = !c;
} }

8
src/DotRecast.Recast/Recast.cs
View File

@ -53,12 +53,12 @@ namespace DotRecast.Recast
public static int[] calcGridSize(Vector3f bmin, float[] bmax, float cs) public static int[] calcGridSize(Vector3f bmin, float[] bmax, float cs)
{ {
return new int[] { (int)((bmax[0] - bmin[0]) / cs + 0.5f), (int)((bmax[2] - bmin[2]) / cs + 0.5f) }; return new int[] { (int)((bmax[0] - bmin.x) / cs + 0.5f), (int)((bmax[2] - bmin.z) / cs + 0.5f) };
} }
public static int[] calcGridSize(Vector3f bmin, Vector3f bmax, float cs) public static int[] calcGridSize(Vector3f bmin, Vector3f bmax, float cs)
{ {
return new int[] { (int)((bmax[0] - bmin[0]) / cs + 0.5f), (int)((bmax[2] - bmin[2]) / cs + 0.5f) }; return new int[] { (int)((bmax.x - bmin.x) / cs + 0.5f), (int)((bmax.z - bmin.z) / cs + 0.5f) };
} }
@ -90,7 +90,7 @@ namespace DotRecast.Recast
int tri = i * 3; int tri = i * 3;
calcTriNormal(verts, tris[tri], tris[tri + 1], tris[tri + 2], ref norm); calcTriNormal(verts, tris[tri], tris[tri + 1], tris[tri + 2], ref norm);
// Check if the face is walkable. // Check if the face is walkable.
if (norm[1] > walkableThr) if (norm.y > walkableThr)
areas[i] = areaMod.apply(areas[i]); areas[i] = areaMod.apply(areas[i]);
} }
@ -138,7 +138,7 @@ namespace DotRecast.Recast
int tri = i * 3; int tri = i * 3;
calcTriNormal(verts, tris[tri], tris[tri + 1], tris[tri + 2], ref norm); calcTriNormal(verts, tris[tri], tris[tri + 1], tris[tri + 2], ref norm);
// Check if the face is walkable. // Check if the face is walkable.
if (norm[1] <= walkableThr) if (norm.y <= walkableThr)
areas[i] = RC_NULL_AREA; areas[i] = RC_NULL_AREA;
} }
} }

66
src/DotRecast.Recast/RecastArea.cs
View File

@ -287,12 +287,12 @@ namespace DotRecast.Recast
{ {
ctx.startTimer("MARK_BOX_AREA"); ctx.startTimer("MARK_BOX_AREA");
int minx = (int)((bmin[0] - chf.bmin[0]) / chf.cs); int minx = (int)((bmin[0] - chf.bmin.x) / chf.cs);
int miny = (int)((bmin[1] - chf.bmin[1]) / chf.ch); int miny = (int)((bmin[1] - chf.bmin.y) / chf.ch);
int minz = (int)((bmin[2] - chf.bmin[2]) / chf.cs); int minz = (int)((bmin[2] - chf.bmin.z) / chf.cs);
int maxx = (int)((bmax[0] - chf.bmin[0]) / chf.cs); int maxx = (int)((bmax[0] - chf.bmin.x) / chf.cs);
int maxy = (int)((bmax[1] - chf.bmin[1]) / chf.ch); int maxy = (int)((bmax[1] - chf.bmin.y) / chf.ch);
int maxz = (int)((bmax[2] - chf.bmin[2]) / chf.cs); int maxz = (int)((bmax[2] - chf.bmin.z) / chf.cs);
if (maxx < 0) if (maxx < 0)
return; return;
@ -340,8 +340,8 @@ namespace DotRecast.Recast
{ {
int vi = i; int vi = i;
int vj = j; int vj = j;
if (((verts[vi + 2] > p[2]) != (verts[vj + 2] > p[2])) if (((verts[vi + 2] > p.z) != (verts[vj + 2] > p.z))
&& (p[0] < (verts[vj] - verts[vi]) * (p[2] - verts[vi + 2]) / (verts[vj + 2] - verts[vi + 2]) && (p.x < (verts[vj] - verts[vi]) * (p.z - verts[vi + 2]) / (verts[vj + 2] - verts[vi + 2])
+ verts[vi])) + verts[vi]))
c = !c; c = !c;
} }
@ -372,15 +372,15 @@ namespace DotRecast.Recast
RecastVectors.max(ref bmax, verts, i); RecastVectors.max(ref bmax, verts, i);
} }
bmin[1] = hmin; bmin.y = hmin;
bmax[1] = hmax; bmax.y = hmax;
int minx = (int)((bmin[0] - chf.bmin[0]) / chf.cs); int minx = (int)((bmin.x - chf.bmin.x) / chf.cs);
int miny = (int)((bmin[1] - chf.bmin[1]) / chf.ch); int miny = (int)((bmin.y - chf.bmin.y) / chf.ch);
int minz = (int)((bmin[2] - chf.bmin[2]) / chf.cs); int minz = (int)((bmin.z - chf.bmin.z) / chf.cs);
int maxx = (int)((bmax[0] - chf.bmin[0]) / chf.cs); int maxx = (int)((bmax.x - chf.bmin.x) / chf.cs);
int maxy = (int)((bmax[1] - chf.bmin[1]) / chf.ch); int maxy = (int)((bmax.y - chf.bmin.y) / chf.ch);
int maxz = (int)((bmax[2] - chf.bmin[2]) / chf.cs); int maxz = (int)((bmax.z - chf.bmin.z) / chf.cs);
if (maxx < 0) if (maxx < 0)
return; return;
@ -414,9 +414,9 @@ namespace DotRecast.Recast
if (s.y >= miny && s.y <= maxy) if (s.y >= miny && s.y <= maxy)
{ {
Vector3f p = new Vector3f(); Vector3f p = new Vector3f();
p[0] = chf.bmin[0] + (x + 0.5f) * chf.cs; p.x = chf.bmin.x + (x + 0.5f) * chf.cs;
p[1] = 0; p.y = 0;
p[2] = chf.bmin[2] + (z + 0.5f) * chf.cs; p.z = chf.bmin.z + (z + 0.5f) * chf.cs;
if (pointInPoly(verts, p)) if (pointInPoly(verts, p))
{ {
@ -520,20 +520,20 @@ namespace DotRecast.Recast
Vector3f bmin = new Vector3f(); Vector3f bmin = new Vector3f();
Vector3f bmax = new Vector3f(); Vector3f bmax = new Vector3f();
bmin[0] = pos[0] - r; bmin.x = pos[0] - r;
bmin[1] = pos[1]; bmin.y = pos[1];
bmin[2] = pos[2] - r; bmin.z = pos[2] - r;
bmax[0] = pos[0] + r; bmax.x = pos[0] + r;
bmax[1] = pos[1] + h; bmax.y = pos[1] + h;
bmax[2] = pos[2] + r; bmax.z = pos[2] + r;
float r2 = r * r; float r2 = r * r;
int minx = (int)((bmin[0] - chf.bmin[0]) / chf.cs); int minx = (int)((bmin.x - chf.bmin.x) / chf.cs);
int miny = (int)((bmin[1] - chf.bmin[1]) / chf.ch); int miny = (int)((bmin.y - chf.bmin.y) / chf.ch);
int minz = (int)((bmin[2] - chf.bmin[2]) / chf.cs); int minz = (int)((bmin.z - chf.bmin.z) / chf.cs);
int maxx = (int)((bmax[0] - chf.bmin[0]) / chf.cs); int maxx = (int)((bmax.x - chf.bmin.x) / chf.cs);
int maxy = (int)((bmax[1] - chf.bmin[1]) / chf.ch); int maxy = (int)((bmax.y - chf.bmin.y) / chf.ch);
int maxz = (int)((bmax[2] - chf.bmin[2]) / chf.cs); int maxz = (int)((bmax.z - chf.bmin.z) / chf.cs);
if (maxx < 0) if (maxx < 0)
return; return;
@ -567,8 +567,8 @@ namespace DotRecast.Recast
if (s.y >= miny && s.y <= maxy) if (s.y >= miny && s.y <= maxy)
{ {
float sx = chf.bmin[0] + (x + 0.5f) * chf.cs; float sx = chf.bmin.x + (x + 0.5f) * chf.cs;
float sz = chf.bmin[2] + (z + 0.5f) * chf.cs; float sz = chf.bmin.z + (z + 0.5f) * chf.cs;
float dx = sx - pos[0]; float dx = sx - pos[0];
float dz = sz - pos[2]; float dz = sz - pos[2];

4
src/DotRecast.Recast/RecastBuilderConfig.cs
View File

@ -60,8 +60,8 @@ namespace DotRecast.Recast
float tsz = cfg.tileSizeZ * cfg.cs; float tsz = cfg.tileSizeZ * cfg.cs;
this.bmin.x += tileX * tsx; this.bmin.x += tileX * tsx;
this.bmin.z += tileZ * tsz; this.bmin.z += tileZ * tsz;
this.bmax.x = this.bmin[0] + tsx; this.bmax.x = this.bmin.x + tsx;
this.bmax.z = this.bmin[2] + tsz; this.bmax.z = this.bmin.z + tsz;
// Expand the heighfield bounding box by border size to find the extents of geometry we need to build this // Expand the heighfield bounding box by border size to find the extents of geometry we need to build this
// tile. // tile.
// //

2
src/DotRecast.Recast/RecastCompact.cs
View File

@ -58,7 +58,7 @@ namespace DotRecast.Recast
chf.maxRegions = 0; chf.maxRegions = 0;
copy(ref chf.bmin, hf.bmin); copy(ref chf.bmin, hf.bmin);
copy(ref chf.bmax, hf.bmax); copy(ref chf.bmax, hf.bmax);
chf.bmax[1] += walkableHeight * hf.ch; chf.bmax.y += walkableHeight * hf.ch;
chf.cs = hf.cs; chf.cs = hf.cs;
chf.ch = hf.ch; chf.ch = hf.ch;
chf.cells = new CompactCell[w * h]; chf.cells = new CompactCell[w * h];

8
src/DotRecast.Recast/RecastContour.cs
View File

@ -786,10 +786,10 @@ namespace DotRecast.Recast
{ {
// If the heightfield was build with bordersize, remove the offset. // If the heightfield was build with bordersize, remove the offset.
float pad = borderSize * chf.cs; float pad = borderSize * chf.cs;
cset.bmin[0] += pad; cset.bmin.x += pad;
cset.bmin[2] += pad; cset.bmin.z += pad;
cset.bmax[0] -= pad; cset.bmax.x -= pad;
cset.bmax[2] -= pad; cset.bmax.z -= pad;
} }
cset.cs = chf.cs; cset.cs = chf.cs;

148
src/DotRecast.Recast/RecastFilledVolumeRasterization.cs
View File

@ -34,8 +34,8 @@ namespace DotRecast.Recast
ctx.startTimer("RASTERIZE_SPHERE"); ctx.startTimer("RASTERIZE_SPHERE");
float[] bounds = float[] bounds =
{ {
center[0] - radius, center[1] - radius, center[2] - radius, center[0] + radius, center[1] + radius, center.x - radius, center.y - radius, center.z - radius, center.x + radius, center.y + radius,
center[2] + radius center.z + radius
}; };
rasterizationFilledShape(hf, bounds, area, flagMergeThr, rasterizationFilledShape(hf, bounds, area, flagMergeThr,
rectangle => intersectSphere(rectangle, center, radius * radius)); rectangle => intersectSphere(rectangle, center, radius * radius));
@ -48,11 +48,11 @@ namespace DotRecast.Recast
ctx.startTimer("RASTERIZE_CAPSULE"); ctx.startTimer("RASTERIZE_CAPSULE");
float[] bounds = float[] bounds =
{ {
Math.Min(start[0], end[0]) - radius, Math.Min(start[1], end[1]) - radius, Math.Min(start.x, end.x) - radius, Math.Min(start.y, end.y) - radius,
Math.Min(start[2], end[2]) - radius, Math.Max(start[0], end[0]) + radius, Math.Max(start[1], end[1]) + radius, Math.Min(start.z, end.z) - radius, Math.Max(start.x, end.x) + radius, Math.Max(start.y, end.y) + radius,
Math.Max(start[2], end[2]) + radius Math.Max(start.z, end.z) + radius
}; };
Vector3f axis = Vector3f.Of(end[0] - start[0], end[1] - start[1], end[2] - start[2]); Vector3f axis = Vector3f.Of(end.x - start.x, end.y - start.y, end.z - start.z);
rasterizationFilledShape(hf, bounds, area, flagMergeThr, rasterizationFilledShape(hf, bounds, area, flagMergeThr,
rectangle => intersectCapsule(rectangle, start, end, axis, radius * radius)); rectangle => intersectCapsule(rectangle, start, end, axis, radius * radius));
ctx.stopTimer("RASTERIZE_CAPSULE"); ctx.stopTimer("RASTERIZE_CAPSULE");
@ -64,11 +64,11 @@ namespace DotRecast.Recast
ctx.startTimer("RASTERIZE_CYLINDER"); ctx.startTimer("RASTERIZE_CYLINDER");
float[] bounds = float[] bounds =
{ {
Math.Min(start[0], end[0]) - radius, Math.Min(start[1], end[1]) - radius, Math.Min(start.x, end.x) - radius, Math.Min(start.y, end.y) - radius,
Math.Min(start[2], end[2]) - radius, Math.Max(start[0], end[0]) + radius, Math.Max(start[1], end[1]) + radius, Math.Min(start.z, end.z) - radius, Math.Max(start.x, end.x) + radius, Math.Max(start.y, end.y) + radius,
Math.Max(start[2], end[2]) + radius Math.Max(start.z, end.z) + radius
}; };
Vector3f axis = Vector3f.Of(end[0] - start[0], end[1] - start[1], end[2] - start[2]); Vector3f axis = Vector3f.Of(end.x - start.x, end.y - start.y, end.z - start.z);
rasterizationFilledShape(hf, bounds, area, flagMergeThr, rasterizationFilledShape(hf, bounds, area, flagMergeThr,
rectangle => intersectCylinder(rectangle, start, end, axis, radius * radius)); rectangle => intersectCylinder(rectangle, start, end, axis, radius * radius));
ctx.stopTimer("RASTERIZE_CYLINDER"); ctx.stopTimer("RASTERIZE_CYLINDER");
@ -80,9 +80,9 @@ namespace DotRecast.Recast
ctx.startTimer("RASTERIZE_BOX"); ctx.startTimer("RASTERIZE_BOX");
Vector3f[] normals = Vector3f[] normals =
{ {
Vector3f.Of(halfEdges[0][0], halfEdges[0][1], halfEdges[0][2]), Vector3f.Of(halfEdges[0].x, halfEdges[0].y, halfEdges[0].z),
Vector3f.Of(halfEdges[1][0], halfEdges[1][1], halfEdges[1][2]), Vector3f.Of(halfEdges[1].x, halfEdges[1].y, halfEdges[1].z),
Vector3f.Of(halfEdges[2][0], halfEdges[2][1], halfEdges[2][2]), Vector3f.Of(halfEdges[2].x, halfEdges[2].y, halfEdges[2].z),
}; };
normalize(ref normals[0]); normalize(ref normals[0]);
normalize(ref normals[1]); normalize(ref normals[1]);
@ -99,9 +99,9 @@ namespace DotRecast.Recast
float s0 = (i & 1) != 0 ? 1f : -1f; float s0 = (i & 1) != 0 ? 1f : -1f;
float s1 = (i & 2) != 0 ? 1f : -1f; float s1 = (i & 2) != 0 ? 1f : -1f;
float s2 = (i & 4) != 0 ? 1f : -1f; float s2 = (i & 4) != 0 ? 1f : -1f;
vertices[i * 3 + 0] = center[0] + s0 * halfEdges[0][0] + s1 * halfEdges[1][0] + s2 * halfEdges[2][0]; vertices[i * 3 + 0] = center.x + s0 * halfEdges[0].x + s1 * halfEdges[1].x + s2 * halfEdges[2].x;
vertices[i * 3 + 1] = center[1] + s0 * halfEdges[0][1] + s1 * halfEdges[1][1] + s2 * halfEdges[2][1]; vertices[i * 3 + 1] = center.y + s0 * halfEdges[0].y + s1 * halfEdges[1].y + s2 * halfEdges[2].y;
vertices[i * 3 + 2] = center[2] + s0 * halfEdges[0][2] + s1 * halfEdges[1][2] + s2 * halfEdges[2][2]; vertices[i * 3 + 2] = center.z + s0 * halfEdges[0].z + s1 * halfEdges[1].z + s2 * halfEdges[2].z;
bounds[0] = Math.Min(bounds[0], vertices[i * 3 + 0]); bounds[0] = Math.Min(bounds[0], vertices[i * 3 + 0]);
bounds[1] = Math.Min(bounds[1], vertices[i * 3 + 1]); bounds[1] = Math.Min(bounds[1], vertices[i * 3 + 1]);
bounds[2] = Math.Min(bounds[2], vertices[i * 3 + 2]); bounds[2] = Math.Min(bounds[2], vertices[i * 3 + 2]);
@ -115,9 +115,9 @@ namespace DotRecast.Recast
{ {
float m = i < 3 ? -1 : 1; float m = i < 3 ? -1 : 1;
int vi = i < 3 ? 0 : 7; int vi = i < 3 ? 0 : 7;
planes[i][0] = m * normals[i % 3][0]; planes[i][0] = m * normals[i % 3].x;
planes[i][1] = m * normals[i % 3][1]; planes[i][1] = m * normals[i % 3].y;
planes[i][2] = m * normals[i % 3][2]; planes[i][2] = m * normals[i % 3].z;
planes[i][3] = vertices[vi * 3] * planes[i][0] + vertices[vi * 3 + 1] * planes[i][1] planes[i][3] = vertices[vi * 3] * planes[i][0] + vertices[vi * 3 + 1] * planes[i][1]
+ vertices[vi * 3 + 2] * planes[i][2]; + vertices[vi * 3 + 2] * planes[i][2];
} }
@ -196,10 +196,10 @@ namespace DotRecast.Recast
return; return;
} }
bounds[3] = Math.Min(bounds[3], hf.bmax[0]); bounds[3] = Math.Min(bounds[3], hf.bmax.x);
bounds[5] = Math.Min(bounds[5], hf.bmax[2]); bounds[5] = Math.Min(bounds[5], hf.bmax.z);
bounds[0] = Math.Max(bounds[0], hf.bmin[0]); bounds[0] = Math.Max(bounds[0], hf.bmin.x);
bounds[2] = Math.Max(bounds[2], hf.bmin[2]); bounds[2] = Math.Max(bounds[2], hf.bmin.z);
if (bounds[3] <= bounds[0] || bounds[4] <= bounds[1] || bounds[5] <= bounds[2]) if (bounds[3] <= bounds[0] || bounds[4] <= bounds[1] || bounds[5] <= bounds[2])
{ {
@ -208,25 +208,25 @@ namespace DotRecast.Recast
float ics = 1.0f / hf.cs; float ics = 1.0f / hf.cs;
float ich = 1.0f / hf.ch; float ich = 1.0f / hf.ch;
int xMin = (int)((bounds[0] - hf.bmin[0]) * ics); int xMin = (int)((bounds[0] - hf.bmin.x) * ics);
int zMin = (int)((bounds[2] - hf.bmin[2]) * ics); int zMin = (int)((bounds[2] - hf.bmin.z) * ics);
int xMax = Math.Min(hf.width - 1, (int)((bounds[3] - hf.bmin[0]) * ics)); int xMax = Math.Min(hf.width - 1, (int)((bounds[3] - hf.bmin.x) * ics));
int zMax = Math.Min(hf.height - 1, (int)((bounds[5] - hf.bmin[2]) * ics)); int zMax = Math.Min(hf.height - 1, (int)((bounds[5] - hf.bmin.z) * ics));
float[] rectangle = new float[5]; float[] rectangle = new float[5];
rectangle[4] = hf.bmin[1]; rectangle[4] = hf.bmin.y;
for (int x = xMin; x <= xMax; x++) for (int x = xMin; x <= xMax; x++)
{ {
for (int z = zMin; z <= zMax; z++) for (int z = zMin; z <= zMax; z++)
{ {
rectangle[0] = x * hf.cs + hf.bmin[0]; rectangle[0] = x * hf.cs + hf.bmin.x;
rectangle[1] = z * hf.cs + hf.bmin[2]; rectangle[1] = z * hf.cs + hf.bmin.z;
rectangle[2] = rectangle[0] + hf.cs; rectangle[2] = rectangle[0] + hf.cs;
rectangle[3] = rectangle[1] + hf.cs; rectangle[3] = rectangle[1] + hf.cs;
float[] h = intersection.Invoke(rectangle); float[] h = intersection.Invoke(rectangle);
if (h != null) if (h != null)
{ {
int smin = (int)Math.Floor((h[0] - hf.bmin[1]) * ich); int smin = (int)Math.Floor((h[0] - hf.bmin.y) * ich);
int smax = (int)Math.Ceiling((h[1] - hf.bmin[1]) * ich); int smax = (int)Math.Ceiling((h[1] - hf.bmin.y) * ich);
if (smin != smax) if (smin != smax)
{ {
int ismin = clamp(smin, 0, SPAN_MAX_HEIGHT); int ismin = clamp(smin, 0, SPAN_MAX_HEIGHT);
@ -240,13 +240,13 @@ namespace DotRecast.Recast
private static float[] intersectSphere(float[] rectangle, Vector3f center, float radiusSqr) private static float[] intersectSphere(float[] rectangle, Vector3f center, float radiusSqr)
{ {
float x = Math.Max(rectangle[0], Math.Min(center[0], rectangle[2])); float x = Math.Max(rectangle[0], Math.Min(center.x, rectangle[2]));
float y = rectangle[4]; float y = rectangle[4];
float z = Math.Max(rectangle[1], Math.Min(center[2], rectangle[3])); float z = Math.Max(rectangle[1], Math.Min(center.z, rectangle[3]));
float mx = x - center[0]; float mx = x - center.x;
float my = y - center[1]; float my = y - center.y;
float mz = z - center[2]; float mz = z - center.z;
float b = my; // dot(m, d) d = (0, 1, 0) float b = my; // dot(m, d) d = (0, 1, 0)
float c = lenSqr(mx, my, mz) - radiusSqr; float c = lenSqr(mx, my, mz) - radiusSqr;
@ -276,7 +276,7 @@ namespace DotRecast.Recast
private static float[] intersectCapsule(float[] rectangle, Vector3f start, Vector3f end, Vector3f axis, float radiusSqr) private static float[] intersectCapsule(float[] rectangle, Vector3f start, Vector3f end, Vector3f axis, float radiusSqr)
{ {
float[] s = mergeIntersections(intersectSphere(rectangle, start, radiusSqr), intersectSphere(rectangle, end, radiusSqr)); float[] s = mergeIntersections(intersectSphere(rectangle, start, radiusSqr), intersectSphere(rectangle, end, radiusSqr));
float axisLen2dSqr = axis[0] * axis[0] + axis[2] * axis[2]; float axisLen2dSqr = axis.x * axis.x + axis.z * axis.z;
if (axisLen2dSqr > EPSILON) if (axisLen2dSqr > EPSILON)
{ {
s = slabsCylinderIntersection(rectangle, start, end, axis, radiusSqr, s); s = slabsCylinderIntersection(rectangle, start, end, axis, radiusSqr, s);
@ -289,20 +289,20 @@ namespace DotRecast.Recast
{ {
float[] s = mergeIntersections( float[] s = mergeIntersections(
rayCylinderIntersection(Vector3f.Of( rayCylinderIntersection(Vector3f.Of(
clamp(start[0], rectangle[0], rectangle[2]), rectangle[4], clamp(start.x, rectangle[0], rectangle[2]), rectangle[4],
clamp(start[2], rectangle[1], rectangle[3]) clamp(start.z, rectangle[1], rectangle[3])
), start, axis, radiusSqr), ), start, axis, radiusSqr),
rayCylinderIntersection(Vector3f.Of( rayCylinderIntersection(Vector3f.Of(
clamp(end[0], rectangle[0], rectangle[2]), rectangle[4], clamp(end.x, rectangle[0], rectangle[2]), rectangle[4],
clamp(end[2], rectangle[1], rectangle[3]) clamp(end.z, rectangle[1], rectangle[3])
), start, axis, radiusSqr)); ), start, axis, radiusSqr));
float axisLen2dSqr = axis[0] * axis[0] + axis[2] * axis[2]; float axisLen2dSqr = axis.x * axis.x + axis.z * axis.z;
if (axisLen2dSqr > EPSILON) if (axisLen2dSqr > EPSILON)
{ {
s = slabsCylinderIntersection(rectangle, start, end, axis, radiusSqr, s); s = slabsCylinderIntersection(rectangle, start, end, axis, radiusSqr, s);
} }
if (axis[1] * axis[1] > EPSILON) if (axis.y * axis.y > EPSILON)
{ {
float[][] rectangleOnStartPlane = ArrayUtils.Of<float>(4, 3); float[][] rectangleOnStartPlane = ArrayUtils.Of<float>(4, 3);
float[][] rectangleOnEndPlane = ArrayUtils.Of<float>(4, 3); float[][] rectangleOnEndPlane = ArrayUtils.Of<float>(4, 3);
@ -314,11 +314,11 @@ namespace DotRecast.Recast
float z = rectangle[(i & 2) + 1]; float z = rectangle[(i & 2) + 1];
Vector3f a = Vector3f.Of(x, rectangle[4], z); Vector3f a = Vector3f.Of(x, rectangle[4], z);
float dotAxisA = dot(axis, a); float dotAxisA = dot(axis, a);
float t = (ds - dotAxisA) / axis[1]; float t = (ds - dotAxisA) / axis.y;
rectangleOnStartPlane[i][0] = x; rectangleOnStartPlane[i][0] = x;
rectangleOnStartPlane[i][1] = rectangle[4] + t; rectangleOnStartPlane[i][1] = rectangle[4] + t;
rectangleOnStartPlane[i][2] = z; rectangleOnStartPlane[i][2] = z;
t = (de - dotAxisA) / axis[1]; t = (de - dotAxisA) / axis.y;
rectangleOnEndPlane[i][0] = x; rectangleOnEndPlane[i][0] = x;
rectangleOnEndPlane[i][1] = rectangle[4] + t; rectangleOnEndPlane[i][1] = rectangle[4] + t;
rectangleOnEndPlane[i][2] = z; rectangleOnEndPlane[i][2] = z;
@ -339,9 +339,9 @@ namespace DotRecast.Recast
int j = (i + 1) % 4; int j = (i + 1) % 4;
// Ray against sphere intersection // Ray against sphere intersection
var m = Vector3f.Of( var m = Vector3f.Of(
rectangleOnPlane[i][0] - start[0], rectangleOnPlane[i][0] - start.x,
rectangleOnPlane[i][1] - start[1], rectangleOnPlane[i][1] - start.y,
rectangleOnPlane[i][2] - start[2] rectangleOnPlane[i][2] - start.z
); );
var d = Vector3f.Of( var d = Vector3f.Of(
rectangleOnPlane[j][0] - rectangleOnPlane[i][0], rectangleOnPlane[j][0] - rectangleOnPlane[i][0],
@ -361,8 +361,8 @@ namespace DotRecast.Recast
{ {
t1 = Math.Max(0, t1); t1 = Math.Max(0, t1);
t2 = Math.Min(1, t2); t2 = Math.Min(1, t2);
float y1 = rectangleOnPlane[i][1] + t1 * d[1]; float y1 = rectangleOnPlane[i][1] + t1 * d.y;
float y2 = rectangleOnPlane[i][1] + t2 * d[1]; float y2 = rectangleOnPlane[i][1] + t2 * d.y;
float[] y = { Math.Min(y1, y2), Math.Max(y1, y2) }; float[] y = { Math.Min(y1, y2), Math.Max(y1, y2) };
s = mergeIntersections(s, y); s = mergeIntersections(s, y);
} }
@ -374,22 +374,22 @@ namespace DotRecast.Recast
private static float[] slabsCylinderIntersection(float[] rectangle, Vector3f start, Vector3f end, Vector3f axis, float radiusSqr, private static float[] slabsCylinderIntersection(float[] rectangle, Vector3f start, Vector3f end, Vector3f axis, float radiusSqr,
float[] s) float[] s)
{ {
if (Math.Min(start[0], end[0]) < rectangle[0]) if (Math.Min(start.x, end.x) < rectangle[0])
{ {
s = mergeIntersections(s, xSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[0])); s = mergeIntersections(s, xSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[0]));
} }
if (Math.Max(start[0], end[0]) > rectangle[2]) if (Math.Max(start.x, end.x) > rectangle[2])
{ {
s = mergeIntersections(s, xSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[2])); s = mergeIntersections(s, xSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[2]));
} }
if (Math.Min(start[2], end[2]) < rectangle[1]) if (Math.Min(start.z, end.z) < rectangle[1])
{ {
s = mergeIntersections(s, zSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[1])); s = mergeIntersections(s, zSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[1]));
} }
if (Math.Max(start[2], end[2]) > rectangle[3]) if (Math.Max(start.z, end.z) > rectangle[3])
{ {
s = mergeIntersections(s, zSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[3])); s = mergeIntersections(s, zSlabCylinderIntersection(rectangle, start, axis, radiusSqr, rectangle[3]));
} }
@ -405,8 +405,8 @@ namespace DotRecast.Recast
private static Vector3f xSlabRayIntersection(float[] rectangle, Vector3f start, Vector3f direction, float x) private static Vector3f xSlabRayIntersection(float[] rectangle, Vector3f start, Vector3f direction, float x)
{ {
// 2d intersection of plane and segment // 2d intersection of plane and segment
float t = (x - start[0]) / direction[0]; float t = (x - start.x) / direction.x;
float z = clamp(start[2] + t * direction[2], rectangle[1], rectangle[3]); float z = clamp(start.z + t * direction.z, rectangle[1], rectangle[3]);
return Vector3f.Of(x, rectangle[4], z); return Vector3f.Of(x, rectangle[4], z);
} }
@ -418,8 +418,8 @@ namespace DotRecast.Recast
private static Vector3f zSlabRayIntersection(float[] rectangle, Vector3f start, Vector3f direction, float z) private static Vector3f zSlabRayIntersection(float[] rectangle, Vector3f start, Vector3f direction, float z)
{ {
// 2d intersection of plane and segment // 2d intersection of plane and segment
float t = (z - start[2]) / direction[2]; float t = (z - start.z) / direction.z;
float x = clamp(start[0] + t * direction[0], rectangle[0], rectangle[2]); float x = clamp(start.x + t * direction.x, rectangle[0], rectangle[2]);
return Vector3f.Of(x, rectangle[4], z); return Vector3f.Of(x, rectangle[4], z);
} }
@ -427,17 +427,17 @@ namespace DotRecast.Recast
private static float[] rayCylinderIntersection(Vector3f point, Vector3f start, Vector3f axis, float radiusSqr) private static float[] rayCylinderIntersection(Vector3f point, Vector3f start, Vector3f axis, float radiusSqr)
{ {
Vector3f d = axis; Vector3f d = axis;
Vector3f m = Vector3f.Of(point[0] - start[0], point[1] - start[1], point[2] - start[2]); Vector3f m = Vector3f.Of(point.x - start.x, point.y - start.y, point.z - start.z);
// float[] n = { 0, 1, 0 }; // float[] n = { 0, 1, 0 };
float md = dot(m, d); float md = dot(m, d);
// float nd = dot(n, d); // float nd = dot(n, d);
float nd = axis[1]; float nd = axis.y;
float dd = dot(d, d); float dd = dot(d, d);
// float nn = dot(n, n); // float nn = dot(n, n);
float nn = 1; float nn = 1;
// float mn = dot(m, n); // float mn = dot(m, n);
float mn = m[1]; float mn = m.y;
// float a = dd * nn - nd * nd; // float a = dd * nn - nd * nd;
float a = dd - nd * nd; float a = dd - nd * nd;
float k = dot(m, m) - radiusSqr; float k = dot(m, m) - radiusSqr;
@ -453,7 +453,7 @@ namespace DotRecast.Recast
// Now known that segment intersects cylinder; figure out how it intersects // Now known that segment intersects cylinder; figure out how it intersects
float tt1 = -mn / nn; // Intersect segment against ’p’ endcap float tt1 = -mn / nn; // Intersect segment against ’p’ endcap
float tt2 = (nd - mn) / nn; // Intersect segment against ’q’ endcap float tt2 = (nd - mn) / nn; // Intersect segment against ’q’ endcap
return new float[] { point[1] + Math.Min(tt1, tt2), point[1] + Math.Max(tt1, tt2) }; return new float[] { point.y + Math.Min(tt1, tt2), point.y + Math.Max(tt1, tt2) };
} }
float b = dd * mn - nd * md; float b = dd * mn - nd * md;
@ -505,7 +505,7 @@ namespace DotRecast.Recast
} }
} }
return new float[] { point[1] + Math.Min(t1, t2), point[1] + Math.Max(t1, t2) }; return new float[] { point.y + Math.Min(t1, t2), point.y + Math.Max(t1, t2) };
} }
private static float[] intersectBox(float[] rectangle, float[] vertices, float[][] planes) private static float[] intersectBox(float[] rectangle, float[] vertices, float[][] planes)
@ -528,21 +528,21 @@ namespace DotRecast.Recast
var point = Vector3f.Of(0, rectangle[1], 0); var point = Vector3f.Of(0, rectangle[1], 0);
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
point[0] = ((i & 1) == 0) ? rectangle[0] : rectangle[2]; point.x = ((i & 1) == 0) ? rectangle[0] : rectangle[2];
point[2] = ((i & 2) == 0) ? rectangle[1] : rectangle[3]; point.z = ((i & 2) == 0) ? rectangle[1] : rectangle[3];
for (int j = 0; j < 6; j++) for (int j = 0; j < 6; j++)
{ {
if (Math.Abs(planes[j][1]) > EPSILON) if (Math.Abs(planes[j][1]) > EPSILON)
{ {
float dotNormalPoint = dot(planes[j], point); float dotNormalPoint = dot(planes[j], point);
float t = (planes[j][3] - dotNormalPoint) / planes[j][1]; float t = (planes[j][3] - dotNormalPoint) / planes[j][1];
float y = point[1] + t; float y = point.y + t;
bool valid = true; bool valid = true;
for (int k = 0; k < 6; k++) for (int k = 0; k < 6; k++)
{ {
if (k != j) if (k != j)
{ {
if (point[0] * planes[k][0] + y * planes[k][1] + point[2] * planes[k][2] > planes[k][3]) if (point.x * planes[k][0] + y * planes[k][1] + point.z * planes[k][2] > planes[k][3])
{ {
valid = false; valid = false;
break; break;
@ -689,8 +689,8 @@ namespace DotRecast.Recast
var point = Vector3f.Of(0, rectangle[1], 0); var point = Vector3f.Of(0, rectangle[1], 0);
for (int i = 0; i < 4; i++) for (int i = 0; i < 4; i++)
{ {
point[0] = ((i & 1) == 0) ? rectangle[0] : rectangle[2]; point.x = ((i & 1) == 0) ? rectangle[0] : rectangle[2];
point[2] = ((i & 2) == 0) ? rectangle[1] : rectangle[3]; point.z = ((i & 2) == 0) ? rectangle[1] : rectangle[3];
float? y = rayTriangleIntersection(point, tri, planes); float? y = rayTriangleIntersection(point, tri, planes);
if (y != null) if (y != null)
{ {
@ -745,7 +745,7 @@ namespace DotRecast.Recast
private static float? rayTriangleIntersection(Vector3f point, int plane, float[][] planes) private static float? rayTriangleIntersection(Vector3f point, int plane, float[][] planes)
{ {
float t = (planes[plane][3] - dot(planes[plane], point)) / planes[plane][1]; float t = (planes[plane][3] - dot(planes[plane], point)) / planes[plane][1];
float[] s = { point[0], point[1] + t, point[2] }; float[] s = { point.x, point.y + t, point.z };
float u = dot(s, planes[plane + 1]) - planes[plane + 1][3]; float u = dot(s, planes[plane + 1]) - planes[plane + 1][3];
if (u < 0.0f || u > 1.0f) if (u < 0.0f || u > 1.0f)
{ {
@ -790,9 +790,9 @@ namespace DotRecast.Recast
private static bool overlapBounds(Vector3f amin, Vector3f amax, float[] bounds) private static bool overlapBounds(Vector3f amin, Vector3f amax, float[] bounds)
{ {
bool overlap = true; bool overlap = true;
overlap = (amin[0] > bounds[3] || amax[0] < bounds[0]) ? false : overlap; overlap = (amin.x > bounds[3] || amax.x < bounds[0]) ? false : overlap;
overlap = (amin[1] > bounds[4]) ? false : overlap; overlap = (amin.y > bounds[4]) ? false : overlap;
overlap = (amin[2] > bounds[5] || amax[2] < bounds[2]) ? false : overlap; overlap = (amin.z > bounds[5] || amax.z < bounds[2]) ? false : overlap;
return overlap; return overlap;
} }
} }

12
src/DotRecast.Recast/RecastLayers.cs
View File

@ -432,10 +432,10 @@ namespace DotRecast.Recast
Vector3f bmax = new Vector3f(); Vector3f bmax = new Vector3f();
copy(ref bmin, chf.bmin); copy(ref bmin, chf.bmin);
copy(ref bmax, chf.bmax); copy(ref bmax, chf.bmax);
bmin[0] += borderSize * chf.cs; bmin.x += borderSize * chf.cs;
bmin[2] += borderSize * chf.cs; bmin.z += borderSize * chf.cs;
bmax[0] -= borderSize * chf.cs; bmax.x -= borderSize * chf.cs;
bmax[2] -= borderSize * chf.cs; bmax.z -= borderSize * chf.cs;
HeightfieldLayerSet lset = new HeightfieldLayerSet(); HeightfieldLayerSet lset = new HeightfieldLayerSet();
lset.layers = new HeightfieldLayerSet.HeightfieldLayer[layerId]; lset.layers = new HeightfieldLayerSet.HeightfieldLayer[layerId];
@ -477,8 +477,8 @@ namespace DotRecast.Recast
// Adjust the bbox to fit the heightfield. // Adjust the bbox to fit the heightfield.
copy(ref layer.bmin, bmin); copy(ref layer.bmin, bmin);
copy(ref layer.bmax, bmax); copy(ref layer.bmax, bmax);
layer.bmin[1] = bmin[1] + hmin * chf.ch; layer.bmin.y = bmin.y + hmin * chf.ch;
layer.bmax[1] = bmin[1] + hmax * chf.ch; layer.bmax.y = bmin.y + hmax * chf.ch;
layer.hmin = hmin; layer.hmin = hmin;
layer.hmax = hmax; layer.hmax = hmax;

8
src/DotRecast.Recast/RecastMesh.cs
View File

@ -1268,13 +1268,13 @@ namespace DotRecast.Recast
{ {
PolyMesh pmesh = meshes[i]; PolyMesh pmesh = meshes[i];
int ox = (int)Math.Floor((pmesh.bmin[0] - mesh.bmin[0]) / mesh.cs + 0.5f); int ox = (int)Math.Floor((pmesh.bmin.x - mesh.bmin.x) / mesh.cs + 0.5f);
int oz = (int)Math.Floor((pmesh.bmin[2] - mesh.bmin[2]) / mesh.cs + 0.5f); int oz = (int)Math.Floor((pmesh.bmin.z - mesh.bmin.z) / mesh.cs + 0.5f);
bool isMinX = (ox == 0); bool isMinX = (ox == 0);
bool isMinZ = (oz == 0); bool isMinZ = (oz == 0);
bool isMaxX = (Math.Floor((mesh.bmax[0] - pmesh.bmax[0]) / mesh.cs + 0.5f)) == 0; bool isMaxX = (Math.Floor((mesh.bmax.x - pmesh.bmax.x) / mesh.cs + 0.5f)) == 0;
bool isMaxZ = (Math.Floor((mesh.bmax[2] - pmesh.bmax[2]) / mesh.cs + 0.5f)) == 0; bool isMaxZ = (Math.Floor((mesh.bmax.z - pmesh.bmax.z) / mesh.cs + 0.5f)) == 0;
bool isOnBorder = (isMinX || isMinZ || isMaxX || isMaxZ); bool isOnBorder = (isMinX || isMinZ || isMaxX || isMaxZ);
for (int j = 0; j < pmesh.nverts; ++j) for (int j = 0; j < pmesh.nverts; ++j)

80
src/DotRecast.Recast/RecastMeshDetail.cs
View File

@ -53,7 +53,7 @@ namespace DotRecast.Recast
private static float vdot2(Vector3f a, Vector3f b) private static float vdot2(Vector3f a, Vector3f b)
{ {
return a[0] * b[0] + a[2] * b[2]; return a.x * b.x + a.z * b.z;
} }
@ -78,16 +78,16 @@ namespace DotRecast.Recast
private static float vdistSq2(float[] p, Vector3f q) private static float vdistSq2(float[] p, Vector3f q)
{ {
float dx = q[0] - p[0]; float dx = q.x - p[0];
float dy = q[2] - p[2]; float dy = q.z - p[2];
return dx * dx + dy * dy; return dx * dx + dy * dy;
} }
private static float vdistSq2(Vector3f p, Vector3f q) private static float vdistSq2(Vector3f p, Vector3f q)
{ {
float dx = q[0] - p[0]; float dx = q.x - p.x;
float dy = q[2] - p[2]; float dy = q.z - p.z;
return dx * dx + dy * dy; return dx * dx + dy * dy;
} }
@ -117,8 +117,8 @@ namespace DotRecast.Recast
private static float vdistSq2(Vector3f p, float[] verts, int q) private static float vdistSq2(Vector3f p, float[] verts, int q)
{ {
float dx = verts[q + 0] - p[0]; float dx = verts[q + 0] - p.x;
float dy = verts[q + 2] - p[2]; float dy = verts[q + 2] - p.z;
return dx * dx + dy * dy; return dx * dx + dy * dy;
} }
@ -154,10 +154,10 @@ namespace DotRecast.Recast
private static float vcross2(Vector3f p1, Vector3f p2, Vector3f p3) private static float vcross2(Vector3f p1, Vector3f p2, Vector3f p3)
{ {
float u1 = p2[0] - p1[0]; float u1 = p2.x - p1.x;
float v1 = p2[2] - p1[2]; float v1 = p2.z - p1.z;
float u2 = p3[0] - p1[0]; float u2 = p3.x - p1.x;
float v2 = p3[2] - p1[2]; float v2 = p3.z - p1.z;
return u1 * v2 - v1 * u2; return u1 * v2 - v1 * u2;
} }
@ -178,9 +178,9 @@ namespace DotRecast.Recast
float v1Sq = vdot2(v1, v1); float v1Sq = vdot2(v1, v1);
float v2Sq = vdot2(v2, v2); float v2Sq = vdot2(v2, v2);
float v3Sq = vdot2(v3, v3); float v3Sq = vdot2(v3, v3);
c[0] = (v1Sq * (v2[2] - v3[2]) + v2Sq * (v3[2] - v1[2]) + v3Sq * (v1[2] - v2[2])) / (2 * cp); c.x = (v1Sq * (v2.z - v3.z) + v2Sq * (v3.z - v1.z) + v3Sq * (v1.z - v2.z)) / (2 * cp);
c[1] = 0; c.y = 0;
c[2] = (v1Sq * (v3[0] - v2[0]) + v2Sq * (v1[0] - v3[0]) + v3Sq * (v2[0] - v1[0])) / (2 * cp); c.z = (v1Sq * (v3.x - v2.x) + v2Sq * (v1.x - v3.x) + v3Sq * (v2.x - v1.x)) / (2 * cp);
r.Exchange(vdist2(c, v1)); r.Exchange(vdist2(c, v1));
RecastVectors.add(ref c, c, verts, p1); RecastVectors.add(ref c, c, verts, p1);
return true; return true;
@ -215,8 +215,8 @@ namespace DotRecast.Recast
float EPS = 1e-4f; float EPS = 1e-4f;
if (u >= -EPS && v >= -EPS && (u + v) <= 1 + EPS) if (u >= -EPS && v >= -EPS && (u + v) <= 1 + EPS)
{ {
float y = verts[a + 1] + v0[1] * u + v1[1] * v; float y = verts[a + 1] + v0.y * u + v1.y * v;
return Math.Abs(y - p[1]); return Math.Abs(y - p.y);
} }
return float.MaxValue; return float.MaxValue;
@ -257,8 +257,8 @@ namespace DotRecast.Recast
{ {
float pqx = poly[q + 0] - poly[p + 0]; float pqx = poly[q + 0] - poly[p + 0];
float pqz = poly[q + 2] - poly[p + 2]; float pqz = poly[q + 2] - poly[p + 2];
float dx = verts[0] - poly[p + 0]; float dx = verts.x - poly[p + 0];
float dz = verts[2] - poly[p + 2]; float dz = verts.z - poly[p + 2];
float d = pqx * pqx + pqz * pqz; float d = pqx * pqx + pqz * pqz;
float t = pqx * dx + pqz * dz; float t = pqx * dx + pqz * dz;
if (d > 0) if (d > 0)
@ -275,8 +275,8 @@ namespace DotRecast.Recast
t = 1; t = 1;
} }
dx = poly[p + 0] + t * pqx - verts[0]; dx = poly[p + 0] + t * pqx - verts.x;
dz = poly[p + 2] + t * pqz - verts[2]; dz = poly[p + 2] + t * pqz - verts.z;
return dx * dx + dz * dz; return dx * dx + dz * dz;
} }
@ -341,8 +341,8 @@ namespace DotRecast.Recast
{ {
int vi = i * 3; int vi = i * 3;
int vj = j * 3; int vj = j * 3;
if (((verts[vi + 2] > p[2]) != (verts[vj + 2] > p[2])) && (p[0] < (verts[vj + 0] - verts[vi + 0]) if (((verts[vi + 2] > p.z) != (verts[vj + 2] > p.z)) && (p.x < (verts[vj + 0] - verts[vi + 0])
* (p[2] - verts[vi + 2]) / (verts[vj + 2] - verts[vi + 2]) + verts[vi + 0])) * (p.z - verts[vi + 2]) / (verts[vj + 2] - verts[vi + 2]) + verts[vi + 0]))
{ {
c = !c; c = !c;
} }
@ -716,7 +716,7 @@ namespace DotRecast.Recast
if (tris[t + 0] == -1 || tris[t + 1] == -1 || tris[t + 2] == -1) if (tris[t + 0] == -1 || tris[t + 1] == -1 || tris[t + 2] == -1)
{ {
Console.Error.WriteLine("Dangling! " + tris[t] + " " + tris[t + 1] + " " + tris[t + 2]); Console.Error.WriteLine("Dangling! " + tris[t] + " " + tris[t + 1] + " " + tris[t + 2]);
// ctx.log(RC_LOG_WARNING, "delaunayHull: Removing dangling face %d [%d,%d,%d].", i, t[0],t[1],t[2]); // ctx.log(RC_LOG_WARNING, "delaunayHull: Removing dangling face %d [%d,%d,%d].", i, t.x,t.y,t.z);
tris[t + 0] = tris[tris.Count - 4]; tris[t + 0] = tris[tris.Count - 4];
tris[t + 1] = tris[tris.Count - 3]; tris[t + 1] = tris[tris.Count - 3];
tris[t + 2] = tris[tris.Count - 2]; tris[t + 2] = tris[tris.Count - 2];
@ -1021,19 +1021,19 @@ namespace DotRecast.Recast
RecastVectors.max(ref bmax, @in, i * 3); RecastVectors.max(ref bmax, @in, i * 3);
} }
int x0 = (int)Math.Floor(bmin[0] / sampleDist); int x0 = (int)Math.Floor(bmin.x / sampleDist);
int x1 = (int)Math.Ceiling(bmax[0] / sampleDist); int x1 = (int)Math.Ceiling(bmax.x / sampleDist);
int z0 = (int)Math.Floor(bmin[2] / sampleDist); int z0 = (int)Math.Floor(bmin.z / sampleDist);
int z1 = (int)Math.Ceiling(bmax[2] / sampleDist); int z1 = (int)Math.Ceiling(bmax.z / sampleDist);
samples.Clear(); samples.Clear();
for (int z = z0; z < z1; ++z) for (int z = z0; z < z1; ++z)
{ {
for (int x = x0; x < x1; ++x) for (int x = x0; x < x1; ++x)
{ {
Vector3f pt = new Vector3f(); Vector3f pt = new Vector3f();
pt[0] = x * sampleDist; pt.x = x * sampleDist;
pt[1] = (bmax[1] + bmin[1]) * 0.5f; pt.y = (bmax.y + bmin.y) * 0.5f;
pt[2] = z * sampleDist; pt.z = z * sampleDist;
// Make sure the samples are not too close to the edges. // Make sure the samples are not too close to the edges.
if (distToPoly(nin, @in, pt) > -sampleDist / 2) if (distToPoly(nin, @in, pt) > -sampleDist / 2)
{ {
@ -1041,7 +1041,7 @@ namespace DotRecast.Recast
} }
samples.Add(x); samples.Add(x);
samples.Add(getHeight(pt[0], pt[1], pt[2], cs, ics, chf.ch, heightSearchRadius, hp)); samples.Add(getHeight(pt.x, pt.y, pt.z, cs, ics, chf.ch, heightSearchRadius, hp));
samples.Add(z); samples.Add(z);
samples.Add(0); // Not added samples.Add(0); // Not added
} }
@ -1073,9 +1073,9 @@ namespace DotRecast.Recast
Vector3f pt = new Vector3f(); Vector3f pt = new Vector3f();
// The sample location is jittered to get rid of some bad triangulations // The sample location is jittered to get rid of some bad triangulations
// which are cause by symmetrical data from the grid structure. // which are cause by symmetrical data from the grid structure.
pt[0] = samples[s + 0] * sampleDist + getJitterX(i) * cs * 0.1f; pt.x = samples[s + 0] * sampleDist + getJitterX(i) * cs * 0.1f;
pt[1] = samples[s + 1] * chf.ch; pt.y = samples[s + 1] * chf.ch;
pt[2] = samples[s + 2] * sampleDist + getJitterY(i) * cs * 0.1f; pt.z = samples[s + 2] * sampleDist + getJitterY(i) * cs * 0.1f;
float d = distToTriMesh(pt, verts, nverts, tris, tris.Count / 4); float d = distToTriMesh(pt, verts, nverts, tris, tris.Count / 4);
if (d < 0) if (d < 0)
{ {
@ -1542,18 +1542,18 @@ namespace DotRecast.Recast
// Move detail verts to world space. // Move detail verts to world space.
for (int j = 0; j < nverts; ++j) for (int j = 0; j < nverts; ++j)
{ {
verts[j * 3 + 0] += orig[0]; verts[j * 3 + 0] += orig.x;
verts[j * 3 + 1] += orig[1] + chf.ch; // Is this offset necessary? See verts[j * 3 + 1] += orig.y + chf.ch; // Is this offset necessary? See
// https://groups.google.com/d/msg/recastnavigation/UQFN6BGCcV0/-1Ny4koOBpkJ // https://groups.google.com/d/msg/recastnavigation/UQFN6BGCcV0/-1Ny4koOBpkJ
verts[j * 3 + 2] += orig[2]; verts[j * 3 + 2] += orig.z;
} }
// Offset poly too, will be used to flag checking. // Offset poly too, will be used to flag checking.
for (int j = 0; j < npoly; ++j) for (int j = 0; j < npoly; ++j)
{ {
poly[j * 3 + 0] += orig[0]; poly[j * 3 + 0] += orig.x;
poly[j * 3 + 1] += orig[1]; poly[j * 3 + 1] += orig.y;
poly[j * 3 + 2] += orig[2]; poly[j * 3 + 2] += orig.z;
} }
// Store detail submesh. // Store detail submesh.

24
src/DotRecast.Recast/RecastRasterization.cs
View File

@ -53,9 +53,9 @@ namespace DotRecast.Recast
private static bool overlapBounds(Vector3f amin, Vector3f amax, Vector3f bmin, Vector3f bmax) private static bool overlapBounds(Vector3f amin, Vector3f amax, Vector3f bmin, Vector3f bmax)
{ {
bool overlap = true; bool overlap = true;
overlap = (amin[0] > bmax[0] || amax[0] < bmin[0]) ? false : overlap; overlap = (amin.x > bmax.x || amax.x < bmin.x) ? false : overlap;
overlap = (amin[1] > bmax[1] || amax[1] < bmin[1]) ? false : overlap; overlap = (amin.y > bmax.y || amax.y < bmin.y) ? false : overlap;
overlap = (amin[2] > bmax[2] || amax[2] < bmin[2]) ? false : overlap; overlap = (amin.z > bmax.z || amax.z < bmin.z) ? false : overlap;
return overlap; return overlap;
} }
@ -260,7 +260,7 @@ namespace DotRecast.Recast
{ {
Vector3f tmin = new Vector3f(); Vector3f tmin = new Vector3f();
Vector3f tmax = new Vector3f(); Vector3f tmax = new Vector3f();
float by = hfBBMax[1] - hfBBMin[1]; float by = hfBBMax.y - hfBBMin.y;
// Calculate the bounding box of the triangle. // Calculate the bounding box of the triangle.
RecastVectors.copy(ref tmin, verts, v0 * 3); RecastVectors.copy(ref tmin, verts, v0 * 3);
@ -275,8 +275,8 @@ namespace DotRecast.Recast
return; return;
// Calculate the footprint of the triangle on the grid's y-axis // Calculate the footprint of the triangle on the grid's y-axis
int z0 = (int)((tmin[2] - hfBBMin[2]) * inverseCellSize); int z0 = (int)((tmin.z - hfBBMin.z) * inverseCellSize);
int z1 = (int)((tmax[2] - hfBBMin[2]) * inverseCellSize); int z1 = (int)((tmax.z - hfBBMin.z) * inverseCellSize);
int w = hf.width; int w = hf.width;
int h = hf.height; int h = hf.height;
@ -299,7 +299,7 @@ namespace DotRecast.Recast
for (int z = z0; z <= z1; ++z) for (int z = z0; z <= z1; ++z)
{ {
// Clip polygon to row. Store the remaining polygon as well // Clip polygon to row. Store the remaining polygon as well
float cellZ = hfBBMin[2] + z * cellSize; float cellZ = hfBBMin.z + z * cellSize;
int[] nvrowin = dividePoly(buf, @in, nvIn, inRow, p1, cellZ + cellSize, 2); int[] nvrowin = dividePoly(buf, @in, nvIn, inRow, p1, cellZ + cellSize, 2);
nvRow = nvrowin[0]; nvRow = nvrowin[0];
nvIn = nvrowin[1]; nvIn = nvrowin[1];
@ -325,8 +325,8 @@ namespace DotRecast.Recast
maxX = Math.Max(maxX, v); maxX = Math.Max(maxX, v);
} }
int x0 = (int)((minX - hfBBMin[0]) * inverseCellSize); int x0 = (int)((minX - hfBBMin.x) * inverseCellSize);
int x1 = (int)((maxX - hfBBMin[0]) * inverseCellSize); int x1 = (int)((maxX - hfBBMin.x) * inverseCellSize);
if (x1 < 0 || x0 >= w) if (x1 < 0 || x0 >= w)
{ {
continue; continue;
@ -339,7 +339,7 @@ namespace DotRecast.Recast
for (int x = x0; x <= x1; ++x) for (int x = x0; x <= x1; ++x)
{ {
// Clip polygon to column. store the remaining polygon as well // Clip polygon to column. store the remaining polygon as well
float cx = hfBBMin[0] + x * cellSize; float cx = hfBBMin.x + x * cellSize;
int[] nvnv2 = dividePoly(buf, inRow, nv2, p1, p2, cx + cellSize, 0); int[] nvnv2 = dividePoly(buf, inRow, nv2, p1, p2, cx + cellSize, 0);
nv = nvnv2[0]; nv = nvnv2[0];
nv2 = nvnv2[1]; nv2 = nvnv2[1];
@ -364,8 +364,8 @@ namespace DotRecast.Recast
spanMax = Math.Max(spanMax, buf[p1 + i * 3 + 1]); spanMax = Math.Max(spanMax, buf[p1 + i * 3 + 1]);
} }
spanMin -= hfBBMin[1]; spanMin -= hfBBMin.y;
spanMax -= hfBBMin[1]; spanMax -= hfBBMin.y;
// Skip the span if it is outside the heightfield bbox // Skip the span if it is outside the heightfield bbox
if (spanMax < 0.0f) if (spanMax < 0.0f)
continue; continue;

54
src/DotRecast.Recast/RecastVectors.cs
View File

@ -27,30 +27,30 @@ namespace DotRecast.Recast
{ {
public static void min(ref Vector3f a, float[] b, int i) public static void min(ref Vector3f a, float[] b, int i)
{ {
a.x = Math.Min(a[0], b[i + 0]); a.x = Math.Min(a.x, b[i + 0]);
a.y = Math.Min(a[1], b[i + 1]); a.y = Math.Min(a.y, b[i + 1]);
a.z = Math.Min(a[2], b[i + 2]); a.z = Math.Min(a.z, b[i + 2]);
} }
public static void min(ref Vector3f a, Vector3f b, int i) public static void min(ref Vector3f a, Vector3f b, int i)
{ {
a.x = Math.Min(a[0], b[i + 0]); a.x = Math.Min(a.x, b[i + 0]);
a.y = Math.Min(a[1], b[i + 1]); a.y = Math.Min(a.y, b[i + 1]);
a.z = Math.Min(a[2], b[i + 2]); a.z = Math.Min(a.z, b[i + 2]);
} }
public static void max(ref Vector3f a, float[] b, int i) public static void max(ref Vector3f a, float[] b, int i)
{ {
a.x = Math.Max(a[0], b[i + 0]); a.x = Math.Max(a.x, b[i + 0]);
a.y = Math.Max(a[1], b[i + 1]); a.y = Math.Max(a.y, b[i + 1]);
a.z = Math.Max(a[2], b[i + 2]); a.z = Math.Max(a.z, b[i + 2]);
} }
public static void max(ref Vector3f a, Vector3f b, int i) public static void max(ref Vector3f a, Vector3f b, int i)
{ {
a.x = Math.Max(a[0], b[i + 0]); a.x = Math.Max(a.x, b[i + 0]);
a.y = Math.Max(a[1], b[i + 1]); a.y = Math.Max(a.y, b[i + 1]);
a.z = Math.Max(a[2], b[i + 2]); a.z = Math.Max(a.z, b[i + 2]);
} }
public static void copy(ref Vector3f @out, float[] @in, int i) public static void copy(ref Vector3f @out, float[] @in, int i)
@ -103,9 +103,9 @@ namespace DotRecast.Recast
public static void add(ref Vector3f e0, Vector3f a, float[] verts, int i) public static void add(ref Vector3f e0, Vector3f a, float[] verts, int i)
{ {
e0.x = a[0] + verts[i]; e0.x = a.x + verts[i];
e0.y = a[1] + verts[i + 1]; e0.y = a.y + verts[i + 1];
e0.z = a[2] + verts[i + 2]; e0.z = a.z + verts[i + 2];
} }
@ -119,9 +119,9 @@ namespace DotRecast.Recast
public static void sub(ref Vector3f e0, Vector3f i, float[] verts, int j) public static void sub(ref Vector3f e0, Vector3f i, float[] verts, int j)
{ {
e0.x = i[0] - verts[j]; e0.x = i.x - verts[j];
e0.y = i[1] - verts[j + 1]; e0.y = i.y - verts[j + 1];
e0.z = i[2] - verts[j + 2]; e0.z = i.z - verts[j + 2];
} }
@ -134,16 +134,16 @@ namespace DotRecast.Recast
public static void cross(float[] dest, Vector3f v1, Vector3f v2) public static void cross(float[] dest, Vector3f v1, Vector3f v2)
{ {
dest[0] = v1[1] * v2[2] - v1[2] * v2[1]; dest[0] = v1.y * v2.z - v1.z * v2.y;
dest[1] = v1[2] * v2[0] - v1[0] * v2[2]; dest[1] = v1.z * v2.x - v1.x * v2.z;
dest[2] = v1[0] * v2[1] - v1[1] * v2[0]; dest[2] = v1.x * v2.y - v1.y * v2.x;
} }
public static void cross(ref Vector3f dest, Vector3f v1, Vector3f v2) public static void cross(ref Vector3f dest, Vector3f v1, Vector3f v2)
{ {
dest.x = v1[1] * v2[2] - v1[2] * v2[1]; dest.x = v1.y * v2.z - v1.z * v2.y;
dest.y = v1[2] * v2[0] - v1[0] * v2[2]; dest.y = v1.z * v2.x - v1.x * v2.z;
dest.z = v1[0] * v2[1] - v1[1] * v2[0]; dest.z = v1.x * v2.y - v1.y * v2.x;
} }
@ -157,7 +157,7 @@ namespace DotRecast.Recast
public static void normalize(ref Vector3f v) public static void normalize(ref Vector3f v)
{ {
float d = (float)(1.0f / Math.Sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2])); float d = (float)(1.0f / Math.Sqrt(v.x * v.x + v.y * v.y + v.z * v.z));
v.x *= d; v.x *= d;
v.y *= d; v.y *= d;
v.z *= d; v.z *= d;
@ -170,12 +170,12 @@ namespace DotRecast.Recast
public static float dot(float[] v1, Vector3f v2) public static float dot(float[] v1, Vector3f v2)
{ {
return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]; return v1[0] * v2.x + v1[1] * v2.y + v1[2] * v2.z;
} }
public static float dot(Vector3f v1, Vector3f v2) public static float dot(Vector3f v1, Vector3f v2)
{ {
return v1[0] * v2[0] + v1[1] * v2[1] + v1[2] * v2[2]; return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
} }
} }

8
src/DotRecast.Recast/RecastVoxelization.cs
View File

@ -48,10 +48,10 @@ namespace DotRecast.Recast
{ {
float[] tbmin = new float[2]; float[] tbmin = new float[2];
float[] tbmax = new float[2]; float[] tbmax = new float[2];
tbmin[0] = builderCfg.bmin[0]; tbmin[0] = builderCfg.bmin.x;
tbmin[1] = builderCfg.bmin[2]; tbmin[1] = builderCfg.bmin.z;
tbmax[0] = builderCfg.bmax[0]; tbmax[0] = builderCfg.bmax.x;
tbmax[1] = builderCfg.bmax[2]; tbmax[1] = builderCfg.bmax.z;
List<ChunkyTriMeshNode> nodes = geom.getChunksOverlappingRect(tbmin, tbmax); List<ChunkyTriMeshNode> nodes = geom.getChunksOverlappingRect(tbmin, tbmax);
foreach (ChunkyTriMeshNode node in nodes) foreach (ChunkyTriMeshNode node in nodes)
{ {