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);
}
