//-----------------------------------------------------------------------
public static void _extrudeCapImpl(ref TriangleBuffer buffer, MultiShape multiShapeToExtrude, MultiPath extrusionMultiPath, TrackMap scaleTracks, TrackMap rotationTracks)
{
std_vector <int> indexBuffer = new std_vector <int>();
// PointList pointList;
std_vector <Vector2> pointList = new std_vector <Vector2>();
Triangulator t = new Triangulator();
t.setMultiShapeToTriangulate(multiShapeToExtrude);
t.triangulate(indexBuffer, pointList);
for (uint i = 0; i < extrusionMultiPath.getPathCount(); ++i)
{
Path extrusionPath = extrusionMultiPath.getPath((int)i);
Track scaleTrack = null;
Track rotationTrack = null;
if (scaleTracks.find(i) != -1) // scaleTracks.end())
{
scaleTrack = scaleTracks[i]; //.find(i).second;
}
if (rotationTracks.find(i) != -1) // rotationTracks.end())
{
rotationTrack = rotationTracks[i]; //.find(i).second;
}
//begin cap
//if (extrusionMultiPath.getIntersectionsMap().find(MultiPath.PathCoordinate(i, 0)) == extrusionMultiPath.getIntersectionsMap().end())
if (extrusionMultiPath.getIntersectionsMap().find(new MultiPath.PathCoordinate(i, 0)) == -1)
{
buffer.rebaseOffset();
buffer.estimateIndexCount((uint)indexBuffer.Count);
buffer.estimateVertexCount((uint)pointList.Count);
Quaternion qBegin = Utils._computeQuaternion(extrusionPath.getDirectionAfter(0));
if (rotationTrack != null)
{
float angle = rotationTrack.getFirstValue();
qBegin = qBegin * new Quaternion((Radian)angle, Vector3.UNIT_Z);
}
float scaleBegin = 1.0f;
if (scaleTrack != null)
{
scaleBegin = scaleTrack.getFirstValue();
}
for (int j = 0; j < pointList.size(); j++)
{
Vector2 vp2 = pointList[j];
Vector3 vp = new Vector3(vp2.x, vp2.y, 0);
Vector3 normal = -Vector3.UNIT_Z;
Vector3 newPoint = extrusionPath.getPoint(0) + qBegin * (scaleBegin * vp);
buffer.vertex(newPoint, qBegin * normal, vp2);
}
for (int i2 = 0; i2 < indexBuffer.Count / 3; i2++)
{
buffer.index(indexBuffer[i2 * 3]);
buffer.index(indexBuffer[i2 * 3 + 2]);
buffer.index(indexBuffer[i2 * 3 + 1]);
}
}
//end cap
//if (extrusionMultiPath.getIntersectionsMap().find(MultiPath.PathCoordinate(i, extrusionPath.getSegCount())) == extrusionMultiPath.getIntersectionsMap().end())
if (extrusionMultiPath.getIntersectionsMap().find(new MultiPath.PathCoordinate(i, (uint)extrusionPath.getSegCount())) == -1)
{
buffer.rebaseOffset();
buffer.estimateIndexCount((uint)indexBuffer.Count);
buffer.estimateVertexCount((uint)pointList.Count);
Quaternion qEnd = Utils._computeQuaternion(extrusionPath.getDirectionBefore(extrusionPath.getSegCount()));
if (rotationTrack != null)
{
float angle = rotationTrack.getLastValue();
qEnd = qEnd * new Quaternion((Radian)angle, Vector3.UNIT_Z);
}
float scaleEnd = 1.0f;
if (scaleTrack != null)
{
scaleEnd = scaleTrack.getLastValue();
}
for (int j = 0; j < pointList.Count; j++)
{
Vector2 vp2 = pointList[j];
Vector3 vp = new Vector3(vp2.x, vp2.y, 0f);
//C++ TO C# CONVERTER WARNING: The following line was determined to be a copy constructor call - this should be verified and a copy constructor should be created if it does not yet exist:
//ORIGINAL LINE: Vector3 normal = Vector3::UNIT_Z;
Vector3 normal = (Vector3.UNIT_Z);
Vector3 newPoint = extrusionPath.getPoint(extrusionPath.getSegCount()) + qEnd * (scaleEnd * vp);
buffer.vertex(newPoint, qEnd * normal, vp2);
}
for (int ii = 0; ii < indexBuffer.Count / 3; ii++)
{
buffer.index(indexBuffer[ii * 3]);
buffer.index(indexBuffer[ii * 3 + 1]);
buffer.index(indexBuffer[ii * 3 + 2]);
}
}
}
}
//-----------------------------------------------------------------------
//
//ORIGINAL LINE: void _latheCapImpl(TriangleBuffer& buffer) const
private void _latheCapImpl(ref TriangleBuffer buffer)
{
std_vector <int> indexBuffer = new std_vector <int>();
std_vector <Vector2> pointList = new std_vector <Vector2>();
buffer.rebaseOffset();
Triangulator t = new Triangulator();
Shape shapeCopy = new Shape();
MultiShape multishapeCopy = new MultiShape();
if (mShapeToExtrude != null)
{
//
//ORIGINAL LINE: shapeCopy = *mShapeToExtrude;
shapeCopy = (mShapeToExtrude);
shapeCopy.close();
t.setShapeToTriangulate(shapeCopy);
}
else
{
//
//ORIGINAL LINE: multishapeCopy = *mMultiShapeToExtrude;
multishapeCopy = (mMultiShapeToExtrude);
multishapeCopy.close();
t.setMultiShapeToTriangulate(mMultiShapeToExtrude);
}
t.triangulate(indexBuffer, pointList);
buffer.estimateIndexCount(2 * (uint)indexBuffer.Count);
buffer.estimateVertexCount(2 * (uint)pointList.Count);
//begin cap
buffer.rebaseOffset();
Quaternion q = new Quaternion();
q.FromAngleAxis(mAngleBegin, Vector3.UNIT_Y);
for (int j = 0; j < pointList.size(); j++)
{
Vector2 vp2 = pointList[j];
Vector3 vp = new Vector3(vp2.x, vp2.y, 0);
//C++ TO C# CONVERTER WARNING: The following line was determined to be a copy constructor call - this should be verified and a copy constructor should be created if it does not yet exist:
//ORIGINAL LINE: Vector3 normal = Vector3::UNIT_Z;
Vector3 normal = (Vector3.UNIT_Z);
addPoint(ref buffer, q * vp, q * normal, vp2);
}
for (int i = 0; i < indexBuffer.size() / 3; i++)
{
buffer.index(indexBuffer[i * 3]);
buffer.index(indexBuffer[i * 3 + 1]);
buffer.index(indexBuffer[i * 3 + 2]);
}
//end cap
buffer.rebaseOffset();
q.FromAngleAxis(mAngleEnd, Vector3.UNIT_Y);
for (int j = 0; j < pointList.size(); j++)
{
Vector2 vp2 = pointList[j];
Vector3 vp = new Vector3(vp2.x, vp2.y, 0);
Vector3 normal = -Vector3.UNIT_Z;
addPoint(ref buffer, q * vp, q * normal, vp2);
}
for (int i = 0; i < indexBuffer.size() / 3; i++)
{
buffer.index(indexBuffer[i * 3]);
buffer.index(indexBuffer[i * 3 + 2]);
buffer.index(indexBuffer[i * 3 + 1]);
}
}
//-----------------------------------------------------------------------
public static void _retriangulate(ref TriangleBuffer newMesh, TriangleBuffer inputMesh, std_vector <Intersect> intersectionList, bool first)
{
std_vector <TriangleBuffer.Vertex> vec = inputMesh.getVertices();
std_vector <int> ind = inputMesh.getIndices();
// Triangulate
// Group intersections by triangle indice
std_map <int, std_vector <Segment3D> > meshIntersects = new std_map <int, std_vector <Segment3D> >();
//for (List<Intersect>.Enumerator it = intersectionList.GetEnumerator(); it.MoveNext(); ++it)
foreach (var it in intersectionList)
{
int it2_find;
if (first)
{
it2_find = meshIntersects.find(it.mTri1);
}
else
{
it2_find = meshIntersects.find(it.mTri2);
}
if (it2_find != -1)
{
std_pair <int, std_vector <Segment3D> > it2 = meshIntersects.get((uint)it2_find);
it2.second.push_back(it.mSeg);
}
else
{
std_vector <Segment3D> vec2 = new std_vector <Segment3D>();
vec2.push_back(it.mSeg);
if (first)
{
meshIntersects[it.mTri1] = vec2;
}
else
{
meshIntersects[it.mTri2] = vec2;
}
}
}
// Build a new TriangleBuffer holding non-intersected triangles and retriangulated-intersected triangles
//for (List<TriangleBuffer.Vertex>.Enumerator it = vec.GetEnumerator(); it.MoveNext(); ++it)
foreach (var it in vec)
{
newMesh.vertex(it);
}
//for (int i = 0; i < (int)ind.Count / 3; i++)
// if (meshIntersects.find(i) == meshIntersects.end())
// newMesh.triangle(ind[i * 3], ind[i * 3 + 1], ind[i * 3 + 2]);
for (int i = 0; i < (int)ind.size() / 3; i++)
{
if (meshIntersects.find(i) == -1)
{
newMesh.triangle(ind[i * 3], ind[i * 3 + 1], ind[i * 3 + 2]);
}
}
int numNonIntersected1 = newMesh.getIndices().size();
//for (std.map<int, List<Segment3D> >.Enumerator it = meshIntersects.begin(); it.MoveNext(); ++it)
foreach (var it in meshIntersects)
{
std_vector <Segment3D> segments = it.Value;
int triIndex = it.Key;
Vector3 v1 = vec[ind[triIndex * 3]].mPosition;
Vector3 v2 = vec[ind[triIndex * 3 + 1]].mPosition;
Vector3 v3 = vec[ind[triIndex * 3 + 2]].mPosition;
Vector3 triNormal = ((v2 - v1).CrossProduct(v3 - v1)).NormalisedCopy;
Vector3 xAxis = triNormal.Perpendicular;
Vector3 yAxis = triNormal.CrossProduct(xAxis);
Vector3 planeOrigin = vec[ind[triIndex * 3]].mPosition;
// Project intersection segments onto triangle plane
std_vector <Segment2D> segments2 = new std_vector <Segment2D>();
//for (List<Segment3D>.Enumerator it2 = segments.GetEnumerator(); it2.MoveNext(); it2++)
// segments2.Add(projectOnAxis(it2.Current, planeOrigin, xAxis, yAxis));
foreach (var it2 in segments)
{
segments2.push_back(projectOnAxis(it2, planeOrigin, xAxis, yAxis));
}
//for (List<Segment2D>.Enumerator it2 = segments2.GetEnumerator(); it2.MoveNext();)
int it2_c = segments2.Count;
for (int j = it2_c - 1; j >= 0; j--)
{
Segment2D it2 = segments2[j];
if ((it2.mA - it2.mB).SquaredLength < 1e-5)
{
//C++ TO C# CONVERTER TODO TASK: There is no direct equivalent to the STL vector 'erase' method in C#:
//it2 = segments2.erase(it2);
segments2.RemoveAt(j);
}
//else
}
// Triangulate
Triangulator t = new Triangulator();
//Triangle2D[[]] tri = new Triangle2D[ind[triIndex * 3]](projectOnAxis(vec.mPosition, planeOrigin, xAxis, yAxis), projectOnAxis(vec[ind[triIndex * 3 + 1]].mPosition, planeOrigin, xAxis, yAxis), projectOnAxis(vec[ind[triIndex * 3 + 2]].mPosition, planeOrigin, xAxis, yAxis));
Triangle2D tri = new Triangle2D(projectOnAxis(vec[ind[triIndex * 3]].mPosition, planeOrigin, xAxis, yAxis),
projectOnAxis(vec[ind[triIndex * 3 + 1]].mPosition, planeOrigin, xAxis, yAxis),
projectOnAxis(vec[ind[triIndex * 3 + 2]].mPosition, planeOrigin, xAxis, yAxis));
std_vector <Vector2> outPointList = new std_vector <Vector2>();//PointList outPointList;
std_vector <int> outIndice = new std_vector <int>();
t.setManualSuperTriangle(tri).setRemoveOutside(false).setSegmentListToTriangulate(ref segments2).triangulate(outIndice, outPointList);
// Deproject and add to triangleBuffer
newMesh.rebaseOffset();
//for (List<int>.Enumerator it = outIndice.GetEnumerator(); it.MoveNext(); ++it)
// newMesh.index(it.Current);
foreach (var oindex in outIndice)
{
newMesh.index(oindex);
}
float x1 = tri.mPoints[0].x;
float y1 = tri.mPoints[0].y;
Vector2 uv1 = vec[ind[triIndex * 3]].mUV;
float x2 = tri.mPoints[1].x;
float y2 = tri.mPoints[1].y;
Vector2 uv2 = vec[ind[triIndex * 3 + 1]].mUV;
float x3 = tri.mPoints[2].x;
float y3 = tri.mPoints[2].y;
Vector2 uv3 = vec[ind[triIndex * 3 + 2]].mUV;
float DET = x1 * y2 - x2 * y1 + x2 * y3 - x3 * y2 + x3 * y1 - x1 * y3;
Vector2 A = ((y2 - y3) * uv1 + (y3 - y1) * uv2 + (y1 - y2) * uv3) / DET;
Vector2 B = ((x3 - x2) * uv1 + (x1 - x3) * uv2 + (x2 - x1) * uv3) / DET;
Vector2 C = ((x2 * y3 - x3 * y2) * uv1 + (x3 * y1 - x1 * y3) * uv2 + (x1 * y2 - x2 * y1) * uv3) / DET;
//for (List<Vector2>.Enumerator it = outPointList.GetEnumerator(); it.MoveNext(); ++it)
foreach (var it2 in outPointList)
{
Vector2 uv = A * it2.x + B * it2.y + C;
newMesh.position(deprojectOnAxis(it2, planeOrigin, xAxis, yAxis));
newMesh.normal(triNormal);
newMesh.textureCoord(uv);
}
}
}