private bool MergeContours(ref Contour ca, ref Contour cb, int ia, int ib)
{
int maxVerts = ca.NVerts + cb.NVerts + 2;
int[] verts = new int[maxVerts * 4];
int nv = 0;
for (int i = 0; i < ca.NVerts; i++)
{
int dst = nv * 4;
int src = ((ia + i) % ca.NVerts) * 4;
verts[dst + 0] = ca.Verts[src + 0];
verts[dst + 1] = ca.Verts[src + 1];
verts[dst + 2] = ca.Verts[src + 2];
verts[dst + 3] = ca.Verts[src + 3];
nv++;
}
for (int i = 0; i < cb.NVerts; i++)
{
int dst = nv * 4;
int src = ((ib + i) % cb.NVerts) * 4;
verts[dst + 0] = cb.Verts[src + 0];
verts[dst + 1] = cb.Verts[src + 1];
verts[dst + 2] = cb.Verts[src + 2];
verts[dst + 3] = cb.Verts[src + 3];
nv++;
}
ca.Verts = verts;
ca.NVerts = nv;
cb.Verts = null;
cb.NVerts = 0;
return(true);
}
public PolyMesh(ContourSet cset, int nvp)
{
Array.Copy(cset.BMin, BMin, 3);
Array.Copy(cset.BMax, BMax, 3);
Cs = cset.Cs;
Ch = cset.Ch;
BorderSize = cset.BorderSize;
int maxVertices = 0;
int maxTris = 0;
int maxVertsPerCont = 0;
for (int i = 0; i < cset.NConts; i++)
{
if (cset.Conts[i].NVerts < 3)
{
continue;
}
maxVertices += cset.Conts[i].NVerts;
maxTris += cset.Conts[i].NVerts - 2;
maxVertsPerCont = Math.Max(maxVertsPerCont, cset.Conts[i].NVerts);
}
short[] vflags = new short[maxVertices];
Verts = new int[maxVertices * 3];
Polys = new int[maxTris * nvp * 2];
Regs = new int[maxTris];
Areas = new short[maxTris];
NVerts = 0;
NPolys = 0;
Nvp = nvp;
MaxPolys = maxTris;
for (int i = 0; i < maxTris * nvp * 2; i++)
{
Polys[i] = 0xffff; // memset(mesh.polys, 0xff)
}
int[] nextVert = new int[maxVertices];
int[] firstVert = new int[VertexBucketCount];
for (int i = 0; i < firstVert.Length; i++)
{
firstVert[i] = -1;
}
int[] indices = new int[maxVertsPerCont];
int[] tris = new int[maxVertsPerCont * 3];
int[] polys = new int[(maxVertsPerCont + 1) * nvp];
int[] tmpPoly = new int[nvp];
for (int i = 0; i < cset.NConts; i++)
{
Contour cont = cset.Conts[i];
if (cont.NVerts < 3)
{
continue;
}
for (int j = 0; j < cont.NVerts; j++)
{
indices[j] = j;
}
int ntris = Triangulate(cont.NVerts, cont.Verts, ref indices, ref tris);
if (ntris <= 0)
{
// error
ntris = -ntris;
}
for (int j = 0; j < cont.NVerts; j++)
{
int v = j * 4;
indices[j] = AddVertex(cont.Verts[v + 0], cont.Verts[v + 1], cont.Verts[v + 2], ref firstVert, ref nextVert);
if ((cont.Verts[v + 3] & ContourSet.BorderVertex) != 0)
{
vflags[indices[j]] = 1;
}
}
//build initial polygons
int npolys = 0;
for (int j = 0; j < polys.Length; j++)
{
polys[j] = 0xffff;
}
for (int j = 0; j < ntris; j++)
{
int t = j * 3;
if (tris[t + 0] != tris[t + 1] && tris[t + 0] != tris[t + 2] && tris[t + 1] != tris[t + 2])
{
polys[npolys * nvp + 0] = indices[tris[t + 0]];
polys[npolys * nvp + 1] = indices[tris[t + 1]];
polys[npolys * nvp + 2] = indices[tris[t + 2]];
npolys++;
}
}
if (npolys == 0)
{
continue;
}
if (nvp > 3)
{
for (;;)
{
int bestMergeVal = 0;
int bestPa = 0, bestPb = 0, bestEa = 0, bestEb = 0;
for (int j = 0; j < npolys - 1; j++)
{
int pj = j * nvp; // polys[j*nvp]
for (int k = j + 1; k < npolys; k++)
{
int pk = k * nvp;
int ea = 0, eb = 0;
int v = GetPolyMergeValue(polys, pj, pk, Verts, ref ea, ref eb, nvp);
if (v > bestMergeVal)
{
bestMergeVal = v;
bestPa = j;
bestPb = k;
bestEa = ea;
bestEb = eb;
}
}
}
if (bestMergeVal > 0)
{
int pa = bestPa * nvp;
int pb = bestPb * nvp;
MergePolys(ref polys, pa, pb, bestEa, bestEb, tmpPoly, nvp);
// fill in the hole at pb with the last poly
Array.Copy(polys, (npolys - 1) * nvp, polys, pb, nvp);
npolys--;
}
else
{
break;
}
}
}
for (int j = 0; j < npolys; j++)
{
int p = NPolys * nvp * 2;
int q = j * nvp;
for (int k = 0; k < nvp; k++)
{
Polys[p + k] = polys[q + k];
}
Regs[NPolys] = cont.Reg;
Areas[NPolys] = cont.Area;
NPolys++;
}
}
for (int i = 0; i < NVerts; i++)
{
//if (vflags[i] > 0)
//{
// if (!CanRemoveVertex(i)) continue;
// if (!RemoveVertex(i, maxTris))
// {
// // error
// }
// for (int j = i; j < NVerts; j++)
// {
// vflags[j] = vflags[j + 1];
// }
// i--;
//}
}
if (!BuildMeshAdjacency(nvp))
{
// error
}
// find portal edges
if (BorderSize > 0) // defaults to 0
{
int w = cset.Width;
int h = cset.Height;
for (int i = 0; i < NPolys; i++)
{
int p = i * 2 * nvp;
for (int j = 0; j < nvp; j++)
{
if (Polys[p + j] == MeshNullIdx)
{
break;
}
if (Polys[p + nvp + j] != MeshNullIdx)
{
continue;
}
int nj = j + 1;
if (nj >= nvp || Polys[p + nj] == MeshNullIdx)
{
nj = 0;
}
int va = Polys[p + j] * 3;
int vb = Polys[p + nj] * 3;
if (Verts[va + 0] == 0 && Verts[vb + 0] == 0)
{
Polys[p + nvp + j] = 0x8000 | 0;
}
else if (Verts[va + 2] == h && Verts[vb + 2] == h)
{
Polys[p + nvp + j] = 0x8000 | 1;
}
else if (Verts[va + 0] == w && Verts[vb + 0] == w)
{
Polys[p + nvp + j] = 0x8000 | 2;
}
else if (Verts[va + 2] == 0 && Verts[vb + 2] == 0)
{
Polys[p + nvp + j] = 0x8000 | 3;
}
}
}
}
// user fills in this data
Flags = new int[NPolys];
}
public ContourSet(CompactHeightfield cfh, float maxError, int maxEdgeLen, int buildFlags = BuildContourFlags.ContourTessWallEdges)
{
int w = cfh.Width;
int h = cfh.Height;
int borderSize = cfh.BorderSize;
BMin = new float[3];
BMax = new float[3];
Array.Copy(cfh.BMin, BMin, 3);
Array.Copy(cfh.BMax, BMax, 3);
if (borderSize > 0)
{
float pad = borderSize * cfh.Cs;
BMin[0] += pad;
BMin[2] += pad;
BMax[0] -= pad;
BMax[2] -= pad;
}
Cs = cfh.Cs;
Ch = cfh.Ch;
Width = cfh.Width - cfh.BorderSize * 2;
Height = cfh.Height - cfh.BorderSize * 2;
BorderSize = cfh.BorderSize;
int maxContours = Math.Max(cfh.MaxRegions, 8);
Conts = new Contour[maxContours];
for (int i = 0; i < maxContours; i++)
{
Conts[i] = new Contour();
}
NConts = 0;
char[] flags = new char[cfh.SpanCount];
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
CompactCell c = cfh.Cells[x + y * w];
for (int i = (int)c.Index, ni = (int)(c.Index + c.Count); i < ni; i++)
{
if (i == 4782)
{
int z = 0;
}
int res = 0;
CompactSpan s = cfh.Spans[i];
if (s.Reg == 0 || (s.Reg & CompactHeightfield.BorderReg) != 0)
{
flags[i] = (char)0;
continue;
}
for (int dir = 0; dir < 4; dir++)
{
int r = 0;
if (s.GetCon(dir) != CompactHeightfield.NotConnected)
{
int ax = x + Helper.GetDirOffsetX(dir);
int ay = y + Helper.GetDirOffsetY(dir);
int ai = (int)cfh.Cells[ax + ay * w].Index + s.GetCon(dir);
r = cfh.Spans[ai].Reg;
}
if (r == cfh.Spans[i].Reg)
{
res |= (1 << dir);
}
}
flags[i] = (char)(res ^ 0xf);
}
}
}
IntArray verts = new IntArray(256);
IntArray simplified = new IntArray(64);
for (int y = 0; y < h; y++)
{
for (int x = 0; x < w; x++)
{
CompactCell c = cfh.Cells[x + y * w];
for (int i = (int)c.Index, ni = (int)(c.Index + c.Count); i < ni; i++)
{
if (flags[i] == 0 || flags[i] == 0xf)
{
flags[i] = (char)0;
continue;
}
int reg = cfh.Spans[i].Reg;
if (reg == 0 || (reg & CompactHeightfield.BorderReg) != 0)
{
continue;
}
uint area = cfh.Areas[i];
verts.Resize(0);
simplified.Resize(0);
WalkContour(x, y, i, cfh, ref flags, ref verts);
SimplifyContour(ref verts, ref simplified, maxError, maxEdgeLen, buildFlags);
RemoveDegenerateSegments(ref simplified);
if ((simplified.Size / 4) >= 3)
{
// We need more space than we allocated...
if (NConts >= maxContours)
{
int oldMax = maxContours;
maxContours *= 2;
Contour[] newConts = new Contour[maxContours];
for (int j = 0; j < maxContours; j++)
{
newConts[j] = new Contour();
}
for (int j = 0; j < NConts; j++)
{
newConts[j] = Conts[j];
}
Conts = newConts;
}
Contour cont = Conts[NConts++];
cont.NVerts = simplified.Size / 4;
cont.Verts = new int[cont.NVerts * 4];
Array.Copy(simplified.ToArray(), cont.Verts, cont.NVerts * 4);
if (borderSize > 0)
{
for (int j = 0; j < cont.NVerts; j++)
{
int v = j * 4;
cont.Verts[v + 0] -= borderSize;
cont.Verts[v + 2] -= borderSize;
}
}
cont.NRVerts = verts.Size / 4;
cont.RVerts = new int[cont.NRVerts * 4];
Array.Copy(verts.ToArray(), cont.RVerts, cont.NRVerts * 4);
if (borderSize > 0)
{
for (int j = 0; j < cont.NRVerts; j++)
{
int v = j * 4;
cont.RVerts[v + 0] -= borderSize;
cont.RVerts[v + 2] -= borderSize;
}
}
cont.Reg = reg;
cont.Area = (short)area;
}
}
}
}
// check and merge droppings
for (int i = 0; i < NConts; i++)
{
Contour cont = Conts[i];
if (CalcAreaOfPolygon2D(cont.Verts, cont.NVerts) < 0)
{
int mergeIdx = -1;
for (int j = 0; j < NConts; j++)
{
if (i == j)
{
continue;
}
if (Conts[j].NVerts > 0 && Conts[j].Reg == cont.Reg)
{
if (CalcAreaOfPolygon2D(Conts[j].Verts, Conts[j].NVerts) > 0)
{
mergeIdx = j;
break;
}
}
}
if (mergeIdx == -1)
{
// error
}
else
{
Contour mcont = Conts[mergeIdx];
int ia = 0, ib = 0;
GetClosestIndices(mcont.Verts, mcont.NVerts, cont.Verts, cont.NVerts, ref ia, ref ib);
if (ia == -1 || ib == -1)
{
// bad merge
continue;
}
if (!MergeContours(ref mcont, ref cont, ia, ib))
{
// Merge failed
continue;
}
}
}
}
}
