/// \exception Ogre::InvalidStateException Input triangle buffer must be set public void modify() { if (mInputTriangleBuffer == null) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Input triangle buffer must be set", "Procedural::SpherifyModifier::modify()"); } ; //for (List<TriangleBuffer.Vertex>.Enumerator it = mInputTriangleBuffer.getVertices().begin(); it != mInputTriangleBuffer.getVertices().end(); ++it) foreach (var it in mInputTriangleBuffer.getVertices()) { float l = (it.mPosition - mCenter).Length; if (l > 1e-6) { it.mNormal = (it.mPosition - mCenter) / l; it.mPosition = mCenter + mRadius * it.mNormal; } } }
/// \exception Ogre::InvalidStateException Input triangle buffer must be set //-------------------------------------------------------------- public void modify() { if (mInputTriangleBuffer == null) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Input triangle buffer must be set", "__FUNCTION__"); } ; Vector3 xvec = mPlaneNormal.Perpendicular; Vector3 yvec = mPlaneNormal.CrossProduct(xvec); //for (List<TriangleBuffer.Vertex>.Enumerator it = mInputTriangleBuffer.getVertices().begin(); it != mInputTriangleBuffer.getVertices().end(); ++it) foreach (var it in mInputTriangleBuffer.getVertices()) { Vector3 v = it.mPosition - mPlaneCenter; float it_mUV_x = v.DotProduct(xvec); float it_mUV_y = v.DotProduct(yvec); it.mUV = new Vector2(it_mUV_x, it_mUV_y); } }
//-------------------------------------------------------------- public void modify() { if (mInputTriangleBuffer == null) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Input triangle buffer must be set", "__FUNCTION__"); } if (mHeight <= 0f) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Height must be strictly positive", "__FUNCTION__"); } if (mRadius <= 0f) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Radius must be strictly positive", "__FUNCTION__"); } ; float angleThreshold = Math.ATan(mHeight / mRadius).ValueRadians; //for (List<TriangleBuffer.Vertex>.Enumerator it = mInputTriangleBuffer.getVertices().begin(); it != mInputTriangleBuffer.getVertices().end(); ++it) foreach (var it in mInputTriangleBuffer.getVertices()) { Vector2 nxz = new Vector2(it.mNormal.x, it.mNormal.z); float alpha = (Math.ATan(it.mNormal.y / nxz.Length).ValueRadians + Math.HALF_PI); if (Math.Abs(alpha) > angleThreshold) { Vector2 vxz = new Vector2(it.mPosition.x, it.mPosition.z); it.mUV = vxz / mRadius; } else { Vector2 vxz = new Vector2(it.mPosition.x, it.mPosition.z); it.mUV.x = Utils.angleTo(Vector2.UNIT_X, vxz).ValueRadians / Math.TWO_PI; it.mUV.y = it.mPosition.y / mHeight - 0.5f; } } }
//-------------------------------------------------------------- public void modify() { if (mInputTriangleBuffer == null) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Input triangle buffer must be set", "__FUNCTION__"); } ; Vector3[] directions = new Vector3[6] { Vector3.UNIT_X, Vector3.UNIT_Y, Vector3.UNIT_Z, Vector3.NEGATIVE_UNIT_X, Vector3.NEGATIVE_UNIT_Y, Vector3.NEGATIVE_UNIT_Z }; //for (List<TriangleBuffer.Vertex>.Enumerator it = mInputTriangleBuffer.getVertices().begin(); it != mInputTriangleBuffer.getVertices().end(); ++it) foreach (var it in mInputTriangleBuffer.getVertices()) { Vector3 v = it.mPosition - mBoxCenter; if (v.IsZeroLength) { continue; } //v.normalise(); v.x /= mBoxSize.x; v.y /= mBoxSize.y; v.z /= mBoxSize.z; //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 n = it->mNormal; Vector3 n = (it.mNormal); float maxAxis = 0; int principalAxis = 0; for (byte i = 0; i < 6; i++) { if (directions[i].DotProduct(n) > maxAxis) { maxAxis = directions[i].DotProduct(n); principalAxis = i; } } Vector3 vX = new Vector3(); Vector3 vY = new Vector3(); if (principalAxis % 3 == 1) { vY = Vector3.UNIT_X; } else { vY = Vector3.UNIT_Y; } vX = directions[principalAxis].CrossProduct(vY); Vector2 uv = new Vector2(0.5f - vX.DotProduct(v), 0.5f - vY.DotProduct(v)); if (mMappingType == MappingType.MT_FULL) { it.mUV = uv; } else if (mMappingType == MappingType.MT_CROSS) { } else if (mMappingType == MappingType.MT_PACKED) { it.mUV = new Vector2((uv.x + principalAxis % 3) / 3, (uv.y + principalAxis / 3) / 2); } } }
//-------------------------------------------------------------- public void modify() { if (mInputTriangleBuffer == null) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Input triangle buffer must be set", "__FUNCTION__"); } ; //std.map<Vector3, int, Vector3Comparator> mapExistingVertices = new std.map<Vector3, int, Vector3Comparator>(); std_map <Vector3, int> mapExistingVertices = new std_map <Vector3, int>(new Vector3Comparator()); std_vector <TriangleBuffer.Vertex> vertices = mInputTriangleBuffer.getVertices(); std_vector <int> indices = mInputTriangleBuffer.getIndices(); int newSize = vertices.size(); // for (std::vector<TriangleBuffer::Vertex>::iterator it = vertices.begin(); it!= vertices.end(); ++it) for (int i = 0; i < vertices.Count; i++) { //size_t currentIndex = it - vertices.begin(); TriangleBuffer.Vertex it = vertices[i]; int currentIndex = i; if (currentIndex >= newSize) { break; } //if (mapExistingVertices.find(it.mPosition) == mapExistingVertices.end()) // mapExistingVertices[it.mPosition] = currentIndex; if (mapExistingVertices.find(it.mPosition) == -1) { mapExistingVertices.insert(it.mPosition, currentIndex); } else { int existingIndex = mapExistingVertices[it.mPosition]; --newSize; if (currentIndex == newSize) { //for (std::vector<int>::iterator it2 = indices.begin(); it2 != indices.end(); ++it2) for (int j = 0; j < indices.Count; j++) { int it2 = indices[j]; if (it2 == currentIndex) { //*it2 = existingIndex; indices[j] = existingIndex; } } } else { int lastIndex = newSize; //*it = vertices[lastIndex]; it = vertices[lastIndex]; //for (std::vector<int>::iterator it2 = indices.begin(); it2 != indices.end(); ++it2) for (int j = 0; j < indices.Count; j++) { int it2 = indices[j]; //if (*it2 == currentIndex) if (it2 == currentIndex) { //*it2 = existingIndex; indices[j] = existingIndex; } //else if (*it2 == lastIndex) else if (it2 == lastIndex) { //*it2 = currentIndex; indices[j] = currentIndex; } } } } } }
//-------------------------------------------------------------- public void modify() { if (mInputTriangleBuffer == null) { OGRE_EXCEPT("Exception::ERR_INVALID_STATE", "Input triangle buffer must be set", "__FUNCTION__"); } ; if (mComputeMode == NormalComputeMode.NCM_TRIANGLE) { if (mMustWeldUnweldFirst) { new UnweldVerticesModifier().setInputTriangleBuffer(mInputTriangleBuffer).modify(); } std_vector <int> indices = mInputTriangleBuffer.getIndices(); std_vector <TriangleBuffer.Vertex> vertices = mInputTriangleBuffer.getVertices(); for (int i = 0; i < indices.size(); i += 3) { Vector3 v1 = vertices[indices[i]].mPosition; Vector3 v2 = vertices[indices[i + 1]].mPosition; Vector3 v3 = vertices[indices[i + 2]].mPosition; Vector3 n = (v2 - v1).CrossProduct(v3 - v1).NormalisedCopy; // //ORIGINAL LINE: vertices[indices[i]].mNormal = n; vertices[indices[i]].mNormal = (n); // //ORIGINAL LINE: vertices[indices[i+1]].mNormal = n; vertices[indices[i + 1]].mNormal = (n); // //ORIGINAL LINE: vertices[indices[i+2]].mNormal = n; vertices[indices[i + 2]].mNormal = (n); } } else { if (mMustWeldUnweldFirst) { new WeldVerticesModifier().setInputTriangleBuffer(mInputTriangleBuffer).modify(); } std_vector <int> indices = mInputTriangleBuffer.getIndices(); std_vector <TriangleBuffer.Vertex> vertices = mInputTriangleBuffer.getVertices(); std_vector <std_vector <Vector3> > tmpNormals = new std_vector <std_vector <Vector3> >(); tmpNormals.resize(vertices.size()); for (int i = 0; i < indices.size(); i += 3) { Vector3 v1 = vertices[indices[i]].mPosition; Vector3 v2 = vertices[indices[i + 1]].mPosition; Vector3 v3 = vertices[indices[i + 2]].mPosition; Vector3 n = (v2 - v1).CrossProduct(v3 - v1); tmpNormals[indices[i]].push_back(n); tmpNormals[indices[i + 1]].push_back(n); tmpNormals[indices[i + 2]].push_back(n); } for (int i = 0; i < vertices.size(); i++) { Vector3 n = (Vector3.ZERO); for (int j = 0; j < tmpNormals[i].size(); j++) { n += tmpNormals[i][j]; } vertices[i].mNormal = n.NormalisedCopy; } } }
//----------------------------------------------------------------------- // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { std_vector <TriangleBuffer.Vertex> vec1 = mMesh1.getVertices(); std_vector <int> ind1 = mMesh1.getIndices(); std_vector <TriangleBuffer.Vertex> vec2 = mMesh2.getVertices(); std_vector <int> ind2 = mMesh2.getIndices(); Segment3D intersectionResult = new Segment3D(); std_vector <Intersect> intersectionList = new std_vector <Intersect>(); // Find all intersections between mMesh1 and mMesh2 int idx1 = 0; //for (std::vector<int>::const_iterator it = ind1.begin(); it != ind1.end(); idx1++) for (int i = 0; i < ind1.Count; i += 3, idx1++) { int it = ind1[i]; //Triangle3D t1(vec1[*it++].mPosition, vec1[*it++].mPosition, vec1[*it++].mPosition); Triangle3D t1 = new Triangle3D(vec1[it].mPosition, vec1[it + 1].mPosition, vec1[it + 2].mPosition); int idx2 = 0; //for (std::vector<int>::const_iterator it2 = ind2.begin(); it2 != ind2.end(); idx2++) for (int j = 0; j < ind2.Count; j += 3, idx2++) { int it2 = ind2[j]; //Triangle3D t2(vec2[*it2++].mPosition, vec2[*it2++].mPosition, vec2[*it2++].mPosition); Triangle3D t2 = new Triangle3D(vec2[it2].mPosition, vec2[it2 + 1].mPosition, vec2[it2 + 2].mPosition); if (t1.findIntersect(t2, ref intersectionResult)) { Intersect intersect = new Intersect(intersectionResult, idx1, idx2); intersectionList.push_back(intersect); } } } // Remove all intersection segments too small to be relevant //for (std::vector<Intersect>::iterator it = intersectionList.begin(); it != intersectionList.end();) // if ((it.mSeg.mB - it.mSeg.mA).squaredLength() < 1e-8) // it = intersectionList.erase(it); // else // ++it; for (int i = intersectionList.Count - 1; i >= 0; i--) { Intersect it = intersectionList[i]; if ((it.mSeg.mB - it.mSeg.mA).SquaredLength < 1e-8) { intersectionList.erase((uint)i); } } // Retriangulate TriangleBuffer newMesh1 = new TriangleBuffer(); TriangleBuffer newMesh2 = new TriangleBuffer(); GlobalMembersProceduralBoolean._retriangulate(ref newMesh1, mMesh1, intersectionList, true); GlobalMembersProceduralBoolean._retriangulate(ref newMesh2, mMesh2, intersectionList, false); //buffer.append(newMesh1); //buffer.append(newMesh2); //return; // Trace contours std_vector <Path> contours = new std_vector <Path>(); std_vector <Segment3D> segmentSoup = new std_vector <Segment3D>(); //for (std::vector<Intersect>::iterator it = intersectionList.begin(); it != intersectionList.end(); ++it) foreach (var it in intersectionList) { segmentSoup.push_back(it.mSeg); } new Path().buildFromSegmentSoup(segmentSoup, ref contours); // Build a lookup from segment to triangle TriLookup triLookup1 = new std_multimap <Segment3D, int>(new Seg3Comparator()), triLookup2 = new std_multimap <Segment3D, int>(new Seg3Comparator()); GlobalMembersProceduralBoolean._buildTriLookup(ref triLookup1, newMesh1); GlobalMembersProceduralBoolean._buildTriLookup(ref triLookup2, newMesh2); std_set <Segment3D> limits = new std_set <Segment3D>(new Seg3Comparator()); //for (std::vector<Segment3D>::iterator it = segmentSoup.begin(); it != segmentSoup.end(); ++it) foreach (var it in segmentSoup) { limits.insert(it.orderedCopy()); } // Build resulting mesh //for (std::vector<Path>::iterator it = contours.begin(); it != contours.end(); ++it) foreach (var it in contours) { // Find 2 seed triangles for each contour Segment3D firstSeg = new Segment3D(it.getPoint(0), it.getPoint(1)); //std_pair<TriLookup::iterator, TriLookup::iterator> it2mesh1 = triLookup1.equal_range(firstSeg.orderedCopy()); //std_pair<TriLookup::iterator, TriLookup::iterator> it2mesh2 = triLookup2.equal_range(firstSeg.orderedCopy()); std_pair <std_pair <Segment3D, List <int> >, std_pair <Segment3D, List <int> > > it2mesh1 = triLookup1.equal_range(firstSeg.orderedCopy()); std_pair <std_pair <Segment3D, List <int> >, std_pair <Segment3D, List <int> > > it2mesh2 = triLookup2.equal_range(firstSeg.orderedCopy()); int mesh1seed1 = 0, mesh1seed2 = 0, mesh2seed1 = 0, mesh2seed2 = 0; //if (it2mesh1.first != triLookup1.end() && it2mesh2.first != triLookup2.end()) if (it2mesh1.first != null && it2mesh2.first != null) { // check which of seed1 and seed2 must be included (it can be 0, 1 or both) //mesh1seed1 = it2mesh1.first.second; //mesh1seed2 = (--it2mesh1.second).second; //mesh2seed1 = it2mesh2.first.second; //mesh2seed2 = (--it2mesh2.second).second; mesh1seed1 = it2mesh1.first.second[0]; mesh1seed2 = it2mesh1.first.second[it2mesh1.first.second.Count - 1]; //(--it2mesh1.second).second[0]; mesh2seed1 = it2mesh2.first.second[0]; mesh2seed2 = it2mesh2.first.second[it2mesh2.first.second.Count - 1]; //(--it2mesh2.second).second[0]; if (mesh1seed1 == mesh1seed2) { mesh1seed2 = -1; } if (mesh2seed1 == mesh2seed2) { mesh2seed2 = -1; } Vector3 vMesh1 = new Vector3(0f, 0f, 0f), nMesh1 = new Vector3(0f, 0f, 0f), vMesh2 = new Vector3(0f, 0f, 0f), nMesh2 = new Vector3(0f, 0f, 0f); for (int i = 0; i < 3; i++) { Vector3 pos = newMesh1.getVertices()[newMesh1.getIndices()[mesh1seed1 * 3 + i]].mPosition; if ((pos - firstSeg.mA).SquaredLength > 1e-6 && (pos - firstSeg.mB).SquaredLength > 1e-6) { vMesh1 = pos; nMesh1 = newMesh1.getVertices()[newMesh1.getIndices()[mesh1seed1 * 3 + i]].mNormal; break; } } for (int i = 0; i < 3; i++) { Vector3 pos = newMesh2.getVertices()[newMesh2.getIndices()[mesh2seed1 * 3 + i]].mPosition; if ((pos - firstSeg.mA).SquaredLength > 1e-6 && (pos - firstSeg.mB).SquaredLength > 1e-6) { vMesh2 = pos; nMesh2 = newMesh2.getVertices()[newMesh2.getIndices()[mesh2seed1 * 3 + i]].mNormal; break; } } bool M2S1InsideM1 = (nMesh1.DotProduct(vMesh2 - firstSeg.mA) < 0f); bool M1S1InsideM2 = (nMesh2.DotProduct(vMesh1 - firstSeg.mA) < 0f); GlobalMembersProceduralBoolean._removeFromTriLookup(mesh1seed1, ref triLookup1); GlobalMembersProceduralBoolean._removeFromTriLookup(mesh2seed1, ref triLookup2); GlobalMembersProceduralBoolean._removeFromTriLookup(mesh1seed2, ref triLookup1); GlobalMembersProceduralBoolean._removeFromTriLookup(mesh2seed2, ref triLookup2); // Recursively add all neighbours of these triangles // Stop when a contour is touched switch (mBooleanOperation) { case BooleanOperation.BT_UNION: if (M1S1InsideM2) { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh1, mesh1seed2, ref triLookup1, limits, false); } else { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh1, mesh1seed1, ref triLookup1, limits, false); } if (M2S1InsideM1) { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh2, mesh2seed2, ref triLookup2, limits, false); } else { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh2, mesh2seed1, ref triLookup2, limits, false); } break; case BooleanOperation.BT_INTERSECTION: if (M1S1InsideM2) { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh1, mesh1seed1, ref triLookup1, limits, false); } else { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh1, mesh1seed2, ref triLookup1, limits, false); } if (M2S1InsideM1) { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh2, mesh2seed1, ref triLookup2, limits, false); } else { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh2, mesh2seed2, ref triLookup2, limits, false); } break; case BooleanOperation.BT_DIFFERENCE: if (M1S1InsideM2) { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh1, mesh1seed2, ref triLookup1, limits, false); } else { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh1, mesh1seed1, ref triLookup1, limits, false); } if (M2S1InsideM1) { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh2, mesh2seed1, ref triLookup2, limits, true); } else { GlobalMembersProceduralBoolean._recursiveAddNeighbour(ref buffer, newMesh2, mesh2seed2, ref triLookup2, limits, true); } break; } } } }
//----------------------------------------------------------------------- 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); } } }
//----------------------------------------------------------------------- public static void _recursiveAddNeighbour(ref TriangleBuffer result, TriangleBuffer source, int triNumber, ref TriLookup lookup, std_set <Segment3D> limits, bool inverted) { if (triNumber == -1) { return; } Utils.log("tri " + (triNumber.ToString())); std_vector <int> ind = source.getIndices(); std_vector <TriangleBuffer.Vertex> vec = source.getVertices(); result.rebaseOffset(); if (inverted) { result.triangle(0, 2, 1); TriangleBuffer.Vertex v = vec[ind[triNumber * 3]]; v.mNormal = -v.mNormal; result.vertex(v); v = vec[ind[triNumber * 3 + 1]]; v.mNormal = -v.mNormal; result.vertex(v); v = vec[ind[triNumber * 3 + 2]]; v.mNormal = -v.mNormal; result.vertex(v); } else { result.triangle(0, 1, 2); result.vertex(vec[ind[triNumber * 3]]); result.vertex(vec[ind[triNumber * 3 + 1]]); result.vertex(vec[ind[triNumber * 3 + 2]]); } //Utils::log("vertex " + StringConverter::toString(vec[ind[triNumber*3]].mPosition)); //Utils::log("vertex " + StringConverter::toString(vec[ind[triNumber*3+1]].mPosition)); //Utils::log("vertex " + StringConverter::toString(vec[ind[triNumber*3+2]].mPosition)); std_pair <Segment3D, List <int> > it = null; int nextTriangle1 = -1; int nextTriangle2 = -1; int nextTriangle3 = -1; int it_find = lookup.find(new Segment3D(vec[ind[triNumber * 3]].mPosition, vec[ind[triNumber * 3 + 1]].mPosition).orderedCopy()); ////if (it != lookup.end() && limits.find(it->first.orderedCopy()) != limits.end()) //// Utils::log("Cross limit1"); //if (it != lookup.end() && limits.find(it->first.orderedCopy()) == limits.end()) { // nextTriangle1 = it->second; // _removeFromTriLookup(nextTriangle1, lookup); //} if (it_find != -1) { it = lookup.get((uint)it_find); if (limits.find(it.first.orderedCopy()) == -1) { nextTriangle1 = it.second[0]; GlobalMembersProceduralBoolean._removeFromTriLookup(nextTriangle1, ref lookup); } } // it = lookup.find(Segment3D(vec[ind[triNumber * 3 + 1]].mPosition, vec[ind[triNumber * 3 + 2]].mPosition).orderedCopy()); it_find = lookup.find(new Segment3D(vec[ind[triNumber * 3 + 1]].mPosition, vec[ind[triNumber * 3 + 2]].mPosition).orderedCopy()); ////if (it != lookup.end() && limits.find(it->first.orderedCopy()) != limits.end()) ////Utils::log("Cross limit2"); //if (it != lookup.end() && limits.find(it->first.orderedCopy()) == limits.end()) { // nextTriangle2 = it->second; // _removeFromTriLookup(nextTriangle2, lookup); //} if (it_find != -1) { it = lookup.get((uint)it_find); if (limits.find(it.first.orderedCopy()) == -1) { nextTriangle2 = it.second[0]; GlobalMembersProceduralBoolean._removeFromTriLookup(nextTriangle2, ref lookup); } } //it = lookup.find(Segment3D(vec[ind[triNumber * 3]].mPosition, vec[ind[triNumber * 3 + 2]].mPosition).orderedCopy()); ////if (it != lookup.end() && limits.find(it->first.orderedCopy()) != limits.end()) //// Utils::log("Cross limit3"); //if (it != lookup.end() && limits.find(it->first.orderedCopy()) == limits.end()) { // nextTriangle3 = it->second; // _removeFromTriLookup(nextTriangle3, lookup); //} it_find = lookup.find(new Segment3D(vec[ind[triNumber * 3]].mPosition, vec[ind[triNumber * 3 + 2]].mPosition).orderedCopy()); if (it_find != -1) { it = lookup.get((uint)it_find); if (limits.find(it.first.orderedCopy()) == -1) { nextTriangle3 = it.second[0]; GlobalMembersProceduralBoolean._removeFromTriLookup(nextTriangle3, ref lookup); } } //Utils::log("add " + StringConverter::toString(nextTriangle1) + " ," + StringConverter::toString(nextTriangle2) + " ,"+StringConverter::toString(nextTriangle3) ); _recursiveAddNeighbour(ref result, source, nextTriangle1, ref lookup, limits, inverted); _recursiveAddNeighbour(ref result, source, nextTriangle2, ref lookup, limits, inverted); _recursiveAddNeighbour(ref result, source, nextTriangle3, ref lookup, limits, inverted); }