// TODO: look at this, I think it is possible to get rid of the branches
static public CellVertices CreateCellVertices(byte config, ref int nextVertex)
{
var verts = new CellVertices()
{
bottomEdge = -1, corner = -1, leftEdge = -1
};
bool hasBL = HasMask(config, MaskBL);
if (hasBL)
{
verts.corner = nextVertex;
++nextVertex;
}
if (hasBL != HasMask(config, MaskTL))
{
verts.leftEdge = nextVertex;
++nextVertex;
}
if (hasBL != HasMask(config, MaskBR))
{
verts.bottomEdge = nextVertex;
++nextVertex;
}
return(verts);
}
static public void CalculateVertices(int index, CellInfo info, CellVertices verts, NativeArray <float3> vertices, int colNum, float cellSize, float heightOffset, float lerpToEdge, float sideOffsetScale, NativeArray <EdgeNormals> edgeNormalsArray)
{
int x = index % colNum;
int y = index / colNum;
float3 pos = new float3(x * cellSize, heightOffset, y * cellSize);
EdgeNormals normals = edgeNormalsArray[index];
if (verts.corner >= 0)
{
vertices[verts.corner] = pos;
}
if (verts.leftEdge >= 0)
{
float edgeLerp = cellSize * VcLerpT(info, lerpToEdge);
float2 offset = math.normalize(normals.leftEdgeDir) * sideOffsetScale;
vertices[verts.leftEdge] = new float3(pos.x + offset.x, pos.y, pos.z + edgeLerp + offset.y);
}
if (verts.bottomEdge >= 0)
{
float edgeLerp = cellSize * HzLerpT(info, lerpToEdge);
float2 offset = math.normalize(normals.bottomEdgeDir) * sideOffsetScale;
vertices[verts.bottomEdge] = new float3(pos.x + edgeLerp + offset.x, pos.y, pos.z + offset.y);
}
}
static public void TopCalculateUvs(CellVertices verts, float scaleX, float scaleY, NativeArray <float3> vertices, NativeArray <float2> uvs)
{
if (verts.corner >= 0)
{
SetUV(verts.corner, vertices, scaleX, scaleY, uvs);
}
if (verts.leftEdge >= 0)
{
SetUV(verts.leftEdge, vertices, scaleX, scaleY, uvs);
}
if (verts.bottomEdge >= 0)
{
SetUV(verts.bottomEdge, vertices, scaleX, scaleY, uvs);
}
}
static public void CalculateVertices(int index, CellInfo info, CellVertices verts, NativeArray <float3> vertices, int colNum, float heightOffset, float cellSize, float lerpToEdge)
{
float3 pos = BasicVertexCalculator.CalculatePosition(index, colNum, cellSize, heightOffset);
if (verts.corner >= 0)
{
vertices[verts.corner] = pos;
}
if (verts.leftEdge >= 0)
{
vertices[verts.leftEdge] = new float3(pos.x, pos.y, pos.z + cellSize * VcLerpT(info, lerpToEdge));
}
if (verts.bottomEdge >= 0)
{
vertices[verts.bottomEdge] = new float3(pos.x + cellSize * HzLerpT(info, lerpToEdge), pos.y, pos.z);
}
}
private static int BottomEdge(CellVertices verts) => verts.bottomEdge;
private static int LeftEdge(CellVertices verts) => verts.leftEdge;
private static int Vertex(CellVertices verts) => verts.corner;
public static int CalculateIndices <TriangleOrderer>(TriangleOrderer orderer, byte config, int triangleIndex, IndexSpan tris, CellVertices bl, CellVertices br, CellVertices tr, CellVertices tl, NativeArray <int> triangles)
where TriangleOrderer : struct, ITriangleOrderer
{
if (tris.length == 0)
{
return(triangleIndex);
}
switch (config)
{
// full
case MaskBL | MaskBR | MaskTR | MaskTL:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tl), Vertex(tr));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tr), Vertex(br));
break;
}
// corners
case MaskBL:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), LeftEdge(bl), BottomEdge(bl));
break;
}
case MaskBR:
{
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), LeftEdge(br), Vertex(br));
break;
}
case MaskTR:
{
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(tl), Vertex(tr), LeftEdge(br));
break;
}
case MaskTL:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), BottomEdge(tl), LeftEdge(bl));
break;
}
// halves
case MaskBL | MaskBR:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), LeftEdge(bl), Vertex(br));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), LeftEdge(bl), LeftEdge(br));
break;
}
case MaskTL | MaskTR:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), Vertex(tr), LeftEdge(bl));
orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(bl), Vertex(tr), LeftEdge(br));
break;
}
case MaskBL | MaskTL:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), BottomEdge(tl), BottomEdge(bl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tl), BottomEdge(tl));
break;
}
case MaskBR | MaskTR:
{
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), Vertex(tr), Vertex(br));
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), BottomEdge(tl), Vertex(tr));
break;
}
// diagonals
case MaskBL | MaskTR:
{
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), Vertex(bl), LeftEdge(bl));
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), LeftEdge(bl), LeftEdge(br));
orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(br), LeftEdge(bl), BottomEdge(tl));
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(tl), Vertex(tr), LeftEdge(br));
break;
}
case MaskTL | MaskBR:
{
orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(bl), Vertex(tl), BottomEdge(tl));
orderer.AddTriangle(triangles, ref triangleIndex, LeftEdge(bl), BottomEdge(tl), BottomEdge(bl));
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), BottomEdge(tl), LeftEdge(br));
orderer.AddTriangle(triangles, ref triangleIndex, BottomEdge(bl), LeftEdge(br), Vertex(br));
break;
}
// three quarters
case MaskBL | MaskTR | MaskBR:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), Vertex(bl), LeftEdge(bl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), LeftEdge(bl), BottomEdge(tl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(br), BottomEdge(tl), Vertex(tr));
break;
}
case MaskBL | MaskTL | MaskBR:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), Vertex(tl), BottomEdge(tl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), BottomEdge(tl), LeftEdge(br));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(bl), LeftEdge(br), Vertex(br));
break;
}
case MaskBL | MaskTL | MaskTR:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), BottomEdge(bl), Vertex(bl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), LeftEdge(br), BottomEdge(bl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tl), Vertex(tr), LeftEdge(br));
break;
}
case MaskTL | MaskTR | MaskBR:
{
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tr), LeftEdge(bl), Vertex(tl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tr), BottomEdge(bl), LeftEdge(bl));
orderer.AddTriangle(triangles, ref triangleIndex, Vertex(tr), Vertex(br), BottomEdge(bl));
break;
}
}
return(triangleIndex);
}
public void CalculateVertices(int index, CellInfo info, CellVertices verts, NativeArray <float3> vertices) => LerpedVertexCalculator.CalculateVertices(index, info, verts, vertices, colNum, heightOffset + heightScale * heights[index], cellSize, lerpToEdge);
public void CalculateVertices(int index, CellInfo info, CellVertices verts, NativeArray <float3> vertices) => CalculateVertices(index, info, verts, vertices, colNum, heightOffset, cellSize, lerpToEdge);
public void CalculateIndices(Orderer orderer, byte config, int triangleIndex, MergeTriInfo mergeInfo, IndexSpan tris, CellVertices bl, CellVertices br, CellVertices tr, CellVertices tl)
{
if (mergeInfo.triangleCount > 0)
{
if (mergeInfo.triangleCount == 1)
{
orderer.AddTriangle(triangles, ref triangleIndex, VertexIndexA0(mergeInfo), VertexIndexA1(mergeInfo), VertexIndexA2(mergeInfo));
}
else if (mergeInfo.triangleCount == 2)
{
orderer.AddTriangle(triangles, ref triangleIndex, VertexIndexA0(mergeInfo), VertexIndexA1(mergeInfo), VertexIndexA2(mergeInfo));
orderer.AddTriangle(triangles, ref triangleIndex, VertexIndexB0(mergeInfo), VertexIndexB1(mergeInfo), VertexIndexB2(mergeInfo));
}
}
else
{
TopCellMesher.CalculateIndices(orderer, config, triangleIndex, tris, bl, br, tr, tl, triangles);
}
}
public void CalculateVertices(int index, CellInfo info, CellVertices verts, NativeArray <float3> vertices) => ScaledLerpedVertexCalculator.CalculateVertices(index, info, verts, vertices, colNum, cellSize, heightOffset + heightScale * heights[index], lerpToEdge, sideOffsetScale, edgeNormalsArray);
public void CalculateVertices(int index, CellInfo info, CellVertices verts, NativeArray <float3> vertices) => CalculateVertices(index, info, verts, vertices, colNum, cellSize, heightOffset, sideOffsetScale, edgeNormalsArray);
