/// Adds a new point to a triangle buffer, using the format defined for that MeshGenerator
/// @param buffer the triangle buffer to update
/// @param position the position of the new point
/// @param normal the normal of the new point
/// @param uv the uv texcoord of the new point
//
//ORIGINAL LINE: inline void addPoint(TriangleBuffer& buffer, const Ogre::Vector3& position, const Ogre::Vector3& normal, const Ogre::Vector2& uv) const
protected void addPoint(ref TriangleBuffer buffer, Vector3 position, Vector3 normal, Vector2 uv)
{
if (mTransform)
{
buffer.position(mPosition + mOrientation * (mScale * position));
}
else
{
buffer.position(position);
}
if (mEnableNormals)
{
if (mTransform)
{
buffer.normal(mOrientation * normal);
}
else
{
buffer.normal(normal);
}
}
if (mSwitchUV)
{
for (byte i = 0; i < mNumTexCoordSet; i++)
{
buffer.textureCoord(mUVOrigin.x + uv.y * mUTile, mUVOrigin.y + uv.x * mVTile);
}
}
else
{
for (byte i = 0; i < mNumTexCoordSet; i++)
{
buffer.textureCoord(mUVOrigin.x + uv.x * mUTile, mUVOrigin.y + uv.y * mVTile);
}
}
}
//-----------------------------------------------------------------------
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);
}
}
}
