mirror of
https://github.com/TorqueGameEngines/Torque3D.git
synced 2026-01-19 20:24:49 +00:00
more compiler compliant cleanups plus a full set of tsMesh::foo to tsmesh::mFoo class var conversions for consistency
This commit is contained in:
Azaezel
parent
b55db9a143
commit
4615bd6db8
|
|
@ -424,10 +424,10 @@ bool VolumetricFog::LoadShape()
|
|||
for (U32 k = 0; k < mesh->mIndices.size(); k++)
|
||||
det_size[i].indices->push_back(mesh->mIndices[k]);
|
||||
|
||||
U32 primitivesSize = mesh->primitives.size();
|
||||
U32 primitivesSize = mesh->mPrimitives.size();
|
||||
for (U32 k = 0; k < primitivesSize; k++)
|
||||
{
|
||||
const TSDrawPrimitive & draw = mesh->primitives[k];
|
||||
const TSDrawPrimitive & draw = mesh->mPrimitives[k];
|
||||
GFXPrimitiveType drawType = GFXdrawTypes[draw.matIndex >> 30];
|
||||
switch (drawType)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1244,9 +1244,9 @@ void GuiShapeEdPreview::updateDetailLevel(const SceneRenderState* state)
|
|||
continue;
|
||||
|
||||
// Count the number of draw calls and materials
|
||||
mNumDrawCalls += mesh->primitives.size();
|
||||
for ( S32 iPrim = 0; iPrim < mesh->primitives.size(); iPrim++ )
|
||||
usedMaterials.push_back_unique( mesh->primitives[iPrim].matIndex & TSDrawPrimitive::MaterialMask );
|
||||
mNumDrawCalls += mesh->mPrimitives.size();
|
||||
for ( S32 iPrim = 0; iPrim < mesh->mPrimitives.size(); iPrim++ )
|
||||
usedMaterials.push_back_unique( mesh->mPrimitives[iPrim].matIndex & TSDrawPrimitive::MaterialMask );
|
||||
|
||||
// For skinned meshes, count the number of bones and weights
|
||||
if ( mesh->getMeshType() == TSMesh::SkinMeshType )
|
||||
|
|
|
|||
|
|
@ -147,13 +147,13 @@ TSMesh* AppMesh::constructTSMesh()
|
|||
}
|
||||
|
||||
// Copy mesh elements
|
||||
tsmesh->verts = points;
|
||||
tsmesh->norms = normals;
|
||||
tsmesh->tverts = uvs;
|
||||
tsmesh->primitives = primitives;
|
||||
tsmesh->mVerts = points;
|
||||
tsmesh->mNorms = normals;
|
||||
tsmesh->mTverts = uvs;
|
||||
tsmesh->mPrimitives = primitives;
|
||||
tsmesh->mIndices = indices;
|
||||
tsmesh->colors = colors;
|
||||
tsmesh->tverts2 = uv2s;
|
||||
tsmesh->mColors = colors;
|
||||
tsmesh->mTverts2 = uv2s;
|
||||
|
||||
// Finish initializing the shape
|
||||
tsmesh->setFlags(flags);
|
||||
|
|
@ -162,8 +162,8 @@ TSMesh* AppMesh::constructTSMesh()
|
|||
tsmesh->numFrames = numFrames;
|
||||
tsmesh->numMatFrames = numMatFrames;
|
||||
tsmesh->vertsPerFrame = vertsPerFrame;
|
||||
tsmesh->createTangents(tsmesh->verts, tsmesh->norms);
|
||||
tsmesh->encodedNorms.set(NULL,0);
|
||||
tsmesh->createTangents(tsmesh->mVerts, tsmesh->mNorms);
|
||||
tsmesh->mEncodedNorms.set(NULL,0);
|
||||
|
||||
return tsmesh;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1172,7 +1172,7 @@ void TSShapeLoader::install()
|
|||
{
|
||||
TSMesh *mesh = shape->meshes[obj.startMeshIndex + iMesh];
|
||||
|
||||
if (mesh && !mesh->primitives.size())
|
||||
if (mesh && !mesh->mPrimitives.size())
|
||||
{
|
||||
S32 oldMeshCount = obj.numMeshes;
|
||||
destructInPlace(mesh);
|
||||
|
|
|
|||
|
|
@ -1364,9 +1364,9 @@ void TSMesh::prepOpcodeCollision()
|
|||
// Figure out how many triangles we have...
|
||||
U32 triCount = 0;
|
||||
const U32 base = 0;
|
||||
for ( U32 i = 0; i < primitives.size(); i++ )
|
||||
for ( U32 i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
TSDrawPrimitive & draw = primitives[i];
|
||||
TSDrawPrimitive & draw = mPrimitives[i];
|
||||
const U32 start = draw.start;
|
||||
|
||||
AssertFatal( draw.matIndex & TSDrawPrimitive::Indexed,"TSMesh::buildPolyList (1)" );
|
||||
|
|
@ -1396,7 +1396,7 @@ void TSMesh::prepOpcodeCollision()
|
|||
}
|
||||
|
||||
// Just do the first trilist for now.
|
||||
mi->SetNbVertices( mVertexData.isReady() ? mNumVerts : verts.size() );
|
||||
mi->SetNbVertices( mVertexData.isReady() ? mNumVerts : mVerts.size() );
|
||||
mi->SetNbTriangles( triCount );
|
||||
|
||||
// Stuff everything into appropriate arrays.
|
||||
|
|
@ -1407,9 +1407,9 @@ void TSMesh::prepOpcodeCollision()
|
|||
mOpPoints = pts;
|
||||
|
||||
// add the polys...
|
||||
for ( U32 i = 0; i < primitives.size(); i++ )
|
||||
for ( U32 i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
TSDrawPrimitive & draw = primitives[i];
|
||||
TSDrawPrimitive & draw = mPrimitives[i];
|
||||
const U32 start = draw.start;
|
||||
|
||||
AssertFatal( draw.matIndex & TSDrawPrimitive::Indexed,"TSMesh::buildPolyList (1)" );
|
||||
|
|
@ -1467,7 +1467,7 @@ void TSMesh::prepOpcodeCollision()
|
|||
}
|
||||
else
|
||||
{
|
||||
pts[i].Set( verts[i].x, verts[i].y, verts[i].z );
|
||||
pts[i].Set( mVerts[i].x, mVerts[i].y, mVerts[i].z );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -122,7 +122,7 @@ void TSMesh::innerRender( TSVertexBufferHandle &vb, GFXPrimitiveBufferHandle &pb
|
|||
GFX->setVertexBuffer( vb );
|
||||
GFX->setPrimitiveBuffer( pb );
|
||||
|
||||
for( U32 p = 0; p < primitives.size(); p++ )
|
||||
for( U32 p = 0; p < mPrimitives.size(); p++ )
|
||||
GFX->drawPrimitive( p );
|
||||
}
|
||||
|
||||
|
|
@ -223,9 +223,9 @@ void TSMesh::innerRender( TSMaterialList *materials, const TSRenderState &rdata,
|
|||
// NOTICE: SFXBB is removed and refraction is disabled!
|
||||
//coreRI->backBuffTex = GFX->getSfxBackBuffer();
|
||||
|
||||
for ( S32 i = 0; i < primitives.size(); i++ )
|
||||
for ( S32 i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
const TSDrawPrimitive &draw = primitives[i];
|
||||
const TSDrawPrimitive &draw = mPrimitives[i];
|
||||
|
||||
// We need to have a material.
|
||||
if ( draw.matIndex & TSDrawPrimitive::NoMaterial )
|
||||
|
|
@ -253,7 +253,7 @@ void TSMesh::innerRender( TSMaterialList *materials, const TSRenderState &rdata,
|
|||
#ifndef TORQUE_OS_MAC
|
||||
|
||||
// Get the instancing material if this mesh qualifies.
|
||||
if ( meshType != SkinMeshType && pb->mPrimitiveArray[i].numVertices < smMaxInstancingVerts )
|
||||
if (mMeshType != SkinMeshType && pb->mPrimitiveArray[i].numVertices < smMaxInstancingVerts )
|
||||
if (matInst && !matInst->getFeatures().hasFeature(MFT_HardwareSkinning))
|
||||
matInst = InstancingMaterialHook::getInstancingMat( matInst );
|
||||
|
||||
|
|
@ -293,13 +293,13 @@ const Point3F * TSMesh::getNormals( S32 firstVert )
|
|||
if ( getFlags( UseEncodedNormals ) )
|
||||
{
|
||||
gNormalStore.setSize( vertsPerFrame );
|
||||
for ( S32 i = 0; i < encodedNorms.size(); i++ )
|
||||
gNormalStore[i] = decodeNormal( encodedNorms[ i + firstVert ] );
|
||||
for ( S32 i = 0; i < mEncodedNorms.size(); i++ )
|
||||
gNormalStore[i] = decodeNormal(mEncodedNorms[ i + firstVert ] );
|
||||
|
||||
return gNormalStore.address();
|
||||
}
|
||||
|
||||
return &norms[firstVert];
|
||||
return &mNorms[firstVert];
|
||||
}
|
||||
|
||||
//-----------------------------------------------------
|
||||
|
|
@ -352,28 +352,28 @@ bool TSMesh::buildPolyList( S32 frame, AbstractPolyList *polyList, U32 &surfaceK
|
|||
{
|
||||
// Don't use vertex() method as we want to retain the original indices
|
||||
OptimizedPolyList::VertIndex vert;
|
||||
vert.vertIdx = opList->insertPoint( verts[ i + firstVert ] );
|
||||
vert.normalIdx = opList->insertNormal( norms[ i + firstVert ] );
|
||||
vert.uv0Idx = opList->insertUV0( tverts[ i + firstVert ] );
|
||||
vert.vertIdx = opList->insertPoint( mVerts[ i + firstVert ] );
|
||||
vert.normalIdx = opList->insertNormal( mNorms[ i + firstVert ] );
|
||||
vert.uv0Idx = opList->insertUV0( mTverts[ i + firstVert ] );
|
||||
if ( hasTVert2 )
|
||||
vert.uv1Idx = opList->insertUV1( tverts2[ i + firstVert ] );
|
||||
vert.uv1Idx = opList->insertUV1(mTverts[ i + firstVert ] );
|
||||
|
||||
opList->mVertexList.push_back( vert );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
base = polyList->addPointAndNormal( verts[firstVert], norms[firstVert] );
|
||||
base = polyList->addPointAndNormal( mVerts[firstVert], mNorms[firstVert] );
|
||||
for ( i = 1; i < vertsPerFrame; i++ )
|
||||
polyList->addPointAndNormal( verts[ i + firstVert ], norms[ i + firstVert ] );
|
||||
polyList->addPointAndNormal(mVerts[ i + firstVert ], mNorms[ i + firstVert ] );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// add the polys...
|
||||
for ( i = 0; i < primitives.size(); i++ )
|
||||
for ( i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
TSDrawPrimitive & draw = primitives[i];
|
||||
TSDrawPrimitive & draw = mPrimitives[i];
|
||||
U32 start = draw.start;
|
||||
|
||||
AssertFatal( draw.matIndex & TSDrawPrimitive::Indexed,"TSMesh::buildPolyList (1)" );
|
||||
|
|
@ -440,9 +440,9 @@ bool TSMesh::getFeatures( S32 frame, const MatrixF& mat, const VectorF&, ConvexF
|
|||
}
|
||||
|
||||
// add the polys...
|
||||
for ( i = 0; i < primitives.size(); i++ )
|
||||
for ( i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
TSDrawPrimitive & draw = primitives[i];
|
||||
TSDrawPrimitive & draw = mPrimitives[i];
|
||||
U32 start = draw.start;
|
||||
|
||||
AssertFatal( draw.matIndex & TSDrawPrimitive::Indexed,"TSMesh::buildPolyList (1)" );
|
||||
|
|
@ -627,7 +627,7 @@ void TSMesh::support( S32 frame, const Point3F &v, F32 *currMaxDP, Point3F *curr
|
|||
|
||||
bool TSMesh::castRay( S32 frame, const Point3F & start, const Point3F & end, RayInfo * rayInfo, TSMaterialList* materials )
|
||||
{
|
||||
if ( planeNormals.empty() )
|
||||
if ( mPlaneNormals.empty() )
|
||||
buildConvexHull(); // if haven't done it yet...
|
||||
|
||||
// Keep track of startTime and endTime. They start out at just under 0 and just over 1, respectively.
|
||||
|
|
@ -657,15 +657,15 @@ bool TSMesh::castRay( S32 frame, const Point3F & start, const Point3F & end, Ray
|
|||
S32 * pplane = &curPlane;
|
||||
bool * pfound = &found;
|
||||
|
||||
S32 startPlane = frame * planesPerFrame;
|
||||
for ( S32 i = startPlane; i < startPlane + planesPerFrame; i++ )
|
||||
S32 startPlane = frame * mPlanesPerFrame;
|
||||
for ( S32 i = startPlane; i < startPlane + mPlanesPerFrame; i++ )
|
||||
{
|
||||
// if start & end outside, no collision
|
||||
// if start & end inside, continue
|
||||
// if start outside, end inside, or visa versa, find intersection of line with plane
|
||||
// then update intersection of line with hull (using startTime and endTime)
|
||||
F32 dot1 = mDot( planeNormals[i], start ) - planeConstants[i];
|
||||
F32 dot2 = mDot( planeNormals[i], end) - planeConstants[i];
|
||||
F32 dot1 = mDot(mPlaneNormals[i], start ) - mPlaneConstants[i];
|
||||
F32 dot2 = mDot(mPlaneNormals[i], end) - mPlaneConstants[i];
|
||||
if ( dot1 * dot2 > 0.0f )
|
||||
{
|
||||
// same side of the plane...which side -- dot==0 considered inside
|
||||
|
|
@ -747,10 +747,10 @@ bool TSMesh::castRay( S32 frame, const Point3F & start, const Point3F & end, Ray
|
|||
// setup rayInfo
|
||||
if ( found && rayInfo )
|
||||
{
|
||||
curMaterial = planeMaterials[ curPlane - startPlane ];
|
||||
curMaterial = mPlaneMaterials[ curPlane - startPlane ];
|
||||
|
||||
rayInfo->t = (F32)startNum/(F32)startDen; // finally divide...
|
||||
rayInfo->normal = planeNormals[curPlane];
|
||||
rayInfo->normal = mPlaneNormals[curPlane];
|
||||
|
||||
if (materials && materials->size() > 0)
|
||||
rayInfo->material = materials->getMaterialInst( curMaterial );
|
||||
|
|
@ -785,9 +785,9 @@ bool TSMesh::castRayRendered( S32 frame, const Point3F & start, const Point3F &
|
|||
BaseMatInstance* bestMaterial = NULL;
|
||||
Point3F dir = end - start;
|
||||
|
||||
for ( S32 i = 0; i < primitives.size(); i++ )
|
||||
for ( S32 i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
TSDrawPrimitive & draw = primitives[i];
|
||||
TSDrawPrimitive & draw = mPrimitives[i];
|
||||
U32 drawStart = draw.start;
|
||||
|
||||
AssertFatal( draw.matIndex & TSDrawPrimitive::Indexed,"TSMesh::castRayRendered (1)" );
|
||||
|
|
@ -927,35 +927,35 @@ bool TSMesh::addToHull( U32 idx0, U32 idx1, U32 idx2 )
|
|||
|
||||
normal.normalize();
|
||||
F32 k = mDot( normal, mVertexData.getBase(idx0).vert() );
|
||||
for ( S32 i = 0; i < planeNormals.size(); i++ )
|
||||
for ( S32 i = 0; i < mPlaneNormals.size(); i++ )
|
||||
{
|
||||
if ( mDot( planeNormals[i], normal ) > 0.99f && mFabs( k-planeConstants[i] ) < 0.01f )
|
||||
if ( mDot(mPlaneNormals[i], normal ) > 0.99f && mFabs( k- mPlaneConstants[i] ) < 0.01f )
|
||||
return false; // this is a repeat...
|
||||
}
|
||||
// new plane, add it to the list...
|
||||
planeNormals.push_back( normal );
|
||||
planeConstants.push_back( k );
|
||||
mPlaneNormals.push_back( normal );
|
||||
mPlaneConstants.push_back( k );
|
||||
return true;
|
||||
}
|
||||
|
||||
bool TSMesh::buildConvexHull()
|
||||
{
|
||||
// already done, return without error
|
||||
if ( planeNormals.size() )
|
||||
if (mPlaneNormals.size() )
|
||||
return true;
|
||||
|
||||
bool error = false;
|
||||
|
||||
// should probably only have 1 frame, but just in case...
|
||||
planesPerFrame = 0;
|
||||
mPlanesPerFrame = 0;
|
||||
S32 frame, i, j;
|
||||
for ( frame = 0; frame < numFrames; frame++ )
|
||||
{
|
||||
S32 firstVert = vertsPerFrame * frame;
|
||||
S32 firstPlane = planeNormals.size();
|
||||
for ( i = 0; i < primitives.size(); i++ )
|
||||
S32 firstPlane = mPlaneNormals.size();
|
||||
for ( i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
TSDrawPrimitive & draw = primitives[i];
|
||||
TSDrawPrimitive & draw = mPrimitives[i];
|
||||
U32 start = draw.start;
|
||||
|
||||
AssertFatal( draw.matIndex & TSDrawPrimitive::Indexed,"TSMesh::buildConvexHull (1)" );
|
||||
|
|
@ -967,7 +967,7 @@ bool TSMesh::buildConvexHull()
|
|||
if ( addToHull( mIndices[start + j + 0] + firstVert,
|
||||
mIndices[start + j + 1] + firstVert,
|
||||
mIndices[start + j + 2] + firstVert ) && frame == 0 )
|
||||
planeMaterials.push_back( draw.matIndex & TSDrawPrimitive::MaterialMask );
|
||||
mPlaneMaterials.push_back( draw.matIndex & TSDrawPrimitive::MaterialMask );
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -984,51 +984,51 @@ bool TSMesh::buildConvexHull()
|
|||
nextIdx = (U32*) ( (dsize_t)nextIdx ^ (dsize_t)&idx0 ^ (dsize_t)&idx1 );
|
||||
idx2 = mIndices[start + j] + firstVert;
|
||||
if ( addToHull( idx0, idx1, idx2 ) && frame == 0 )
|
||||
planeMaterials.push_back( draw.matIndex & TSDrawPrimitive::MaterialMask );
|
||||
mPlaneMaterials.push_back( draw.matIndex & TSDrawPrimitive::MaterialMask );
|
||||
}
|
||||
}
|
||||
}
|
||||
// make sure all the verts on this frame are inside all the planes
|
||||
for ( i = 0; i < vertsPerFrame; i++ )
|
||||
for ( j = firstPlane; j < planeNormals.size(); j++ )
|
||||
if ( mDot( mVertexData.getBase(firstVert + i).vert(), planeNormals[j] ) - planeConstants[j] < 0.01 ) // .01 == a little slack
|
||||
for ( j = firstPlane; j < mPlaneNormals.size(); j++ )
|
||||
if ( mDot( mVertexData.getBase(firstVert + i).vert(), mPlaneNormals[j] ) - mPlaneConstants[j] < 0.01 ) // .01 == a little slack
|
||||
error = true;
|
||||
|
||||
if ( frame == 0 )
|
||||
planesPerFrame = planeNormals.size();
|
||||
mPlanesPerFrame = mPlaneNormals.size();
|
||||
|
||||
if ( (frame + 1) * planesPerFrame != planeNormals.size() )
|
||||
if ( (frame + 1) * mPlanesPerFrame != mPlaneNormals.size() )
|
||||
{
|
||||
// eek, not all frames have same number of planes...
|
||||
while ( (frame + 1) * planesPerFrame > planeNormals.size() )
|
||||
while ( (frame + 1) * mPlanesPerFrame > mPlaneNormals.size() )
|
||||
{
|
||||
// we're short, duplicate last plane till we match
|
||||
U32 sz = planeNormals.size();
|
||||
planeNormals.increment();
|
||||
planeNormals.last() = planeNormals[sz-1];
|
||||
planeConstants.increment();
|
||||
planeConstants.last() = planeConstants[sz-1];
|
||||
U32 sz = mPlaneNormals.size();
|
||||
mPlaneNormals.increment();
|
||||
mPlaneNormals.last() = mPlaneNormals[sz-1];
|
||||
mPlaneConstants.increment();
|
||||
mPlaneConstants.last() = mPlaneConstants[sz-1];
|
||||
}
|
||||
while ( (frame + 1) * planesPerFrame < planeNormals.size() )
|
||||
while ( (frame + 1) * mPlanesPerFrame < mPlaneNormals.size() )
|
||||
{
|
||||
// harsh -- last frame has more than other frames
|
||||
// duplicate last plane in each frame
|
||||
for ( S32 k = frame - 1; k >= 0; k-- )
|
||||
{
|
||||
planeNormals.insert( k * planesPerFrame + planesPerFrame );
|
||||
planeNormals[k * planesPerFrame + planesPerFrame] = planeNormals[k * planesPerFrame + planesPerFrame - 1];
|
||||
planeConstants.insert( k * planesPerFrame + planesPerFrame );
|
||||
planeConstants[k * planesPerFrame + planesPerFrame] = planeConstants[k * planesPerFrame + planesPerFrame - 1];
|
||||
mPlaneNormals.insert( k * mPlanesPerFrame + mPlanesPerFrame );
|
||||
mPlaneNormals[k * mPlanesPerFrame + mPlanesPerFrame] = mPlaneNormals[k * mPlanesPerFrame + mPlanesPerFrame - 1];
|
||||
mPlaneConstants.insert( k * mPlanesPerFrame + mPlanesPerFrame );
|
||||
mPlaneConstants[k * mPlanesPerFrame + mPlanesPerFrame] = mPlaneConstants[k * mPlanesPerFrame + mPlanesPerFrame - 1];
|
||||
if ( k == 0 )
|
||||
{
|
||||
planeMaterials.increment();
|
||||
planeMaterials.last() = planeMaterials[planeMaterials.size() - 2];
|
||||
mPlaneMaterials.increment();
|
||||
mPlaneMaterials.last() = mPlaneMaterials[mPlaneMaterials.size() - 2];
|
||||
}
|
||||
}
|
||||
planesPerFrame++;
|
||||
mPlanesPerFrame++;
|
||||
}
|
||||
}
|
||||
AssertFatal( (frame + 1) * planesPerFrame == planeNormals.size(),"TSMesh::buildConvexHull (3)" );
|
||||
AssertFatal( (frame + 1) * mPlanesPerFrame == mPlaneNormals.size(),"TSMesh::buildConvexHull (3)" );
|
||||
}
|
||||
return !error;
|
||||
}
|
||||
|
|
@ -1051,7 +1051,7 @@ void TSMesh::computeBounds( const MatrixF &transform, Box3F &bounds, S32 frame,
|
|||
|
||||
AssertFatal(!mVertexData.isReady() || (mVertexData.isReady() && mNumVerts == mVertexData.size() && mNumVerts == vertsPerFrame), "vertex number mismatch");
|
||||
|
||||
if(verts.size() == 0 && mVertexData.isReady() && mVertexData.size() > 0)
|
||||
if(mVerts.size() == 0 && mVertexData.isReady() && mVertexData.size() > 0)
|
||||
{
|
||||
baseVert = &mVertexData.getBase(0).vert();
|
||||
stride = mVertexData.vertSize();
|
||||
|
|
@ -1066,11 +1066,11 @@ void TSMesh::computeBounds( const MatrixF &transform, Box3F &bounds, S32 frame,
|
|||
}
|
||||
else
|
||||
{
|
||||
baseVert = verts.address();
|
||||
baseVert = mVerts.address();
|
||||
stride = sizeof(Point3F);
|
||||
|
||||
if ( frame < 0 )
|
||||
numVerts = verts.size();
|
||||
numVerts = mVerts.size();
|
||||
else
|
||||
{
|
||||
baseVert += frame * vertsPerFrame;
|
||||
|
|
@ -1131,22 +1131,22 @@ void TSMesh::computeBounds( const Point3F *v, S32 numVerts, S32 stride, const Ma
|
|||
S32 TSMesh::getNumPolys() const
|
||||
{
|
||||
S32 count = 0;
|
||||
for ( S32 i = 0; i < primitives.size(); i++ )
|
||||
for ( S32 i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
switch (primitives[i].matIndex & TSDrawPrimitive::TypeMask)
|
||||
switch (mPrimitives[i].matIndex & TSDrawPrimitive::TypeMask)
|
||||
{
|
||||
case TSDrawPrimitive::Triangles:
|
||||
count += primitives[i].numElements / 3;
|
||||
count += mPrimitives[i].numElements / 3;
|
||||
break;
|
||||
|
||||
case TSDrawPrimitive::Fan:
|
||||
count += primitives[i].numElements - 2;
|
||||
count += mPrimitives[i].numElements - 2;
|
||||
break;
|
||||
|
||||
case TSDrawPrimitive::Strip:
|
||||
// Don't count degenerate triangles
|
||||
for ( S32 j = primitives[i].start;
|
||||
j < primitives[i].start+primitives[i].numElements-2;
|
||||
for ( S32 j = mPrimitives[i].start;
|
||||
j < mPrimitives[i].start+ mPrimitives[i].numElements-2;
|
||||
j++ )
|
||||
{
|
||||
if ((mIndices[j] != mIndices[j+1]) &&
|
||||
|
|
@ -1162,11 +1162,11 @@ S32 TSMesh::getNumPolys() const
|
|||
|
||||
//-----------------------------------------------------
|
||||
|
||||
TSMesh::TSMesh() : meshType( StandardMeshType )
|
||||
TSMesh::TSMesh() : mMeshType( StandardMeshType )
|
||||
{
|
||||
VECTOR_SET_ASSOCIATION( planeNormals );
|
||||
VECTOR_SET_ASSOCIATION( planeConstants );
|
||||
VECTOR_SET_ASSOCIATION( planeMaterials );
|
||||
VECTOR_SET_ASSOCIATION(mPlaneNormals );
|
||||
VECTOR_SET_ASSOCIATION(mPlaneConstants );
|
||||
VECTOR_SET_ASSOCIATION(mPlaneMaterials );
|
||||
mParentMesh = -1;
|
||||
|
||||
mOptTree = NULL;
|
||||
|
|
@ -1181,7 +1181,7 @@ TSMesh::TSMesh() : meshType( StandardMeshType )
|
|||
mVertSize = 0;
|
||||
mVertOffset = 0;
|
||||
|
||||
parentMeshObject = NULL;
|
||||
mParentMeshObject = NULL;
|
||||
}
|
||||
|
||||
//-----------------------------------------------------
|
||||
|
|
@ -1326,8 +1326,8 @@ void TSSkinMesh::createSkinBatchData()
|
|||
}
|
||||
else
|
||||
{
|
||||
batchData.initialNorms = norms;
|
||||
batchData.initialVerts = verts;
|
||||
batchData.initialNorms = mNorms;
|
||||
batchData.initialVerts = mVerts;
|
||||
}
|
||||
|
||||
// Build the batch operations
|
||||
|
|
@ -1546,10 +1546,10 @@ void TSSkinMesh::computeBounds( const MatrixF &transform, Box3F &bounds, S32 fra
|
|||
{
|
||||
TORQUE_UNUSED(frame);
|
||||
|
||||
if (verts.size() != 0)
|
||||
if (mVerts.size() != 0)
|
||||
{
|
||||
// Use unskinned verts
|
||||
TSMesh::computeBounds( verts.address(), verts.size(), sizeof(Point3F), transform, bounds, center, radius );
|
||||
TSMesh::computeBounds(mVerts.address(), mVerts.size(), sizeof(Point3F), transform, bounds, center, radius );
|
||||
}
|
||||
else if (frame <= 0 && batchData.initialVerts.size() > 0)
|
||||
{
|
||||
|
|
@ -2368,10 +2368,10 @@ void TSMesh::dumpPrimitives(U32 startVertex, U32 startIndex, GFXPrimitive *piArr
|
|||
// go through and create PrimitiveInfo array
|
||||
GFXPrimitive pInfo;
|
||||
|
||||
U32 primitivesSize = primitives.size();
|
||||
U32 primitivesSize = mPrimitives.size();
|
||||
for (U32 i = 0; i < primitivesSize; i++)
|
||||
{
|
||||
const TSDrawPrimitive & draw = primitives[i];
|
||||
const TSDrawPrimitive & draw = mPrimitives[i];
|
||||
|
||||
GFXPrimitiveType drawType = getDrawType(draw.matIndex >> 30);
|
||||
|
||||
|
|
@ -2436,21 +2436,21 @@ void TSMesh::assemble( bool skip )
|
|||
|
||||
S32 numVerts = tsalloc.get32();
|
||||
S32 *ptr32 = getSharedData32(mParentMesh, 3 * numVerts, (S32**)smVertsList.address(), skip );
|
||||
verts.set( (Point3F*)ptr32, numVerts );
|
||||
mVerts.set( (Point3F*)ptr32, numVerts );
|
||||
|
||||
S32 numTVerts = tsalloc.get32();
|
||||
ptr32 = getSharedData32(mParentMesh, 2 * numTVerts, (S32**)smTVertsList.address(), skip );
|
||||
tverts.set( (Point2F*)ptr32, numTVerts );
|
||||
mTverts.set( (Point2F*)ptr32, numTVerts );
|
||||
|
||||
if ( TSShape::smReadVersion > 25 )
|
||||
{
|
||||
numTVerts = tsalloc.get32();
|
||||
ptr32 = getSharedData32(mParentMesh, 2 * numTVerts, (S32**)smTVerts2List.address(), skip );
|
||||
tverts2.set( (Point2F*)ptr32, numTVerts );
|
||||
mTverts2.set( (Point2F*)ptr32, numTVerts );
|
||||
|
||||
S32 numVColors = tsalloc.get32();
|
||||
ptr32 = getSharedData32(mParentMesh, numVColors, (S32**)smColorsList.address(), skip );
|
||||
colors.set( (ColorI*)ptr32, numVColors );
|
||||
mColors.set( (ColorI*)ptr32, numVColors );
|
||||
}
|
||||
|
||||
S8 *ptr8;
|
||||
|
|
@ -2459,27 +2459,27 @@ void TSMesh::assemble( bool skip )
|
|||
// we have encoded normals and we want to use them...
|
||||
if (mParentMesh < 0 )
|
||||
tsalloc.getPointer32( numVerts * 3 ); // adva nce past norms, don't use
|
||||
norms.set( NULL, 0 );
|
||||
mNorms.set( NULL, 0 );
|
||||
|
||||
ptr8 = getSharedData8(mParentMesh, numVerts, (S8**)smEncodedNormsList.address(), skip );
|
||||
encodedNorms.set( ptr8, numVerts );
|
||||
mEncodedNorms.set( ptr8, numVerts );
|
||||
}
|
||||
else if ( TSShape::smReadVersion > 21 )
|
||||
{
|
||||
// we have encoded normals but we don't want to use them...
|
||||
ptr32 = getSharedData32(mParentMesh, 3 * numVerts, (S32**)smNormsList.address(), skip );
|
||||
norms.set( (Point3F*)ptr32, numVerts );
|
||||
mNorms.set( (Point3F*)ptr32, numVerts );
|
||||
|
||||
if (mParentMesh < 0 )
|
||||
tsalloc.getPointer8( numVerts ); // advance past encoded normls, don't use
|
||||
encodedNorms.set( NULL, 0 );
|
||||
mEncodedNorms.set( NULL, 0 );
|
||||
}
|
||||
else
|
||||
{
|
||||
// no encoded normals...
|
||||
ptr32 = getSharedData32(mParentMesh, 3 * numVerts, (S32**)smNormsList.address(), skip );
|
||||
norms.set( (Point3F*)ptr32, numVerts );
|
||||
encodedNorms.set( NULL, 0 );
|
||||
mNorms.set( (Point3F*)ptr32, numVerts );
|
||||
mEncodedNorms.set( NULL, 0 );
|
||||
}
|
||||
|
||||
// copy the primitives and indices...how we do this depends on what
|
||||
|
|
@ -2553,7 +2553,7 @@ void TSMesh::assemble( bool skip )
|
|||
AssertFatal(chkPrim==szPrimOut && chkInd==szIndOut,"TSMesh::primitive conversion");
|
||||
|
||||
// store output
|
||||
primitives.set(primOut, szPrimOut);
|
||||
mPrimitives.set(primOut, szPrimOut);
|
||||
mIndices.set(indOut, szIndOut);
|
||||
|
||||
// delete temporary arrays if necessary
|
||||
|
|
@ -2569,7 +2569,7 @@ void TSMesh::assemble( bool skip )
|
|||
|
||||
vertsPerFrame = tsalloc.get32();
|
||||
U32 flags = (U32)tsalloc.get32();
|
||||
if ( encodedNorms.size() )
|
||||
if ( mEncodedNorms.size() )
|
||||
flags |= UseEncodedNormals;
|
||||
|
||||
setFlags( flags );
|
||||
|
|
@ -2577,9 +2577,9 @@ void TSMesh::assemble( bool skip )
|
|||
// Set color & tvert2 flags if we have an old version
|
||||
if (TSShape::smReadVersion < 27)
|
||||
{
|
||||
if (colors.size() > 0) setFlags(HasColor);
|
||||
if (tverts2.size() > 0) setFlags(HasTVert2);
|
||||
mNumVerts = verts.size();
|
||||
if (mColors.size() > 0) setFlags(HasColor);
|
||||
if (mTverts2.size() > 0) setFlags(HasTVert2);
|
||||
mNumVerts = mVerts.size();
|
||||
}
|
||||
|
||||
tsalloc.checkGuard();
|
||||
|
|
@ -2587,7 +2587,7 @@ void TSMesh::assemble( bool skip )
|
|||
if ( tsalloc.allocShape32( 0 ) && TSShape::smReadVersion < 19 )
|
||||
computeBounds(); // only do this if we copied the data...
|
||||
|
||||
createTangents(verts, norms);
|
||||
createTangents(mVerts, mNorms);
|
||||
}
|
||||
|
||||
void TSMesh::disassemble()
|
||||
|
|
@ -2636,39 +2636,39 @@ void TSMesh::disassemble()
|
|||
else
|
||||
{
|
||||
// verts...
|
||||
tsalloc.set32(verts.size());
|
||||
tsalloc.set32(mVerts.size());
|
||||
if (mParentMesh < 0)
|
||||
tsalloc.copyToBuffer32((S32*)verts.address(), 3 * verts.size()); // if no parent mesh, then save off our verts
|
||||
tsalloc.copyToBuffer32((S32*)mVerts.address(), 3 * mVerts.size()); // if no parent mesh, then save off our verts
|
||||
|
||||
// tverts...
|
||||
tsalloc.set32(tverts.size());
|
||||
tsalloc.set32(mTverts.size());
|
||||
if (mParentMesh < 0)
|
||||
tsalloc.copyToBuffer32((S32*)tverts.address(), 2 * tverts.size()); // if no parent mesh, then save off our tverts
|
||||
tsalloc.copyToBuffer32((S32*)mTverts.address(), 2 * mTverts.size()); // if no parent mesh, then save off our tverts
|
||||
|
||||
if (TSShape::smVersion > 25)
|
||||
{
|
||||
// tverts2...
|
||||
tsalloc.set32(tverts2.size());
|
||||
tsalloc.set32(mTverts2.size());
|
||||
if (mParentMesh < 0)
|
||||
tsalloc.copyToBuffer32((S32*)tverts2.address(), 2 * tverts2.size()); // if no parent mesh, then save off our tverts
|
||||
tsalloc.copyToBuffer32((S32*)mTverts2.address(), 2 * mTverts2.size()); // if no parent mesh, then save off our tverts
|
||||
|
||||
// colors
|
||||
tsalloc.set32(colors.size());
|
||||
tsalloc.set32(mColors.size());
|
||||
if (mParentMesh < 0)
|
||||
tsalloc.copyToBuffer32((S32*)colors.address(), colors.size()); // if no parent mesh, then save off our tverts
|
||||
tsalloc.copyToBuffer32((S32*)mColors.address(), mColors.size()); // if no parent mesh, then save off our tverts
|
||||
}
|
||||
|
||||
// norms...
|
||||
if (mParentMesh < 0) // if no parent mesh, then save off our norms
|
||||
tsalloc.copyToBuffer32((S32*)norms.address(), 3 * norms.size()); // norms.size()==verts.size() or error...
|
||||
tsalloc.copyToBuffer32((S32*)mNorms.address(), 3 * mNorms.size()); // norms.size()==verts.size() or error...
|
||||
|
||||
// encoded norms...
|
||||
if (mParentMesh < 0)
|
||||
{
|
||||
// if no parent mesh, compute encoded normals and copy over
|
||||
for (S32 i = 0; i < norms.size(); i++)
|
||||
for (S32 i = 0; i < mNorms.size(); i++)
|
||||
{
|
||||
U8 normIdx = encodedNorms.size() ? encodedNorms[i] : encodeNormal(norms[i]);
|
||||
U8 normIdx = mEncodedNorms.size() ? mEncodedNorms[i] : encodeNormal(mNorms[i]);
|
||||
tsalloc.copyToBuffer8((S8*)&normIdx, 1);
|
||||
}
|
||||
}
|
||||
|
|
@ -2677,14 +2677,14 @@ void TSMesh::disassemble()
|
|||
// optimize triangle draw order during disassemble
|
||||
{
|
||||
FrameTemp<TriListOpt::IndexType> tmpIdxs(mIndices.size());
|
||||
for ( S32 i = 0; i < primitives.size(); i++ )
|
||||
for ( S32 i = 0; i < mPrimitives.size(); i++ )
|
||||
{
|
||||
const TSDrawPrimitive& prim = primitives[i];
|
||||
const TSDrawPrimitive& prim = mPrimitives[i];
|
||||
|
||||
// only optimize triangle lists (strips and fans are assumed to be already optimized)
|
||||
if ( (prim.matIndex & TSDrawPrimitive::TypeMask) == TSDrawPrimitive::Triangles )
|
||||
{
|
||||
TriListOpt::OptimizeTriangleOrdering(verts.size(), prim.numElements,
|
||||
TriListOpt::OptimizeTriangleOrdering(mVerts.size(), prim.numElements,
|
||||
mIndices.address() + prim.start, tmpIdxs.address());
|
||||
dCopyArray(mIndices.address() + prim.start, tmpIdxs.address(),
|
||||
prim.numElements);
|
||||
|
|
@ -2695,8 +2695,8 @@ void TSMesh::disassemble()
|
|||
if (TSShape::smVersion > 25)
|
||||
{
|
||||
// primitives...
|
||||
tsalloc.set32( primitives.size() );
|
||||
tsalloc.copyToBuffer32((S32*)primitives.address(),3*primitives.size());
|
||||
tsalloc.set32(mPrimitives.size() );
|
||||
tsalloc.copyToBuffer32((S32*)mPrimitives.address(),3* mPrimitives.size());
|
||||
|
||||
// indices...
|
||||
tsalloc.set32(mIndices.size());
|
||||
|
|
@ -2705,15 +2705,15 @@ void TSMesh::disassemble()
|
|||
else
|
||||
{
|
||||
// primitives
|
||||
tsalloc.set32( primitives.size() );
|
||||
for (S32 i=0; i<primitives.size(); i++)
|
||||
tsalloc.set32(mPrimitives.size() );
|
||||
for (S32 i=0; i<mPrimitives.size(); i++)
|
||||
{
|
||||
S16 start = (S16)primitives[i].start;
|
||||
S16 numElements = (S16)primitives[i].numElements;
|
||||
S16 start = (S16)mPrimitives[i].start;
|
||||
S16 numElements = (S16)mPrimitives[i].numElements;
|
||||
|
||||
tsalloc.copyToBuffer16(&start, 1);
|
||||
tsalloc.copyToBuffer16(&numElements, 1);
|
||||
tsalloc.copyToBuffer32(&(primitives[i].matIndex), 1);
|
||||
tsalloc.copyToBuffer32(&(mPrimitives[i].matIndex), 1);
|
||||
}
|
||||
|
||||
// indices
|
||||
|
|
@ -2772,7 +2772,7 @@ void TSSkinMesh::assemble( bool skip )
|
|||
batchData.initialNorms.set(NULL, 0);
|
||||
|
||||
ptr8 = getSharedData8(mParentMesh, numVerts, (S8**)smEncodedNormsList.address(), skip);
|
||||
encodedNorms.set(ptr8, numVerts);
|
||||
mEncodedNorms.set(ptr8, numVerts);
|
||||
// Note: we don't set the encoded normals flag because we handle them in updateSkin and
|
||||
// hide the fact that we are using them from base class (TSMesh)
|
||||
}
|
||||
|
|
@ -2785,33 +2785,33 @@ void TSSkinMesh::assemble( bool skip )
|
|||
if (mParentMesh < 0)
|
||||
tsalloc.getPointer8(numVerts); // advance past encoded normls, don't use
|
||||
|
||||
encodedNorms.set(NULL, 0);
|
||||
mEncodedNorms.set(NULL, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
// no encoded normals...
|
||||
ptr32 = getSharedData32(mParentMesh, 3 * numVerts, (S32**)smNormsList.address(), skip);
|
||||
batchData.initialNorms.set((Point3F*)ptr32, numVerts);
|
||||
encodedNorms.set(NULL, 0);
|
||||
mEncodedNorms.set(NULL, 0);
|
||||
}
|
||||
|
||||
// Sometimes we'll have a mesh with 0 verts but initialVerts is set,
|
||||
// so set these accordingly
|
||||
if (verts.size() == 0)
|
||||
if (mVerts.size() == 0)
|
||||
{
|
||||
verts = batchData.initialVerts;
|
||||
mVerts = batchData.initialVerts;
|
||||
}
|
||||
|
||||
if (norms.size() == 0)
|
||||
if (mNorms.size() == 0)
|
||||
{
|
||||
norms = batchData.initialNorms;
|
||||
mNorms = batchData.initialNorms;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// Set from the mesh data
|
||||
batchData.initialVerts = verts;
|
||||
batchData.initialNorms = norms;
|
||||
batchData.initialVerts = mVerts;
|
||||
batchData.initialNorms = mNorms;
|
||||
}
|
||||
|
||||
sz = tsalloc.get32();
|
||||
|
|
@ -2885,15 +2885,15 @@ void TSSkinMesh::disassemble()
|
|||
// if we have no parent mesh, then save off our verts & norms
|
||||
if (mParentMesh < 0)
|
||||
{
|
||||
tsalloc.copyToBuffer32((S32*)verts.address(), 3 * verts.size());
|
||||
tsalloc.copyToBuffer32((S32*)mVerts.address(), 3 * mVerts.size());
|
||||
|
||||
// no longer do this here...let tsmesh handle this
|
||||
tsalloc.copyToBuffer32((S32*)norms.address(), 3 * norms.size());
|
||||
tsalloc.copyToBuffer32((S32*)mNorms.address(), 3 * mNorms.size());
|
||||
|
||||
// if no parent mesh, compute encoded normals and copy over
|
||||
for (S32 i = 0; i < norms.size(); i++)
|
||||
for (S32 i = 0; i < mNorms.size(); i++)
|
||||
{
|
||||
U8 normIdx = encodedNorms.size() ? encodedNorms[i] : encodeNormal(norms[i]);
|
||||
U8 normIdx = mEncodedNorms.size() ? mEncodedNorms[i] : encodeNormal(mNorms[i]);
|
||||
tsalloc.copyToBuffer8((S8*)&normIdx, 1);
|
||||
}
|
||||
}
|
||||
|
|
@ -2939,7 +2939,7 @@ void TSSkinMesh::disassemble()
|
|||
|
||||
TSSkinMesh::TSSkinMesh()
|
||||
{
|
||||
meshType = SkinMeshType;
|
||||
mMeshType = SkinMeshType;
|
||||
batchData.initialized = false;
|
||||
maxBones = -1;
|
||||
}
|
||||
|
|
@ -2958,9 +2958,9 @@ inline void TSMesh::findTangent( U32 index1,
|
|||
const Point3F &v2 = _verts[index2];
|
||||
const Point3F &v3 = _verts[index3];
|
||||
|
||||
const Point2F &w1 = tverts[index1];
|
||||
const Point2F &w2 = tverts[index2];
|
||||
const Point2F &w3 = tverts[index3];
|
||||
const Point2F &w1 = mTverts[index1];
|
||||
const Point2F &w2 = mTverts[index2];
|
||||
const Point2F &w3 = mTverts[index3];
|
||||
|
||||
F32 x1 = v2.x - v1.x;
|
||||
F32 x2 = v3.x - v1.x;
|
||||
|
|
@ -3025,11 +3025,11 @@ void TSMesh::createTangents(const Vector<Point3F> &_verts, const Vector<Point3F>
|
|||
Point3F *tan1 = tan0.address() + numVerts;
|
||||
dMemset( tan0.address(), 0, sizeof(Point3F) * 2 * numVerts );
|
||||
|
||||
U32 numPrimatives = primitives.size();
|
||||
U32 numPrimatives = mPrimitives.size();
|
||||
|
||||
for (S32 i = 0; i < numPrimatives; i++ )
|
||||
{
|
||||
const TSDrawPrimitive & draw = primitives[i];
|
||||
const TSDrawPrimitive & draw = mPrimitives[i];
|
||||
GFXPrimitiveType drawType = getDrawType( draw.matIndex >> 30 );
|
||||
|
||||
U32 p1Index = 0;
|
||||
|
|
@ -3066,7 +3066,7 @@ void TSMesh::createTangents(const Vector<Point3F> &_verts, const Vector<Point3F>
|
|||
}
|
||||
}
|
||||
|
||||
tangents.setSize( numVerts );
|
||||
mTangents.setSize( numVerts );
|
||||
|
||||
// fill out final info from accumulated basis data
|
||||
for( U32 i = 0; i < numVerts; i++ )
|
||||
|
|
@ -3077,12 +3077,12 @@ void TSMesh::createTangents(const Vector<Point3F> &_verts, const Vector<Point3F>
|
|||
|
||||
Point3F tempPt = t - n * mDot( n, t );
|
||||
tempPt.normalize();
|
||||
tangents[i] = tempPt;
|
||||
mTangents[i] = tempPt;
|
||||
|
||||
Point3F cp;
|
||||
mCross( n, t, &cp );
|
||||
|
||||
tangents[i].w = (mDot( cp, b ) < 0.0f) ? -1.0f : 1.0f;
|
||||
mTangents[i].w = (mDot( cp, b ) < 0.0f) ? -1.0f : 1.0f;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3090,7 +3090,7 @@ void TSMesh::convertToVertexData()
|
|||
{
|
||||
if (!mVertexData.isReady())
|
||||
{
|
||||
_convertToVertexData(mVertexData, verts, norms);
|
||||
_convertToVertexData(mVertexData, mVerts, mNorms);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -3111,39 +3111,39 @@ void TSSkinMesh::convertToVertexData()
|
|||
|
||||
void TSMesh::copySourceVertexDataFrom(const TSMesh* srcMesh)
|
||||
{
|
||||
verts = srcMesh->verts;
|
||||
tverts = srcMesh->tverts;
|
||||
norms = srcMesh->norms;
|
||||
colors = srcMesh->colors;
|
||||
tverts2 = srcMesh->tverts2;
|
||||
mVerts = srcMesh->mVerts;
|
||||
mTverts = srcMesh->mTverts;
|
||||
mNorms = srcMesh->mNorms;
|
||||
mColors = srcMesh->mColors;
|
||||
mTverts2 = srcMesh->mTverts2;
|
||||
|
||||
if (verts.size() == 0)
|
||||
if (mVerts.size() == 0)
|
||||
{
|
||||
bool hasTVert2 = srcMesh->getHasTVert2();
|
||||
bool hasColor = srcMesh->getHasColor();
|
||||
|
||||
verts.setSize(srcMesh->mNumVerts);
|
||||
tverts.setSize(srcMesh->mNumVerts);
|
||||
norms.setSize(srcMesh->mNumVerts);
|
||||
mVerts.setSize(srcMesh->mNumVerts);
|
||||
mTverts.setSize(srcMesh->mNumVerts);
|
||||
mNorms.setSize(srcMesh->mNumVerts);
|
||||
|
||||
if (hasColor)
|
||||
colors.setSize(mNumVerts);
|
||||
mColors.setSize(mNumVerts);
|
||||
if (hasTVert2)
|
||||
tverts2.setSize(mNumVerts);
|
||||
mTverts2.setSize(mNumVerts);
|
||||
|
||||
// Fill arrays
|
||||
for (U32 i = 0; i < mNumVerts; i++)
|
||||
{
|
||||
const __TSMeshVertexBase &cv = srcMesh->mVertexData.getBase(i);
|
||||
const __TSMeshVertex_3xUVColor &cvc = srcMesh->mVertexData.getColor(i);
|
||||
verts[i] = cv.vert();
|
||||
tverts[i] = cv.tvert();
|
||||
norms[i] = cv.normal();
|
||||
mVerts[i] = cv.vert();
|
||||
mTverts[i] = cv.tvert();
|
||||
mNorms[i] = cv.normal();
|
||||
|
||||
if (hasColor)
|
||||
cvc.color().getColor(&colors[i]);
|
||||
cvc.color().getColor(&mColors[i]);
|
||||
if (hasTVert2)
|
||||
tverts2[i] = cvc.tvert2();
|
||||
mTverts2[i] = cvc.tvert2();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -3173,21 +3173,21 @@ void TSSkinMesh::copySourceVertexDataFrom(const TSMesh* srcMesh)
|
|||
|
||||
U32 TSMesh::getNumVerts()
|
||||
{
|
||||
return mVertexData.isReady() ? mNumVerts : verts.size();
|
||||
return mVertexData.isReady() ? mNumVerts : mVerts.size();
|
||||
}
|
||||
|
||||
void TSMesh::_convertToVertexData(TSMeshVertexArray &outArray, const Vector<Point3F> &_verts, const Vector<Point3F> &_norms)
|
||||
{
|
||||
// Update tangents list
|
||||
createTangents(verts, norms);
|
||||
createTangents(mVerts, mNorms);
|
||||
|
||||
AssertFatal(_verts.size() == mNumVerts, "vert count mismatch");
|
||||
AssertFatal(!getHasColor() || colors.size() == _verts.size(), "Vector of color elements should be the same size as other vectors");
|
||||
AssertFatal(!getHasTVert2() || tverts2.size() == _verts.size(), "Vector of tvert2 elements should be the same size as other vectors");
|
||||
AssertFatal(!getHasColor() || mColors.size() == _verts.size(), "Vector of color elements should be the same size as other vectors");
|
||||
AssertFatal(!getHasTVert2() || mTverts2.size() == _verts.size(), "Vector of tvert2 elements should be the same size as other vectors");
|
||||
|
||||
AssertFatal(!outArray.isReady(), "Mesh already converted to aligned data! Re-check code!");
|
||||
AssertFatal(_verts.size() == _norms.size() &&
|
||||
_verts.size() == tangents.size(),
|
||||
_verts.size() == mTangents.size(),
|
||||
"Vectors: verts, norms, tangents must all be the same size");
|
||||
AssertFatal(mVertSize == outArray.vertSize(), "Size inconsistency");
|
||||
|
||||
|
|
@ -3206,18 +3206,18 @@ void TSMesh::_convertToVertexData(TSMeshVertexArray &outArray, const Vector<Poin
|
|||
__TSMeshVertexBase &v = outArray.getBase(i);
|
||||
v.vert(_verts[i]);
|
||||
v.normal(_norms[i]);
|
||||
v.tangent(tangents[i]);
|
||||
v.tangent(mTangents[i]);
|
||||
|
||||
if (i < tverts.size())
|
||||
v.tvert(tverts[i]);
|
||||
if (i < mTverts.size())
|
||||
v.tvert(mTverts[i]);
|
||||
|
||||
if (hasTVert2 || hasColor)
|
||||
{
|
||||
__TSMeshVertex_3xUVColor &vc = outArray.getColor(i);
|
||||
if (hasTVert2 && i < tverts2.size())
|
||||
vc.tvert2(tverts2[i]);
|
||||
if (hasColor && i < colors.size())
|
||||
vc.color(colors[i]);
|
||||
if (hasTVert2 && i < mTverts2.size())
|
||||
vc.tvert2(mTverts2[i]);
|
||||
if (hasColor && i < mColors.size())
|
||||
vc.color(mColors[i]);
|
||||
}
|
||||
|
||||
// NOTE: skin verts are set later on for the skinned mesh, otherwise we'll set the default (i.e. 0) if we need one for a rigid mesh
|
||||
|
|
@ -3231,7 +3231,7 @@ void TSMesh::_convertToVertexData(TSMeshVertexArray &outArray, const Vector<Poin
|
|||
|
||||
void TSMesh::makeEditable()
|
||||
{
|
||||
bool hasVerts = verts.size() != 0;
|
||||
bool hasVerts = mVerts.size() != 0;
|
||||
|
||||
if(mVertexData.isReady() && !hasVerts)
|
||||
{
|
||||
|
|
@ -3282,7 +3282,7 @@ void TSSkinMesh::addWeightsFromVertexBuffer()
|
|||
|
||||
void TSSkinMesh::makeEditable()
|
||||
{
|
||||
bool hasVerts = verts.size() != 0;
|
||||
bool hasVerts = mVerts.size() != 0;
|
||||
|
||||
// Reconstruct bone mapping
|
||||
if (mVertexData.isReady() && !hasVerts)
|
||||
|
|
@ -3307,36 +3307,36 @@ void TSSkinMesh::makeEditable()
|
|||
|
||||
void TSMesh::clearEditable()
|
||||
{
|
||||
if (verts.size() == 0)
|
||||
if (mVerts.size() == 0)
|
||||
return;
|
||||
|
||||
if (colors.empty())
|
||||
if (mColors.empty())
|
||||
clearFlags(HasColor);
|
||||
else
|
||||
setFlags(HasColor);
|
||||
|
||||
if (tverts2.empty())
|
||||
if (mTverts2.empty())
|
||||
clearFlags(HasTVert2);
|
||||
else
|
||||
setFlags(HasTVert2);
|
||||
|
||||
verts.free_memory();
|
||||
norms.free_memory();
|
||||
tangents.free_memory();
|
||||
tverts.free_memory();
|
||||
tverts2.free_memory();
|
||||
colors.free_memory();
|
||||
mVerts.free_memory();
|
||||
mNorms.free_memory();
|
||||
mTangents.free_memory();
|
||||
mTverts.free_memory();
|
||||
mTverts2.free_memory();
|
||||
mColors.free_memory();
|
||||
}
|
||||
|
||||
void TSMesh::updateMeshFlags()
|
||||
{
|
||||
// Make sure flags are correct
|
||||
if (colors.empty())
|
||||
if (mColors.empty())
|
||||
clearFlags(HasColor);
|
||||
else
|
||||
setFlags(HasColor);
|
||||
|
||||
if (tverts2.empty())
|
||||
if (mTverts2.empty())
|
||||
clearFlags(HasTVert2);
|
||||
else
|
||||
setFlags(HasTVert2);
|
||||
|
|
|
|||
|
|
@ -251,7 +251,7 @@ public:
|
|||
|
||||
protected:
|
||||
|
||||
U32 meshType;
|
||||
U32 mMeshType;
|
||||
Box3F mBounds;
|
||||
Point3F mCenter;
|
||||
F32 mRadius;
|
||||
|
|
@ -259,7 +259,7 @@ protected:
|
|||
|
||||
const GFXVertexFormat *mVertexFormat;
|
||||
|
||||
TSMesh *parentMeshObject; ///< Current parent object instance
|
||||
TSMesh *mParentMeshObject; ///< Current parent object instance
|
||||
|
||||
U32 mPrimBufferOffset;
|
||||
|
||||
|
|
@ -299,12 +299,12 @@ protected:
|
|||
FlagMask = Billboard|BillboardZAxis|HasDetailTexture|UseEncodedNormals|HasColor|HasTVert2
|
||||
};
|
||||
|
||||
U32 getMeshType() const { return meshType & TypeMask; }
|
||||
U32 getHasColor() const { return colors.size() > 0 || meshType & HasColor; }
|
||||
U32 getHasTVert2() const { return tverts2.size() > 0 || meshType & HasTVert2; }
|
||||
void setFlags(U32 flag) { meshType |= flag; }
|
||||
void clearFlags(U32 flag) { meshType &= ~flag; }
|
||||
U32 getFlags( U32 flag = 0xFFFFFFFF ) const { return meshType & flag; }
|
||||
U32 getMeshType() const { return mMeshType & TypeMask; }
|
||||
U32 getHasColor() const { return mColors.size() > 0 || mMeshType & HasColor; }
|
||||
U32 getHasTVert2() const { return mTverts2.size() > 0 || mMeshType & HasTVert2; }
|
||||
void setFlags(U32 flag) { mMeshType |= flag; }
|
||||
void clearFlags(U32 flag) { mMeshType &= ~flag; }
|
||||
U32 getFlags( U32 flag = 0xFFFFFFFF ) const { return mMeshType & flag; }
|
||||
|
||||
const Point3F* getNormals( S32 firstVert );
|
||||
|
||||
|
|
@ -319,34 +319,34 @@ protected:
|
|||
/// @name Vertex data
|
||||
/// @{
|
||||
|
||||
FreeableVector<Point3F> verts;
|
||||
FreeableVector<Point3F> norms;
|
||||
FreeableVector<Point2F> tverts;
|
||||
FreeableVector<Point4F> tangents;
|
||||
FreeableVector<Point3F> mVerts;
|
||||
FreeableVector<Point3F> mNorms;
|
||||
FreeableVector<Point2F> mTverts;
|
||||
FreeableVector<Point4F> mTangents;
|
||||
|
||||
// Optional second texture uvs.
|
||||
FreeableVector<Point2F> tverts2;
|
||||
FreeableVector<Point2F> mTverts2;
|
||||
|
||||
// Optional vertex colors data.
|
||||
FreeableVector<ColorI> colors;
|
||||
FreeableVector<ColorI> mColors;
|
||||
/// @}
|
||||
|
||||
Vector<TSDrawPrimitive> primitives;
|
||||
Vector<U8> encodedNorms;
|
||||
Vector<TSDrawPrimitive> mPrimitives;
|
||||
Vector<U8> mEncodedNorms;
|
||||
Vector<U32> mIndices;
|
||||
|
||||
/// billboard data
|
||||
Point3F billboardAxis;
|
||||
Point3F mBillboardAxis;
|
||||
|
||||
/// @name Convex Hull Data
|
||||
/// Convex hulls are convex (no angles >= 180º) meshes used for collision
|
||||
/// @{
|
||||
|
||||
Vector<Point3F> planeNormals;
|
||||
Vector<F32> planeConstants;
|
||||
Vector<U32> planeMaterials;
|
||||
S32 planesPerFrame;
|
||||
U32 mergeBufferStart;
|
||||
Vector<Point3F> mPlaneNormals;
|
||||
Vector<F32> mPlaneConstants;
|
||||
Vector<U32> mPlaneMaterials;
|
||||
S32 mPlanesPerFrame;
|
||||
U32 mMergeBufferStart;
|
||||
/// @}
|
||||
|
||||
/// @name Render Methods
|
||||
|
|
|
|||
|
|
@ -246,9 +246,9 @@ void MeshFit::addSourceMesh( const TSShape::Object& obj, const TSMesh* mesh )
|
|||
{
|
||||
// Add indices
|
||||
S32 indicesBase = mIndices.size();
|
||||
for ( S32 i = 0; i < mesh->primitives.size(); i++ )
|
||||
for ( S32 i = 0; i < mesh->mPrimitives.size(); i++ )
|
||||
{
|
||||
const TSDrawPrimitive& draw = mesh->primitives[i];
|
||||
const TSDrawPrimitive& draw = mesh->mPrimitives[i];
|
||||
if ( (draw.matIndex & TSDrawPrimitive::TypeMask) == TSDrawPrimitive::Triangles )
|
||||
{
|
||||
mIndices.merge( &mesh->mIndices[draw.start], draw.numElements );
|
||||
|
|
@ -282,7 +282,7 @@ void MeshFit::addSourceMesh( const TSShape::Object& obj, const TSMesh* mesh )
|
|||
S32 count, stride;
|
||||
U8* pVert;
|
||||
|
||||
if ( mesh->mVertexData.isReady() && mesh->verts.size() == 0 )
|
||||
if ( mesh->mVertexData.isReady() && mesh->mVerts.size() == 0 )
|
||||
{
|
||||
count = mesh->mVertexData.size();
|
||||
stride = mesh->mVertexData.vertSize();
|
||||
|
|
@ -290,9 +290,9 @@ void MeshFit::addSourceMesh( const TSShape::Object& obj, const TSMesh* mesh )
|
|||
}
|
||||
else
|
||||
{
|
||||
count = mesh->verts.size();
|
||||
count = mesh->mVerts.size();
|
||||
stride = sizeof(Point3F);
|
||||
pVert = (U8*)mesh->verts.address();
|
||||
pVert = (U8*)mesh->mVerts.address();
|
||||
}
|
||||
|
||||
MatrixF objMat;
|
||||
|
|
@ -337,12 +337,12 @@ TSMesh* MeshFit::createTriMesh( F32* verts, S32 numVerts, U32* indices, S32 numT
|
|||
mesh->mIndices.push_back( indices[i*3 + 1] );
|
||||
}
|
||||
|
||||
mesh->verts.set( verts, numVerts );
|
||||
mesh->mVerts.set( verts, numVerts );
|
||||
|
||||
// Compute mesh normals
|
||||
mesh->norms.setSize( mesh->verts.size() );
|
||||
for (S32 iNorm = 0; iNorm < mesh->norms.size(); iNorm++)
|
||||
mesh->norms[iNorm] = Point3F::Zero;
|
||||
mesh->mNorms.setSize( mesh->mVerts.size() );
|
||||
for (S32 iNorm = 0; iNorm < mesh->mNorms.size(); iNorm++)
|
||||
mesh->mNorms[iNorm] = Point3F::Zero;
|
||||
|
||||
// Sum triangle normals for each vertex
|
||||
for (S32 iInd = 0; iInd < mesh->mIndices.size(); iInd += 3)
|
||||
|
|
@ -352,38 +352,38 @@ TSMesh* MeshFit::createTriMesh( F32* verts, S32 numVerts, U32* indices, S32 numT
|
|||
S32 idx1 = mesh->mIndices[iInd + 1];
|
||||
S32 idx2 = mesh->mIndices[iInd + 2];
|
||||
|
||||
const Point3F& v0 = mesh->verts[idx0];
|
||||
const Point3F& v1 = mesh->verts[idx1];
|
||||
const Point3F& v2 = mesh->verts[idx2];
|
||||
const Point3F& v0 = mesh->mVerts[idx0];
|
||||
const Point3F& v1 = mesh->mVerts[idx1];
|
||||
const Point3F& v2 = mesh->mVerts[idx2];
|
||||
|
||||
Point3F n;
|
||||
mCross(v2 - v0, v1 - v0, &n);
|
||||
n.normalize(); // remove this to use 'weighted' normals (large triangles will have more effect)
|
||||
|
||||
mesh->norms[idx0] += n;
|
||||
mesh->norms[idx1] += n;
|
||||
mesh->norms[idx2] += n;
|
||||
mesh->mNorms[idx0] += n;
|
||||
mesh->mNorms[idx1] += n;
|
||||
mesh->mNorms[idx2] += n;
|
||||
}
|
||||
|
||||
// Normalize the vertex normals (this takes care of averaging the triangle normals)
|
||||
for (S32 iNorm = 0; iNorm < mesh->norms.size(); iNorm++)
|
||||
mesh->norms[iNorm].normalize();
|
||||
for (S32 iNorm = 0; iNorm < mesh->mNorms.size(); iNorm++)
|
||||
mesh->mNorms[iNorm].normalize();
|
||||
|
||||
// Set some dummy UVs
|
||||
mesh->tverts.setSize( numVerts );
|
||||
for ( S32 j = 0; j < mesh->tverts.size(); j++ )
|
||||
mesh->tverts[j].set( 0, 0 );
|
||||
mesh->mTverts.setSize( numVerts );
|
||||
for ( S32 j = 0; j < mesh->mTverts.size(); j++ )
|
||||
mesh->mTverts[j].set( 0, 0 );
|
||||
|
||||
// Add a single triangle-list primitive
|
||||
mesh->primitives.increment();
|
||||
mesh->primitives.last().start = 0;
|
||||
mesh->primitives.last().numElements = mesh->mIndices.size();
|
||||
mesh->primitives.last().matIndex = TSDrawPrimitive::Triangles |
|
||||
mesh->mPrimitives.increment();
|
||||
mesh->mPrimitives.last().start = 0;
|
||||
mesh->mPrimitives.last().numElements = mesh->mIndices.size();
|
||||
mesh->mPrimitives.last().matIndex = TSDrawPrimitive::Triangles |
|
||||
TSDrawPrimitive::Indexed |
|
||||
TSDrawPrimitive::NoMaterial;
|
||||
|
||||
mesh->createTangents( mesh->verts, mesh->norms );
|
||||
mesh->encodedNorms.set( NULL,0 );
|
||||
mesh->createTangents( mesh->mVerts, mesh->mNorms);
|
||||
mesh->mEncodedNorms.set( NULL,0 );
|
||||
|
||||
return mesh;
|
||||
}
|
||||
|
|
@ -404,13 +404,13 @@ void MeshFit::addBox( const Point3F& sides, const MatrixF& mat )
|
|||
if ( !mesh )
|
||||
return;
|
||||
|
||||
if (mesh->verts.size() > 0)
|
||||
if (mesh->mVerts.size() > 0)
|
||||
{
|
||||
for (S32 i = 0; i < mesh->verts.size(); i++)
|
||||
for (S32 i = 0; i < mesh->mVerts.size(); i++)
|
||||
{
|
||||
Point3F v = mesh->verts[i];
|
||||
Point3F v = mesh->mVerts[i];
|
||||
v.convolve(sides);
|
||||
mesh->verts[i] = v;
|
||||
mesh->mVerts[i] = v;
|
||||
}
|
||||
|
||||
mesh->mVertexData.setReady(false);
|
||||
|
|
@ -799,7 +799,7 @@ DefineTSShapeConstructorMethod( addPrimitive, bool, ( const char* meshName, cons
|
|||
MatrixF mat( txfm.getMatrix() );
|
||||
|
||||
// Transform the mesh vertices
|
||||
if ( mesh->mVertexData.isReady() && mesh->verts.size() == 0 )
|
||||
if ( mesh->mVertexData.isReady() && mesh->mVerts.size() == 0 )
|
||||
{
|
||||
for (S32 i = 0; i < mesh->mVertexData.size(); i++)
|
||||
{
|
||||
|
|
@ -811,10 +811,10 @@ DefineTSShapeConstructorMethod( addPrimitive, bool, ( const char* meshName, cons
|
|||
}
|
||||
else
|
||||
{
|
||||
for (S32 i = 0; i < mesh->verts.size(); i++)
|
||||
for (S32 i = 0; i < mesh->mVerts.size(); i++)
|
||||
{
|
||||
Point3F v(mesh->verts[i]);
|
||||
mat.mulP( v, &mesh->verts[i] );
|
||||
Point3F v(mesh->mVerts[i]);
|
||||
mat.mulP( v, &mesh->mVerts[i] );
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -592,11 +592,11 @@ void TSShape::initObjects()
|
|||
|
||||
if (mesh->mParentMesh >= 0 && mesh->mParentMesh < meshes.size())
|
||||
{
|
||||
mesh->parentMeshObject = meshes[mesh->mParentMesh];
|
||||
mesh->mParentMeshObject = meshes[mesh->mParentMesh];
|
||||
}
|
||||
else
|
||||
{
|
||||
mesh->parentMeshObject = NULL;
|
||||
mesh->mParentMeshObject = NULL;
|
||||
}
|
||||
|
||||
mesh->mVertexFormat = &mVertexFormat;
|
||||
|
|
@ -623,7 +623,7 @@ void TSShape::initVertexBuffers()
|
|||
continue;
|
||||
|
||||
destIndices += mesh->mIndices.size();
|
||||
destPrims += mesh->primitives.size();
|
||||
destPrims += mesh->mPrimitives.size();
|
||||
}
|
||||
|
||||
// For HW skinning we can just use the static buffer
|
||||
|
|
@ -660,14 +660,14 @@ void TSShape::initVertexBuffers()
|
|||
AssertFatal(mesh->mVertOffset / mVertexSize == vertStart, "offset mismatch");
|
||||
|
||||
vertStart += mesh->mNumVerts;
|
||||
primStart += mesh->primitives.size();
|
||||
primStart += mesh->mPrimitives.size();
|
||||
indStart += mesh->mIndices.size();
|
||||
|
||||
mesh->mVB = mShapeVertexBuffer;
|
||||
mesh->mPB = mShapeVertexIndices;
|
||||
|
||||
// Advance
|
||||
piInput += mesh->primitives.size();
|
||||
piInput += mesh->mPrimitives.size();
|
||||
ibIndices += mesh->mIndices.size();
|
||||
|
||||
if (TSSkinMesh::smDebugSkinVerts && mesh->getMeshType() == TSMesh::SkinMeshType)
|
||||
|
|
@ -906,12 +906,12 @@ void TSShape::initVertexFeatures()
|
|||
mesh->mVertexData.setReady(true);
|
||||
|
||||
#ifdef TORQUE_DEBUG
|
||||
AssertFatal(mesh->mNumVerts == mesh->verts.size(), "vert mismatch");
|
||||
AssertFatal(mesh->mNumVerts == mesh->mVerts.size(), "vert mismatch");
|
||||
for (U32 i = 0; i < mesh->mNumVerts; i++)
|
||||
{
|
||||
Point3F v1 = mesh->verts[i];
|
||||
Point3F v1 = mesh->mVerts[i];
|
||||
Point3F v2 = mesh->mVertexData.getBase(i).vert();
|
||||
AssertFatal(mesh->verts[i] == mesh->mVertexData.getBase(i).vert(), "vert data mismatch");
|
||||
AssertFatal(mesh->mVerts[i] == mesh->mVertexData.getBase(i).vert(), "vert data mismatch");
|
||||
}
|
||||
|
||||
if (mesh->getMeshType() == TSMesh::SkinMeshType)
|
||||
|
|
@ -987,11 +987,11 @@ void TSShape::initMaterialList()
|
|||
if (!mesh)
|
||||
continue;
|
||||
|
||||
for (k=0; k<mesh->primitives.size(); k++)
|
||||
for (k=0; k<mesh->mPrimitives.size(); k++)
|
||||
{
|
||||
if (mesh->primitives[k].matIndex & TSDrawPrimitive::NoMaterial)
|
||||
if (mesh->mPrimitives[k].matIndex & TSDrawPrimitive::NoMaterial)
|
||||
continue;
|
||||
S32 flags = materialList->getFlags(mesh->primitives[k].matIndex & TSDrawPrimitive::MaterialMask);
|
||||
S32 flags = materialList->getFlags(mesh->mPrimitives[k].matIndex & TSDrawPrimitive::MaterialMask);
|
||||
if (flags & TSMaterialList::AuxiliaryMap)
|
||||
continue;
|
||||
if (flags & TSMaterialList::Translucent)
|
||||
|
|
@ -1001,7 +1001,7 @@ void TSShape::initMaterialList()
|
|||
break;
|
||||
}
|
||||
}
|
||||
if (k!=mesh->primitives.size())
|
||||
if (k!=mesh->mPrimitives.size())
|
||||
break;
|
||||
}
|
||||
if (j!=obj.numMeshes)
|
||||
|
|
@ -1521,15 +1521,15 @@ void TSShape::assembleShape()
|
|||
// fill in location of verts, tverts, and normals for detail levels
|
||||
if (mesh && meshType!=TSMesh::DecalMeshType)
|
||||
{
|
||||
TSMesh::smVertsList[i] = mesh->verts.address();
|
||||
TSMesh::smTVertsList[i] = mesh->tverts.address();
|
||||
TSMesh::smVertsList[i] = mesh->mVerts.address();
|
||||
TSMesh::smTVertsList[i] = mesh->mTverts.address();
|
||||
if (smReadVersion >= 26)
|
||||
{
|
||||
TSMesh::smTVerts2List[i] = mesh->tverts2.address();
|
||||
TSMesh::smColorsList[i] = mesh->colors.address();
|
||||
TSMesh::smTVerts2List[i] = mesh->mTverts2.address();
|
||||
TSMesh::smColorsList[i] = mesh->mColors.address();
|
||||
}
|
||||
TSMesh::smNormsList[i] = mesh->norms.address();
|
||||
TSMesh::smEncodedNormsList[i] = mesh->encodedNorms.address();
|
||||
TSMesh::smNormsList[i] = mesh->mNorms.address();
|
||||
TSMesh::smEncodedNormsList[i] = mesh->mEncodedNorms.address();
|
||||
TSMesh::smDataCopied[i] = !skip; // as long as we didn't skip this mesh, the data should be in shape now
|
||||
if (meshType==TSMesh::SkinMeshType)
|
||||
{
|
||||
|
|
@ -1617,9 +1617,9 @@ void TSShape::assembleShape()
|
|||
if (skin)
|
||||
{
|
||||
TSMesh::smVertsList[i] = skin->batchData.initialVerts.address();
|
||||
TSMesh::smTVertsList[i] = skin->tverts.address();
|
||||
TSMesh::smTVertsList[i] = skin->mTverts.address();
|
||||
TSMesh::smNormsList[i] = skin->batchData.initialNorms.address();
|
||||
TSMesh::smEncodedNormsList[i] = skin->encodedNorms.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();
|
||||
|
|
@ -1805,15 +1805,15 @@ bool TSShape::canWriteOldFormat() const
|
|||
continue;
|
||||
|
||||
// Cannot use old format if using the new functionality (COLORs, 2nd UV set)
|
||||
if (meshes[i]->tverts2.size() || meshes[i]->colors.size())
|
||||
if (meshes[i]->mTverts2.size() || meshes[i]->mColors.size())
|
||||
return false;
|
||||
|
||||
// Cannot use old format if any primitive has too many triangles
|
||||
// (ie. cannot fit in a S16)
|
||||
for (S32 j = 0; j < meshes[i]->primitives.size(); j++)
|
||||
for (S32 j = 0; j < meshes[i]->mPrimitives.size(); j++)
|
||||
{
|
||||
if ((meshes[i]->primitives[j].start +
|
||||
meshes[i]->primitives[j].numElements) >= (1 << 15))
|
||||
if ((meshes[i]->mPrimitives[j].start +
|
||||
meshes[i]->mPrimitives[j].numElements) >= (1 << 15))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1340,7 +1340,7 @@ DefineTSShapeConstructorMethod( getMeshMaterial, const char*, ( const char* name
|
|||
GET_MESH( getMeshMaterial, mesh, name, "" );
|
||||
|
||||
// Return the name of the first material attached to this mesh
|
||||
S32 matIndex = mesh->primitives[0].matIndex & TSDrawPrimitive::MaterialMask;
|
||||
S32 matIndex = mesh->mPrimitives[0].matIndex & TSDrawPrimitive::MaterialMask;
|
||||
if ((matIndex >= 0) && (matIndex < mShape->materialList->size()))
|
||||
return mShape->materialList->getMaterialName( matIndex );
|
||||
else
|
||||
|
|
@ -1377,10 +1377,10 @@ DefineTSShapeConstructorMethod( setMeshMaterial, bool, ( const char* meshName, c
|
|||
}
|
||||
|
||||
// Set this material for all primitives in the mesh
|
||||
for ( S32 i = 0; i < mesh->primitives.size(); i++ )
|
||||
for ( S32 i = 0; i < mesh->mPrimitives.size(); i++ )
|
||||
{
|
||||
U32 matType = mesh->primitives[i].matIndex & ( TSDrawPrimitive::TypeMask | TSDrawPrimitive::Indexed );
|
||||
mesh->primitives[i].matIndex = ( matType | matIndex );
|
||||
U32 matType = mesh->mPrimitives[i].matIndex & ( TSDrawPrimitive::TypeMask | TSDrawPrimitive::Indexed );
|
||||
mesh->mPrimitives[i].matIndex = ( matType | matIndex );
|
||||
}
|
||||
|
||||
ADD_TO_CHANGE_SET();
|
||||
|
|
|
|||
|
|
@ -938,7 +938,7 @@ TSMesh* TSShape::copyMesh( const TSMesh* srcMesh ) const
|
|||
|
||||
// Copy mesh elements
|
||||
mesh->mIndices = srcMesh->mIndices;
|
||||
mesh->primitives = srcMesh->primitives;
|
||||
mesh->mPrimitives = srcMesh->mPrimitives;
|
||||
mesh->numFrames = srcMesh->numFrames;
|
||||
mesh->numMatFrames = srcMesh->numMatFrames;
|
||||
mesh->vertsPerFrame = srcMesh->vertsPerFrame;
|
||||
|
|
@ -948,8 +948,8 @@ TSMesh* TSShape::copyMesh( const TSMesh* srcMesh ) const
|
|||
// Copy vertex data in an *unpacked* form
|
||||
mesh->copySourceVertexDataFrom(srcMesh);
|
||||
|
||||
mesh->createTangents(mesh->verts, mesh->norms);
|
||||
mesh->encodedNorms.set(NULL, 0);
|
||||
mesh->createTangents(mesh->mVerts, mesh->mNorms);
|
||||
mesh->mEncodedNorms.set(NULL, 0);
|
||||
|
||||
mesh->computeBounds();
|
||||
|
||||
|
|
@ -1108,12 +1108,12 @@ bool TSShape::addMesh(TSShape* srcShape, const String& srcMeshName, const String
|
|||
// Copy materials used by the source mesh (only if from a different shape)
|
||||
if (srcShape != this)
|
||||
{
|
||||
for (S32 i = 0; i < mesh->primitives.size(); i++)
|
||||
for (S32 i = 0; i < mesh->mPrimitives.size(); i++)
|
||||
{
|
||||
if (!(mesh->primitives[i].matIndex & TSDrawPrimitive::NoMaterial))
|
||||
if (!(mesh->mPrimitives[i].matIndex & TSDrawPrimitive::NoMaterial))
|
||||
{
|
||||
S32 drawType = (mesh->primitives[i].matIndex & (~TSDrawPrimitive::MaterialMask));
|
||||
S32 srcMatIndex = mesh->primitives[i].matIndex & TSDrawPrimitive::MaterialMask;
|
||||
S32 drawType = (mesh->mPrimitives[i].matIndex & (~TSDrawPrimitive::MaterialMask));
|
||||
S32 srcMatIndex = mesh->mPrimitives[i].matIndex & TSDrawPrimitive::MaterialMask;
|
||||
const String& matName = srcShape->materialList->getMaterialName(srcMatIndex);
|
||||
|
||||
// Add the material if it does not already exist
|
||||
|
|
@ -1124,7 +1124,7 @@ bool TSShape::addMesh(TSShape* srcShape, const String& srcMeshName, const String
|
|||
materialList->push_back(matName, srcShape->materialList->getFlags(srcMatIndex));
|
||||
}
|
||||
|
||||
mesh->primitives[i].matIndex = drawType | destMatIndex;
|
||||
mesh->mPrimitives[i].matIndex = drawType | destMatIndex;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -86,10 +86,10 @@ S32 TSSortedMesh::getNumPolys()
|
|||
Cluster & cluster = clusters[cIdx];
|
||||
for (S32 i=cluster.startPrimitive; i<cluster.endPrimitive; i++)
|
||||
{
|
||||
if (primitives[i].matIndex & TSDrawPrimitive::Triangles)
|
||||
count += primitives[i].numElements / 3;
|
||||
if (mPrimitives[i].matIndex & TSDrawPrimitive::Triangles)
|
||||
count += mPrimitives[i].numElements / 3;
|
||||
else
|
||||
count += primitives[i].numElements - 2;
|
||||
count += mPrimitives[i].numElements - 2;
|
||||
}
|
||||
cIdx = cluster.frontCluster; // always use frontCluster...we assume about the same no matter what
|
||||
}
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@ public:
|
|||
void disassemble();
|
||||
|
||||
TSSortedMesh() {
|
||||
meshType = SortedMeshType;
|
||||
mMeshType = SortedMeshType;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue