1524 lines
45 KiB
C++
Executable File
1524 lines
45 KiB
C++
Executable File
//-----------------------------------------------------------------------------
|
|
// Torque Game Engine
|
|
// Copyright (C) GarageGames.com, Inc.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#include "ts/tsShape.h"
|
|
#include "ts/tsShapeInstance.h"
|
|
|
|
// methods in this file are used for reading pre-version 19 shapes
|
|
// methods for reading/writing sequences still used...
|
|
|
|
#define OldPageSize 25000 // old page size must be mutliple of 4 so that we can always "over-read" up to next dword
|
|
|
|
struct OldAlloc
|
|
{
|
|
static S32 sz32;
|
|
static S32 cnt32;
|
|
|
|
static S32 sz16;
|
|
static S32 cnt16;
|
|
|
|
static S32 sz8;
|
|
static S32 cnt8;
|
|
|
|
static S32 guard32;
|
|
static S16 guard16;
|
|
static S8 guard8;
|
|
};
|
|
|
|
S32 OldAlloc::sz32;
|
|
S32 OldAlloc::cnt32;
|
|
S32 OldAlloc::sz16;
|
|
S32 OldAlloc::cnt16;
|
|
S32 OldAlloc::sz8;
|
|
S32 OldAlloc::cnt8;
|
|
S32 OldAlloc::guard32;
|
|
S16 OldAlloc::guard16;
|
|
S8 OldAlloc::guard8;
|
|
|
|
S32 getDWordCount32()
|
|
{
|
|
return OldAlloc::cnt32;
|
|
}
|
|
|
|
S32 getDWordCount16()
|
|
{
|
|
if (OldAlloc::cnt16&1)
|
|
return (OldAlloc::cnt16+2) >> 1;
|
|
else
|
|
return OldAlloc::cnt16 >> 1;
|
|
}
|
|
|
|
S32 getDWordCount8()
|
|
{
|
|
if (OldAlloc::cnt8&3)
|
|
return (OldAlloc::cnt8+4) >> 2;
|
|
else
|
|
return OldAlloc::cnt8 >> 2;
|
|
}
|
|
|
|
S32 * oldInitAlloc32()
|
|
{
|
|
OldAlloc::sz32 = 0;
|
|
OldAlloc::cnt32 = 0;
|
|
OldAlloc::guard32 = 0;
|
|
return NULL;
|
|
}
|
|
|
|
S16 * oldInitAlloc16()
|
|
{
|
|
OldAlloc::sz16 = 0;
|
|
OldAlloc::cnt16 = 0;
|
|
OldAlloc::guard16 = 0;
|
|
return NULL;
|
|
}
|
|
|
|
S8 * oldInitAlloc8()
|
|
{
|
|
OldAlloc::sz8= 0;
|
|
OldAlloc::cnt8 = 0;
|
|
OldAlloc::guard8 = 0;
|
|
return NULL;
|
|
}
|
|
|
|
S32 oldAllocOffset(S32 *)
|
|
{
|
|
return OldAlloc::cnt32;
|
|
}
|
|
|
|
S32 oldAllocOffset(S16 *)
|
|
{
|
|
return OldAlloc::cnt16;
|
|
}
|
|
|
|
S8 * oldAlloc(S32 * & addr, S32 count)
|
|
{
|
|
if (OldAlloc::cnt32+count>OldAlloc::sz32)
|
|
{
|
|
S32 numPages = 1+((OldAlloc::cnt32+count)/OldPageSize);
|
|
OldAlloc::sz32 = numPages * OldPageSize;
|
|
S32 * tmp = new S32[OldAlloc::sz32];
|
|
if (addr)
|
|
dMemcpy((U8*)tmp,(U8*)addr,OldAlloc::cnt32*sizeof(U32));
|
|
delete [] addr;
|
|
addr = tmp;
|
|
}
|
|
S8 * ret = (S8*) &addr[OldAlloc::cnt32];
|
|
OldAlloc::cnt32 += count;
|
|
return ret;
|
|
}
|
|
|
|
S8 * oldAlloc(S16 * & addr, S32 count)
|
|
{
|
|
if (OldAlloc::cnt16+count>OldAlloc::sz16)
|
|
{
|
|
S32 numPages = 1+((OldAlloc::cnt16+count)/OldPageSize);
|
|
OldAlloc::sz16 = numPages * OldPageSize;
|
|
S16 * tmp = new S16[OldAlloc::sz16];
|
|
if (addr)
|
|
dMemcpy((U8*)tmp,(U8*)addr,OldAlloc::cnt16*sizeof(S16));
|
|
delete [] addr;
|
|
addr = tmp;
|
|
}
|
|
S8 * ret = (S8*) &addr[OldAlloc::cnt16];
|
|
OldAlloc::cnt16 += count;
|
|
return ret;
|
|
}
|
|
|
|
S8 * oldAlloc(S8 * & addr, S32 count)
|
|
{
|
|
if (OldAlloc::cnt8+count>OldAlloc::sz8)
|
|
{
|
|
S32 numPages = 1+((OldAlloc::cnt8+count)/OldPageSize);
|
|
OldAlloc::sz8 = numPages * OldPageSize;
|
|
S8 * tmp = new S8[OldAlloc::sz8];
|
|
if (addr)
|
|
dMemcpy((U8*)tmp,(U8*)addr,OldAlloc::cnt8);
|
|
delete [] addr;
|
|
addr = tmp;
|
|
}
|
|
S8 * ret = (S8*) &addr[OldAlloc::cnt8];
|
|
OldAlloc::cnt8 += count;
|
|
return ret;
|
|
}
|
|
|
|
S32 readAlloc32(Stream * s, S32 * & memBuffer32)
|
|
{
|
|
S32 tmp;
|
|
s->read(sizeof(tmp),(U8*)&tmp); // this won't flip, which is perfect.
|
|
U32 * ptr = (U32*)oldAlloc(memBuffer32,1);
|
|
*ptr = tmp;
|
|
return (S32)convertLEndianToHost(tmp); // return flipped value for use.
|
|
}
|
|
|
|
S32 readAlloc32(Stream * s, S32 & storage)
|
|
{
|
|
S32 tmp;
|
|
s->read(sizeof(tmp),(U8*)&tmp); // this won't flip, which is perfect.
|
|
storage = tmp;
|
|
return (S32)convertLEndianToHost(tmp); // return flipped value
|
|
}
|
|
|
|
void readAlloc(Stream * s, S32 * & memBuffer32, S32 size)
|
|
{
|
|
s->read(sizeof(S32)*size,oldAlloc(memBuffer32,size));
|
|
}
|
|
|
|
void readAlloc(Stream * s, S16 * & memBuffer16, S32 size)
|
|
{
|
|
s->read(sizeof(S16)*size,oldAlloc(memBuffer16,size));
|
|
}
|
|
|
|
void readAlloc(Stream * s, S8 * & memBuffer8, S32 size)
|
|
{
|
|
s->read(sizeof(S8)*size,oldAlloc(memBuffer8,size));
|
|
}
|
|
|
|
void oldAllocGuard(S32 * & addr32, S16 * & addr16, S8 * & addr8)
|
|
{
|
|
S32 * ptr32 = (S32*)oldAlloc(addr32,1);
|
|
*ptr32 = convertLEndianToHost(OldAlloc::guard32++); // flip, since tsShape will expect it.
|
|
|
|
S16 * ptr16 = (S16*)oldAlloc(addr16,1);
|
|
*ptr16 = convertLEndianToHost(OldAlloc::guard16++); // flip, since tsShape will expect it.
|
|
|
|
S8 * ptr8 = (S8*)oldAlloc(addr8,1);
|
|
*ptr8 = OldAlloc::guard8++;
|
|
}
|
|
|
|
#define DebugGuard() oldAllocGuard(memBuffer32,memBuffer16,memBuffer8)
|
|
|
|
void readAllocMesh(Stream * s, S32 * & memBuffer32, S16 * & memBuffer16, S8 * & memBuffer8, U32 meshType)
|
|
{
|
|
memBuffer8;
|
|
|
|
if (meshType==TSMesh::NullMeshType)
|
|
return;
|
|
|
|
// standard mesh read
|
|
|
|
DebugGuard();
|
|
|
|
// numFrames, numMatFrames
|
|
readAlloc(s,memBuffer32,2);
|
|
|
|
// parent mesh
|
|
S32 * ptr32 = (S32*)oldAlloc(memBuffer32,1);
|
|
*ptr32 = convertLEndianToHost(-1); // flip, since tsShape will flip back.
|
|
|
|
// allocate memory for mBounds,mCenter, and mRadius...just filler, will be computed later
|
|
oldAlloc(memBuffer32,10);
|
|
|
|
// read in verts
|
|
S32 sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz*3);
|
|
|
|
// read in tverts
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz*2);
|
|
|
|
// read in normals
|
|
s->read(&sz); // we could assume same as verts, but apparently in file.
|
|
readAlloc(s,memBuffer32,sz*3);
|
|
|
|
// read in primitives
|
|
sz = readAlloc32(s,memBuffer32);
|
|
if (TSShape::smReadVersion<18)
|
|
{
|
|
for (S32 j=0; j<sz; j++)
|
|
{
|
|
S32 a,b;
|
|
s->read(&a);
|
|
s->read(&b);
|
|
U16 * ptr16 = (U16*)oldAlloc(memBuffer16,2);
|
|
ptr16[0]=convertLEndianToHost((S16)a); // flip, since tsShape will flip back.
|
|
ptr16[1]=convertLEndianToHost((S16)b); // flip, since tsShape will flip back.
|
|
readAlloc32(s,memBuffer32);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (S32 j=0; j<sz; j++)
|
|
{
|
|
readAlloc(s,memBuffer16,2);
|
|
readAlloc(s,memBuffer32,1);
|
|
}
|
|
}
|
|
|
|
// read in indices
|
|
sz = readAlloc32(s,memBuffer32);
|
|
if (TSShape::smReadVersion<18)
|
|
{
|
|
U32 idx;
|
|
U16 * idxPtr = (U16*)oldAlloc(memBuffer16,sz);
|
|
for (S32 j=0;j<sz;j++)
|
|
{
|
|
s->read(sizeof(idx),(U8*)&idx);
|
|
idxPtr[j]=(U16)idx;
|
|
}
|
|
}
|
|
else
|
|
readAlloc(s,memBuffer16,sz);
|
|
|
|
// mergeIndices...none
|
|
ptr32 = (S32*)oldAlloc(memBuffer32,1);
|
|
*ptr32 = convertLEndianToHost((S32)0);
|
|
|
|
// vertsPerFrame, flags
|
|
readAlloc(s,memBuffer32,2);
|
|
|
|
DebugGuard();
|
|
|
|
if (meshType==TSMesh::SkinMeshType)
|
|
{
|
|
// read in initial verts
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz*3);
|
|
|
|
// read in initial normals
|
|
s->read(&sz); // we assume same as verts
|
|
readAlloc(s,memBuffer32,sz*3);
|
|
|
|
// read in initial transforms
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz*16);
|
|
|
|
// read in vertexIndx
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz);
|
|
|
|
// read in boneIndex
|
|
s->read(&sz); // toss
|
|
readAlloc(s,memBuffer32,sz);
|
|
|
|
// read in nodeIndex -- but let's move it...
|
|
// vertexIndex, boneIndex, and weight have same # of entries
|
|
// nodeIndex is different (it's number of bones)
|
|
// first allocate room for weights, then read in nodeIndex list
|
|
S32 weightStart = oldAllocOffset(memBuffer32);
|
|
oldAlloc(memBuffer32,sz); // this is memory for the weights
|
|
|
|
// actually read in node index
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz); // read in nodeIndex array
|
|
|
|
// read in weight
|
|
s->read(&sz); // toss
|
|
F32 * ptr32 = (F32*)(memBuffer32 + weightStart);
|
|
for (S32 i=0; i<sz; i++)
|
|
s->read(sizeof(F32),(U8*)(ptr32+i));
|
|
|
|
DebugGuard();
|
|
}
|
|
if (meshType==TSMesh::SortedMeshType)
|
|
{
|
|
// clusters...
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz*8);
|
|
|
|
// start cluster...
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz);
|
|
|
|
// firstVert...
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz);
|
|
|
|
// numVerts...
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz);
|
|
|
|
// firstTVerts...
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz);
|
|
|
|
// always write z-depth?
|
|
bool alwaysWriteZ;
|
|
s->read(&alwaysWriteZ);
|
|
S32 * ptr32 = (S32*) oldAlloc(memBuffer32,1);
|
|
*ptr32 = alwaysWriteZ ? convertLEndianToHost(1) : convertLEndianToHost(0); // flip, since tsShape will flip back.
|
|
|
|
DebugGuard();
|
|
}
|
|
if (meshType==TSMesh::DecalMeshType)
|
|
{
|
|
// startPrimitive...
|
|
sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz);
|
|
|
|
if (TSShape::smReadVersion>=17)
|
|
{
|
|
// obsolete, so we read it all, but throw it all away.
|
|
|
|
// startTVerts...
|
|
s->read(&sz);
|
|
S32 tmp;
|
|
while (sz--)
|
|
s->read(&tmp);
|
|
|
|
// tvertIndex...
|
|
s->read(&sz);
|
|
while (sz--)
|
|
s->read(&tmp);
|
|
}
|
|
|
|
// materialIndex...
|
|
readAlloc32(s,memBuffer32);
|
|
|
|
DebugGuard();
|
|
}
|
|
}
|
|
|
|
// versioning hack...
|
|
Vector<S32> kfStart(__FILE__, __LINE__);
|
|
|
|
// NOTE: with version 17 and on there are no more keyframes...kept around for reading old shapes
|
|
struct Keyframe
|
|
{
|
|
S32 firstNodeState;
|
|
S32 firstObjectState;
|
|
S32 firstDecalState;
|
|
|
|
void read(Stream * s) { s->read(&firstNodeState);s->read(&firstObjectState);s->read(&firstDecalState);}
|
|
void write(Stream * s) { s->write(firstNodeState);s->write(firstObjectState);s->write(firstDecalState);}
|
|
};
|
|
|
|
// read in and throw away
|
|
Vector<Keyframe> keyframes(__FILE__,__LINE__);
|
|
|
|
void TSShape::readOldShape(Stream * s,
|
|
S32 * & memBuffer32, S16 * & memBuffer16, S8 * & memBuffer8,
|
|
S32 & count32, S32 & count16, S32 & count8)
|
|
{
|
|
S32 i,tmp;
|
|
|
|
// first allocate some memory
|
|
memBuffer32 = oldInitAlloc32();
|
|
memBuffer16 = oldInitAlloc16();
|
|
memBuffer8 = oldInitAlloc8();
|
|
|
|
// allocate storage for vector counts
|
|
oldAlloc(memBuffer32,15);
|
|
// contents of memBuffer32 might change, but eventually these will go here...
|
|
// numNodes = memBuffer32[0];
|
|
// numObjects = memBuffer32[1];
|
|
// numDecals = memBuffer32[2];
|
|
// numSubShapes = memBuffer32[3];
|
|
// numIflMaterials = memBuffer32[4];
|
|
// numNodeStates = memBuffer32[5];
|
|
// numObjectStates = memBuffer32[6];
|
|
// numDecalStates = memBuffer32[7];
|
|
// numTriggers = memBuffer32[8];
|
|
// numDetails = memBuffer32[9];
|
|
// numMeshes = memBuffer32[10]
|
|
// numSkins = memBuffer32[11];
|
|
// numNames = memBuffer32[12];
|
|
// mSmalletVisibleSize = memBuffer32[13];
|
|
// mSmallestVisibleDL = memBuffer32[14];
|
|
|
|
DebugGuard();
|
|
|
|
// radius
|
|
readAlloc(s,memBuffer32,1);
|
|
// tube radius
|
|
readAlloc(s,memBuffer32,1);
|
|
// center
|
|
readAlloc(s,memBuffer32,3);
|
|
// bounds
|
|
readAlloc(s,memBuffer32,6);
|
|
|
|
DebugGuard();
|
|
|
|
S32 numNodes = readAlloc32(s,memBuffer32[0]);
|
|
S32 nodeStart = oldAllocOffset(memBuffer32);
|
|
if (smReadVersion>=17)
|
|
{
|
|
readAlloc(s,memBuffer32,numNodes*2);
|
|
// compute other 3 members at load time...
|
|
// for now, allocate the storage and move things around
|
|
oldAlloc(memBuffer32,numNodes*3);
|
|
S32 * pNodeStart = memBuffer32+nodeStart;
|
|
for (i=numNodes-1; i>=0; i--)
|
|
dMemmove(&pNodeStart[i*5],&pNodeStart[i*2],sizeof(S32)*2);
|
|
}
|
|
else
|
|
{
|
|
// handle obsolete (bool) member
|
|
for (i=0; i<numNodes; i++)
|
|
{
|
|
readAlloc(s,memBuffer32,2);
|
|
bool obsolete;
|
|
s->read(&obsolete);
|
|
oldAlloc(memBuffer32,3);
|
|
}
|
|
}
|
|
|
|
DebugGuard();
|
|
|
|
S32 numObjects = readAlloc32(s,memBuffer32[1]);
|
|
S32 objectStart = oldAllocOffset(memBuffer32);
|
|
readAlloc(s,memBuffer32,numObjects*4);
|
|
// compute other 2 members at load time...
|
|
// for now, allocate storage and move things around
|
|
oldAlloc(memBuffer32,numObjects*2);
|
|
S32 * pObjectStart = memBuffer32 + objectStart;
|
|
for (i=numObjects-1; i>=0; i--)
|
|
dMemmove(&pObjectStart[i*6],&pObjectStart[i*4],sizeof(S32)*4);
|
|
|
|
DebugGuard();
|
|
|
|
S32 numDecals = readAlloc32(s,memBuffer32[2]);
|
|
S32 decalStart = oldAllocOffset(memBuffer32);
|
|
readAlloc(s,memBuffer32,numDecals*4);
|
|
// compute other 1 member at load time...
|
|
// for now, allocate storage and move things around
|
|
oldAlloc(memBuffer32,numDecals);
|
|
S32 * pDecalStart = memBuffer32 + decalStart;
|
|
for (i=numDecals-1; i>=0; i--)
|
|
dMemmove(&pDecalStart[i*5],&pDecalStart[i*4],sizeof(S32)*4);
|
|
|
|
DebugGuard();
|
|
|
|
S32 numIflMaterials = readAlloc32(s,memBuffer32[4]);
|
|
S32 iflStart = oldAllocOffset(memBuffer32);
|
|
readAlloc(s,memBuffer32,numIflMaterials*2);
|
|
// compute other 3 members at load time...
|
|
// for now, allocate storage and move things around
|
|
oldAlloc(memBuffer32,numIflMaterials*3);
|
|
S32 * pIflStart = memBuffer32 + iflStart;
|
|
for (i=numIflMaterials-1; i>=0; i--)
|
|
dMemmove(&pIflStart[i*5],&pIflStart[i*2],sizeof(S32)*2);
|
|
|
|
DebugGuard();
|
|
|
|
S32 numSubShapes = readAlloc32(s,memBuffer32[3]);
|
|
S32 subShapeFirstStart = oldAllocOffset(memBuffer32);
|
|
readAlloc(s,memBuffer32,numSubShapes); // subShapeFirstNode
|
|
s->read(&tmp); // toss
|
|
readAlloc(s,memBuffer32,numSubShapes); // subShapeFirstObject
|
|
s->read(&tmp); // toss
|
|
readAlloc(s,memBuffer32,numSubShapes); // subShapeFirstDecal
|
|
|
|
DebugGuard();
|
|
|
|
S32 subShapeNumStart = oldAllocOffset(memBuffer32);
|
|
oldAlloc(memBuffer32,3*numSubShapes); // allocate memory for subShapeNum* vectors
|
|
|
|
DebugGuard();
|
|
|
|
// compute subShapeNum* vectors
|
|
S32 * pSubShapeFirstStart = memBuffer32+subShapeFirstStart;
|
|
S32 * pSubShapeNumStart = memBuffer32+subShapeNumStart;
|
|
S32 prev, first;
|
|
for (i=0; i<3; i++)
|
|
{
|
|
prev = ((i==0) ? numNodes : (i==1 ? numObjects : numDecals));
|
|
for (S32 j=numSubShapes-1; j>=0; j--)
|
|
{
|
|
first = convertLEndianToHost(pSubShapeFirstStart[j]); // flip to get value out
|
|
pSubShapeNumStart[j] = prev - first;
|
|
pSubShapeNumStart[j] = convertLEndianToHost(pSubShapeNumStart[j]); // flip to put value in.
|
|
prev = first;
|
|
}
|
|
pSubShapeFirstStart += numSubShapes;
|
|
pSubShapeNumStart += numSubShapes;
|
|
}
|
|
|
|
// if older than version 16, read in mesh index list for later use
|
|
if (smReadVersion<16)
|
|
{
|
|
S32 sz = readAlloc32(s,memBuffer32);
|
|
readAlloc(s,memBuffer32,sz); // this is the meshIndexList
|
|
}
|
|
|
|
// if older than version 17, read in keyframes for later use
|
|
// but don't add to shapes buffer because we'll be done with
|
|
// them on exit from this method
|
|
if (smReadVersion<17)
|
|
{
|
|
S32 sz;
|
|
s->read(&sz);
|
|
keyframes.setSize(sz);
|
|
for (i=0; i<sz; i++)
|
|
keyframes[i].read(s);
|
|
}
|
|
|
|
S32 numNodeStates = readAlloc32(s,memBuffer32[5]);
|
|
S32 nodeStateStart32 = oldAllocOffset(memBuffer32);
|
|
S32 nodeStateStart16 = oldAllocOffset(memBuffer16);
|
|
for (i=0;i<numNodeStates;i++)
|
|
{
|
|
readAlloc(s,memBuffer16,4); // read Quat16....rotation
|
|
readAlloc(s,memBuffer32,3); // read Point3F...translation
|
|
}
|
|
|
|
DebugGuard();
|
|
|
|
S32 numObjectStates = readAlloc32(s,memBuffer32[6]);
|
|
S32 objectStateStart = oldAllocOffset(memBuffer32);
|
|
readAlloc(s,memBuffer32,numObjectStates*3);
|
|
|
|
DebugGuard();
|
|
|
|
S32 numDecalStates = readAlloc32(s,memBuffer32[7]);
|
|
S32 decalStateStart = oldAllocOffset(memBuffer32);
|
|
if (smReadVersion<14)
|
|
{
|
|
// add in default decal state info
|
|
S32 * firstState = (S32*) oldAlloc(memBuffer32,numDecals);
|
|
for (i=0;i<numDecals;i++)
|
|
firstState[i]=convertLEndianToHost(-1);
|
|
}
|
|
readAlloc(s,memBuffer32,numDecalStates);
|
|
|
|
DebugGuard();
|
|
|
|
S32 numTriggers = readAlloc32(s,memBuffer32[8]);
|
|
readAlloc(s,memBuffer32,numTriggers*2);
|
|
|
|
DebugGuard();
|
|
|
|
S32 numDetails = readAlloc32(s,memBuffer32[9]);
|
|
S32 detailStart = oldAllocOffset(memBuffer32);
|
|
readAlloc(s,memBuffer32,numDetails*4);
|
|
// compute other 3 members at load time...
|
|
// for now, allocate storage and move things around
|
|
oldAlloc(memBuffer32,numDetails*3);
|
|
S32 * pDetailStart = memBuffer32 + detailStart;
|
|
for (i=numDetails-1; i>=0; i--)
|
|
dMemmove(&pDetailStart[i*7],&pDetailStart[i*4],4*sizeof(S32));
|
|
// now find the smallest renderable detail level and size
|
|
Detail * pd = (Detail*)pDetailStart;
|
|
memBuffer32[13] = 0; // initialize to something valid
|
|
memBuffer32[14] = 0; // initialize to something valid
|
|
for (i=0; i<numDetails; i++)
|
|
{
|
|
S32 dsize = (S32) convertLEndianToHost(pd[i].size);
|
|
if (dsize>=0.0f)
|
|
{
|
|
memBuffer32[13] = (S32)dsize;
|
|
memBuffer32[14] = i;
|
|
}
|
|
pd[i].maxError = convertLEndianToHost(-1.0f);
|
|
pd[i].averageError = convertLEndianToHost(-1.0f);
|
|
pd[i].polyCount = convertLEndianToHost(0);
|
|
}
|
|
|
|
DebugGuard();
|
|
|
|
// deal with sequences the old fashion way...
|
|
kfStart.clear(); // for older shapes...
|
|
S32 numSequences;
|
|
s->read(&numSequences);
|
|
sequences.setSize(numSequences);
|
|
for (i=0; i<numSequences; i++)
|
|
{
|
|
constructInPlace(&sequences[i]);
|
|
sequences[i].read(s);
|
|
}
|
|
|
|
// read meshes
|
|
S32 numMeshes = readAlloc32(s,memBuffer32[10]);
|
|
for (i=0; i<numMeshes; i++)
|
|
{
|
|
S32 meshType = readAlloc32(s,memBuffer32);
|
|
readAllocMesh(s,memBuffer32,memBuffer16,memBuffer8,meshType);
|
|
}
|
|
|
|
DebugGuard();
|
|
|
|
// names...
|
|
S32 numNames = readAlloc32(s,memBuffer32[12]);
|
|
for (i=0;i<numNames;i++)
|
|
{
|
|
S32 sz;
|
|
s->read(&sz);
|
|
readAlloc(s,memBuffer8,sz);
|
|
*oldAlloc(memBuffer8,1) = 0; // end the string
|
|
}
|
|
|
|
DebugGuard();
|
|
|
|
// material list...read the old fashion way
|
|
S32 gotList;
|
|
s->read(&gotList);
|
|
if (gotList)
|
|
{
|
|
materialList = new TSMaterialList;
|
|
materialList->read(*s);
|
|
if (mExporterVersion<116)
|
|
{
|
|
// for any material that is translucent and doesn't tile, add zero border property
|
|
for (i=0; i<(S32)materialList->getMaterialCount(); i++)
|
|
{
|
|
U32 flags = materialList->getFlags(i);
|
|
if ((flags & TSMaterialList::Translucent) && !(flags&(TSMaterialList::S_Wrap|TSMaterialList::T_Wrap)))
|
|
materialList->setFlags(i,flags|TSMaterialList::MipMap_ZeroBorder);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
materialList = NULL;
|
|
|
|
// allocate memory for these vectors here...filled in below
|
|
S32 detailFirstSkinCount = oldAllocOffset(memBuffer32);
|
|
oldAlloc(memBuffer32,numDetails);
|
|
S32 detailNumSkinCount = oldAllocOffset(memBuffer32);
|
|
oldAlloc(memBuffer32,numDetails);
|
|
|
|
DebugGuard();
|
|
|
|
// skins
|
|
S32 numSkins = readAlloc32(s,memBuffer32[11]);
|
|
for (i=0; i<numSkins; i++)
|
|
readAllocMesh(s,memBuffer32,memBuffer16,memBuffer8,TSMesh::SkinMeshType);
|
|
|
|
DebugGuard();
|
|
|
|
if (numSkins==0)
|
|
{
|
|
S32 * pSkinCounts = (S32*)memBuffer32+detailFirstSkinCount;
|
|
for (i=0; i<2*numDetails; i++)
|
|
pSkinCounts[i]=convertLEndianToHost((U32)0);
|
|
}
|
|
if (numSkins)
|
|
{
|
|
S32 sz;
|
|
s->read(&sz);
|
|
S32 * pDetailFirstSkin = memBuffer32+detailFirstSkinCount;
|
|
S32 * pDetailNumSkin = memBuffer32+detailNumSkinCount;
|
|
s->read(numDetails*sizeof(S32),(S8*)pDetailFirstSkin);
|
|
S32 prev = numSkins;
|
|
for (i=numDetails-1; i>=0; i--)
|
|
{
|
|
pDetailNumSkin[i] = convertLEndianToHost(prev - convertLEndianToHost(pDetailFirstSkin[i]));
|
|
prev = convertLEndianToHost(pDetailFirstSkin[i]);
|
|
}
|
|
}
|
|
|
|
DebugGuard();
|
|
|
|
if (smReadVersion<17)
|
|
{
|
|
for (i=0; i<(S32)sequences.size(); i++)
|
|
{
|
|
Sequence & seq = sequences[i];
|
|
rearrangeKeyframeData(seq,kfStart[i],(U8*)(memBuffer32+nodeStateStart32),(U8*)(memBuffer16+nodeStateStart16),(U8*)(memBuffer32+objectStateStart),(U8*)(memBuffer32+decalStateStart),3*sizeof(S32),4*sizeof(S16),3*sizeof(S32),sizeof(S32));
|
|
}
|
|
}
|
|
|
|
count32 = getDWordCount32();
|
|
count16 = getDWordCount16();
|
|
count8 = getDWordCount8();
|
|
}
|
|
|
|
void TSShape::rearrangeKeyframeData(Sequence & seq, S32 startKeyframe, U8 * pRot, U8 * pTrans, U8 * pos, U8 * pds, S32 rotSize, S32 tranSize, S32 osSize, S32 dsSize)
|
|
{
|
|
// count nodes, objects, and decals...
|
|
S32 numNodes = 0;
|
|
S32 numObjects = 0;
|
|
S32 numDecals = 0;
|
|
S32 numKeyframes = seq.numKeyframes;
|
|
S32 j;
|
|
TSIntegerSet objectMembership = seq.frameMatters;
|
|
objectMembership.overlap(seq.matFrameMatters);
|
|
objectMembership.overlap(seq.visMatters);
|
|
for (j=0; j<MAX_TS_SET_SIZE; j++)
|
|
{
|
|
if (seq.rotationMatters.test(j)) // we're old sequence, so same as translationMatters
|
|
numNodes++;
|
|
if (objectMembership.test(j))
|
|
numObjects++;
|
|
if (seq.decalMatters.test(j))
|
|
numDecals++;
|
|
}
|
|
|
|
// fill in default size and location info...
|
|
if (!pRot && numKeyframes*numNodes)
|
|
pRot = (U8*)&nodeRotations[0];
|
|
if (!pTrans && numKeyframes*numNodes)
|
|
pTrans = (U8*)&nodeTranslations[0];
|
|
if (rotSize<0)
|
|
rotSize = sizeof(Quat16);
|
|
if (tranSize<0)
|
|
tranSize = sizeof(Point3F);
|
|
if (!pos && numKeyframes*numObjects)
|
|
pos = (U8*)&objectStates[0];
|
|
if (osSize<0)
|
|
osSize = sizeof(ObjectState);
|
|
if (!pds && numKeyframes*numDecals)
|
|
pds = (U8*)&decalStates[0];
|
|
if (dsSize<0)
|
|
dsSize = sizeof(DecalState);
|
|
|
|
if (seq.numKeyframes)
|
|
{
|
|
seq.baseRotation = numNodes ? keyframes[startKeyframe].firstNodeState : 0;
|
|
seq.baseTranslation = numNodes ? keyframes[startKeyframe].firstNodeState : 0;
|
|
seq.baseObjectState = numObjects ? keyframes[startKeyframe].firstObjectState : 0;
|
|
seq.baseDecalState = numDecals ? keyframes[startKeyframe].firstDecalState : 0;
|
|
rearrangeStates( seq.baseRotation, numKeyframes, numNodes, pRot,rotSize);
|
|
rearrangeStates( seq.baseTranslation, numKeyframes, numNodes, pTrans,tranSize);
|
|
rearrangeStates( seq.baseObjectState, numKeyframes, numObjects, pos, osSize);
|
|
rearrangeStates( seq.baseDecalState, numKeyframes, numDecals, pds, dsSize);
|
|
}
|
|
}
|
|
|
|
void TSShape::rearrangeStates(S32 start, S32 a, S32 b, U8 * dat, S32 size)
|
|
{
|
|
// have to account for different packing size...
|
|
U8 * copy = new U8[a*b*size];
|
|
dMemcpy(copy,&dat[start*size],a*b*size);
|
|
for (S32 i=0; i<a; i++)
|
|
for (S32 j=0; j<b; j++)
|
|
dMemcpy(dat + size*(start+j*a+i), copy + size*(i*b+j), size);
|
|
delete [] copy;
|
|
}
|
|
|
|
//-------------------------------------------------
|
|
// put old skins into object list
|
|
//-------------------------------------------------
|
|
|
|
void TSShape::fixupOldSkins(S32 numMeshes, S32 numSkins, S32 numDetails, S32 * detailFirstSkin, S32 * detailNumSkins)
|
|
{
|
|
#if !defined(TORQUE_LIB)
|
|
// this method not necessary in exporter, and a couple lines won't compile for exporter
|
|
if (!objects.address() || !meshes.address() || !numSkins)
|
|
// not ready for this yet, will catch it on the next pass
|
|
return;
|
|
|
|
S32 numObjects = objects.size();
|
|
TSObject * newObjects = objects.address() + objects.size();
|
|
TSSkinMesh ** skins = (TSSkinMesh**)&meshes[numMeshes];
|
|
Vector<TSSkinMesh*> skinsCopy;
|
|
|
|
// Note: newObjects has as much free space as we need, so we just need to keep track of the
|
|
// number of objects we use and then update objects.size
|
|
S32 numSkinObjects = 0;
|
|
S32 skinsUsed = 0;
|
|
S32 emptySkins = 0;
|
|
S32 i;
|
|
for (i=0; i<numSkins; i++)
|
|
if (skins[i]==NULL)
|
|
emptySkins++; // probably never, but just in case
|
|
while (skinsUsed<numSkins-emptySkins)
|
|
{
|
|
TSObject & object = newObjects[numSkinObjects++];
|
|
objects.increment();
|
|
object.nameIndex = 0; // no name
|
|
object.numMeshes = 0;
|
|
object.startMeshIndex = numMeshes + skinsCopy.size();
|
|
object.nodeIndex = -1;
|
|
object.nextSibling = -1;
|
|
object.firstDecal = -1;
|
|
for (S32 dl=0; dl<numDetails; dl++)
|
|
{
|
|
// find one mesh per detail to add to this object
|
|
// don't really need to be versions of the same object
|
|
i = 0;
|
|
while (i<detailFirstSkin[dl] || detailFirstSkin[dl]<0)
|
|
i++;
|
|
for (; i<numSkins && i<detailFirstSkin[dl]+detailNumSkins[dl]; i++)
|
|
{
|
|
if (skins[i])
|
|
{
|
|
// found an unused skin... copy it to skinsCopy and set to NULL
|
|
skinsCopy.push_back(skins[i]);
|
|
skins[i]=NULL;
|
|
object.numMeshes++;
|
|
skinsUsed++;
|
|
break;
|
|
}
|
|
}
|
|
if (i==numSkins || i==detailFirstSkin[dl]+detailNumSkins[dl])
|
|
{
|
|
skinsCopy.push_back(NULL);
|
|
object.numMeshes++;
|
|
}
|
|
}
|
|
// exit above loop with one skin per detail...despose of trailing null meshes
|
|
while (!skinsCopy.empty() && skinsCopy.last()==NULL)
|
|
{
|
|
skinsCopy.decrement();
|
|
object.numMeshes--;
|
|
}
|
|
// if no meshes, don't need object
|
|
if (!object.numMeshes)
|
|
{
|
|
objects.decrement();
|
|
numSkinObjects--;
|
|
}
|
|
}
|
|
dMemcpy(skins,skinsCopy.address(),skinsCopy.size()*sizeof(TSSkinMesh*));
|
|
|
|
if (subShapeFirstObject.size()==1)
|
|
// as long as only one subshape, we'll now be rendered
|
|
subShapeNumObjects[0] += numSkinObjects;
|
|
|
|
// now for something ugly -- we've added somoe objects to hold the skins...
|
|
// now we have to add default states for those objects
|
|
// we also have to increment base states on all the sequences that are loaded
|
|
dMemmove(objectStates.address()+numObjects+numSkinObjects,objectStates.address()+numObjects,(objectStates.size()-numObjects)*sizeof(ObjectState));
|
|
for (i=numObjects; i<numObjects+numSkinObjects; i++)
|
|
{
|
|
objectStates[i].vis=1.0f;
|
|
objectStates[i].frameIndex=0;
|
|
objectStates[i].matFrameIndex=0;
|
|
}
|
|
for (i=0;i<sequences.size();i++)
|
|
{
|
|
sequences[i].baseObjectState += numSkinObjects;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-------------------------------------------------
|
|
// some macros used for read/write
|
|
//-------------------------------------------------
|
|
|
|
// write a vector of structs (minus the first 'm')
|
|
#define writeVectorStructMinus(a,m) \
|
|
{\
|
|
s->write(a.size() - m); \
|
|
for (S32 i=m;i<a.size();i++) \
|
|
a[i].write(s); \
|
|
}
|
|
|
|
// write a vector of simple types (minus the first 'm')
|
|
#define writeVectorSimpleMinus(a,m) \
|
|
{\
|
|
s->write(a.size() - m); \
|
|
for (S32 i=m;i<a.size();i++) \
|
|
s->write(a[i]); \
|
|
}
|
|
|
|
// same as above with m=0
|
|
#define writeVectorStruct(a) writeVectorStructMinus(a,0)
|
|
#define writeVectorSimple(a) writeVectorSimpleMinus(a,0)
|
|
|
|
// read a vector of structs -- over-writing any existing data
|
|
#define readVectorStruct(a) \
|
|
{ \
|
|
S32 sz; \
|
|
s->read(&sz); \
|
|
a.setSize(sz); \
|
|
for (S32 i=0;i<sz;i++) \
|
|
a[i].read(s); \
|
|
}
|
|
|
|
// read a vector of simple types -- over-writing any existing data
|
|
#define readVectorSimple(a) \
|
|
{ \
|
|
S32 sz; \
|
|
s->read(&sz); \
|
|
a.setSize(sz); \
|
|
for (S32 i=0;i<sz;i++) \
|
|
s->read(&a[i]); \
|
|
}
|
|
|
|
// read a vector of structs -- append to any existing data
|
|
#define appendVectorStruct(a) \
|
|
{ \
|
|
S32 sz; \
|
|
S32 oldSz = a.size(); \
|
|
s->read(&sz); \
|
|
a.setSize(oldSz + sz); \
|
|
for (S32 i=0;i<sz;i++) \
|
|
a[i + oldSz].read(s); \
|
|
}
|
|
|
|
// read a vector of simple types -- append to any existing data
|
|
#define appendVectorSimple(a) \
|
|
{ \
|
|
S32 sz; \
|
|
S32 oldSz = a.size(); \
|
|
s->read(&sz); \
|
|
a.setSize(oldSz + sz); \
|
|
for (S32 i=0;i<sz;i++) \
|
|
s->read(&a[i + oldSz]); \
|
|
}
|
|
|
|
//-------------------------------------------------
|
|
// export all sequences
|
|
//-------------------------------------------------
|
|
void TSShape::exportSequences(Stream * s)
|
|
{
|
|
// write version
|
|
s->write(smVersion);
|
|
|
|
S32 i,sz;
|
|
|
|
// write node names
|
|
// -- this is how we will map imported sequence nodes to shape nodes
|
|
sz = nodes.size();
|
|
s->write(sz);
|
|
for (i=0;i<nodes.size();i++)
|
|
writeName(s,nodes[i].nameIndex);
|
|
|
|
// legacy write -- write zero objects, don't pretend to support object export anymore
|
|
s->write(0);
|
|
|
|
// on import, we will need to adjust keyframe data based on number of
|
|
// nodes/objects in this shape...number of nodes can be inferred from
|
|
// above, but number of objects cannot be. Write that quantity here:
|
|
s->write(objects.size());
|
|
|
|
// write node states -- skip default node states
|
|
s->write(nodeRotations.size());
|
|
for (i=0;i<nodeRotations.size();i++)
|
|
{
|
|
s->write(nodeRotations[i].x);
|
|
s->write(nodeRotations[i].y);
|
|
s->write(nodeRotations[i].z);
|
|
s->write(nodeRotations[i].w);
|
|
}
|
|
s->write(nodeTranslations.size());
|
|
for (i=0;i<nodeTranslations.size(); i++)
|
|
{
|
|
s->write(nodeTranslations[i].x);
|
|
s->write(nodeTranslations[i].y);
|
|
s->write(nodeTranslations[i].z);
|
|
}
|
|
s->write(nodeUniformScales.size());
|
|
for (i=0;i<nodeUniformScales.size();i++)
|
|
s->write(nodeUniformScales[i]);
|
|
s->write(nodeAlignedScales.size());
|
|
for (i=0;i<nodeAlignedScales.size();i++)
|
|
{
|
|
s->write(nodeAlignedScales[i].x);
|
|
s->write(nodeAlignedScales[i].y);
|
|
s->write(nodeAlignedScales[i].z);
|
|
}
|
|
s->write(nodeArbitraryScaleRots.size());
|
|
for (i=0;i<nodeArbitraryScaleRots.size();i++)
|
|
{
|
|
s->write(nodeArbitraryScaleRots[i].x);
|
|
s->write(nodeArbitraryScaleRots[i].y);
|
|
s->write(nodeArbitraryScaleRots[i].z);
|
|
s->write(nodeArbitraryScaleRots[i].w);
|
|
}
|
|
for (i=0;i<nodeArbitraryScaleFactors.size();i++)
|
|
{
|
|
s->write(nodeArbitraryScaleFactors[i].x);
|
|
s->write(nodeArbitraryScaleFactors[i].y);
|
|
s->write(nodeArbitraryScaleFactors[i].z);
|
|
}
|
|
s->write(groundTranslations.size());
|
|
for (i=0;i<groundTranslations.size();i++)
|
|
{
|
|
s->write(groundTranslations[i].x);
|
|
s->write(groundTranslations[i].y);
|
|
s->write(groundTranslations[i].z);
|
|
}
|
|
for (i=0;i<groundRotations.size();i++)
|
|
{
|
|
s->write(groundRotations[i].x);
|
|
s->write(groundRotations[i].y);
|
|
s->write(groundRotations[i].z);
|
|
s->write(groundRotations[i].w);
|
|
}
|
|
|
|
// write object states -- legacy..no object states
|
|
s->write((S32)0);
|
|
|
|
// write sequences
|
|
s->write(sequences.size());
|
|
for (i=0;i<sequences.size();i++)
|
|
{
|
|
Sequence & seq = sequences[i];
|
|
|
|
// first write sequence name
|
|
writeName(s,seq.nameIndex);
|
|
|
|
// now write the sequence itself
|
|
seq.write(s,false); // false --> don't write name index
|
|
}
|
|
|
|
// write out all the triggers...
|
|
s->write(triggers.size());
|
|
for (i=0; i<triggers.size(); i++)
|
|
{
|
|
s->write(triggers[i].state);
|
|
s->write(triggers[i].pos);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------
|
|
// import sequences into existing shape
|
|
//-------------------------------------------------
|
|
bool TSShape::importSequences(Stream * s)
|
|
{
|
|
// write version
|
|
s->read(&smReadVersion);
|
|
if (smReadVersion>smVersion)
|
|
{
|
|
// error -- don't support future version yet :>
|
|
Con::errorf(ConsoleLogEntry::General,
|
|
"Sequence import failed: shape exporter newer than running executable.");
|
|
return false;
|
|
}
|
|
|
|
Vector<S32> nodeMap; // node index of each node from imported sequences
|
|
Vector<S32> objectMap; // object index of objects from imported sequences
|
|
VECTOR_SET_ASSOCIATION(nodeMap);
|
|
VECTOR_SET_ASSOCIATION(objectMap);
|
|
|
|
S32 i,sz;
|
|
|
|
// read node names
|
|
// -- this is how we will map imported sequence nodes to our nodes
|
|
s->read(&sz);
|
|
nodeMap.setSize(sz);
|
|
Vector<S32> checkForDups;
|
|
for (i=0;i<sz;i++)
|
|
{
|
|
U32 startSize = names.size();
|
|
S32 nameIndex = readName(s,true);
|
|
U32 count = 0;
|
|
if (nameIndex>=0)
|
|
{
|
|
while (checkForDups.size()<nameIndex+1)
|
|
checkForDups.push_back(0);
|
|
count = checkForDups[nameIndex]++;
|
|
}
|
|
if (count)
|
|
{
|
|
// not first time this name came up...look for later instance of the node
|
|
S32 j;
|
|
nodeMap[i]=-1;
|
|
for (j=0; j<nodes.size(); j++)
|
|
{
|
|
if (nodes[j].nameIndex==nameIndex && count--==0)
|
|
break;
|
|
}
|
|
nodeMap[i]=j;
|
|
if (j==nodes.size())
|
|
{
|
|
Con::errorf(ConsoleLogEntry::General,"Sequence import failed: sequence node \"%s\" duplicated more in sequence than in shape.",names[nameIndex]);
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
nodeMap[i] = findNode(nameIndex);
|
|
if (nodeMap[i]<0)
|
|
{
|
|
// error -- node found in sequence but not shape
|
|
Con::errorf(ConsoleLogEntry::General,
|
|
"Sequence import failed: sequence node \"%s\" not found in base shape.",names[nameIndex]);
|
|
if (names.size()!=startSize)
|
|
{
|
|
names.decrement();
|
|
AssertFatal(names.size()==startSize,"TSShape::importSequence: assertion failed");
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// read the following size, but won't do anything with it...legacy: was going to support
|
|
// import of sequences that animate objects...we don't...
|
|
s->read(&sz); sz;
|
|
|
|
// before reading keyframes, take note of a couple numbers
|
|
S32 oldShapeNumObjects;
|
|
s->read(&oldShapeNumObjects);
|
|
|
|
// read keyframes
|
|
if (smReadVersion<17)
|
|
{
|
|
keyframes.clear();
|
|
appendVectorStruct(keyframes);
|
|
}
|
|
|
|
// adjust all the new keyframes
|
|
S32 adjNodeRots = smReadVersion<22 ? nodeRotations.size() - nodeMap.size() : nodeRotations.size();
|
|
S32 adjNodeTrans = smReadVersion<22 ? nodeTranslations.size() - nodeMap.size() : nodeTranslations.size();
|
|
S32 adjNodeScales1 = nodeUniformScales.size();
|
|
S32 adjNodeScales2 = nodeAlignedScales.size();
|
|
S32 adjNodeScales3 = nodeArbitraryScaleFactors.size();
|
|
S32 adjObjectStates = objectStates.size() - oldShapeNumObjects;
|
|
S32 adjGroundStates = smReadVersion<22 ? 0 : groundTranslations.size(); // groundTrans==groundRot
|
|
for (i=0;i<keyframes.size();i++)
|
|
{
|
|
// have keyframes only for old shapes...use adjNodeRots for adjustment
|
|
// since same as adjNodeScales...
|
|
keyframes[i].firstNodeState += adjNodeRots;
|
|
keyframes[i].firstObjectState += adjObjectStates;
|
|
}
|
|
|
|
// add these node states to our own
|
|
if (smReadVersion>21)
|
|
{
|
|
s->read(&sz);
|
|
S32 oldSz = nodeRotations.size();
|
|
nodeRotations.setSize(sz+oldSz);
|
|
for (i=oldSz;i<oldSz+sz; i++)
|
|
{
|
|
s->read(&nodeRotations[i].x);
|
|
s->read(&nodeRotations[i].y);
|
|
s->read(&nodeRotations[i].z);
|
|
s->read(&nodeRotations[i].w);
|
|
}
|
|
s->read(&sz);
|
|
oldSz = nodeTranslations.size();
|
|
nodeTranslations.setSize(sz+oldSz);
|
|
for (i=oldSz;i<sz+oldSz;i++)
|
|
{
|
|
s->read(&nodeTranslations[i].x);
|
|
s->read(&nodeTranslations[i].y);
|
|
s->read(&nodeTranslations[i].z);
|
|
}
|
|
s->read(&sz);
|
|
oldSz = nodeUniformScales.size();
|
|
nodeUniformScales.setSize(sz+oldSz);
|
|
for (i=oldSz;i<sz+oldSz;i++)
|
|
s->read(&nodeUniformScales[i]);
|
|
s->read(&sz);
|
|
oldSz = nodeAlignedScales.size();
|
|
nodeAlignedScales.setSize(sz+oldSz);
|
|
for (i=oldSz;i<sz+oldSz;i++)
|
|
{
|
|
s->read(&nodeAlignedScales[i].x);
|
|
s->read(&nodeAlignedScales[i].y);
|
|
s->read(&nodeAlignedScales[i].z);
|
|
}
|
|
s->read(&sz);
|
|
oldSz = nodeArbitraryScaleRots.size();
|
|
nodeArbitraryScaleRots.setSize(sz+oldSz);
|
|
for (i=oldSz;i<sz+oldSz;i++)
|
|
{
|
|
s->read(&nodeArbitraryScaleRots[i].x);
|
|
s->read(&nodeArbitraryScaleRots[i].y);
|
|
s->read(&nodeArbitraryScaleRots[i].z);
|
|
s->read(&nodeArbitraryScaleRots[i].w);
|
|
}
|
|
oldSz = nodeArbitraryScaleFactors.size();
|
|
nodeArbitraryScaleFactors.setSize(sz+oldSz);
|
|
for (i=oldSz;i<sz+oldSz;i++)
|
|
{
|
|
s->read(&nodeArbitraryScaleFactors[i].x);
|
|
s->read(&nodeArbitraryScaleFactors[i].y);
|
|
s->read(&nodeArbitraryScaleFactors[i].z);
|
|
}
|
|
s->read(&sz);
|
|
oldSz = groundTranslations.size();
|
|
groundTranslations.setSize(sz+oldSz);
|
|
for (i=oldSz;i<sz+oldSz;i++)
|
|
{
|
|
s->read(&groundTranslations[i].x);
|
|
s->read(&groundTranslations[i].y);
|
|
s->read(&groundTranslations[i].z);
|
|
}
|
|
groundRotations.setSize(sz+oldSz);
|
|
for (i=oldSz;i<sz+oldSz;i++)
|
|
{
|
|
s->read(&groundRotations[i].x);
|
|
s->read(&groundRotations[i].y);
|
|
s->read(&groundRotations[i].z);
|
|
s->read(&groundRotations[i].w);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
s->read(&sz);
|
|
S32 oldSz1 = nodeRotations.size();
|
|
S32 oldSz2 = nodeTranslations.size();
|
|
nodeRotations.setSize(oldSz1+sz);
|
|
nodeTranslations.setSize(oldSz2+sz);
|
|
for (i=0; i<sz; i++)
|
|
{
|
|
s->read(&nodeRotations[i+oldSz1].x);
|
|
s->read(&nodeRotations[i+oldSz1].y);
|
|
s->read(&nodeRotations[i+oldSz1].z);
|
|
s->read(&nodeRotations[i+oldSz1].w);
|
|
s->read(&nodeTranslations[i+oldSz2].x);
|
|
s->read(&nodeTranslations[i+oldSz2].y);
|
|
s->read(&nodeTranslations[i+oldSz2].z);
|
|
}
|
|
}
|
|
|
|
// add these object states to our own -- shouldn't be any...assume it
|
|
s->read(&sz);
|
|
|
|
// read sequences
|
|
s->read(&sz);
|
|
S32 startSeqNum = sequences.size();
|
|
kfStart.clear(); // versioning hack -- holds start of range of keyframes used by each sequence loaded
|
|
for (i=0;i<sz;i++)
|
|
{
|
|
sequences.increment();
|
|
Sequence & seq = sequences.last();
|
|
constructInPlace(&seq);
|
|
|
|
// read name
|
|
seq.nameIndex = readName(s,true);
|
|
|
|
// read the rest of the sequence
|
|
seq.read(s,false);
|
|
if (smReadVersion>21)
|
|
{
|
|
seq.baseRotation += adjNodeRots;
|
|
seq.baseTranslation += adjNodeTrans;
|
|
if (seq.animatesUniformScale())
|
|
seq.baseScale += adjNodeScales1;
|
|
else if (seq.animatesAlignedScale())
|
|
seq.baseScale += adjNodeScales2;
|
|
else if (seq.animatesArbitraryScale())
|
|
seq.baseScale += adjNodeScales3;
|
|
}
|
|
else if (smReadVersion>=17)
|
|
{
|
|
seq.baseRotation += adjNodeRots; // == adjNodeTrans
|
|
seq.baseTranslation += adjNodeTrans; // == adjNodeTrans
|
|
}
|
|
|
|
// not quite so easy...
|
|
// now we have to remap nodes from shape the sequence came from to this shape
|
|
// that's where nodeMap comes in handy...
|
|
// ditto for the objects.
|
|
|
|
// first the nodes
|
|
S32 j;
|
|
TSIntegerSet newMembership1;
|
|
TSIntegerSet newMembership2;
|
|
TSIntegerSet newMembership3;
|
|
for (j=0; j<(S32)nodeMap.size(); j++)
|
|
{
|
|
if (seq.translationMatters.test(j))
|
|
newMembership1.set(nodeMap[j]);
|
|
if (seq.rotationMatters.test(j))
|
|
newMembership2.set(nodeMap[j]);
|
|
if (seq.scaleMatters.test(j))
|
|
newMembership3.set(nodeMap[j]);
|
|
}
|
|
seq.translationMatters = newMembership1;
|
|
seq.rotationMatters = newMembership2;
|
|
seq.scaleMatters = newMembership3;
|
|
|
|
// adjust trigger numbers...we'll read triggers after sequences...
|
|
seq.firstTrigger += triggers.size();
|
|
|
|
// finally, adjust ground transform's nodes states
|
|
seq.firstGroundFrame += adjGroundStates;
|
|
}
|
|
if (smReadVersion<17)
|
|
for (i=startSeqNum; i<sequences.size(); i++)
|
|
// rearrange some data and add some info to the sequences
|
|
rearrangeKeyframeData(sequences[i],kfStart[i-startSeqNum]);
|
|
|
|
if (smReadVersion<22)
|
|
{
|
|
for (i=startSeqNum; i<sequences.size(); i++)
|
|
{
|
|
// move ground transform data to ground vectors
|
|
Sequence & seq = sequences[i];
|
|
S32 oldSz = groundTranslations.size();
|
|
groundTranslations.setSize(oldSz+seq.numGroundFrames);
|
|
groundRotations.setSize(oldSz+seq.numGroundFrames);
|
|
for (S32 j=0;j<seq.numGroundFrames;j++)
|
|
{
|
|
groundTranslations[j+oldSz] = nodeTranslations[seq.firstGroundFrame+adjNodeTrans+j];
|
|
groundRotations[j+oldSz] = nodeRotations[seq.firstGroundFrame+adjNodeRots+j];
|
|
}
|
|
seq.firstGroundFrame = oldSz;
|
|
}
|
|
}
|
|
|
|
// add the new triggers
|
|
if (smReadVersion>8)
|
|
{
|
|
S32 sz;
|
|
S32 oldSz = triggers.size();
|
|
s->read(&sz);
|
|
triggers.setSize(oldSz+sz);
|
|
for (S32 i=0; i<sz;i++)
|
|
{
|
|
s->read(&triggers[i+oldSz].state);
|
|
s->read(&triggers[i+oldSz].pos);
|
|
}
|
|
}
|
|
|
|
if (smInitOnRead)
|
|
init();
|
|
|
|
return true;
|
|
}
|
|
|
|
//-------------------------------------------------
|
|
// read/write sequence
|
|
//-------------------------------------------------
|
|
void TSShape::Sequence::read(Stream * s, bool readNameIndex)
|
|
{
|
|
if (readNameIndex)
|
|
s->read(&nameIndex);
|
|
flags = 0;
|
|
if (TSShape::smReadVersion>21)
|
|
s->read(&flags);
|
|
else
|
|
flags=0;
|
|
if (TSShape::smReadVersion<17)
|
|
{
|
|
// prior to version 17 we had a vector of keyframes and needed to track range of keyframes not just number
|
|
S32 startKeyframe, endKeyframe;
|
|
s->read(&startKeyframe);
|
|
s->read(&endKeyframe);
|
|
numKeyframes = endKeyframe - startKeyframe;
|
|
kfStart.push_back(startKeyframe);
|
|
}
|
|
else
|
|
// just need number of keyframes...
|
|
s->read(&numKeyframes);
|
|
s->read(&duration);
|
|
|
|
if (TSShape::smReadVersion<22)
|
|
{
|
|
bool tmp;
|
|
s->read(&tmp);
|
|
if (tmp)
|
|
flags |= Blend;
|
|
s->read(&tmp);
|
|
if (tmp)
|
|
flags |= Cyclic;
|
|
s->read(&tmp);
|
|
if (tmp)
|
|
flags |= MakePath;
|
|
}
|
|
|
|
s->read(&priority);
|
|
s->read(&firstGroundFrame);
|
|
s->read(&numGroundFrames);
|
|
if (TSShape::smReadVersion>21)
|
|
{
|
|
s->read(&baseRotation);
|
|
s->read(&baseTranslation);
|
|
s->read(&baseScale);
|
|
s->read(&baseObjectState);
|
|
s->read(&baseDecalState);
|
|
}
|
|
else if (TSShape::smReadVersion>=17)
|
|
{
|
|
s->read(&baseRotation);
|
|
baseTranslation=baseRotation;
|
|
s->read(&baseObjectState);
|
|
s->read(&baseDecalState);
|
|
}
|
|
if (TSShape::smReadVersion>8)
|
|
{
|
|
s->read(&firstTrigger);
|
|
s->read(&numTriggers);
|
|
}
|
|
else
|
|
{
|
|
firstTrigger = 0;
|
|
numTriggers = 0;
|
|
}
|
|
if (TSShape::smReadVersion>7)
|
|
s->read(&toolBegin);
|
|
else
|
|
toolBegin=0.0f;
|
|
|
|
// now the membership sets:
|
|
rotationMatters.read(s);
|
|
if (TSShape::smReadVersion<22)
|
|
translationMatters=rotationMatters;
|
|
else
|
|
{
|
|
translationMatters.read(s);
|
|
scaleMatters.read(s);
|
|
}
|
|
if (TSShape::smReadVersion<17)
|
|
{
|
|
TSIntegerSet objectMembership; // obsolete
|
|
objectMembership.read(s);
|
|
}
|
|
if (TSShape::smReadVersion>10)
|
|
decalMatters.read(s);
|
|
if (TSShape::smReadVersion>5)
|
|
iflMatters.read(s);
|
|
visMatters.read(s);
|
|
frameMatters.read(s);
|
|
matFrameMatters.read(s);
|
|
if (TSShape::smReadVersion<17)
|
|
{
|
|
// obsolete...
|
|
TSIntegerSet nodeTransformStatic;
|
|
nodeTransformStatic.read(s);
|
|
}
|
|
|
|
dirtyFlags = 0;
|
|
if (rotationMatters.testAll() || translationMatters.testAll() || scaleMatters.testAll())
|
|
dirtyFlags |= TSShapeInstance::TransformDirty;
|
|
if (visMatters.testAll())
|
|
dirtyFlags |= TSShapeInstance::VisDirty;
|
|
if (frameMatters.testAll())
|
|
dirtyFlags |= TSShapeInstance::FrameDirty;
|
|
if (matFrameMatters.testAll())
|
|
dirtyFlags |= TSShapeInstance::MatFrameDirty;
|
|
if (decalMatters.testAll())
|
|
dirtyFlags |= TSShapeInstance::DecalDirty;
|
|
if (iflMatters.testAll())
|
|
dirtyFlags |= TSShapeInstance::IflDirty;
|
|
}
|
|
|
|
void TSShape::Sequence::write(Stream * s, bool writeNameIndex)
|
|
{
|
|
if (writeNameIndex)
|
|
s->write(nameIndex);
|
|
s->write(flags);
|
|
s->write(numKeyframes);
|
|
s->write(duration);
|
|
s->write(priority);
|
|
s->write(firstGroundFrame);
|
|
s->write(numGroundFrames);
|
|
s->write(baseRotation);
|
|
s->write(baseTranslation);
|
|
s->write(baseScale);
|
|
s->write(baseObjectState);
|
|
s->write(baseDecalState);
|
|
s->write(firstTrigger);
|
|
s->write(numTriggers);
|
|
s->write(toolBegin);
|
|
|
|
// now the membership sets:
|
|
rotationMatters.write(s);
|
|
translationMatters.write(s);
|
|
scaleMatters.write(s);
|
|
decalMatters.write(s);
|
|
iflMatters.write(s);
|
|
visMatters.write(s);
|
|
frameMatters.write(s);
|
|
matFrameMatters.write(s);
|
|
}
|
|
|
|
void TSShape::writeName(Stream * s, S32 nameIndex)
|
|
{
|
|
const char * name = "";
|
|
if (nameIndex>=0)
|
|
name = names[nameIndex];
|
|
S32 sz = (S32)dStrlen(name);
|
|
s->write(sz);
|
|
if (sz)
|
|
s->write(sz*sizeof(char),name);
|
|
}
|
|
|
|
S32 TSShape::readName(Stream * s, bool addName)
|
|
{
|
|
static char buffer[256];
|
|
S32 sz;
|
|
S32 nameIndex = -1;
|
|
s->read(&sz);
|
|
if (sz)
|
|
{
|
|
s->read(sz*sizeof(char),buffer);
|
|
buffer[sz] = '\0';
|
|
nameIndex = findName(buffer);
|
|
if (nameIndex<0 && addName)
|
|
{
|
|
nameIndex = names.size();
|
|
names.increment();
|
|
names.last() = StringTable->insert(buffer,false); // case insensitive
|
|
}
|
|
}
|
|
return nameIndex;
|
|
}
|