TorqueGameEngines/Torque3D
1
0
Fork 0
mirror of https://github.com/TorqueGameEngines/Torque3D.git synced 2026-03-11 16:30:48 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Rename all member variables to follow the style guidelines (prefixed with the 'm') - class ColladaPrimitive

Browse source
This commit is contained in:
bank 2014-05-12 19:03:16 +04:00
parent 1619e194e1
commit 9ccf5baf94
1 changed files with 43 additions and 43 deletions
Download patch file Download diff file Expand all files Collapse all files

86
Engine/source/ts/collada/colladaUtils.h
View file

@ -475,14 +475,14 @@ public:
/// Template child class for supported Collada primitive elements
template<class T> class ColladaPrimitive : public BasePrimitive
{
T* primitive;
domListOfUInts *pTriangleData;
T* mPrimitive;
domListOfUInts *mTriangleData;
S32 stride;
public:
ColladaPrimitive(const daeElement* e) : pTriangleData(0)
ColladaPrimitive(const daeElement* e) : mTriangleData(0)
{
// Cast to geometric primitive element
primitive = daeSafeCast<T>(const_cast<daeElement*>(e));
mPrimitive = daeSafeCast<T>(const_cast<daeElement*>(e));
// Determine stride
stride = 0;
@ -493,13 +493,13 @@ public:
}
~ColladaPrimitive()
{
delete pTriangleData;
delete mTriangleData;
}
/// Most primitives can use these common implementations
const char* getElementName() { return primitive->getElementName(); }
const char* getMaterial() { return primitive->getMaterial(); }
const domInputLocalOffset_Array& getInputs() { return primitive->getInput_array(); }
const char* getElementName() { return mPrimitive->getElementName(); }
const char* getMaterial() { return mPrimitive->getMaterial(); }
const domInputLocalOffset_Array& getInputs() { return mPrimitive->getInput_array(); }
S32 getStride() const { return stride; }
/// Each supported primitive needs to implement this method (and convert
@ -512,21 +512,21 @@ public:
template<> inline const domListOfUInts *ColladaPrimitive<domTriangles>::getTriangleData()
{
// Return the <p> integer list directly
return (primitive->getP() ? &(primitive->getP()->getValue()) : NULL);
return (mPrimitive->getP() ? &(mPrimitive->getP()->getValue()) : NULL);
}
//-----------------------------------------------------------------------------
// <tristrips>
template<> inline const domListOfUInts *ColladaPrimitive<domTristrips>::getTriangleData()
{
if (!pTriangleData)
if (!mTriangleData)
{
// Convert strips to triangles
pTriangleData = new domListOfUInts();
mTriangleData = new domListOfUInts();
for (S32 iStrip = 0; iStrip < primitive->getCount(); iStrip++) {
for (S32 iStrip = 0; iStrip < mPrimitive->getCount(); iStrip++) {
domP* P = primitive->getP_array()[iStrip];
domP* P = mPrimitive->getP_array()[iStrip];
// Ignore invalid P arrays
if (!P || !P->getValue().getCount())
@ -541,33 +541,33 @@ template<> inline const domListOfUInts *ColladaPrimitive<domTristrips>::getTrian
if (iTri & 0x1)
{
// CW triangle
pTriangleData->appendArray(stride, v0);
pTriangleData->appendArray(stride, v0 + 2*stride);
pTriangleData->appendArray(stride, v0 + stride);
mTriangleData->appendArray(stride, v0);
mTriangleData->appendArray(stride, v0 + 2*stride);
mTriangleData->appendArray(stride, v0 + stride);
}
else
{
// CCW triangle
pTriangleData->appendArray(stride*3, v0);
mTriangleData->appendArray(stride*3, v0);
}
}
}
}
return pTriangleData;
return mTriangleData;
}
//-----------------------------------------------------------------------------
// <trifans>
template<> inline const domListOfUInts *ColladaPrimitive<domTrifans>::getTriangleData()
{
if (!pTriangleData)
if (!mTriangleData)
{
// Convert strips to triangles
pTriangleData = new domListOfUInts();
mTriangleData = new domListOfUInts();
for (S32 iStrip = 0; iStrip < primitive->getCount(); iStrip++) {
for (S32 iStrip = 0; iStrip < mPrimitive->getCount(); iStrip++) {
domP* P = primitive->getP_array()[iStrip];
domP* P = mPrimitive->getP_array()[iStrip];
// Ignore invalid P arrays
if (!P || !P->getValue().getCount())
@ -579,27 +579,27 @@ template<> inline const domListOfUInts *ColladaPrimitive<domTrifans>::getTriangl
// Convert the fan back to a triangle list
domUint* v0 = pSrcData + stride;
for (S32 iTri = 0; iTri < numTriangles; iTri++, v0 += stride) {
pTriangleData->appendArray(stride, pSrcData); // shared vertex
pTriangleData->appendArray(stride, v0); // previous vertex
pTriangleData->appendArray(stride, v0+stride); // current vertex
mTriangleData->appendArray(stride, pSrcData); // shared vertex
mTriangleData->appendArray(stride, v0); // previous vertex
mTriangleData->appendArray(stride, v0+stride); // current vertex
}
}
}
return pTriangleData;
return mTriangleData;
}
//-----------------------------------------------------------------------------
// <polygons>
template<> inline const domListOfUInts *ColladaPrimitive<domPolygons>::getTriangleData()
{
if (!pTriangleData)
if (!mTriangleData)
{
// Convert polygons to triangles
pTriangleData = new domListOfUInts();
mTriangleData = new domListOfUInts();
for (S32 iPoly = 0; iPoly < primitive->getCount(); iPoly++) {
for (S32 iPoly = 0; iPoly < mPrimitive->getCount(); iPoly++) {
domP* P = primitive->getP_array()[iPoly];
domP* P = mPrimitive->getP_array()[iPoly];
// Ignore invalid P arrays
if (!P || !P->getValue().getCount())
@ -613,41 +613,41 @@ template<> inline const domListOfUInts *ColladaPrimitive<domPolygons>::getTriang
domUint* v0 = pSrcData;
pSrcData += stride;
for (S32 iTri = 0; iTri < numPoints-2; iTri++) {
pTriangleData->appendArray(stride, v0);
pTriangleData->appendArray(stride*2, pSrcData);
mTriangleData->appendArray(stride, v0);
mTriangleData->appendArray(stride*2, pSrcData);
pSrcData += stride;
}
}
}
return pTriangleData;
return mTriangleData;
}
//-----------------------------------------------------------------------------
// <polylist>
template<> inline const domListOfUInts *ColladaPrimitive<domPolylist>::getTriangleData()
{
if (!pTriangleData)
if (!mTriangleData)
{
// Convert polygons to triangles
pTriangleData = new domListOfUInts();
mTriangleData = new domListOfUInts();
// Check that the P element has the right number of values (this
// has been seen with certain models exported using COLLADAMax)
const domListOfUInts& vcount = primitive->getVcount()->getValue();
const domListOfUInts& vcount = mPrimitive->getVcount()->getValue();
U32 expectedCount = 0;
for (S32 iPoly = 0; iPoly < vcount.getCount(); iPoly++)
expectedCount += vcount[iPoly];
expectedCount *= stride;
if (!primitive->getP() || !primitive->getP()->getValue().getCount() ||
(primitive->getP()->getValue().getCount() != expectedCount) )
if (!mPrimitive->getP() || !mPrimitive->getP()->getValue().getCount() ||
(mPrimitive->getP()->getValue().getCount() != expectedCount) )
{
Con::warnf("<polylist> element found with invalid <p> array. This primitive will be ignored.");
return pTriangleData;
return mTriangleData;
}
domUint* pSrcData = &(primitive->getP()->getValue()[0]);
domUint* pSrcData = &(mPrimitive->getP()->getValue()[0]);
for (S32 iPoly = 0; iPoly < vcount.getCount(); iPoly++) {
// Use a simple tri-fan (centered at the first point) method of
@ -655,14 +655,14 @@ template<> inline const domListOfUInts *ColladaPrimitive<domPolylist>::getTriang
domUint* v0 = pSrcData;
pSrcData += stride;
for (S32 iTri = 0; iTri < vcount[iPoly]-2; iTri++) {
pTriangleData->appendArray(stride, v0);
pTriangleData->appendArray(stride*2, pSrcData);
mTriangleData->appendArray(stride, v0);
mTriangleData->appendArray(stride*2, pSrcData);
pSrcData += stride;
}
pSrcData += stride;
}
}
return pTriangleData;
return mTriangleData;
}
//-----------------------------------------------------------------------------