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

Engine/source/ts/collada/colladaAppMesh.cpp

@@ -319,17 +319,17 @@ public:
 ColladaAppMesh::ColladaAppMesh(const domInstance_geometry* instance, ColladaAppNode* node)
    : instanceGeom(instance), instanceCtrl(0), appNode(node), geomExt(0)
 {
-   flags = 0;
-   numFrames = 0;
-   numMatFrames = 0;
+   mFlags = 0;
+   mNumFrames = 0;
+   mNumMatFrames = 0;
 }
 
 ColladaAppMesh::ColladaAppMesh(const domInstance_controller* instance, ColladaAppNode* node)
    : instanceGeom(0), instanceCtrl(instance), appNode(node), geomExt(0)
 {
-   flags = 0;
-   numFrames = 0;
-   numMatFrames = 0;
+   mFlags = 0;
+   mNumFrames = 0;
+   mNumMatFrames = 0;
 }
 
 const char* ColladaAppMesh::getName(bool allowFixed)
@@ -367,8 +367,8 @@ bool ColladaAppMesh::animatesMatFrame(const AppSequence* appSeq)
    // - by animating the morph weights for morph targets with different UVs
 
    // Check if the MAYA profile texture transform is animated
-   for (S32 iMat = 0; iMat < appMaterials.size(); iMat++) {
-      ColladaAppMaterial* appMat = static_cast<ColladaAppMaterial*>(appMaterials[iMat]);
+   for (S32 iMat = 0; iMat < mAppMaterials.size(); iMat++) {
+      ColladaAppMaterial* appMat = static_cast<ColladaAppMaterial*>(mAppMaterials[iMat]);
       if (appMat->effectExt &&
           appMat->effectExt->animatesTextureTransform(appSeq->getStart(), appSeq->getEnd()))
          return true;
@@ -446,17 +446,17 @@ S32 ColladaAppMesh::addMaterial(const char* symbol)
 
             // Find the index of the bound material in the shape global list
             const domMaterial* mat = daeSafeCast<domMaterial>(matArray[iBind]->getTarget().getElement());
-            for (matIndex = 0; matIndex < appMaterials.size(); matIndex++) {
-               if (static_cast<ColladaAppMaterial*>(appMaterials[matIndex])->mat == mat)
+            for (matIndex = 0; matIndex < mAppMaterials.size(); matIndex++) {
+               if (static_cast<ColladaAppMaterial*>(mAppMaterials[matIndex])->mat == mat)
                   break;
             }
 
             // Check if this material needs to be added to the shape global list
-            if (matIndex == appMaterials.size()) {
+            if (matIndex == mAppMaterials.size()) {
                if (mat)
-                  appMaterials.push_back(new ColladaAppMaterial(mat));
+                  mAppMaterials.push_back(new ColladaAppMaterial(mat));
                else
-                  appMaterials.push_back(new ColladaAppMaterial(symbol));
+                  mAppMaterials.push_back(new ColladaAppMaterial(symbol));
             }
 
             break;
@@ -466,7 +466,7 @@ S32 ColladaAppMesh::addMaterial(const char* symbol)
    else
    {
       // No Collada material is present for this symbol, so just create an empty one
-      appMaterials.push_back(new ColladaAppMaterial(symbol));
+      mAppMaterials.push_back(new ColladaAppMaterial(symbol));
    }
 
    // Add this symbol to the bound list for the mesh
@@ -477,7 +477,7 @@ S32 ColladaAppMesh::addMaterial(const char* symbol)
 void ColladaAppMesh::getPrimitives(const domGeometry* geometry)
 {
    // Only do this once
-   if (primitives.size())
+   if (mPrimitives.size())
       return;
 
    // Read the <geometry> extension
@@ -517,16 +517,16 @@ void ColladaAppMesh::getPrimitives(const domGeometry* geometry)
          continue;
 
       // Create TSMesh primitive
-      primitives.increment();
-      TSDrawPrimitive& primitive = primitives.last();
-      primitive.start = indices.size();
+      mPrimitives.increment();
+      TSDrawPrimitive& primitive = mPrimitives.last();
+      primitive.start = mIndices.size();
       primitive.matIndex = (TSDrawPrimitive::Triangles | TSDrawPrimitive::Indexed) |
                            addMaterial(meshPrims[iPrim]->getMaterial());
 
       // Get the AppMaterial associated with this primitive
       ColladaAppMaterial* appMat = 0;
       if (!(primitive.matIndex & TSDrawPrimitive::NoMaterial))
-         appMat = static_cast<ColladaAppMaterial*>(appMaterials[primitive.matIndex & TSDrawPrimitive::MaterialMask]);
+         appMat = static_cast<ColladaAppMaterial*>(mAppMaterials[primitive.matIndex & TSDrawPrimitive::MaterialMask]);
 
       // Force the material to be double-sided if this geometry is double-sided.
       if (geomExt->double_sided && appMat && appMat->effectExt)
@@ -534,8 +534,8 @@ void ColladaAppMesh::getPrimitives(const domGeometry* geometry)
 
       // Pre-allocate triangle indices
       primitive.numElements = numTriangles * 3;
-      indices.setSize(indices.size() + primitive.numElements);
-      U32* dstIndex = indices.end() - primitive.numElements;
+      mIndices.setSize(mIndices.size() + primitive.numElements);
+      U32* dstIndex = mIndices.end() - primitive.numElements;
 
       // Determine the offset for each element type in the stream, and also the
       // maximum input offset, which will be the number of indices per vertex we
@@ -569,12 +569,12 @@ void ColladaAppMesh::getPrimitives(const domGeometry* geometry)
                daeErrorHandler::get()->handleWarning(avar("Splitting primitive "
                   "in %s: too many verts for 16-bit indices.", _GetNameOrId(geometry)));
 
-               primitives.last().numElements -= indicesRemaining;
-               primitives.push_back(TSDrawPrimitive(primitives.last()));
+               mPrimitives.last().numElements -= indicesRemaining;
+               mPrimitives.push_back(TSDrawPrimitive(mPrimitives.last()));
             }
 
-            primitives.last().numElements = indicesRemaining;
-            primitives.last().start = indices.size() - indicesRemaining;
+            mPrimitives.last().numElements = indicesRemaining;
+            mPrimitives.last().start = mIndices.size() - indicesRemaining;
 
             tupleMap.clear();
          }
@@ -631,7 +631,7 @@ void ColladaAppMesh::getVertexData(const domGeometry* geometry, F32 time, const
                                    Vector<Point2F>& v_uv2s,
                                    bool appendValues)
 {
-   if (!primitives.size())
+   if (!mPrimitives.size())
       return;
 
    MeshStreams streams;
@@ -676,7 +676,7 @@ void ColladaAppMesh::getVertexData(const domGeometry* geometry, F32 time, const
          streams.readInputs(meshPrims[tuple.prim]->getInputs());
          S32 matIndex = addMaterial(meshPrims[tuple.prim]->getMaterial());
          if (matIndex != TSDrawPrimitive::NoMaterial)
-            appMat = static_cast<ColladaAppMaterial*>(appMaterials[matIndex]);
+            appMat = static_cast<ColladaAppMaterial*>(mAppMaterials[matIndex]);
          else
             appMat = 0;
 
@@ -923,10 +923,10 @@ void ColladaAppMesh::lockMesh(F32 t, const MatrixF& objectOffset)
    // Now get the vertex data at the specified time
    if (geometry->getElementType() == COLLADA_TYPE::GEOMETRY) {
       getPrimitives(daeSafeCast<domGeometry>(geometry));
-      getVertexData(daeSafeCast<domGeometry>(geometry), t, objectOffset, points, normals, colors, uvs, uv2s, true);
+      getVertexData(daeSafeCast<domGeometry>(geometry), t, objectOffset, mPoints, mNormals, mColors, mUVs, mUV2s, true);
    }
    else if (geometry->getElementType() == COLLADA_TYPE::MORPH) {
-      getMorphVertexData(daeSafeCast<domMorph>(geometry), t, objectOffset, points, normals, colors, uvs, uv2s);
+      getMorphVertexData(daeSafeCast<domMorph>(geometry), t, objectOffset, mPoints, mNormals, mColors, mUVs, mUV2s);
    }
    else {
       daeErrorHandler::get()->handleWarning(avar("Unsupported geometry type "
@@ -937,7 +937,7 @@ void ColladaAppMesh::lockMesh(F32 t, const MatrixF& objectOffset)
 void ColladaAppMesh::lookupSkinData()
 {
    // Only lookup skin data once
-   if (!isSkin() || weight.size())
+   if (!isSkin() || mWeight.size())
       return;
 
    // Get the skin and vertex weight data
@@ -950,7 +950,7 @@ void ColladaAppMesh::lookupSkinData()
    streams.readInputs(skin->getJoints()->getInput_array());
    streams.readInputs(weightIndices.getInput_array());
 
-   MatrixF invObjOffset(objectOffset);
+   MatrixF invObjOffset(mObjectOffset);
    invObjOffset.inverse();
 
    // Get the bind shape matrix
@@ -971,7 +971,7 @@ void ColladaAppMesh::lookupSkinData()
 
    // Set vertex weights
    bool tooManyWeightsWarning = false;
-   for (S32 iVert = 0; iVert < vertsPerFrame; iVert++) {
+   for (S32 iVert = 0; iVert < mVertsPerFrame; iVert++) {
       const domUint* vcount = (domUint*)weights_vcount.getRaw(0);
       const domInt* vindices = (domInt*)weights_v.getRaw(0);
       vindices += vindicesOffset[vertTuples[iVert].vertex];
@@ -1002,25 +1002,25 @@ void ColladaAppMesh::lookupSkinData()
             }
 
             // Too many weights => find and replace the smallest one
-            S32 minIndex = weight.size() - TSSkinMesh::BatchData::maxBonePerVert;
-            F32 minWeight = weight[minIndex];
-            for (S32 i = minIndex + 1; i < weight.size(); i++)
+            S32 minIndex = mWeight.size() - TSSkinMesh::BatchData::maxBonePerVert;
+            F32 minWeight = mWeight[minIndex];
+            for (S32 i = minIndex + 1; i < mWeight.size(); i++)
             {
-               if (weight[i] < minWeight)
+               if (mWeight[i] < minWeight)
                {
-                  minWeight = weight[i];
+                  minWeight = mWeight[i];
                   minIndex = i;
                }
             }
 
-            boneIndex[minIndex] = bIndex;
-            weight[minIndex] = bWeight;
+            mBoneIndex[minIndex] = bIndex;
+            mWeight[minIndex] = bWeight;
          }
          else
          {
-            vertexIndex.push_back( iVert );
-            boneIndex.push_back( bIndex );
-            weight.push_back( bWeight );
+            mVertexIndex.push_back( iVert );
+            mBoneIndex.push_back( bIndex );
+            mWeight.push_back( bWeight );
             nonZeroWeightCount++;
          }
       }
@@ -1028,26 +1028,26 @@ void ColladaAppMesh::lookupSkinData()
 
    // Normalize vertex weights (force weights for each vert to sum to 1)
    S32 iWeight = 0;
-   while (iWeight < weight.size()) {
+   while (iWeight < mWeight.size()) {
       // Find the last weight with the same vertex number, and sum all weights for
       // that vertex
       F32 invTotalWeight = 0;
       S32 iLast;
-      for (iLast = iWeight; iLast < weight.size(); iLast++) {
-         if (vertexIndex[iLast] != vertexIndex[iWeight])
+      for (iLast = iWeight; iLast < mWeight.size(); iLast++) {
+         if (mVertexIndex[iLast] != mVertexIndex[iWeight])
             break;
-         invTotalWeight += weight[iLast];
+         invTotalWeight += mWeight[iLast];
       }
 
       // Then normalize the vertex weights
       invTotalWeight = 1.0f / invTotalWeight;
       for (; iWeight < iLast; iWeight++)
-         weight[iWeight] *= invTotalWeight;
+         mWeight[iWeight] *= invTotalWeight;
    }
 
    // Add dummy AppNodes to allow Collada joints to be mapped to 3space nodes
-   bones.setSize(streams.joints.size());
-   initialTransforms.setSize(streams.joints.size());
+   mBones.setSize(streams.joints.size());
+   mInitialTransforms.setSize(streams.joints.size());
    for (S32 iJoint = 0; iJoint < streams.joints.size(); iJoint++)
    {
       const char* jointName = streams.joints.getStringValue(iJoint);
@@ -1075,9 +1075,9 @@ void ColladaAppMesh::lookupSkinData()
             "defaulting to instance_controller parent node '%s'", jointName, appNode->getName()));
          joint = appNode->getDomNode();
       }
-      bones[iJoint] = new ColladaAppNode(joint);
+      mBones[iJoint] = new ColladaAppNode(joint);
 
-      initialTransforms[iJoint] = objectOffset;
+      mInitialTransforms[iJoint] = mObjectOffset;
 
       // Bone scaling is generally ignored during import, since 3space only
       // stores default node transform and rotation. Compensate for this by
@@ -1089,16 +1089,16 @@ void ColladaAppMesh::lookupSkinData()
          invScale.x = invScale.x ? (1.0f / invScale.x) : 0;
          invScale.y = invScale.y ? (1.0f / invScale.y) : 0;
          invScale.z = invScale.z ? (1.0f / invScale.z) : 0;
-         initialTransforms[iJoint].scale(invScale);
+         mInitialTransforms[iJoint].scale(invScale);
       }
 
       // Inverted node coordinate spaces (negative scale factor) are corrected
       // in ColladaAppNode::getNodeTransform, so need to apply the same operation
       // here to match
       if (m_matF_determinant(invBind) < 0.0f)
-         initialTransforms[iJoint].scale(Point3F(1, 1, -1));
+         mInitialTransforms[iJoint].scale(Point3F(1, 1, -1));
 
-      initialTransforms[iJoint].mul(invBind);
-      initialTransforms[iJoint].mul(bindShapeMatrix);
+      mInitialTransforms[iJoint].mul(invBind);
+      mInitialTransforms[iJoint].mul(bindShapeMatrix);
    }
 }

Engine/source/ts/collada/colladaShapeLoader.cpp

@@ -458,9 +458,9 @@ void updateMaterialsScript(const Torque::Path &path, bool copyTextures = false)
 
    // First see what materials we need to update
    PersistenceManager persistMgr;
-   for ( U32 iMat = 0; iMat < AppMesh::appMaterials.size(); iMat++ )
+   for ( U32 iMat = 0; iMat < AppMesh::mAppMaterials.size(); iMat++ )
    {
-      ColladaAppMaterial *mat = dynamic_cast<ColladaAppMaterial*>( AppMesh::appMaterials[iMat] );
+      ColladaAppMaterial *mat = dynamic_cast<ColladaAppMaterial*>( AppMesh::mAppMaterials[iMat] );
       if ( mat )
       {
          Material *mappedMat;

Engine/source/ts/loader/appMesh.cpp

@@ -23,10 +23,10 @@
 #include "ts/loader/appMesh.h"
 #include "ts/loader/tsShapeLoader.h"
 
-Vector<AppMaterial*> AppMesh::appMaterials;
+Vector<AppMaterial*> AppMesh::mAppMaterials;
 
 AppMesh::AppMesh()
-   : flags(0), numFrames(0), numMatFrames(0), vertsPerFrame(0)
+   : mFlags(0), mNumFrames(0), mNumMatFrames(0), mVertsPerFrame(0)
 {
 }
 
@@ -44,43 +44,43 @@ void AppMesh::computeBounds(Box3F& bounds)
 
       // Setup bone transforms
       Vector<MatrixF> boneTransforms;
-      boneTransforms.setSize( nodeIndex.size() );
+      boneTransforms.setSize( mNodeIndex.size() );
       for (S32 iBone = 0; iBone < boneTransforms.size(); iBone++)
       {
-         MatrixF nodeMat = bones[iBone]->getNodeTransform( TSShapeLoader::DefaultTime );
+         MatrixF nodeMat = mBones[iBone]->getNodeTransform( TSShapeLoader::DefaultTime );
          TSShapeLoader::zapScale(nodeMat);
-         boneTransforms[iBone].mul( nodeMat, initialTransforms[iBone] );
+         boneTransforms[iBone].mul( nodeMat, mInitialTransforms[iBone] );
       }
 
       // Multiply verts by weighted bone transforms
-      for (S32 iVert = 0; iVert < initialVerts.size(); iVert++)
-         points[iVert].set( Point3F::Zero );
+      for (S32 iVert = 0; iVert < mInitialVerts.size(); iVert++)
+         mPoints[iVert].set( Point3F::Zero );
 
-      for (S32 iWeight = 0; iWeight < vertexIndex.size(); iWeight++)
+      for (S32 iWeight = 0; iWeight < mVertexIndex.size(); iWeight++)
       {
-         const S32& vertIndex = vertexIndex[iWeight];
-         const MatrixF& deltaTransform = boneTransforms[ boneIndex[iWeight] ];
+         const S32& vertIndex = mVertexIndex[iWeight];
+         const MatrixF& deltaTransform = boneTransforms[ mBoneIndex[iWeight] ];
 
          Point3F v;
-         deltaTransform.mulP( initialVerts[vertIndex], &v );
-         v *= weight[iWeight];
+         deltaTransform.mulP( mInitialVerts[vertIndex], &v );
+         v *= mWeight[iWeight];
 
-         points[vertIndex] += v;
+         mPoints[vertIndex] += v;
       }
 
       // compute bounds for the skinned mesh
-      for (S32 iVert = 0; iVert < initialVerts.size(); iVert++)
-         bounds.extend( points[iVert] );
+      for (S32 iVert = 0; iVert < mInitialVerts.size(); iVert++)
+         bounds.extend( mPoints[iVert] );
    }
    else
    {
       MatrixF transform = getMeshTransform(TSShapeLoader::DefaultTime);
       TSShapeLoader::zapScale(transform);
 
-      for (S32 iVert = 0; iVert < points.size(); iVert++)
+      for (S32 iVert = 0; iVert < mPoints.size(); iVert++)
       {
          Point3F p;
-         transform.mulP(points[iVert], &p);
+         transform.mulP(mPoints[iVert], &p);
          bounds.extend(p);
       }
    }
@@ -89,39 +89,39 @@ void AppMesh::computeBounds(Box3F& bounds)
 void AppMesh::computeNormals()
 {
    // Clear normals
-   normals.setSize( points.size() );
-   for (S32 iNorm = 0; iNorm < normals.size(); iNorm++)
-      normals[iNorm] = Point3F::Zero;
+   mNormals.setSize( mPoints.size() );
+   for (S32 iNorm = 0; iNorm < mNormals.size(); iNorm++)
+      mNormals[iNorm] = Point3F::Zero;
 
    // Sum triangle normals for each vertex
-   for (S32 iPrim = 0; iPrim < primitives.size(); iPrim++)
+   for (S32 iPrim = 0; iPrim < mPrimitives.size(); iPrim++)
    {
-      const TSDrawPrimitive& prim = primitives[iPrim];
+      const TSDrawPrimitive& prim = mPrimitives[iPrim];
 
       for (S32 iInd = 0; iInd < prim.numElements; iInd += 3)
       {
          // Compute the normal for this triangle
-         S32 idx0 = indices[prim.start + iInd + 0];
-         S32 idx1 = indices[prim.start + iInd + 1];
-         S32 idx2 = indices[prim.start + iInd + 2];
+         S32 idx0 = mIndices[prim.start + iInd + 0];
+         S32 idx1 = mIndices[prim.start + iInd + 1];
+         S32 idx2 = mIndices[prim.start + iInd + 2];
 
-         const Point3F& v0 = points[idx0];
-         const Point3F& v1 = points[idx1];
-         const Point3F& v2 = points[idx2];
+         const Point3F& v0 = mPoints[idx0];
+         const Point3F& v1 = mPoints[idx1];
+         const Point3F& v2 = mPoints[idx2];
 
          Point3F n;
          mCross(v2 - v0, v1 - v0, &n);
          n.normalize();    // remove this to use 'weighted' normals (large triangles will have more effect)
 
-         normals[idx0] += n;
-         normals[idx1] += n;
-         normals[idx2] += n;
+         mNormals[idx0] += n;
+         mNormals[idx1] += n;
+         mNormals[idx2] += n;
       }
    }
 
    // Normalize the vertex normals (this takes care of averaging the triangle normals)
-   for (S32 iNorm = 0; iNorm < normals.size(); iNorm++)
-      normals[iNorm].normalize();
+   for (S32 iNorm = 0; iNorm < mNormals.size(); iNorm++)
+      mNormals[iNorm].normalize();
 }
 
 TSMesh* AppMesh::constructTSMesh()
@@ -133,13 +133,13 @@ TSMesh* AppMesh::constructTSMesh()
       tsmesh = tsskin;
 
       // Copy skin elements
-      tsskin->weight = weight;
-      tsskin->boneIndex = boneIndex;
-      tsskin->vertexIndex = vertexIndex;
-      tsskin->batchData.nodeIndex = nodeIndex;
-      tsskin->batchData.initialTransforms = initialTransforms;
-      tsskin->batchData.initialVerts = initialVerts;
-      tsskin->batchData.initialNorms = initialNorms;
+      tsskin->weight = mWeight;
+      tsskin->boneIndex = mBoneIndex;
+      tsskin->vertexIndex = mVertexIndex;
+      tsskin->batchData.nodeIndex = mNodeIndex;
+      tsskin->batchData.initialTransforms = mInitialTransforms;
+      tsskin->batchData.initialVerts = mInitialVerts;
+      tsskin->batchData.initialNorms = mInitialNorms;
    }
    else
    {
@@ -147,20 +147,20 @@ TSMesh* AppMesh::constructTSMesh()
    }
 
    // Copy mesh elements
-   tsmesh->verts = points;
-   tsmesh->norms = normals;
-   tsmesh->tverts = uvs;
-   tsmesh->primitives = primitives;
-   tsmesh->indices = indices;
-   tsmesh->colors = colors;
-   tsmesh->tverts2 = uv2s;
+   tsmesh->verts = mPoints;
+   tsmesh->norms = mNormals;
+   tsmesh->tverts = mUVs;
+   tsmesh->primitives = mPrimitives;
+   tsmesh->indices = mIndices;
+   tsmesh->colors = mColors;
+   tsmesh->tverts2 = mUV2s;
 
    // Finish initializing the shape
-   tsmesh->setFlags(flags);
+   tsmesh->setFlags(mFlags);
    tsmesh->computeBounds();
-   tsmesh->numFrames = numFrames;
-   tsmesh->numMatFrames = numMatFrames;
-   tsmesh->vertsPerFrame = vertsPerFrame;
+   tsmesh->numFrames = mNumFrames;
+   tsmesh->numMatFrames = mNumMatFrames;
+   tsmesh->vertsPerFrame = mVertsPerFrame;
    tsmesh->createTangents(tsmesh->verts, tsmesh->norms);
    tsmesh->encodedNorms.set(NULL,0);
 

Engine/source/ts/loader/appMesh.h

@@ -42,33 +42,33 @@ class AppMesh
 {
 public:
    // Mesh and skin elements
-   Vector<Point3F> points;
-   Vector<Point3F> normals;
-   Vector<Point2F> uvs;
-   Vector<Point2F> uv2s;
-   Vector<ColorI> colors;
-   Vector<TSDrawPrimitive> primitives;
-   Vector<U32> indices;
+   Vector<Point3F> mPoints;
+   Vector<Point3F> mNormals;
+   Vector<Point2F> mUVs;
+   Vector<Point2F> mUV2s;
+   Vector<ColorI> mColors;
+   Vector<TSDrawPrimitive> mPrimitives;
+   Vector<U32> mIndices;
 
    // Skin elements
-   Vector<F32> weight;
-   Vector<S32> boneIndex;
-   Vector<S32> vertexIndex;
-   Vector<S32> nodeIndex;
-   Vector<MatrixF> initialTransforms;
-   Vector<Point3F> initialVerts;
-   Vector<Point3F> initialNorms;
-
-   U32 flags;
-   U32 vertsPerFrame;
-   S32 numFrames;
-   S32 numMatFrames;
+   Vector<F32> mWeight;
+   Vector<S32> mBoneIndex;
+   Vector<S32> mVertexIndex;
+   Vector<S32> mNodeIndex;
+   Vector<MatrixF> mInitialTransforms;
+   Vector<Point3F> mInitialVerts;
+   Vector<Point3F> mInitialNorms;
+
+   U32 mFlags;
+   U32 mVertsPerFrame;
+   S32 mNumFrames;
+   S32 mNumMatFrames;
 
    // Loader elements (can be discarded after loading)
-   S32                           detailSize;
-   MatrixF                       objectOffset;
-   Vector<AppNode*>              bones;
-   static Vector<AppMaterial*>   appMaterials;
+   S32                           mDetailSize;
+   MatrixF                       mObjectOffset;
+   Vector<AppNode*>              mBones;
+   static Vector<AppMaterial*>   mAppMaterials;
 
 public:
    AppMesh();

Engine/source/ts/loader/tsShapeLoader.cpp

@@ -377,7 +377,7 @@ bool cmpMeshNameAndSize(const String& key, const Vector<String>& names, void* ar
    {
       if (names[i].compare(key, 0, String::NoCase) == 0)
       {
-         if (meshes[i]->detailSize == meshSize)
+         if (meshes[i]->mDetailSize == meshSize)
             return false;
       }
    }
@@ -396,17 +396,17 @@ void TSShapeLoader::generateObjects()
       for (S32 iMesh = 0; iMesh < subshape->objMeshes.size(); iMesh++)
       {
          AppMesh* mesh = subshape->objMeshes[iMesh];
-         mesh->detailSize = 2;
-         String name = String::GetTrailingNumber( mesh->getName(), mesh->detailSize );
-         name = getUniqueName( name, cmpMeshNameAndSize, meshNames, &(subshape->objMeshes), (void*)mesh->detailSize );
+         mesh->mDetailSize = 2;
+         String name = String::GetTrailingNumber( mesh->getName(), mesh->mDetailSize );
+         name = getUniqueName( name, cmpMeshNameAndSize, meshNames, &(subshape->objMeshes), (void*)mesh->mDetailSize );
          meshNames.push_back( name );
 
          // Fix up any collision details that don't have a negative detail level.
          if (  dStrStartsWith(meshNames[iMesh], "Collision") ||
                dStrStartsWith(meshNames[iMesh], "LOSCol") )
          {
-            if (mesh->detailSize > 0)
-               mesh->detailSize = -mesh->detailSize;
+            if (mesh->mDetailSize > 0)
+               mesh->mDetailSize = -mesh->mDetailSize;
          }
       }
 
@@ -421,7 +421,7 @@ void TSShapeLoader::generateObjects()
          {
             if ((meshNames[i].compare(meshNames[j]) < 0) ||
                ((meshNames[i].compare(meshNames[j]) == 0) &&
-               (subshape->objMeshes[i]->detailSize < subshape->objMeshes[j]->detailSize)))
+               (subshape->objMeshes[i]->mDetailSize < subshape->objMeshes[j]->mDetailSize)))
             {
                {
                   AppMesh* tmp = subshape->objMeshes[i];
@@ -463,17 +463,17 @@ void TSShapeLoader::generateObjects()
          shape->objects.last().numMeshes++;
 
          // Set mesh flags
-         mesh->flags = 0;
+         mesh->mFlags = 0;
          if (mesh->isBillboard())
          {
-            mesh->flags |= TSMesh::Billboard;
+            mesh->mFlags |= TSMesh::Billboard;
             if (mesh->isBillboardZAxis())
-               mesh->flags |= TSMesh::BillboardZAxis;
+               mesh->mFlags |= TSMesh::BillboardZAxis;
          }
 
          // Set the detail name... do fixups for collision details.
          const char* detailName = "detail";
-         if ( mesh->detailSize < 0 )
+         if ( mesh->mDetailSize < 0 )
          {
             if (  dStrStartsWith(meshNames[iMesh], "Collision") ||
                   dStrStartsWith(meshNames[iMesh], "Col") )
@@ -484,11 +484,11 @@ void TSShapeLoader::generateObjects()
 
          // Attempt to add the detail (will fail if it already exists)
          S32 oldNumDetails = shape->details.size();
-         shape->addDetail(detailName, mesh->detailSize, iSub);
+         shape->addDetail(detailName, mesh->mDetailSize, iSub);
          if (shape->details.size() > oldNumDetails)
          {
             Con::warnf("Object mesh \"%s\" has no matching detail (\"%s%d\" has"
-               " been added automatically)", mesh->getName(false), detailName, mesh->detailSize);
+               " been added automatically)", mesh->getName(false), detailName, mesh->mDetailSize);
          }
       }
 
@@ -519,30 +519,30 @@ void TSShapeLoader::generateSkins()
       skin->lookupSkinData();
 
       // Just copy initial verts and norms for now
-      skin->initialVerts.set(skin->points.address(), skin->vertsPerFrame);
-      skin->initialNorms.set(skin->normals.address(), skin->vertsPerFrame);
+      skin->mInitialVerts.set(skin->mPoints.address(), skin->mVertsPerFrame);
+      skin->mInitialNorms.set(skin->mNormals.address(), skin->mVertsPerFrame);
 
       // Map bones to nodes
-      skin->nodeIndex.setSize(skin->bones.size());
-      for (S32 iBone = 0; iBone < skin->bones.size(); iBone++)
+      skin->mNodeIndex.setSize(skin->mBones.size());
+      for (S32 iBone = 0; iBone < skin->mBones.size(); iBone++)
       {
          // Find the node that matches this bone
-         skin->nodeIndex[iBone] = -1;
+         skin->mNodeIndex[iBone] = -1;
          for (S32 iNode = 0; iNode < appNodes.size(); iNode++)
          {
-            if (appNodes[iNode]->isEqual(skin->bones[iBone]))
+            if (appNodes[iNode]->isEqual(skin->mBones[iBone]))
             {
-               delete skin->bones[iBone];
-               skin->bones[iBone] = appNodes[iNode];
-               skin->nodeIndex[iBone] = iNode;
+               delete skin->mBones[iBone];
+               skin->mBones[iBone] = appNodes[iNode];
+               skin->mNodeIndex[iBone] = iNode;
                break;
             }
          }
 
-         if (skin->nodeIndex[iBone] == -1)
+         if (skin->mNodeIndex[iBone] == -1)
          {
             Con::warnf("Could not find bone %d. Defaulting to first node", iBone);
-            skin->nodeIndex[iBone] = 0;
+            skin->mNodeIndex[iBone] = 0;
          }
       }
    }
@@ -569,7 +569,7 @@ void TSShapeLoader::generateDefaultStates()
 
          zapScale(nodeMat);
 
-         appMesh->objectOffset = nodeMat.inverse() * meshMat;
+         appMesh->mObjectOffset = nodeMat.inverse() * meshMat;
       }
 
       generateObjectState(shape->objects[iObject], DefaultTime, true, true);
@@ -603,8 +603,8 @@ void TSShapeLoader::generateObjectState(TSShape::Object& obj, F32 t, bool addFra
       generateFrame(obj, t, addFrame, addMatFrame);
 
       // set the frame number for the object state
-      state.frameIndex = appMeshes[obj.startMeshIndex]->numFrames - 1;
-      state.matFrameIndex = appMeshes[obj.startMeshIndex]->numMatFrames - 1;
+      state.frameIndex = appMeshes[obj.startMeshIndex]->mNumFrames - 1;
+      state.matFrameIndex = appMeshes[obj.startMeshIndex]->mNumMatFrames - 1;
    }
 }
 
@@ -614,45 +614,45 @@ void TSShapeLoader::generateFrame(TSShape::Object& obj, F32 t, bool addFrame, bo
    {
       AppMesh* appMesh = appMeshes[obj.startMeshIndex + iMesh];
 
-      U32 oldNumPoints = appMesh->points.size();
-      U32 oldNumUvs = appMesh->uvs.size();
+      U32 oldNumPoints = appMesh->mPoints.size();
+      U32 oldNumUvs = appMesh->mUVs.size();
 
       // Get the mesh geometry at time, 't'
       // Geometry verts, normals and tverts can be animated (different set for
       // each frame), but the TSDrawPrimitives stay the same, so the way lockMesh
       // works is that it will only generate the primitives once, then after that
       // will just append verts, normals and tverts each time it is called.
-      appMesh->lockMesh(t, appMesh->objectOffset);
+      appMesh->lockMesh(t, appMesh->mObjectOffset);
 
       // Calculate vertex normals if required
-      if (appMesh->normals.size() != appMesh->points.size())
+      if (appMesh->mNormals.size() != appMesh->mPoints.size())
          appMesh->computeNormals();
 
       // If this is the first call, set the number of points per frame
-      if (appMesh->numFrames == 0)
+      if (appMesh->mNumFrames == 0)
       {
-         appMesh->vertsPerFrame = appMesh->points.size();
+         appMesh->mVertsPerFrame = appMesh->mPoints.size();
       }
       else
       {
          // Check frame topology => ie. that the right number of points, normals
          // and tverts was added
-         if ((appMesh->points.size() - oldNumPoints) != appMesh->vertsPerFrame)
+         if ((appMesh->mPoints.size() - oldNumPoints) != appMesh->mVertsPerFrame)
          {
             Con::warnf("Wrong number of points (%d) added at time=%f (expected %d)",
-               appMesh->points.size() - oldNumPoints, t, appMesh->vertsPerFrame);
+               appMesh->mPoints.size() - oldNumPoints, t, appMesh->mVertsPerFrame);
             addFrame = false;
          }
-         if ((appMesh->normals.size() - oldNumPoints) != appMesh->vertsPerFrame)
+         if ((appMesh->mNormals.size() - oldNumPoints) != appMesh->mVertsPerFrame)
          {
             Con::warnf("Wrong number of normals (%d) added at time=%f (expected %d)",
-               appMesh->normals.size() - oldNumPoints, t, appMesh->vertsPerFrame);
+               appMesh->mNormals.size() - oldNumPoints, t, appMesh->mVertsPerFrame);
             addFrame = false;
          }
-         if ((appMesh->uvs.size() - oldNumUvs) != appMesh->vertsPerFrame)
+         if ((appMesh->mUVs.size() - oldNumUvs) != appMesh->mVertsPerFrame)
          {
             Con::warnf("Wrong number of tverts (%d) added at time=%f (expected %d)",
-               appMesh->uvs.size() - oldNumUvs, t, appMesh->vertsPerFrame);
+               appMesh->mUVs.size() - oldNumUvs, t, appMesh->mVertsPerFrame);
             addMatFrame = false;
          }
       }
@@ -663,21 +663,21 @@ void TSShapeLoader::generateFrame(TSShape::Object& obj, F32 t, bool addFrame, bo
       // points/normals/tverts are already in place!
       if (addFrame)
       {
-         appMesh->numFrames++;
+         appMesh->mNumFrames++;
       }
       else
       {
-         appMesh->points.setSize(oldNumPoints);
-         appMesh->normals.setSize(oldNumPoints);
+         appMesh->mPoints.setSize(oldNumPoints);
+         appMesh->mNormals.setSize(oldNumPoints);
       }
 
       if (addMatFrame)
       {
-         appMesh->numMatFrames++;
+         appMesh->mNumMatFrames++;
       }
       else
       {
-         appMesh->uvs.setSize(oldNumPoints);
+         appMesh->mUVs.setSize(oldNumPoints);
       }
    }
 }
@@ -690,11 +690,11 @@ void TSShapeLoader::generateMaterialList()
 {
    // Install the materials into the material list
    shape->materialList = new TSMaterialList;
-   for (S32 iMat = 0; iMat < AppMesh::appMaterials.size(); iMat++)
+   for (S32 iMat = 0; iMat < AppMesh::mAppMaterials.size(); iMat++)
    {
-      updateProgress(Load_GenerateMaterials, "Generating materials...", AppMesh::appMaterials.size(), iMat);
+      updateProgress(Load_GenerateMaterials, "Generating materials...", AppMesh::mAppMaterials.size(), iMat);
 
-      AppMaterial* appMat = AppMesh::appMaterials[iMat];
+      AppMaterial* appMat = AppMesh::mAppMaterials[iMat];
       shape->materialList->push_back(appMat->getName(), appMat->getFlags(), U32(-1), U32(-1), U32(-1), 1.0f, appMat->getReflectance());
    }
 }
@@ -1119,7 +1119,7 @@ void TSShapeLoader::sortDetails()
             // object does not already have a mesh with an equal or higher detail)
             S32 meshIndex = (iDet < object.numMeshes) ? iDet : object.numMeshes-1;
 
-            if (appMeshes[object.startMeshIndex + meshIndex]->detailSize < shape->details[iDet].size)
+            if (appMeshes[object.startMeshIndex + meshIndex]->mDetailSize < shape->details[iDet].size)
             {
                // Add a NULL mesh
                appMeshes.insert(object.startMeshIndex + iDet, NULL);
@@ -1256,9 +1256,9 @@ TSShapeLoader::~TSShapeLoader()
    clearNodeTransformCache();
 
    // Clear shared AppMaterial list
-   for (S32 iMat = 0; iMat < AppMesh::appMaterials.size(); iMat++)
-      delete AppMesh::appMaterials[iMat];
-   AppMesh::appMaterials.clear();
+   for (S32 iMat = 0; iMat < AppMesh::mAppMaterials.size(); iMat++)
+      delete AppMesh::mAppMaterials[iMat];
+   AppMesh::mAppMaterials.clear();
 
    // Delete Subshapes
    delete boundsNode;