public static float Distance(RecastVertex left, RecastVertex right)
{
float dx = right.X - left.X;
float dy = right.Y - left.Y;
float dz = right.Z - left.Z;
return((float)Math.Sqrt(dx * dx + dy * dy + dz * dz));
}
public static float SquareDistance(RecastVertex left, RecastVertex right)
{
float dx = right.X - left.X;
float dy = right.Y - left.Y;
float dz = right.Z - left.Z;
return(dx * dx + dy * dy + dz * dz);
}
public static RecastVertex Cross(RecastVertex left, RecastVertex right)
{
return(new RecastVertex
{
X = left.Y * right.Z - left.Z * right.Y,
Y = left.Z * right.X - left.X * right.Z,
Z = left.X * right.Y - left.Y * right.X
});
}
public static RecastVertex Max(RecastVertex left, RecastVertex right)
{
return(new RecastVertex
{
X = Math.Max(left.X, right.X),
Y = Math.Max(left.Y, right.Y),
Z = Math.Max(left.Z, right.Z)
});
}
public static RecastVertex Mult(RecastVertex left, RecastVertex right, int scale)
{
return(new RecastVertex
{
X = left.X + (right.X * scale),
Y = left.Y + (right.Y * scale),
Z = left.Z + (right.Z * scale)
});
}
public static RecastVertex Mult(RecastVertex left, int scale)
{
return(new RecastVertex
{
X = left.X * scale,
Y = left.Y * scale,
Z = left.Z * scale
});
}
public static RecastVertex Sub(RecastVertex left, RecastVertex right)
{
return(new RecastVertex
{
X = left.X - right.X,
Y = left.Y - right.Y,
Z = left.Z - right.Z
});
}
public static RecastVertex Add(RecastVertex left, RecastVertex right)
{
return(new RecastVertex
{
X = left.X + right.X,
Y = left.Y + right.Y,
Z = left.Z + right.Z
});
}
public void AddOffMeshConnection(RecastVertex start, RecastVertex end, float radius, bool biDirectional,
short area, int flags)
{
OffMeshConnectionVerts.AddRange(new [] { start.X, start.Y, start.Z, end.X, end.Y, end.Z });
OffMeshConnectionRadii.Add(radius);
OffMeshConnectionDirections.Add(biDirectional ? 1 : 0);
OffMeshConnectionAreas.Add(area);
OffMeshConnectionFlags.Add(flags);
OffMeshConnectionIds.Add(1000 + OffMeshConnectionCount++);
}
private void CalcTriNormal(RecastVertex v0, RecastVertex v1, RecastVertex v2, out float[] norm)
{
RecastVertex e0, e1, n;
e0 = RecastVertex.Sub(v1, v0);
e1 = RecastVertex.Sub(v2, v0);
n = RecastVertex.Cross(e0, e1);
n.Normalize();
norm = n.ToArray();
}
public bool Equals(RecastVertex other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return(other.X.Equals(X) && other.Y.Equals(Y) && other.Z.Equals(Z));
}
public void CalculateBounds()
{
if (Vertexes.Count != 0)
{
MinBounds = Vertexes[0];
MaxBounds = Vertexes[0];
foreach (RecastVertex recastVertex in Vertexes)
{
MinBounds = RecastVertex.Min(MinBounds, recastVertex);
MaxBounds = RecastVertex.Max(MaxBounds, recastVertex);
}
}
}
private void RasterizeTriangle(List <RecastVertex> vertexes, int v0, int v1, int v2, short area, float ics, float ich, int flagMergeThr)
{
int w = Width;
int h = Height;
RecastVertex tempMin, tempMax;
float by = Bmax[1] - Bmin[1];
tempMin = new RecastVertex(vertexes[v0]);
tempMax = new RecastVertex(vertexes[v0]);
tempMin = RecastVertex.Min(tempMin, vertexes[v1]);
tempMin = RecastVertex.Min(tempMin, vertexes[v2]);
tempMax = RecastVertex.Max(tempMax, vertexes[v1]);
tempMax = RecastVertex.Max(tempMax, vertexes[v2]);
if (!OverlapBounds(Bmin, Bmax, tempMin.ToArray(), tempMax.ToArray()))
{
return;
}
int x0 = (int)((tempMin[0] - Bmin[0]) * ics);
int y0 = (int)((tempMin[2] - Bmin[2]) * ics);
int x1 = (int)((tempMax[0] - Bmin[0]) * ics);
int y1 = (int)((tempMax[2] - Bmin[2]) * ics);
x0 = Math.Max(0, Math.Min(x0, w - 1));
y0 = Math.Max(0, Math.Min(y0, h - 1));
x1 = Math.Max(0, Math.Min(x1, w - 1));
y1 = Math.Max(0, Math.Min(y1, h - 1));
float[] inArray = new float[7 * 3], outArray = new float[7 * 3], inrowArray = new float[7 * 3];
for (int y = y0; y <= y1; y++)
{
Array.Copy(vertexes[v0].ToArray(), 0, inArray, 0, 3);
Array.Copy(vertexes[v1].ToArray(), 0, inArray, 1 * 3, 3);
Array.Copy(vertexes[v2].ToArray(), 0, inArray, 2 * 3, 3);
int nvrow = 3;
float cz = Bmin[2] + y * Cs;
nvrow = ClipPoly(inArray, nvrow, ref outArray, 0, 1, -cz);
if (nvrow < 3)
{
continue;
}
nvrow = ClipPoly(outArray, nvrow, ref inrowArray, 0, -1, cz + Cs);
if (nvrow < 3)
{
continue;
}
for (int x = x0; x <= x1; x++)
{
int nv = nvrow;
float cx = Bmin[0] + x * Cs;
nv = ClipPoly(inrowArray, nv, ref outArray, 1, 0, -cx);
if (nv < 3)
{
continue;
}
nv = ClipPoly(outArray, nv, ref inArray, -1, 0, cx + Cs);
if (nv < 3)
{
continue;
}
float smin = inArray[1], smax = inArray[1];
for (int i = 1; i < nv; i++)
{
smin = Math.Min(smin, inArray[i * 3 + 1]);
smax = Math.Max(smax, inArray[i * 3 + 1]);
}
smin -= Bmin[1];
smax -= Bmin[1];
if (smax.CompareTo(0.0f) < 0 || smin.CompareTo(by) > 0)
{
continue;
}
if (smin.CompareTo(0.0f) < 0)
{
smin = 0;
}
if (smax.CompareTo(by) > 0)
{
smax = by;
}
int ismin = Math.Max(0, Math.Min((int)Math.Floor(smin * ich), short.MaxValue));
int ismax = Math.Max(ismin + 1, Math.Min((int)Math.Floor(smax * ich), short.MaxValue));
AddSpan(x, y, ismin, ismax, area, flagMergeThr);
}
}
}
public RecastVertex(RecastVertex copy) : this()
{
X = copy.X;
Y = copy.Y;
Z = copy.Z;
}
public static float Dot(RecastVertex left, RecastVertex right)
{
return(left.X * right.X + left.Y * right.Y + left.Z * right.Z);
}
