From aefa7960567c1c55f79f53c811676459c7e4eb25 Mon Sep 17 00:00:00 2001 From: bank Date: Mon, 12 May 2014 18:20:59 +0400 Subject: [PATCH] Rename all member variables to follow the style guidelines (prefixed with the 'm') - class AppMesh --- Engine/source/ts/collada/colladaAppMesh.cpp | 110 +++++++++--------- .../source/ts/collada/colladaShapeLoader.cpp | 4 +- Engine/source/ts/loader/appMesh.cpp | 102 ++++++++-------- Engine/source/ts/loader/appMesh.h | 44 +++---- Engine/source/ts/loader/tsShapeLoader.cpp | 102 ++++++++-------- 5 files changed, 181 insertions(+), 181 deletions(-) diff --git a/Engine/source/ts/collada/colladaAppMesh.cpp b/Engine/source/ts/collada/colladaAppMesh.cpp index c4036fbe9..8b4836d4a 100644 --- a/Engine/source/ts/collada/colladaAppMesh.cpp +++ b/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(appMaterials[iMat]); + for (S32 iMat = 0; iMat < mAppMaterials.size(); iMat++) { + ColladaAppMaterial* appMat = static_cast(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(matArray[iBind]->getTarget().getElement()); - for (matIndex = 0; matIndex < appMaterials.size(); matIndex++) { - if (static_cast(appMaterials[matIndex])->mat == mat) + for (matIndex = 0; matIndex < mAppMaterials.size(); matIndex++) { + if (static_cast(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 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(appMaterials[primitive.matIndex & TSDrawPrimitive::MaterialMask]); + appMat = static_cast(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& 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(appMaterials[matIndex]); + appMat = static_cast(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(geometry)); - getVertexData(daeSafeCast(geometry), t, objectOffset, points, normals, colors, uvs, uv2s, true); + getVertexData(daeSafeCast(geometry), t, objectOffset, mPoints, mNormals, mColors, mUVs, mUV2s, true); } else if (geometry->getElementType() == COLLADA_TYPE::MORPH) { - getMorphVertexData(daeSafeCast(geometry), t, objectOffset, points, normals, colors, uvs, uv2s); + getMorphVertexData(daeSafeCast(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); } } diff --git a/Engine/source/ts/collada/colladaShapeLoader.cpp b/Engine/source/ts/collada/colladaShapeLoader.cpp index 219b07459..07d2b7a40 100644 --- a/Engine/source/ts/collada/colladaShapeLoader.cpp +++ b/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( AppMesh::appMaterials[iMat] ); + ColladaAppMaterial *mat = dynamic_cast( AppMesh::mAppMaterials[iMat] ); if ( mat ) { Material *mappedMat; diff --git a/Engine/source/ts/loader/appMesh.cpp b/Engine/source/ts/loader/appMesh.cpp index 8db105689..749431eb0 100644 --- a/Engine/source/ts/loader/appMesh.cpp +++ b/Engine/source/ts/loader/appMesh.cpp @@ -23,10 +23,10 @@ #include "ts/loader/appMesh.h" #include "ts/loader/tsShapeLoader.h" -Vector AppMesh::appMaterials; +Vector 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 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); diff --git a/Engine/source/ts/loader/appMesh.h b/Engine/source/ts/loader/appMesh.h index dc6b193c6..784660901 100644 --- a/Engine/source/ts/loader/appMesh.h +++ b/Engine/source/ts/loader/appMesh.h @@ -42,33 +42,33 @@ class AppMesh { public: // Mesh and skin elements - Vector points; - Vector normals; - Vector uvs; - Vector uv2s; - Vector colors; - Vector primitives; - Vector indices; + Vector mPoints; + Vector mNormals; + Vector mUVs; + Vector mUV2s; + Vector mColors; + Vector mPrimitives; + Vector mIndices; // Skin elements - Vector weight; - Vector boneIndex; - Vector vertexIndex; - Vector nodeIndex; - Vector initialTransforms; - Vector initialVerts; - Vector initialNorms; + Vector mWeight; + Vector mBoneIndex; + Vector mVertexIndex; + Vector mNodeIndex; + Vector mInitialTransforms; + Vector mInitialVerts; + Vector mInitialNorms; - U32 flags; - U32 vertsPerFrame; - S32 numFrames; - S32 numMatFrames; + U32 mFlags; + U32 mVertsPerFrame; + S32 mNumFrames; + S32 mNumMatFrames; // Loader elements (can be discarded after loading) - S32 detailSize; - MatrixF objectOffset; - Vector bones; - static Vector appMaterials; + S32 mDetailSize; + MatrixF mObjectOffset; + Vector mBones; + static Vector mAppMaterials; public: AppMesh(); diff --git a/Engine/source/ts/loader/tsShapeLoader.cpp b/Engine/source/ts/loader/tsShapeLoader.cpp index a1b1b4ac4..8b01afab0 100644 --- a/Engine/source/ts/loader/tsShapeLoader.cpp +++ b/Engine/source/ts/loader/tsShapeLoader.cpp @@ -377,7 +377,7 @@ bool cmpMeshNameAndSize(const String& key, const Vector& 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;