public BoxUVModifier() { mInputTriangleBuffer = null; mMappingType = MappingType.MT_FULL; mBoxSize = Vector3.UNIT_SCALE; mBoxCenter = Vector3.ZERO; }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { buffer.rebaseOffset(); buffer.estimateVertexCount((mNumSegCircle + 1) * (mNumSegSection + 1)); buffer.estimateIndexCount((mNumSegCircle) * (mNumSegSection + 1) * 6); float deltaSection = (Math.TWO_PI / mNumSegSection); float deltaCircle = (Math.TWO_PI / mNumSegCircle); int offset = 0; for (uint i = 0; i <= mNumSegCircle; i++) { for (uint j = 0; j <= mNumSegSection; j++) { Vector3 c0 = new Vector3(mRadius, 0.0f, 0.0f); Vector3 v0 = new Vector3(mRadius + mSectionRadius * cosf(j * deltaSection), mSectionRadius * sinf(j * deltaSection), 0.0f); Quaternion q = new Quaternion(); q.FromAngleAxis(new Radian(i * deltaCircle), Vector3.UNIT_Y); Vector3 v = q * v0; Vector3 c = q * c0; addPoint(ref buffer, v, (v - c).NormalisedCopy, new Vector2(i / (float)mNumSegCircle, j / (float)mNumSegSection)); if (i != mNumSegCircle) { buffer.index(offset + (int)mNumSegSection + 1); buffer.index(offset); buffer.index(offset + (int)mNumSegSection); buffer.index(offset + (int)mNumSegSection + 1); buffer.index(offset + 1); buffer.index(offset); } offset++; } } }
// * // * Outputs a triangleBuffer // // //ORIGINAL LINE: TriangleBuffer buildTriangleBuffer() const public TriangleBuffer buildTriangleBuffer() { TriangleBuffer tbuffer = new TriangleBuffer(); addToTriangleBuffer(ref tbuffer); return(tbuffer); }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { buffer.rebaseOffset(); buffer.estimateVertexCount((mNumSegHeight + 1) * (mNumSegBase + 1) + mNumSegBase + 2); buffer.estimateIndexCount(mNumSegHeight * mNumSegBase * 6 + 3 * mNumSegBase); float deltaAngle = (Math.TWO_PI / mNumSegBase); float deltaHeight = mHeight / (float)mNumSegHeight; int offset = 0; Vector3 refNormal = new Vector3(mRadius, mHeight, 0.0f); Quaternion q = new Quaternion(); for (uint i = 0; i <= mNumSegHeight; i++) { float r0 = mRadius * (1 - i / (float)mNumSegHeight); for (uint j = 0; j <= mNumSegBase; j++) { float x0 = r0 * cosf(j * deltaAngle); float z0 = r0 * sinf(j * deltaAngle); q.FromAngleAxis(new Radian(-deltaAngle * j), Vector3.UNIT_Y); addPoint(ref buffer, new Vector3(x0, i * deltaHeight, z0), q * refNormal, new Vector2(j / (float)mNumSegBase, i / (float)mNumSegHeight)); if (i != mNumSegHeight && j != mNumSegBase) { buffer.index(offset + (int)mNumSegBase + 2); buffer.index(offset); buffer.index(offset + (int)mNumSegBase + 1); buffer.index(offset + (int)mNumSegBase + +2); buffer.index(offset + 1); buffer.index(offset); } offset++; } } //low cap int centerIndex = offset; addPoint(ref buffer, Vector3.ZERO, Vector3.NEGATIVE_UNIT_Y, Vector2.UNIT_Y); offset++; for (uint j = 0; j <= mNumSegBase; j++) { float x0 = mRadius * cosf(j * deltaAngle); float z0 = mRadius * sinf(j * deltaAngle); addPoint(ref buffer, new Vector3(x0, 0.0f, z0), Vector3.NEGATIVE_UNIT_Y, new Vector2(j / (float)mNumSegBase, 0.0f)); if (j != mNumSegBase) { buffer.index(centerIndex); buffer.index(offset); buffer.index(offset + 1); } offset++; } }
public PlaneUVModifier() { mPlaneNormal = Vector3.UNIT_Y; mPlaneCenter = Vector3.ZERO; mPlaneSize = Vector2.UNIT_SCALE; mInputTriangleBuffer = null; }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // * @exception Ogre::InvalidStateException Either shape or multishape must be defined! // * @exception Ogre::InvalidStateException Required parameter is zero! // //----------------------------------------------------------------------- // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { if (mShapeToExtrude == null && mMultiShapeToExtrude == null) { OGRE_EXCEPT("Ogre::Exception::ERR_INVALID_STATE", "Either shape or multishape must be defined!", "Procedural::Lathe::addToTriangleBuffer(Procedural::TriangleBuffer)"); } ; // Triangulate the begin and end caps if (!mClosed && mCapped) { _latheCapImpl(ref buffer); } // Extrudes the body if (mShapeToExtrude != null) { _latheBodyImpl(ref buffer, mShapeToExtrude); } else { for (uint i = 0; i < mMultiShapeToExtrude.getShapeCount(); i++) { _latheBodyImpl(ref buffer, mMultiShapeToExtrude.getShape(i)); } } }
/// Internal. Builds a "corner" of the rounded box, ie a 1/8th of a sphere // //ORIGINAL LINE: void _addCorner(TriangleBuffer& buffer, bool isXPositive, bool isYPositive, bool isZPositive) const private void _addCorner(ref TriangleBuffer buffer, bool isXPositive, bool isYPositive, bool isZPositive) { buffer.rebaseOffset(); buffer.estimateVertexCount((uint)((mChamferNumSeg + 1) * (mChamferNumSeg + 1))); buffer.estimateIndexCount((uint)(mChamferNumSeg * mChamferNumSeg * 6)); int offset = 0; Vector3 offsetPosition = new Vector3((isXPositive ? 1 : -1) * .5f * mSizeX, (isYPositive ? 1 : -1) * .5f * mSizeY, (isZPositive ? 1 : -1) * .5f * mSizeZ); float deltaRingAngle = (Math.HALF_PI / mChamferNumSeg); float deltaSegAngle = (Math.HALF_PI / mChamferNumSeg); float offsetRingAngle = isYPositive ? 0 : Math.HALF_PI; float offsetSegAngle = 0f; if (isXPositive && isZPositive) { offsetSegAngle = 0; } if ((!isXPositive) && isZPositive) { offsetSegAngle = 1.5f * Math.PI; } if (isXPositive && (!isZPositive)) { offsetSegAngle = Math.HALF_PI; } if ((!isXPositive) && (!isZPositive)) { offsetSegAngle = Math.PI; } // Generate the group of rings for the sphere for (ushort ring = 0; ring <= mChamferNumSeg; ring++) { float r0 = mChamferSize * sinf(ring * deltaRingAngle + offsetRingAngle); float y0 = mChamferSize * cosf(ring * deltaRingAngle + offsetRingAngle); // Generate the group of segments for the current ring for (ushort seg = 0; seg <= mChamferNumSeg; seg++) { float x0 = r0 * sinf(seg * deltaSegAngle + offsetSegAngle); float z0 = r0 * cosf(seg * deltaSegAngle + offsetSegAngle); // Add one vertex to the strip which makes up the sphere addPoint(ref buffer, new Vector3(x0 + offsetPosition.x, y0 + offsetPosition.y, z0 + offsetPosition.z), new Vector3(x0, y0, z0).NormalisedCopy, new Vector2((float)seg / (float)mChamferNumSeg, (float)ring / (float)mChamferNumSeg)); if ((ring != mChamferNumSeg) && (seg != mChamferNumSeg)) { // each vertex (except the last) has six indices pointing to it buffer.index(offset + mChamferNumSeg + 2); buffer.index(offset); buffer.index(offset + mChamferNumSeg + 1); buffer.index(offset + mChamferNumSeg + 2); buffer.index(offset + 1); buffer.index(offset); } offset++; } // end for seg } // end for ring }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // //----------------------------------------------------------------------- // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { Path p = new HelixPath().setHeight(mHeight).setNumRound(mNumRound).setNumSegPath((uint)mNumSegPath).setRadius(mRadiusHelix).realizePath(); Shape s = new CircleShape().setRadius(mRadiusCircle).setNumSeg((uint)mNumSegCircle).realizeShape(); new Extruder().setExtrusionPath(p).setShapeToExtrude(s).addToTriangleBuffer(ref buffer); }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { buffer.rebaseOffset(); buffer.estimateVertexCount((mNumSegX + 1) * (mNumSegY + 1)); buffer.estimateIndexCount(mNumSegX * mNumSegY * 6); int offset = 0; Vector3 vX = mNormal.Perpendicular; Vector3 vY = mNormal.CrossProduct(vX); Vector3 delta1 = mSizeX / (float)mNumSegX * vX; Vector3 delta2 = mSizeY / (float)mNumSegY * vY; // build one corner of the square Vector3 orig = -0.5f * mSizeX * vX - 0.5f * mSizeY * vY; for (ushort i1 = 0; i1 <= mNumSegX; i1++) { for (ushort i2 = 0; i2 <= mNumSegY; i2++) { addPoint(ref buffer, orig + i1 * delta1 + i2 * delta2, mNormal, new Vector2(i1 / (float)mNumSegX, i2 / (float)mNumSegY)); } } bool reverse = false; if (delta1.CrossProduct(delta2).DotProduct(mNormal) > 0f) { reverse = true; } for (ushort n1 = 0; n1 < mNumSegX; n1++) { for (ushort n2 = 0; n2 < mNumSegY; n2++) { if (reverse) { buffer.index(offset + 0); buffer.index(offset + (int)(mNumSegY + 1)); buffer.index(offset + 1); buffer.index(offset + 1); buffer.index(offset + (int)(mNumSegY + 1)); buffer.index(offset + (int)(mNumSegY + 1) + 1); } else { buffer.index(offset + 0); buffer.index(offset + 1); buffer.index(offset + (int)(mNumSegY + 1)); buffer.index(offset + 1); buffer.index(offset + (int)(mNumSegY + 1) + 1); buffer.index(offset + (int)(mNumSegY + 1)); } offset++; } offset++; } //return this; }
/// \exception Ogre::InvalidParametersException Input triangle buffer must not be null public SpherifyModifier setInputTriangleBuffer(TriangleBuffer inputTriangleBuffer) { if (inputTriangleBuffer == null) { OGRE_EXCEPT("Ogre::Exception::ERR_INVALIDPARAMS", "Input triangle buffer must not be null", "Procedural::SpherifyModifier::setInputTriangleBuffer(Procedural::TriangleBuffer*)"); } ; mInputTriangleBuffer = inputTriangleBuffer; return(this); }
//----------------------------------------------------------------------- public static void _extrudeShape(ref TriangleBuffer buffer, Shape shape, Vector3 position, Quaternion orientationLeft, Quaternion orientationRight, float scale, float scaleCorrectionLeft, float scaleCorrectionRight, float totalShapeLength, float uTexCoord, bool joinToTheNextSection, Track shapeTextureTrack) { float lineicShapePos = 0.0f; int numSegShape = shape.getSegCount(); // Insert new points for (uint j = 0; j <= numSegShape; ++j) { Vector2 vp2 = shape.getPoint((int)j); Quaternion orientation = (vp2.x > 0) ? orientationRight : orientationLeft; Vector2 vp2normal = shape.getAvgNormal(j); Vector3 vp = new Vector3(); if (vp2.x > 0) { vp = new Vector3(scaleCorrectionRight * vp2.x, vp2.y, 0); } else { vp = new Vector3(scaleCorrectionLeft * vp2.x, vp2.y, 0); } Vector3 normal = new Vector3(vp2normal.x, vp2normal.y, 0); buffer.rebaseOffset(); Vector3 newPoint = position + orientation * (scale * vp); if (j > 0) { lineicShapePos += (vp2 - shape.getPoint((int)j - 1)).Length; } float vTexCoord = 0f; if (shapeTextureTrack != null) { vTexCoord = shapeTextureTrack.getValue(lineicShapePos, lineicShapePos / totalShapeLength, j); } else { vTexCoord = lineicShapePos / totalShapeLength; } buffer.vertex(newPoint, orientation * normal, new Vector2(uTexCoord, vTexCoord)); if (j < numSegShape && joinToTheNextSection) { if (shape.getOutSide() == Side.SIDE_LEFT) { buffer.triangle(numSegShape + 1, numSegShape + 2, 0); buffer.triangle(0, numSegShape + 2, 1); } else { buffer.triangle(numSegShape + 2, numSegShape + 1, 0); buffer.triangle(numSegShape + 2, 0, 1); } } } }
public void append(TriangleBuffer other) { rebaseOffset(); foreach (var it in other.mIndices) { mIndices.push_back(globalOffset + it); } foreach (var it in other.mVertices) { mVertices.push_back(it); } }
//----------------------------------------------------------------------- public static void _buildTriLookup(ref TriLookup lookup, TriangleBuffer newMesh) { std_vector <TriangleBuffer.Vertex> nvec = newMesh.getVertices(); std_vector <int> nind = newMesh.getIndices(); for (int i = 0; i < (int)nind.Count / 3; i++) { lookup.insert(new Segment3D(nvec[nind[i * 3]].mPosition, nvec[nind[i * 3 + 1]].mPosition).orderedCopy(), i); lookup.insert(new KeyValuePair <Segment3D, int>(new Segment3D(nvec[nind[i * 3]].mPosition, nvec[nind[i * 3 + 2]].mPosition).orderedCopy(), i)); lookup.insert(new KeyValuePair <Segment3D, int>(new Segment3D(nvec[nind[i * 3 + 1]].mPosition, nvec[nind[i * 3 + 2]].mPosition).orderedCopy(), i)); } }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { //int offset = 0; // Generate the pseudo-box shape PlaneGenerator pg = new PlaneGenerator(); pg.setUTile(mUTile).setVTile(mVTile); if (mTransform != null) { pg.setScale(mScale); pg.setOrientation(mOrientation); } pg.setNumSegX(mNumSegY).setNumSegY(mNumSegX).setSizeX(mSizeY).setSizeY(mSizeX).setNormal(Vector3.NEGATIVE_UNIT_Z).setPosition((.5f * mSizeZ + mChamferSize) * (mOrientation * Vector3.NEGATIVE_UNIT_Z)).addToTriangleBuffer(ref buffer); buffer.rebaseOffset(); pg.setNumSegX(mNumSegY).setNumSegY(mNumSegX).setSizeX(mSizeY).setSizeY(mSizeX).setNormal(Vector3.UNIT_Z).setPosition((.5f * mSizeZ + mChamferSize) * (mOrientation * Vector3.UNIT_Z)).addToTriangleBuffer(ref buffer); buffer.rebaseOffset(); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegX).setSizeX(mSizeZ).setSizeY(mSizeX).setNormal(Vector3.NEGATIVE_UNIT_Y).setPosition((.5f * mSizeY + mChamferSize) * (mOrientation * Vector3.NEGATIVE_UNIT_Y)).addToTriangleBuffer(ref buffer); buffer.rebaseOffset(); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegX).setSizeX(mSizeZ).setSizeY(mSizeX).setNormal(Vector3.UNIT_Y).setPosition((.5f * mSizeY + mChamferSize) * (mOrientation * Vector3.UNIT_Y)).addToTriangleBuffer(ref buffer); buffer.rebaseOffset(); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegY).setSizeX(mSizeZ).setSizeY(mSizeY).setNormal(Vector3.NEGATIVE_UNIT_X).setPosition((.5f * mSizeX + mChamferSize) * (mOrientation * Vector3.NEGATIVE_UNIT_X)).addToTriangleBuffer(ref buffer); buffer.rebaseOffset(); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegY).setSizeX(mSizeZ).setSizeY(mSizeY).setNormal(Vector3.UNIT_X).setPosition((.5f * mSizeX + mChamferSize) * (mOrientation * Vector3.UNIT_X)).addToTriangleBuffer(ref buffer); // Generate the corners _addCorner(ref buffer, true, true, true); _addCorner(ref buffer, true, true, false); _addCorner(ref buffer, true, false, true); _addCorner(ref buffer, true, false, false); _addCorner(ref buffer, false, true, true); _addCorner(ref buffer, false, true, false); _addCorner(ref buffer, false, false, true); _addCorner(ref buffer, false, false, false); // Generate the edges _addEdge(ref buffer, -1, -1, 0); _addEdge(ref buffer, -1, 1, 0); _addEdge(ref buffer, 1, -1, 0); _addEdge(ref buffer, 1, 1, 0); _addEdge(ref buffer, -1, 0, -1); _addEdge(ref buffer, -1, 0, 1); _addEdge(ref buffer, 1, 0, -1); _addEdge(ref buffer, 1, 0, 1); _addEdge(ref buffer, 0, -1, -1); _addEdge(ref buffer, 0, -1, 1); _addEdge(ref buffer, 0, 1, -1); _addEdge(ref buffer, 0, 1, 1); }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { PlaneGenerator pg = new PlaneGenerator(); pg.setUTile(mUTile).setVTile(mVTile); if (mTransform != null) { pg.setScale(mScale); pg.setOrientation(mOrientation); } pg.setNumSegX(mNumSegY).setNumSegY(mNumSegX).setSizeX(mSizeY).setSizeY(mSizeX).setNormal(Vector3.NEGATIVE_UNIT_Z).setPosition(mScale * (mPosition + .5f * mSizeZ * (mOrientation * Vector3.NEGATIVE_UNIT_Z))).addToTriangleBuffer(ref buffer); pg.setNumSegX(mNumSegY).setNumSegY(mNumSegX).setSizeX(mSizeY).setSizeY(mSizeX).setNormal(Vector3.UNIT_Z).setPosition(mScale * (mPosition + .5f * mSizeZ * (mOrientation * Vector3.UNIT_Z))).addToTriangleBuffer(ref buffer); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegX).setSizeX(mSizeZ).setSizeY(mSizeX).setNormal(Vector3.NEGATIVE_UNIT_Y).setPosition(mScale * (mPosition + .5f * mSizeY * (mOrientation * Vector3.NEGATIVE_UNIT_Y))).addToTriangleBuffer(ref buffer); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegX).setSizeX(mSizeZ).setSizeY(mSizeX).setNormal(Vector3.UNIT_Y).setPosition(mScale * (mPosition + .5f * mSizeY * (mOrientation * Vector3.UNIT_Y))).addToTriangleBuffer(ref buffer); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegY).setSizeX(mSizeZ).setSizeY(mSizeY).setNormal(Vector3.NEGATIVE_UNIT_X).setPosition(mScale * (mPosition + .5f * mSizeX * (mOrientation * Vector3.NEGATIVE_UNIT_X))).addToTriangleBuffer(ref buffer); pg.setNumSegX(mNumSegZ).setNumSegY(mNumSegY).setSizeX(mSizeZ).setSizeY(mSizeY).setNormal(Vector3.UNIT_X).setPosition(mScale * (mPosition + .5f * mSizeX * (mOrientation * Vector3.UNIT_X))).addToTriangleBuffer(ref buffer); }
// //ORIGINAL LINE: Ogre::MeshPtr realizeMesh(const string& name = "", const Ogre::String& group = "General") public MeshPtr realizeMesh(string name, string group) { TriangleBuffer tbuffer = new TriangleBuffer(); addToTriangleBuffer(ref tbuffer); MeshPtr mesh = null;// MeshManager.Singleton.CreateManual(name, group); //new MeshPtr(); if (name == "") { mesh = tbuffer.transformToMesh(Utils.getName("mesh_procedural_"), group); } else { mesh = tbuffer.transformToMesh(name, group); } return(mesh); }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { buffer.rebaseOffset(); buffer.estimateVertexCount((uint)((mNumSegCircle * mP + 1) * (mNumSegSection + 1))); buffer.estimateIndexCount((uint)((mNumSegCircle * mP) * (mNumSegSection + 1) * 6)); int offset = 0; for (uint i = 0; i <= mNumSegCircle * mP; i++) { float phi = Math.TWO_PI * i / (float)mNumSegCircle; float x0 = mRadius * (2 + cosf(mQ * phi / (float)mP)) * cosf(phi) / 3.0f; float y0 = mRadius * sinf(mQ * phi / (float)mP) / 3.0f; float z0 = mRadius * (2 + cosf(mQ * phi / (float)mP)) * sinf(phi) / 3.0f; float phi1 = Math.TWO_PI * (i + 1) / (float)mNumSegCircle; float x1 = mRadius * (2 + cosf(mQ * phi1 / (float)mP)) * cosf(phi1) / 3.0f; float y1 = mRadius * sinf(mQ * phi1 / mP) / 3.0f; float z1 = mRadius * (2 + cosf(mQ * phi1 / (float)mP)) * sinf(phi1) / 3.0f; Vector3 v0 = new Vector3(x0, y0, z0); Vector3 v1 = new Vector3(x1, y1, z1); Vector3 direction = ((v1 - v0).NormalisedCopy); Quaternion q = Utils._computeQuaternion(direction); for (uint j = 0; j <= mNumSegSection; j++) { float alpha = Math.TWO_PI * j / mNumSegSection; Vector3 vp = mSectionRadius * (q * new Vector3(cosf(alpha), sinf(alpha), 0)); addPoint(ref buffer, v0 + vp, vp.NormalisedCopy, new Vector2(i / (float)mNumSegCircle, j / (float)mNumSegSection)); if (i != mNumSegCircle * mP) { buffer.index(offset + (int)mNumSegSection + 1); buffer.index(offset + (int)mNumSegSection); buffer.index(offset); buffer.index(offset + (int)mNumSegSection + 1); buffer.index(offset); buffer.index(offset + 1); } offset++; } } }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { buffer.rebaseOffset(); buffer.estimateVertexCount((mNumRings + 1) * (mNumSegments + 1)); buffer.estimateIndexCount(mNumRings * (mNumSegments + 1) * 6); float fDeltaRingAngle = (Math.PI / mNumRings); float fDeltaSegAngle = (Math.TWO_PI / mNumSegments); int offset = 0; // Generate the group of rings for the sphere for (uint ring = 0; ring <= mNumRings; ring++) { float r0 = mRadius * sinf(ring * fDeltaRingAngle); float y0 = mRadius * cosf(ring * fDeltaRingAngle); // Generate the group of segments for the current ring for (uint seg = 0; seg <= mNumSegments; seg++) { float x0 = r0 * sinf(seg * fDeltaSegAngle); float z0 = r0 * cosf(seg * fDeltaSegAngle); // Add one vertex to the strip which makes up the sphere addPoint(ref buffer, new Vector3(x0, y0, z0), new Vector3(x0, y0, z0).NormalisedCopy, new Vector2((float)seg / (float)mNumSegments, (float)ring / (float)mNumRings)); if (ring != mNumRings) { if (seg != mNumSegments) { // each vertex (except the last) has six indices pointing to it if (ring != mNumRings - 1) { buffer.triangle(offset + (int)mNumSegments + 2, offset, offset + (int)mNumSegments + 1); } if (ring != 0) { buffer.triangle(offset + (int)mNumSegments + 2, offset + 1, offset); } } offset++; } } // end for seg } // end for ring }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // //void addToTriangleBuffer(ref TriangleBuffer& buffer) const; //----------------------------------------------------------------------- //void Triangulator::addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { PointList pointList = new std_vector <Vector2>(); std_vector <int> indexBuffer = new std_vector <int>(); triangulate(indexBuffer, pointList); for (int j = 0; j < pointList.size(); j++) { Vector2 vp2 = pointList[j]; Vector3 vp = new Vector3(vp2.x, vp2.y, 0f); Vector3 normal = -Vector3.UNIT_Z; addPoint(ref buffer, vp, normal, new Vector2(vp2.x, vp2.y)); } 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]); } }
/// 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); } } }
//----------------------------------------------------------------------- // //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]); } }
//----------------------------------------------------------------------- // //ORIGINAL LINE: void _latheBodyImpl(TriangleBuffer& buffer, const Shape* shapeToExtrude) const private void _latheBodyImpl(ref TriangleBuffer buffer, Shape shapeToExtrude) { if (shapeToExtrude == null) { OGRE_EXCEPT("Ogre::Exception::ERR_INVALID_STATE", "Shape must not be null!", "Procedural::Lathe::_latheBodyImpl(Procedural::TriangleBuffer&, const Procedural::Shape*)"); } int numSegShape = shapeToExtrude.getSegCount(); if (numSegShape < 2) { OGRE_EXCEPT("Ogre::Exception::ERR_INVALID_STATE", "Shape must contain at least two points", "Procedural::Lathe::_latheBodyImpl(Procedural::TriangleBuffer&, const Procedural::Shape*)"); } int offset = 0; //int numSeg = mClosed?mNumSeg+1:mNumSeg; int numSeg = (int)mNumSeg + 1; buffer.rebaseOffset(); buffer.estimateIndexCount((uint)(numSeg * numSegShape * 6)); buffer.estimateVertexCount((uint)((numSegShape + 1) * (numSeg + 1))); Radian angleEnd = new Radian(mAngleEnd); if (mAngleBegin > mAngleEnd) { angleEnd += (Radian)Math.TWO_PI; } for (int i = 0; i < numSeg; i++) { Radian angle = new Radian(); if (mClosed) { angle = i / (float)mNumSeg * Math.TWO_PI; } else { angle = mAngleBegin + i / (float)mNumSeg * (angleEnd - mAngleBegin); } Quaternion q = new Quaternion(); q.FromAngleAxis(angle, Vector3.UNIT_Y); for (int j = 0; j <= numSegShape; j++) { Vector2 v0 = shapeToExtrude.getPoint(j); Vector3 vp = new Vector3(v0.x, v0.y, 0); Vector2 vp2direction = shapeToExtrude.getAvgDirection((uint)j); Vector2 vp2normal = vp2direction.Perpendicular; Vector3 normal = new Vector3(vp2normal.x, vp2normal.y, 0); normal.Normalise(); if (shapeToExtrude.getOutSide() == Side.SIDE_RIGHT) { normal = -normal; } addPoint(ref buffer, q * vp, q * normal, new Vector2(i / (float)mNumSeg, j / (float)numSegShape)); if (j < numSegShape && i < numSeg - 1) { if (shapeToExtrude.getOutSide() == Side.SIDE_RIGHT) { buffer.triangle(offset + numSegShape + 2, offset, offset + numSegShape + 1); buffer.triangle(offset + numSegShape + 2, offset + 1, offset); } else { buffer.triangle(offset + numSegShape + 2, offset + numSegShape + 1, offset); buffer.triangle(offset + numSegShape + 2, offset, offset + 1); } } offset++; } } }
public HemisphereUVModifier() { mInputTriangleBuffer = null; mTextureRectangleTop = new Mogre.RealRect(0, 0, 1, 1); mTextureRectangleBottom = new Mogre.RealRect(0, 0, 1, 1); }
// * // * Builds the mesh into the given TriangleBuffer // * @param buffer The TriangleBuffer on where to append the mesh. // // //ORIGINAL LINE: void addToTriangleBuffer(TriangleBuffer& buffer) const public override void addToTriangleBuffer(ref TriangleBuffer buffer) { buffer.rebaseOffset(); if (mCapped) { buffer.estimateVertexCount((mNumSegHeight + 1) * (mNumSegBase + 1) + 2 * (mNumSegBase + 1) + 2); buffer.estimateIndexCount(mNumSegHeight * (mNumSegBase + 1) * 6 + 6 * mNumSegBase); } else { buffer.estimateVertexCount((mNumSegHeight + 1) * (mNumSegBase + 1)); buffer.estimateIndexCount(mNumSegHeight * (mNumSegBase + 1) * 6); } float deltaAngle = (Math.TWO_PI / mNumSegBase); float deltaHeight = mHeight / (float)mNumSegHeight; int offset = 0; for (uint i = 0; i <= mNumSegHeight; i++) { for (uint j = 0; j <= mNumSegBase; j++) { float x0 = mRadius * cosf(j * deltaAngle); float z0 = mRadius * sinf(j * deltaAngle); addPoint(ref buffer, new Vector3(x0, (float)i * deltaHeight, z0), new Vector3(x0, 0f, z0).NormalisedCopy, new Vector2((float)j / (float)mNumSegBase, (float)i / (float)mNumSegHeight)); if (i != mNumSegHeight) { buffer.index(offset + (int)mNumSegBase + 1); buffer.index(offset); buffer.index(offset + (int)mNumSegBase); buffer.index(offset + (int)mNumSegBase + 1); buffer.index(offset + 1); buffer.index(offset); } offset++; } } if (mCapped) { //low cap int centerIndex = offset; addPoint(ref buffer, Vector3.ZERO, Vector3.NEGATIVE_UNIT_Y, Vector2.ZERO); offset++; for (uint j = 0; j <= mNumSegBase; j++) { float x0 = cosf(j * deltaAngle); float z0 = sinf(j * deltaAngle); addPoint(ref buffer, new Vector3(mRadius * x0, 0.0f, mRadius * z0), Vector3.NEGATIVE_UNIT_Y, new Vector2(x0, z0)); if (j != mNumSegBase) { buffer.index(centerIndex); buffer.index(offset); buffer.index(offset + 1); } offset++; } // high cap centerIndex = offset; addPoint(ref buffer, new Vector3(0, mHeight, 0), Vector3.UNIT_Y, Vector2.ZERO); offset++; for (uint j = 0; j <= mNumSegBase; j++) { float x0 = cosf(j * deltaAngle); float z0 = sinf(j * deltaAngle); addPoint(ref buffer, new Vector3(x0 * mRadius, mHeight, mRadius * z0), Vector3.UNIT_Y, new Vector2(x0, z0)); if (j != mNumSegBase) { buffer.index(centerIndex); buffer.index(offset + 1); buffer.index(offset); } offset++; } } }
// * // * Overloaded by each generator to implement the specifics // public abstract void addToTriangleBuffer(ref TriangleBuffer buffer);
public HemisphereUVModifier setInputTriangleBuffer(TriangleBuffer inputTriangleBuffer) { mInputTriangleBuffer = inputTriangleBuffer; return(this); }
public CylinderUVModifier() { mInputTriangleBuffer = null; mRadius = 1.0f; mHeight = 1.0f; }
/// Sets the input Triangle Buffer public ShowNormalsGenerator setTriangleBuffer(TriangleBuffer triangleBuffer) { mTriangleBuffer = triangleBuffer; return(this); }
public ShowNormalsGenerator() { mTriangleBuffer = null; mSize = 1.0f; mVisualStyle = VisualStyle.VS_LINE; }
public BoxUVModifier setInputTriangleBuffer(TriangleBuffer inputTriangleBuffer) { mInputTriangleBuffer = inputTriangleBuffer; return(this); }