public static void DisableCamCollision(TriangleClassification?classification = null)
{
List <uint> triangleAddresses = GetLevelTriangleAddresses();
triangleAddresses.ForEach(address =>
{
float ynorm = Config.Stream.GetSingle(address + TriangleOffsetsConfig.NormY);
TriangleClassification triClassification = CalculateClassification(ynorm);
if (classification == null || classification == triClassification)
{
ButtonUtilities.DisableCamCollisionForTriangle(address);
}
});
}
public static void NeutralizeTriangles(TriangleClassification?classification = null)
{
List <uint> triangleAddresses = GetLevelTriangleAddresses();
triangleAddresses.ForEach(address =>
{
float ynorm = Config.Stream.GetSingle(address + TriangleOffsetsConfig.NormY);
TriangleClassification triClassification = CalculateClassification(ynorm);
if (classification == null || classification == triClassification)
{
ButtonUtilities.NeutralizeTriangle(new List <uint>()
{
address
});
}
});
}
public static uint GetCurrentTriangle(TriangleClassification classification)
{
switch (classification)
{
case TriangleClassification.Wall:
return(Config.Stream.GetUInt(MarioConfig.StructAddress + MarioConfig.WallTriangleOffset));
case TriangleClassification.Floor:
return(Config.Stream.GetUInt(MarioConfig.StructAddress + MarioConfig.FloorTriangleOffset));
case TriangleClassification.Ceiling:
return(Config.Stream.GetUInt(MarioConfig.StructAddress + MarioConfig.CeilingTriangleOffset));
default:
throw new ArgumentOutOfRangeException();
}
}
public override float GetSizeForOrthographicView(TriangleClassification classification)
{
switch (classification)
{
case TriangleClassification.Wall:
return(50);
case TriangleClassification.Floor:
return(78);
case TriangleClassification.Ceiling:
return(160);
default:
throw new ArgumentOutOfRangeException();
}
}
public override Color GetColorForOrthographicView(TriangleClassification classification)
{
switch (classification)
{
case TriangleClassification.Wall:
return(Color.Green);
case TriangleClassification.Floor:
return(Color.Blue);
case TriangleClassification.Ceiling:
return(Color.Red);
default:
throw new ArgumentOutOfRangeException();
}
}
public static double GetSignedDistanceFromPointToLine(
double pX, double pZ, double v1X, double v1Z, double v2X, double v2Z, double v3X, double v3Z, int p1Index, int p2Index,
TriangleClassification classification, bool?misalignmentOffsetNullable = null)
{
pX = PuUtilities.GetRelativeCoordinate(pX);
pZ = PuUtilities.GetRelativeCoordinate(pZ);
double[] vX = new double[] { v1X, v2X, v3X };
double[] vZ = new double[] { v1Z, v2Z, v3Z };
double p1X = vX[p1Index - 1];
double p1Z = vZ[p1Index - 1];
double p2X = vX[p2Index - 1];
double p2Z = vZ[p2Index - 1];
double dist = MoreMath.GetDistanceFromPointToLine(pX, pZ, p1X, p1Z, p2X, p2Z);
bool leftOfLine = MoreMath.IsPointLeftOfLine(pX, pZ, p1X, p1Z, p2X, p2Z);
bool floorTri = MoreMath.IsPointLeftOfLine(v3X, v3Z, v1X, v1Z, v2X, v2Z);
bool onSideOfLineTowardsTri = floorTri == leftOfLine;
double signedDist = dist * (onSideOfLineTowardsTri ? 1 : -1);
bool misalignmentOffset = misalignmentOffsetNullable ?? SavedSettingsConfig.UseMisalignmentOffsetForDistanceToLine;
if (misalignmentOffset && classification != TriangleClassification.Wall)
{
if (p1X == p2X)
{
bool thirdPointOnLeft = p1Z >= p2Z == floorTri;
if ((thirdPointOnLeft && p1X >= 0) || (!thirdPointOnLeft && p1X <= 0))
{
signedDist += 1;
}
}
else if (p1Z == p2Z)
{
bool thirdPointOnTop = p1X <= p2X == floorTri;
if ((thirdPointOnTop && p1Z >= 0) || (!thirdPointOnTop && p1Z <= 0))
{
signedDist += 1;
}
}
}
return(signedDist);
}
public TriangleListForm(
MapLevelTriangleObjectI levelTriangleObject,
TriangleClassification classification,
List <uint> triAddressList)
{
InitializeComponent();
_levelTriangleObject = levelTriangleObject;
_triAddressList = triAddressList;
_lastRemoveTime = 0;
Text = classification + " Triangle List";
labelNumTriangles.Text = _triAddressList.Count + " Triangles";
FormClosing += (sender, e) => TriangleListFormClosing();
buttonSort.Click += (sender, e) => RefreshAndSort();
buttonAnnihilate.Click += (sender, e) => Annihilate();
buttonInject.Click += (sender, e) => Inject();
buttonRemove.Click += (sender, e) => Remove();
RefreshAndSort();
}
public static List <uint> GetTriangleAddressesInCell(int cellX, int cellZ, bool staticPartition, TriangleClassification classification)
{
uint partitionAddress = staticPartition ? TriangleConfig.StaticTrianglePartitionAddress : TriangleConfig.DynamicTrianglePartitionAddress;
int typeInt;
switch (classification)
{
case TriangleClassification.Wall:
typeInt = 2;
break;
case TriangleClassification.Floor:
typeInt = 0;
break;
case TriangleClassification.Ceiling:
typeInt = 1;
break;
default:
throw new ArgumentOutOfRangeException();
}
int typeSize = 2 * 4;
int xSize = 3 * typeSize;
int zSize = 16 * xSize;
uint address = (uint)(partitionAddress + cellZ * zSize + cellX * xSize + typeInt * typeSize);
address = Config.Stream.GetUInt(address);
List <uint> output = new List <uint>();
while (address != 0)
{
uint triAddress = Config.Stream.GetUInt(address + 4);
output.Add(triAddress);
address = Config.Stream.GetUInt(address);
}
return(output);
}
public static List <uint> GetTriangleAddressesInMarioCell(bool staticPartition, TriangleClassification classification)
{
(int cellX, int cellZ) = GetMarioCell();
return(GetTriangleAddressesInCell(cellX, cellZ, staticPartition, classification));
}
public static List <uint> GetTriangleAddressesForPosition(float x, float z, bool staticPartition, TriangleClassification classification)
{
(int cellX, int cellZ) = GetCell(x, z);
return(GetTriangleAddressesInCell(cellX, cellZ, staticPartition, classification));
}
public TriangleStruct(uint triangleAddress)
{
Address = triangleAddress;
SurfaceType = Config.Stream.GetUInt16(triangleAddress + TriangleOffsetsConfig.SurfaceType);
ExertionForceIndex = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.ExertionForceIndex);
ExertionAngle = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.ExertionAngle);
Flags = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.Flags);
Room = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.Room);
YMin = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.YMin);
YMax = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.YMax);
X1 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.X1);
Y1 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.Y1);
Z1 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.Z1);
X2 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.X2);
Y2 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.Y2);
Z2 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.Z2);
X3 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.X3);
Y3 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.Y3);
Z3 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.Z3);
NormX = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormX);
NormY = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormY);
NormZ = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormZ);
NormOffset = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormOffset);
AssociatedObject = Config.Stream.GetUInt32(triangleAddress + TriangleOffsetsConfig.AssociatedObject);
Classification = TriangleUtilities.CalculateClassification(NormY);
XProjection = (Flags & TriangleOffsetsConfig.XProjectionMask) != 0;
BelongsToObject = (Flags & TriangleOffsetsConfig.BelongsToObjectMask) != 0;
NoCamCollision = (Flags & TriangleOffsetsConfig.NoCamCollisionMask) != 0;
FieldValueList = new List <object> {
"0x" + Address.ToString("X8"),
Classification,
SurfaceType,
ExertionForceIndex,
ExertionAngle,
"0x" + Flags.ToString("X2"),
XProjection,
BelongsToObject,
NoCamCollision,
Room,
YMin,
YMax,
X1,
Y1,
Z1,
X2,
Y2,
Z2,
X3,
Y3,
Z3,
NormX,
NormY,
NormZ,
NormOffset,
"0x" + AssociatedObject.ToString("X8"),
};
}
private TriangleDataModel(uint triangleAddress)
{
Address = triangleAddress;
SurfaceType = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.SurfaceType);
ExertionForceIndex = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.ExertionForceIndex);
ExertionAngle = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.ExertionAngle);
Flags = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.Flags);
Room = Config.Stream.GetByte(triangleAddress + TriangleOffsetsConfig.Room);
YMinMinus5 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.YMinMinus5);
YMaxPlus5 = Config.Stream.GetInt16(triangleAddress + TriangleOffsetsConfig.YMaxPlus5);
X1 = TriangleOffsetsConfig.GetX1(triangleAddress);
Y1 = TriangleOffsetsConfig.GetY1(triangleAddress);
Z1 = TriangleOffsetsConfig.GetZ1(triangleAddress);
X2 = TriangleOffsetsConfig.GetX2(triangleAddress);
Y2 = TriangleOffsetsConfig.GetY2(triangleAddress);
Z2 = TriangleOffsetsConfig.GetZ2(triangleAddress);
X3 = TriangleOffsetsConfig.GetX3(triangleAddress);
Y3 = TriangleOffsetsConfig.GetY3(triangleAddress);
Z3 = TriangleOffsetsConfig.GetZ3(triangleAddress);
NormX = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormX);
NormY = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormY);
NormZ = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormZ);
NormOffset = Config.Stream.GetSingle(triangleAddress + TriangleOffsetsConfig.NormOffset);
AssociatedObject = Config.Stream.GetUInt32(triangleAddress + TriangleOffsetsConfig.AssociatedObject);
Classification = TriangleUtilities.CalculateClassification(NormY);
XProjection = (Flags & TriangleOffsetsConfig.XProjectionMask) != 0;
BelongsToObject = (Flags & TriangleOffsetsConfig.BelongsToObjectMask) != 0;
NoCamCollision = (Flags & TriangleOffsetsConfig.NoCamCollisionMask) != 0;
Description = TableConfig.TriangleInfo.GetDescription(SurfaceType);
Slipperiness = TableConfig.TriangleInfo.GetSlipperiness(SurfaceType) ?? 0;
SlipperinessDescription = TableConfig.TriangleInfo.GetSlipperinessDescription(SurfaceType);
FrictionMultiplier = TableConfig.TriangleInfo.GetFrictionMultiplier(SurfaceType);
SlopeAccel = TableConfig.TriangleInfo.GetSlopeAccel(SurfaceType);
SlopeDecelValue = TableConfig.TriangleInfo.GetSlopeDecelValue(SurfaceType);
Exertion = TableConfig.TriangleInfo.GetExertion(SurfaceType) ?? false;
FieldValueList = new List <object> {
HexUtilities.FormatValue(Address, 8),
Classification,
HexUtilities.FormatValue(SurfaceType, 2),
Description,
HexUtilities.FormatValue(Slipperiness, 2),
SlipperinessDescription,
Exertion,
ExertionForceIndex,
ExertionAngle,
HexUtilities.FormatValue(Flags, 2),
XProjection,
BelongsToObject,
NoCamCollision,
Room,
YMinMinus5,
YMaxPlus5,
X1,
Y1,
Z1,
X2,
Y2,
Z2,
X3,
Y3,
Z3,
NormX,
NormY,
NormZ,
NormOffset,
HexUtilities.FormatValue(AssociatedObject, 8),
};
}
void SliceMeshOnAxis(Mesh activeMesh, bool gizmosPass, SlicerAxisData activeAxisData)
{
Gizmos.matrix = transform.localToWorldMatrix;
Vector3 axis = Vector3.zero;
axis[activeAxisData.AxisIndex] = 1;
Vector3[] vertices = activeMesh.vertices;
Vector2[] uv = activeMesh.uv;
Vector3[] normals = activeMesh.normals;
Vector4[] tangents = activeMesh.tangents;
int[] triangles = activeMesh.triangles;
// Second copy so that we can modify triangles buffer while iterating through it
int[] newTriangles = activeMesh.triangles;
List <NewTriangleWith1NewVertex> additionalTrianglesWith1NewVertices = new List <NewTriangleWith1NewVertex>();
List <NewTriangleWith2NewVertex> additionalTrianglesWith2NewVertices = new List <NewTriangleWith2NewVertex>();
NativeArray <float3> verticesNativeArray = new NativeArray <float3>(vertices.Length, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
for (int i = 0; i < vertices.Length; i++)
{
verticesNativeArray[i] = vertices[i];
}
NativeArray <int>[] classificationArrays = new NativeArray <int> [2];
// Loop through all the planes and classify the source vertices relative to each plane
for (var planeIndex = 0; planeIndex < 2; planeIndex++)
{
Plane plane = activeAxisData.CalculatePlane(planeIndex);
classificationArrays[planeIndex] = new NativeArray <int>(vertices.Length, Allocator.TempJob,
NativeArrayOptions.UninitializedMemory);
var jobData = new Classifier.ClassifyVerticesAgainstPlane()
{
vertices = verticesNativeArray,
classificationResult = classificationArrays[planeIndex],
planeDistance = plane.distance,
planeNormal = plane.normal
};
var handle = jobData.Schedule(vertices.Length, 128);
handle.Complete(); // Block until all jobs are done
}
for (var planeIndex = 0; planeIndex < 2; planeIndex++)
{
Plane plane = activeAxisData.CalculatePlane(planeIndex);
var classificationArray = classificationArrays[planeIndex];
for (int i = 0; i < triangles.Length / 3; i++)
{
int index1 = triangles[i * 3 + 0];
int index2 = triangles[i * 3 + 1];
int index3 = triangles[i * 3 + 2];
TriangleClassification triangleClassification =
Classifier.ClassifyTriangle(index1, index2, index3, classificationArray);
if (triangleClassification == TriangleClassification.Straddle)
{
int classificationSum = (classificationArray[index1] + classificationArray[index2] +
classificationArray[index3]);
if (classificationSum == 1 + 1 - 1 || // Two in front
classificationSum == 1 - 1 - 1) // Two behind
{
// Which out which vertex is isolated at the back of the plane
int isolatedIndex = -1;
for (int j = 0; j < 3; j++)
{
if (classificationArray[triangles[i * 3 + j]] != classificationSum)
{
isolatedIndex = j;
break;
}
}
Debug.Assert(isolatedIndex >= 0 && isolatedIndex <= 2);
int indexA = (isolatedIndex + 1) % 3;
int indexB = (isolatedIndex + 2) % 3;
// Categorise the three points in the triangle, as the one isolated behind the plane, then the other two in winding order
Vector3 isolatedPoint = vertices[triangles[i * 3 + isolatedIndex]];
Vector3 pointA = vertices[triangles[i * 3 + indexA]];
Vector3 pointB = vertices[triangles[i * 3 + indexB]];
// Calculate the normalized intersection along each edge from the isolated point
float interpolantA = plane.GetPlaneIntersectionInterpolant(isolatedPoint, pointA);
float interpolantB = plane.GetPlaneIntersectionInterpolant(isolatedPoint, pointB);
Vector3 newPointA = Vector3.Lerp(isolatedPoint, pointA, interpolantA);
Vector3 newPointB = Vector3.Lerp(isolatedPoint, pointB, interpolantB);
Vector3 newUVA = Vector2.Lerp(uv[triangles[i * 3 + isolatedIndex]],
uv[triangles[i * 3 + indexA]], interpolantA);
Vector3 newUVB = Vector2.Lerp(uv[triangles[i * 3 + isolatedIndex]],
uv[triangles[i * 3 + indexB]], interpolantB);
Vector3 newNormalA = Vector3.Lerp(normals[triangles[i * 3 + isolatedIndex]],
normals[triangles[i * 3 + indexA]], interpolantA);
Vector3 newNormalB = Vector3.Lerp(normals[triangles[i * 3 + isolatedIndex]],
normals[triangles[i * 3 + indexB]], interpolantB);
Vector3 newTangentA = Vector3.Lerp(tangents[triangles[i * 3 + isolatedIndex]],
tangents[triangles[i * 3 + indexA]], interpolantA);
Vector3 newTangentB = Vector3.Lerp(tangents[triangles[i * 3 + isolatedIndex]],
tangents[triangles[i * 3 + indexB]], interpolantB);
#if SHOW_DEBUG_CLIPPING
// ORIGINAL TRIANGLE
if (gizmosPass)
{
Vector3 point1 = vertices[index1];
Vector3 point2 = vertices[index2];
Vector3 point3 = vertices[index3];
Gizmos.color = Color.green;
GizmoHelper.DrawTriangle(point1, point2, point3);
}
#endif
Vector3 transformedOffset = activeAxisData.GetTransformedOffset(planeIndex);
// NEW CLIPPED TRIANGLE
if (classificationSum == 1 + 1 - 1 || // Two in front
classificationSum == 1 - 1 - 1) // Two behind
{
additionalTrianglesWith1NewVertices.Add(new NewTriangleWith1NewVertex()
{
ExistingIndex1 = triangles[i * 3 + indexA],
ExistingIndex2 = triangles[i * 3 + indexB],
NewVertexPosition1 = newPointA + transformedOffset,
NewVertexUV1 = newUVA,
NewVertexNormal1 = newNormalA,
NewVertexTangent1 = newTangentA,
Flipped = false,
});
// Add other triangle
additionalTrianglesWith2NewVertices.Add(new NewTriangleWith2NewVertex()
{
ExistingIndex1 = triangles[i * 3 + indexB],
NewVertexPosition1 = newPointA + transformedOffset,
NewVertexUV1 = newUVA,
NewVertexNormal1 = newNormalA,
NewVertexTangent1 = newTangentA,
NewVertexPosition2 = newPointB + transformedOffset,
NewVertexUV2 = newUVB,
NewVertexNormal2 = newNormalB,
NewVertexTangent2 = newTangentB,
Flipped = false,
});
#if SHOW_DEBUG_CLIPPING
if (gizmosPass)
{
Gizmos.color = Color.white;
GizmoHelper.DrawTriangle(pointB, pointA, newPointA);
GizmoHelper.DrawTriangle(pointB, newPointA, newPointB);
}
#endif
}
if (classificationSum == 1 + 1 - 1 || // Two in front
classificationSum == 1 - 1 - 1) // Two behind
{
additionalTrianglesWith2NewVertices.Add(new NewTriangleWith2NewVertex()
{
ExistingIndex1 = triangles[i * 3 + isolatedIndex],
NewVertexPosition1 = newPointA + transformedOffset,
NewVertexUV1 = newUVA,
NewVertexNormal1 = newNormalA,
NewVertexTangent1 = newTangentA,
NewVertexPosition2 = newPointB + transformedOffset,
NewVertexUV2 = newUVB,
NewVertexNormal2 = newNormalB,
NewVertexTangent2 = newTangentB,
Flipped = true,
});
}
// DRAW SPLIT LINE
// if (gizmosPass)
// {
// // Transformed
// Gizmos.color = Color.blue;
// Gizmos.DrawLine(newPointA + transformedOffset, newPointB + transformedOffset);
// }
}
else
{
throw new NotSupportedException("Unexpected and unhandled classification sum");
}
}
if (triangleClassification == TriangleClassification.Straddle)
{
// Zero out the indices for the straddling triangles as they are being replaced with new triangles
// Note: This is wasteful and in the future we should reuse these indices for one of the new triangles
newTriangles[i * 3 + 0] = 0;
newTriangles[i * 3 + 1] = 0;
newTriangles[i * 3 + 2] = 0;
}
}
}
float sourceInset = sourceMesh.bounds.size[activeAxisData.AxisIndex] *
(activeAxisData.TotalInsetProportion);
float scale = (size[activeAxisData.AxisIndex] - sourceInset) /
(sourceMesh.bounds.size[activeAxisData.AxisIndex] - sourceInset);
Vector3 scaleOffset = axis * (activeAxisData.GetInset(0) *
sourceMesh.bounds.size[activeAxisData.AxisIndex] - (activeAxisData.GetInset(1)) *
sourceMesh.bounds.size[activeAxisData.AxisIndex]) / 2f
+ sourceMesh.bounds.center;
for (int v = 0; v < vertices.Length; v++)
{
bool allBehind = true;
for (var planeIndex = 0; planeIndex < 2; planeIndex++)
{
if (classificationArrays[planeIndex][v] == -1)
{
vertices[v] += activeAxisData.GetTransformedOffset(planeIndex);
allBehind = false;
}
}
if (allBehind)
{
var vertex = vertices[v];
//scaleOffset = activeAxisData.GetInset(2) - activeAxisData.GetInset(1);
vertex -= scaleOffset;
vertex[activeAxisData.AxisIndex] *= scale;
vertex += scaleOffset;
vertices[v] = vertex;
}
}
int baseTriangleCount = triangles.Length; // Before additional triangles start getting taken into account
int baseVertexCount = vertices.Length; // Before additional triangles start getting taken into account
int additionalTriangleCount =
additionalTrianglesWith1NewVertices.Count + additionalTrianglesWith2NewVertices.Count;
// Resize the triangle indices to accomodate the additional triangles we're adding
Array.Resize(ref newTriangles, baseTriangleCount + (additionalTriangleCount * 3));
// Resize the vertex attribute buffers to accomodate the additional triangles we're adding
Array.Resize(ref vertices,
baseVertexCount + additionalTrianglesWith1NewVertices.Count +
additionalTrianglesWith2NewVertices.Count * 2);
Array.Resize(ref uv,
baseVertexCount + additionalTrianglesWith1NewVertices.Count +
additionalTrianglesWith2NewVertices.Count * 2);
Array.Resize(ref normals,
baseVertexCount + additionalTrianglesWith1NewVertices.Count +
additionalTrianglesWith2NewVertices.Count * 2);
Array.Resize(ref tangents,
baseVertexCount + additionalTrianglesWith1NewVertices.Count +
additionalTrianglesWith2NewVertices.Count * 2);
// Add in new triangles with one new vertex
for (var index = 0; index < additionalTrianglesWith1NewVertices.Count; index++)
{
NewTriangleWith1NewVertex newTriangleWith1NewVertex = additionalTrianglesWith1NewVertices[index];
vertices[baseVertexCount + index] = newTriangleWith1NewVertex.NewVertexPosition1;
uv[baseVertexCount + index] = newTriangleWith1NewVertex.NewVertexUV1;
normals[baseVertexCount + index] = newTriangleWith1NewVertex.NewVertexNormal1;
tangents[baseVertexCount + index] = newTriangleWith1NewVertex.NewVertexTangent1;
if (newTriangleWith1NewVertex.Flipped)
{
newTriangles[baseTriangleCount + index * 3 + 2] = newTriangleWith1NewVertex.ExistingIndex1;
newTriangles[baseTriangleCount + index * 3 + 1] = newTriangleWith1NewVertex.ExistingIndex2;
newTriangles[baseTriangleCount + index * 3 + 0] = baseVertexCount + index;
}
else
{
newTriangles[baseTriangleCount + index * 3 + 0] = newTriangleWith1NewVertex.ExistingIndex1;
newTriangles[baseTriangleCount + index * 3 + 1] = newTriangleWith1NewVertex.ExistingIndex2;
newTriangles[baseTriangleCount + index * 3 + 2] = baseVertexCount + index;
}
}
int offset = additionalTrianglesWith1NewVertices.Count; // Offset to accomodate the new triangles we added
// Add in new triangles with two new vertices
for (var index = 0; index < additionalTrianglesWith2NewVertices.Count; index++)
{
NewTriangleWith2NewVertex newTriangleWith2NewVertex = additionalTrianglesWith2NewVertices[index];
vertices[baseVertexCount + offset + index * 2 + 0] = newTriangleWith2NewVertex.NewVertexPosition1;
uv[baseVertexCount + offset + index * 2 + 0] = newTriangleWith2NewVertex.NewVertexUV1;
normals[baseVertexCount + offset + index * 2 + 0] = newTriangleWith2NewVertex.NewVertexNormal1;
tangents[baseVertexCount + offset + index * 2 + 0] = newTriangleWith2NewVertex.NewVertexTangent1;
vertices[baseVertexCount + offset + index * 2 + 1] = newTriangleWith2NewVertex.NewVertexPosition2;
uv[baseVertexCount + offset + index * 2 + 1] = newTriangleWith2NewVertex.NewVertexUV2;
normals[baseVertexCount + offset + index * 2 + 1] = newTriangleWith2NewVertex.NewVertexNormal2;
tangents[baseVertexCount + offset + index * 2 + 1] = newTriangleWith2NewVertex.NewVertexTangent2;
if (newTriangleWith2NewVertex.Flipped)
{
newTriangles[baseTriangleCount + offset * 3 + index * 3 + 0] =
newTriangleWith2NewVertex.ExistingIndex1;
newTriangles[baseTriangleCount + offset * 3 + index * 3 + 1] =
baseVertexCount + offset + index * 2 + 0;
newTriangles[baseTriangleCount + offset * 3 + index * 3 + 2] =
baseVertexCount + offset + index * 2 + 1;
}
else
{
newTriangles[baseTriangleCount + offset * 3 + index * 3 + 2] =
newTriangleWith2NewVertex.ExistingIndex1;
newTriangles[baseTriangleCount + offset * 3 + index * 3 + 1] =
baseVertexCount + offset + index * 2 + 0;
newTriangles[baseTriangleCount + offset * 3 + index * 3 + 0] =
baseVertexCount + offset + index * 2 + 1;
}
}
activeMesh.vertices = vertices;
activeMesh.uv = uv;
activeMesh.normals = normals;
activeMesh.tangents = tangents;
activeMesh.triangles = newTriangles;
// Cleanup the native arrays
verticesNativeArray.Dispose();
for (var planeIndex = 0; planeIndex < 2; planeIndex++)
{
classificationArrays[planeIndex].Dispose();
}
}
public void Setup()
{
triangle = new TriangleClassification();
}
