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

Engine/source/gui/editor/guiShapeEdPreview.cpp

@@ -1236,8 +1236,8 @@ void GuiShapeEdPreview::updateDetailLevel(const SceneRenderState* state)
          if ( mesh->getMeshType() == TSMesh::SkinMeshType )
          {
             const TSSkinMesh* skin = dynamic_cast<const TSSkinMesh*>(mesh);
-            mNumBones += skin->batchData.initialTransforms.size();
-            mNumWeights += skin->weight.size();
+            mNumBones += skin->mBatchData.initialTransforms.size();
+            mNumWeights += skin->mWeight.size();
          }
       }
 

Engine/source/ts/loader/appMesh.cpp

@@ -133,13 +133,13 @@ TSMesh* AppMesh::constructTSMesh()
       tsmesh = tsskin;
 
       // Copy skin elements
-      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;
+      tsskin->mWeight = mWeight;
+      tsskin->mBoneIndex = mBoneIndex;
+      tsskin->mVertexIndex = mVertexIndex;
+      tsskin->mBatchData.nodeIndex = mNodeIndex;
+      tsskin->mBatchData.initialTransforms = mInitialTransforms;
+      tsskin->mBatchData.initialVerts = mInitialVerts;
+      tsskin->mBatchData.initialNorms = mInitialNorms;
    }
    else
    {

Engine/source/ts/tsMesh.cpp

@@ -1180,53 +1180,53 @@ void TSSkinMesh::updateSkin( const Vector<MatrixF> &transforms, TSVertexBufferHa
 {
    PROFILE_SCOPE( TSSkinMesh_UpdateSkin );
 
-   AssertFatal(batchDataInitialized, "Batch data not initialized. Call createBatchData() before any skin update is called.");
+   AssertFatal(mBatchDataInitialized, "Batch data not initialized. Call createBatchData() before any skin update is called.");
 
    // set arrays
 #if defined(TORQUE_MAX_LIB)
-   mVerts.setSize(batchData.initialVerts.size());
-   mNorms.setSize(batchData.initialNorms.size());
+   mVerts.setSize(mBatchData.initialVerts.size());
+   mNorms.setSize(mBatchData.initialNorms.size());
 #else
-   if ( !batchDataInitialized && mEncodedNorms.size() )
+   if ( !mBatchDataInitialized && mEncodedNorms.size() )
    {
       // we co-opt responsibility for updating encoded normals from mesh
       gNormalStore.setSize( mVertsPerFrame );
       for ( S32 i = 0; i < mVertsPerFrame; i++ )
          gNormalStore[i] = decodeNormal( mEncodedNorms[i] );
 
-      batchData.initialNorms.set( gNormalStore.address(), mVertsPerFrame );
+      mBatchData.initialNorms.set( gNormalStore.address(), mVertsPerFrame );
    }
 #endif
 
    static Vector<MatrixF> sBoneTransforms;
-   sBoneTransforms.setSize( batchData.nodeIndex.size() );
+   sBoneTransforms.setSize( mBatchData.nodeIndex.size() );
 
    // set up bone transforms
    PROFILE_START(TSSkinMesh_UpdateTransforms);
-   for( S32 i=0; i<batchData.nodeIndex.size(); i++ )
+   for( S32 i=0; i<mBatchData.nodeIndex.size(); i++ )
    {
-      S32 node = batchData.nodeIndex[i];
-      sBoneTransforms[i].mul( transforms[node], batchData.initialTransforms[i] );
+      S32 node = mBatchData.nodeIndex[i];
+      sBoneTransforms[i].mul( transforms[node], mBatchData.initialTransforms[i] );
    }
    const MatrixF * matrices = &sBoneTransforms[0];
    PROFILE_END();
 
    // Perform skinning
-   const bool bBatchByVert = !batchData.vertexBatchOperations.empty();
+   const bool bBatchByVert = !mBatchData.vertexBatchOperations.empty();
    if(bBatchByVert)
    {
-      const Point3F *inVerts = &batchData.initialVerts[0];
-      const Point3F *inNorms = &batchData.initialNorms[0];
+      const Point3F *inVerts = &mBatchData.initialVerts[0];
+      const Point3F *inNorms = &mBatchData.initialNorms[0];
 
       Point3F srcVtx, srcNrm;
 
-      AssertFatal( batchData.vertexBatchOperations.size() == batchData.initialVerts.size(), "Assumption failed!" );
+      AssertFatal( mBatchData.vertexBatchOperations.size() == mBatchData.initialVerts.size(), "Assumption failed!" );
 
       register Point3F skinnedVert;
       register Point3F skinnedNorm;
 
-      for( Vector<BatchData::BatchedVertex>::const_iterator itr = batchData.vertexBatchOperations.begin(); 
-         itr != batchData.vertexBatchOperations.end(); itr++ )
+      for( Vector<BatchData::BatchedVertex>::const_iterator itr = mBatchData.vertexBatchOperations.begin(); 
+         itr != mBatchData.vertexBatchOperations.end(); itr++ )
       {
          const BatchData::BatchedVertex &curVert = *itr;
 
@@ -1275,11 +1275,11 @@ void TSSkinMesh::updateSkin( const Vector<MatrixF> &transforms, TSVertexBufferHa
       zero_vert_normal_bulk(mNumVerts, outPtr, outStride);
 
       // Iterate over transforms, and perform batch transform x skin_vert
-      for(Vector<S32>::const_iterator itr = batchData.transformKeys.begin();
-          itr != batchData.transformKeys.end(); itr++)
+      for(Vector<S32>::const_iterator itr = mBatchData.transformKeys.begin();
+          itr != mBatchData.transformKeys.end(); itr++)
       {
          const S32 boneXfmIdx = *itr;
-         const BatchData::BatchedTransform &curTransform = *batchData.transformBatchOperations.retreive(boneXfmIdx);
+         const BatchData::BatchedTransform &curTransform = *mBatchData.transformBatchOperations.retreive(boneXfmIdx);
          const MatrixF &curBoneMat = matrices[boneXfmIdx];
          const S32 numVerts = curTransform.numElements;
 
@@ -1307,14 +1307,14 @@ S32 QSORT_CALLBACK _sort_BatchedVertWeight( const void *a, const void *b )
 
 void TSSkinMesh::createBatchData()
 {
-   if(batchDataInitialized)
+   if(mBatchDataInitialized)
       return;
 
-   batchDataInitialized = true;
-   S32 * curVtx = vertexIndex.begin();
-   S32 * curBone = boneIndex.begin();
-   F32 * curWeight = weight.begin();
-   const S32 * endVtx = vertexIndex.end();
+   mBatchDataInitialized = true;
+   S32 * curVtx = mVertexIndex.begin();
+   S32 * curBone = mBoneIndex.begin();
+   F32 * curWeight = mWeight.begin();
+   const S32 * endVtx = mVertexIndex.end();
 
    // Temp vector to build batch operations
    Vector<BatchData::BatchedVertex> batchOperations;
@@ -1408,7 +1408,7 @@ void TSSkinMesh::createBatchData()
 
 #ifdef _BATCH_BY_VERTEX
    // Copy data to member, and be done
-   batchData.vertexBatchOperations.set(batchOperations.address(), batchOperations.size());
+   mBatchData.vertexBatchOperations.set(batchOperations.address(), batchOperations.size());
 
    // Convert to batch-by-transform, which is better for CPU skinning, 
    // where-as GPU skinning would data for batch-by-vertex operation
@@ -1424,18 +1424,18 @@ void TSSkinMesh::createBatchData()
 
          // Find the proper batched transform, and add this vertex/weight to the
          // list of verts affected by the transform
-         BatchData::BatchedTransform *bt = batchData.transformBatchOperations.retreive(transformOp.transformIndex);
+         BatchData::BatchedTransform *bt = mBatchData.transformBatchOperations.retreive(transformOp.transformIndex);
          if(!bt)
          {
             bt = new BatchData::BatchedTransform;
-            batchData.transformBatchOperations.insert(bt, transformOp.transformIndex);
+            mBatchData.transformBatchOperations.insert(bt, transformOp.transformIndex);
             bt->_tmpVec = new Vector<BatchData::BatchedVertWeight>;
-            batchData.transformKeys.push_back(transformOp.transformIndex);
+            mBatchData.transformKeys.push_back(transformOp.transformIndex);
          }
 
          bt->_tmpVec->increment();
-         bt->_tmpVec->last().vert = batchData.initialVerts[curTransform.vertexIndex];
-         bt->_tmpVec->last().normal = batchData.initialNorms[curTransform.vertexIndex];
+         bt->_tmpVec->last().vert = mBatchData.initialVerts[curTransform.vertexIndex];
+         bt->_tmpVec->last().normal = mBatchData.initialNorms[curTransform.vertexIndex];
          bt->_tmpVec->last().weight = transformOp.weight;
          bt->_tmpVec->last().vidx = curTransform.vertexIndex;
       }
@@ -1443,10 +1443,10 @@ void TSSkinMesh::createBatchData()
 
    // Now iterate the resulting operations and convert the vectors to aligned
    // memory locations
-   const S32 numBatchOps = batchData.transformKeys.size();
+   const S32 numBatchOps = mBatchData.transformKeys.size();
    for(S32 i = 0; i < numBatchOps; i++)
    {
-      BatchData::BatchedTransform &curTransform = *batchData.transformBatchOperations.retreive(batchData.transformKeys[i]);
+      BatchData::BatchedTransform &curTransform = *mBatchData.transformBatchOperations.retreive(mBatchData.transformKeys[i]);
       const S32 numVerts = curTransform._tmpVec->size();
 
       // Allocate a chunk of aligned memory and copy in values
@@ -1464,7 +1464,7 @@ void TSSkinMesh::createBatchData()
    // Now sort the batch data so that the skin function writes close to linear output
    for(S32 i = 0; i < numBatchOps; i++)
    {
-      BatchData::BatchedTransform &curTransform = *batchData.transformBatchOperations.retreive(batchData.transformKeys[i]);
+      BatchData::BatchedTransform &curTransform = *mBatchData.transformBatchOperations.retreive(mBatchData.transformKeys[i]);
       dQsort(curTransform.alignedMem, curTransform.numElements, sizeof(BatchData::BatchedVertWeight), _sort_BatchedVertWeight);
    }
 #endif
@@ -1489,11 +1489,11 @@ void TSSkinMesh::render(   TSMaterialList *materials,
 
    // Initialize the vertex data if it needs it
    if(!mVertexData.isReady() )
-      _convertToAlignedMeshData(mVertexData, batchData.initialVerts, batchData.initialNorms);
+      _convertToAlignedMeshData(mVertexData, mBatchData.initialVerts, mBatchData.initialNorms);
    AssertFatal(mVertexData.size() == mNumVerts, "Vert # mismatch");
 
    // Initialize the skin batch if that isn't ready
-   if(!batchDataInitialized)
+   if(!mBatchDataInitialized)
       createBatchData();
 
    const bool vertsChanged = vertexBuffer.isNull() || vertexBuffer->mNumVerts != mNumVerts;
@@ -1550,7 +1550,7 @@ void TSSkinMesh::computeBounds( const MatrixF &transform, Box3F &bounds, S32 fra
    if (frame < 0)
    {
       // Use unskinned verts
-      TSMesh::computeBounds( batchData.initialVerts.address(), batchData.initialVerts.size(), sizeof(Point3F), transform, bounds, center, radius );
+      TSMesh::computeBounds( mBatchData.initialVerts.address(), mBatchData.initialVerts.size(), sizeof(Point3F), transform, bounds, center, radius );
    }
    else
    {
@@ -2765,14 +2765,14 @@ void TSMesh::disassemble()
 void TSSkinMesh::assemble( bool skip )
 {
    // avoid a crash on computeBounds...
-   batchData.initialVerts.set( NULL, 0 );
+   mBatchData.initialVerts.set( NULL, 0 );
 
    TSMesh::assemble( skip );
 
    S32 sz = tsalloc.get32();
    S32 numVerts = sz;
    S32 * ptr32 = getSharedData32( mParentMesh, 3 * numVerts, (S32**)smVertsList.address(), skip );
-   batchData.initialVerts.set( (Point3F*)ptr32, sz );
+   mBatchData.initialVerts.set( (Point3F*)ptr32, sz );
 
    S8 * ptr8;
    if ( TSShape::smReadVersion>21 && TSMesh::smUseEncodedNormals )
@@ -2780,7 +2780,7 @@ void TSSkinMesh::assemble( bool skip )
       // we have encoded normals and we want to use them...
       if ( mParentMesh < 0 )
          tsalloc.getPointer32( numVerts * 3 ); // advance past norms, don't use
-      batchData.initialNorms.set( NULL, 0 );
+      mBatchData.initialNorms.set( NULL, 0 );
 
       ptr8 = getSharedData8( mParentMesh, numVerts, (S8**)smEncodedNormsList.address(), skip );
       mEncodedNorms.set( ptr8, numVerts );
@@ -2791,7 +2791,7 @@ void TSSkinMesh::assemble( bool skip )
    {
       // we have encoded normals but we don't want to use them...
       ptr32 = getSharedData32( mParentMesh, 3 * numVerts, (S32**)smNormsList.address(), skip );
-      batchData.initialNorms.set( (Point3F*)ptr32, numVerts );
+      mBatchData.initialNorms.set( (Point3F*)ptr32, numVerts );
 
       if ( mParentMesh < 0 )
          tsalloc.getPointer8( numVerts ); // advance past encoded normls, don't use
@@ -2802,34 +2802,34 @@ void TSSkinMesh::assemble( bool skip )
    {
       // no encoded normals...
       ptr32 = getSharedData32( mParentMesh, 3 * numVerts, (S32**)smNormsList.address(), skip );
-      batchData.initialNorms.set( (Point3F*)ptr32, numVerts );
+      mBatchData.initialNorms.set( (Point3F*)ptr32, numVerts );
       mEncodedNorms.set( NULL, 0 );
    }
 
    sz = tsalloc.get32();
    ptr32 = getSharedData32( mParentMesh, 16 * sz, (S32**)smInitTransformList.address(), skip );
-   batchData.initialTransforms.set( ptr32, sz );
+   mBatchData.initialTransforms.set( ptr32, sz );
 
    sz = tsalloc.get32();
    ptr32 = getSharedData32( mParentMesh, sz, (S32**)smVertexIndexList.address(), skip );
-   vertexIndex.set( ptr32, sz );
+   mVertexIndex.set( ptr32, sz );
 
    ptr32 = getSharedData32( mParentMesh, sz, (S32**)smBoneIndexList.address(), skip );
-   boneIndex.set( ptr32, sz );
+   mBoneIndex.set( ptr32, sz );
 
    ptr32 = getSharedData32( mParentMesh, sz, (S32**)smWeightList.address(), skip );
-   weight.set( (F32*)ptr32, sz );
+   mWeight.set( (F32*)ptr32, sz );
 
    sz = tsalloc.get32();
    ptr32 = getSharedData32( mParentMesh, sz, (S32**)smNodeIndexList.address(), skip );
-   batchData.nodeIndex.set( ptr32, sz );
+   mBatchData.nodeIndex.set( ptr32, sz );
 
    tsalloc.checkGuard();
 
    if ( tsalloc.allocShape32( 0 ) && TSShape::smReadVersion < 19 )
       TSMesh::computeBounds(); // only do this if we copied the data...
 
-   createTangents(batchData.initialVerts, batchData.initialNorms);
+   createTangents(mBatchData.initialVerts, mBatchData.initialNorms);
 }
 
 //-----------------------------------------------------------------------------
@@ -2839,40 +2839,40 @@ void TSSkinMesh::disassemble()
 {
    TSMesh::disassemble();
 
-   tsalloc.set32( batchData.initialVerts.size() );
+   tsalloc.set32( mBatchData.initialVerts.size() );
    // if we have no parent mesh, then save off our verts & norms
    if ( mParentMesh < 0 )
    {
-      tsalloc.copyToBuffer32( (S32*)batchData.initialVerts.address(), 3 * batchData.initialVerts.size() );
+      tsalloc.copyToBuffer32( (S32*)mBatchData.initialVerts.address(), 3 * mBatchData.initialVerts.size() );
 
       // no longer do this here...let tsmesh handle this
-      tsalloc.copyToBuffer32( (S32*)batchData.initialNorms.address(), 3 * batchData.initialNorms.size() );
+      tsalloc.copyToBuffer32( (S32*)mBatchData.initialNorms.address(), 3 * mBatchData.initialNorms.size() );
 
       // if no parent mesh, compute encoded normals and copy over
-      for ( S32 i = 0; i < batchData.initialNorms.size(); i++ )
+      for ( S32 i = 0; i < mBatchData.initialNorms.size(); i++ )
       {
-         U8 normIdx = mEncodedNorms.size() ? mEncodedNorms[i] : encodeNormal( batchData.initialNorms[i] );
+         U8 normIdx = mEncodedNorms.size() ? mEncodedNorms[i] : encodeNormal( mBatchData.initialNorms[i] );
          tsalloc.copyToBuffer8( (S8*)&normIdx, 1 );
       }
    }
 
-   tsalloc.set32( batchData.initialTransforms.size() );
+   tsalloc.set32( mBatchData.initialTransforms.size() );
    if ( mParentMesh < 0 )
-      tsalloc.copyToBuffer32( (S32*)batchData.initialTransforms.address(), batchData.initialTransforms.size() * 16 );
+      tsalloc.copyToBuffer32( (S32*)mBatchData.initialTransforms.address(), mBatchData.initialTransforms.size() * 16 );
 
-   tsalloc.set32( vertexIndex.size() );
+   tsalloc.set32( mVertexIndex.size() );
    if ( mParentMesh < 0 )
    {
-      tsalloc.copyToBuffer32( (S32*)vertexIndex.address(), vertexIndex.size() );
+      tsalloc.copyToBuffer32( (S32*)mVertexIndex.address(), mVertexIndex.size() );
 
-      tsalloc.copyToBuffer32( (S32*)boneIndex.address(), boneIndex.size() );
+      tsalloc.copyToBuffer32( (S32*)mBoneIndex.address(), mBoneIndex.size() );
 
-      tsalloc.copyToBuffer32( (S32*)weight.address(), weight.size() );
+      tsalloc.copyToBuffer32( (S32*)mWeight.address(), mWeight.size() );
    }
 
-   tsalloc.set32( batchData.nodeIndex.size() );
+   tsalloc.set32( mBatchData.nodeIndex.size() );
    if ( mParentMesh < 0 )
-      tsalloc.copyToBuffer32( (S32*)batchData.nodeIndex.address(), batchData.nodeIndex.size() );
+      tsalloc.copyToBuffer32( (S32*)mBatchData.nodeIndex.address(), mBatchData.nodeIndex.size() );
 
    tsalloc.setGuard();
 }
@@ -2881,7 +2881,7 @@ TSSkinMesh::TSSkinMesh()
 {
    mMeshType = SkinMeshType;
    mDynamic = true;
-   batchDataInitialized = false;
+   mBatchDataInitialized = false;
 }
 
 //-----------------------------------------------------------------------------
@@ -3040,7 +3040,7 @@ void TSMesh::convertToAlignedMeshData()
 void TSSkinMesh::convertToAlignedMeshData()
 {
    if(!mVertexData.isReady())
-      _convertToAlignedMeshData(mVertexData, batchData.initialVerts, batchData.initialNorms);
+      _convertToAlignedMeshData(mVertexData, mBatchData.initialVerts, mBatchData.initialNorms);
 }
 
 void TSMesh::_convertToAlignedMeshData( TSMeshVertexArray &vertexData, const Vector<Point3F> &_verts, const Vector<Point3F> &_norms )

Engine/source/ts/tsMesh.h

@@ -501,13 +501,13 @@ public:
    typedef TSMesh Parent;
 
    /// Structure containing data needed to batch skinning
-   BatchData batchData;
-   bool batchDataInitialized;
+   BatchData mBatchData;
+   bool mBatchDataInitialized;
    
    /// vectors that define the vertex, weight, bone tuples
-   Vector<F32> weight;
-   Vector<S32> boneIndex;
-   Vector<S32> vertexIndex;
+   Vector<F32> mWeight;
+   Vector<S32> mBoneIndex;
+   Vector<S32> mVertexIndex;
 
    /// set verts and normals...
    void updateSkin( const Vector<MatrixF> &transforms, TSVertexBufferHandle &instanceVB, GFXPrimitiveBufferHandle &instancePB );

Engine/source/ts/tsShape.cpp

@@ -1188,13 +1188,13 @@ void TSShape::assembleShape()
          if (meshType==TSMesh::SkinMeshType)
          {
             TSSkinMesh * skin = (TSSkinMesh*)mesh;
-            TSMesh::smVertsList[i]  = skin->batchData.initialVerts.address();
-            TSMesh::smNormsList[i]  = skin->batchData.initialNorms.address();
-            TSSkinMesh::smInitTransformList[i] = skin->batchData.initialTransforms.address();
-            TSSkinMesh::smVertexIndexList[i] = skin->vertexIndex.address();
-            TSSkinMesh::smBoneIndexList[i] = skin->boneIndex.address();
-            TSSkinMesh::smWeightList[i] = skin->weight.address();
-            TSSkinMesh::smNodeIndexList[i] = skin->batchData.nodeIndex.address();
+            TSMesh::smVertsList[i]  = skin->mBatchData.initialVerts.address();
+            TSMesh::smNormsList[i]  = skin->mBatchData.initialNorms.address();
+            TSSkinMesh::smInitTransformList[i] = skin->mBatchData.initialTransforms.address();
+            TSSkinMesh::smVertexIndexList[i] = skin->mVertexIndex.address();
+            TSSkinMesh::smBoneIndexList[i] = skin->mBoneIndex.address();
+            TSSkinMesh::smWeightList[i] = skin->mWeight.address();
+            TSSkinMesh::smNodeIndexList[i] = skin->mBatchData.nodeIndex.address();
          }
       }
    }
@@ -1270,16 +1270,16 @@ void TSShape::assembleShape()
          // fill in location of verts, tverts, and normals for shared detail levels
          if (skin)
          {
-            TSMesh::smVertsList[i]  = skin->batchData.initialVerts.address();
+            TSMesh::smVertsList[i]  = skin->mBatchData.initialVerts.address();
             TSMesh::smTVertsList[i] = skin->mTVerts.address();
-            TSMesh::smNormsList[i]  = skin->batchData.initialNorms.address();
+            TSMesh::smNormsList[i]  = skin->mBatchData.initialNorms.address();
             TSMesh::smEncodedNormsList[i]  = skin->mEncodedNorms.address();
             TSMesh::smDataCopied[i] = !skip; // as long as we didn't skip this mesh, the data should be in shape now
-            TSSkinMesh::smInitTransformList[i] = skin->batchData.initialTransforms.address();
-            TSSkinMesh::smVertexIndexList[i] = skin->vertexIndex.address();
-            TSSkinMesh::smBoneIndexList[i] = skin->boneIndex.address();
-            TSSkinMesh::smWeightList[i] = skin->weight.address();
-            TSSkinMesh::smNodeIndexList[i] = skin->batchData.nodeIndex.address();
+            TSSkinMesh::smInitTransformList[i] = skin->mBatchData.initialTransforms.address();
+            TSSkinMesh::smVertexIndexList[i] = skin->mVertexIndex.address();
+            TSSkinMesh::smBoneIndexList[i] = skin->mBoneIndex.address();
+            TSSkinMesh::smWeightList[i] = skin->mWeight.address();
+            TSSkinMesh::smNodeIndexList[i] = skin->mBatchData.nodeIndex.address();
          }
       }
 

Engine/source/ts/tsShapeEdit.cpp

@@ -485,10 +485,10 @@ bool TSShape::addNode(const String& name, const String& parentName, const Point3
       if (meshes[i] && (meshes[i]->getMeshType() == TSMesh::SkinMeshType))
       {
          TSSkinMesh* skin = dynamic_cast<TSSkinMesh*>(meshes[i]);
-         for (S32 j = 0; j < skin->batchData.nodeIndex.size(); j++)
+         for (S32 j = 0; j < skin->mBatchData.nodeIndex.size(); j++)
          {
-            if (skin->batchData.nodeIndex[j] >= nodeIndex)
-               skin->batchData.nodeIndex[j]++;
+            if (skin->mBatchData.nodeIndex[j] >= nodeIndex)
+               skin->mBatchData.nodeIndex[j]++;
          }
       }
    }
@@ -613,12 +613,12 @@ bool TSShape::removeNode(const String& name)
       if (meshes[i] && (meshes[i]->getMeshType() == TSMesh::SkinMeshType))
       {
          TSSkinMesh* skin = dynamic_cast<TSSkinMesh*>(meshes[i]);
-         for (S32 j = 0; j < skin->batchData.nodeIndex.size(); j++)
+         for (S32 j = 0; j < skin->mBatchData.nodeIndex.size(); j++)
          {
-            if (skin->batchData.nodeIndex[j] == nodeIndex)
-               skin->batchData.nodeIndex[j] = nodeParentIndex;
-            if (skin->batchData.nodeIndex[j] > nodeIndex)
-               skin->batchData.nodeIndex[j]--;
+            if (skin->mBatchData.nodeIndex[j] == nodeIndex)
+               skin->mBatchData.nodeIndex[j] = nodeParentIndex;
+            if (skin->mBatchData.nodeIndex[j] > nodeIndex)
+               skin->mBatchData.nodeIndex[j]--;
          }
       }
    }
@@ -876,14 +876,14 @@ TSMesh* TSShape::copyMesh( const TSMesh* srcMesh ) const
 
       // Copy skin elements
       const TSSkinMesh *srcSkin = dynamic_cast<const TSSkinMesh*>(srcMesh);
-      skin->weight = srcSkin->weight;
-      skin->vertexIndex = srcSkin->vertexIndex;
-      skin->boneIndex = srcSkin->boneIndex;
+      skin->mWeight = srcSkin->mWeight;
+      skin->mVertexIndex = srcSkin->mVertexIndex;
+      skin->mBoneIndex = srcSkin->mBoneIndex;
 
-      skin->batchData.nodeIndex = srcSkin->batchData.nodeIndex;
-      skin->batchData.initialTransforms = srcSkin->batchData.initialTransforms;
-      skin->batchData.initialVerts = srcSkin->batchData.initialVerts;
-      skin->batchData.initialNorms = srcSkin->batchData.initialNorms;
+      skin->mBatchData.nodeIndex = srcSkin->mBatchData.nodeIndex;
+      skin->mBatchData.initialTransforms = srcSkin->mBatchData.initialTransforms;
+      skin->mBatchData.initialVerts = srcSkin->mBatchData.initialVerts;
+      skin->mBatchData.initialNorms = srcSkin->mBatchData.initialNorms;
 
       mesh = static_cast<TSMesh*>(skin);
    }
@@ -1073,9 +1073,9 @@ bool TSShape::addMesh(TSShape* srcShape, const String& srcMeshName, const String
       for (S32 i = 0; i < srcShape->nodes.size(); i++)
          nodeMap.push_back( findNode( srcShape->getName(srcShape->nodes[i].nameIndex) ) );
 
-      for (S32 i = 0; i < srcSkin->boneIndex.size(); i++)
+      for (S32 i = 0; i < srcSkin->mBoneIndex.size(); i++)
       {
-         S32 srcNode = srcSkin->boneIndex[i];
+         S32 srcNode = srcSkin->mBoneIndex[i];
          if (nodeMap[srcNode] == -1)
          {
             const char* name = srcShape->getName(srcShape->nodes[srcNode].nameIndex).c_str();
@@ -1088,9 +1088,9 @@ bool TSShape::addMesh(TSShape* srcShape, const String& srcMeshName, const String
       TSSkinMesh *skin = dynamic_cast<TSSkinMesh*>(mesh);
 
       // Remap node indices
-      skin->batchData.nodeIndex = srcSkin->batchData.nodeIndex;
-      for (S32 i = 0; i < skin->batchData.nodeIndex.size(); i++)
-         skin->batchData.nodeIndex[i] = nodeMap[skin->batchData.nodeIndex[i]];
+      skin->mBatchData.nodeIndex = srcSkin->mBatchData.nodeIndex;
+      for (S32 i = 0; i < skin->mBatchData.nodeIndex.size(); i++)
+         skin->mBatchData.nodeIndex[i] = nodeMap[skin->mBatchData.nodeIndex[i]];
    }
 
    // Add the copied mesh to the shape