//----------------------------------------------------------------------------- // V12 Engine // // Copyright (c) 2001 GarageGames.Com // Portions Copyright (c) 2001 by Sierra Online, Inc. //----------------------------------------------------------------------------- #ifndef _TSSHAPE_H_ #define _TSSHAPE_H_ #ifndef _TSMESH_H_ #include "ts/tsMesh.h" #endif #ifndef _TSDECAL_H_ #include "ts/tsDecal.h" #endif #ifndef _TSINTEGERSET_H_ #include "ts/tsIntegerSet.h" #endif #ifndef _TSTRANSFORM_H_ #include "ts/tsTransform.h" #endif #ifndef _TSSHAPEALLOC_H_ #include "ts/tsShapeAlloc.h" #endif #ifndef _PLATFORM_H_ #include "Platform/platform.h" #endif #ifndef _RESMANAGER_H_ #include "Core/resManager.h" #endif #ifndef _MMATH_H_ #include "Math/mMath.h" #endif #ifndef _STREAM_H_ #include "Core/stream.h" #endif #define DTS_EXPORTER_CURRENT_VERSION 123 class TSMaterialList; class TSLastDetail; class TSShape : public ResourceInstance { public: enum { UniformScale=0x01, AlignedScale=0x02, ArbitraryScale=0x04, Blend=0x08, Cyclic=0x10, MakePath=0x20, IflInit=0x40, HasTranslucency=0x80, AnyScale=UniformScale|AlignedScale|ArbitraryScale }; // Nodes hold the transforms in the shape tree... struct Node { S32 nameIndex; S32 parentIndex; // computed at runtime S32 firstObject; S32 firstChild; S32 nextSibling; }; // Objects hold renderable items (in particular meshes)... // Each object has a number of meshes associated with it. // Each mesh corresponds to a different detail level. // "meshIndicesIndex" points to numMeshes consecutive indices // into the meshList and meshType vectors. It indexes the // meshIndexList vector (meshIndexList is merely a clearinghouse // for the object's mesh lists). Some indices may correspond to // no mesh -- which means no mesh will be drawn for the part for // the given detail level. See comments on the meshIndexList // for how null meshes are coded. // Note: stored this way so that there is no address specific information. struct Object { S32 nameIndex; S32 numMeshes; S32 startMeshIndex; // index into meshes array... S32 nodeIndex; // computed at load S32 nextSibling; S32 firstDecal; }; // Decals hang off objects like objects hang off nodes. A decal is rendered on // top of an object (normally will be translucent). Note: they hang off objects // conceptually...however, in the shapeInstance they are in their own list and // that list is rendered after all the objects are. struct Decal { S32 nameIndex; S32 numMeshes; S32 startMeshIndex; // index into meshes array... S32 objectIndex; // computed at load S32 nextSibling; }; // IFL materials are used to animate material lists -- i.e., run through a series // of frames of a material... they work by replacing a material in the material // list so that it is transparent to the rest of the code. // Offset time of each frame is stored in iflFrameOffsets vector, starting at index position // firstFrameOffsetIndex.. struct IflMaterial { S32 nameIndex; // file name w/ extension S32 materialSlot; S32 firstFrame; S32 firstFrameOffTimeIndex; S32 numFrames; }; // A Sequence holds all the information necessary to perform a particular animation (sequence). // Sequences index a range of keyframes...keyframes are assumed to be equally spaced in time. // Each node and object is either a member of the sequence or not. If not, they are set to // default values when we switch to the sequence unless they are members of some other active sequence. // Blended sequences "add" a transform to the current transform of a node. Any object animation of // a blended sequence over-rides any existing object state. Blended sequences are always // applied after non-blended sequences. struct Sequence { S32 nameIndex; S32 numKeyframes; F32 duration; S32 baseRotation; S32 baseTranslation; S32 baseScale; S32 baseObjectState; S32 baseDecalState; S32 firstGroundFrame; S32 numGroundFrames; S32 firstTrigger; S32 numTriggers; F32 toolBegin; // These bitsets code whether this sequence cares certain aspects of animation // e.g., the rotation, translation, or scale of node transforms, // or the visibility, frame or material frame of objects. TSIntegerSet rotationMatters; // set of nodes TSIntegerSet translationMatters; // set of nodes TSIntegerSet scaleMatters; // set of nodes TSIntegerSet visMatters; // set of objects TSIntegerSet frameMatters; // set of objects TSIntegerSet matFrameMatters; // set of objects TSIntegerSet decalMatters; // set of decals TSIntegerSet iflMatters; // set of ifls S32 priority; U32 flags; U32 dirtyFlags; // determined at load time bool testFlags(U32 comp) const { return (flags&comp)!=0; } bool animatesScale() const { return testFlags(AnyScale); } bool animatesUniformScale() const { return testFlags(UniformScale); } bool animatesAlignedScale() const { return testFlags(AlignedScale); } bool animatesArbitraryScale() const { return testFlags(ArbitraryScale); } bool isBlend() const { return testFlags(Blend); } bool isCyclic() const { return testFlags(Cyclic); } bool makePath() const { return testFlags(MakePath); } void read(Stream *, bool readNameIndex = true); void write(Stream *, bool writeNameIndex = true); }; // Describes state of an individual object. Includes everything in an object that can be // controlled by animation. struct ObjectState { F32 vis; S32 frameIndex; S32 matFrameIndex; }; // Describes state of a decal. struct DecalState { S32 frameIndex; }; // When time on a sequence advances past a certain point, a trigger takes effect and changes // one of the state variables to on or off...(state variables found on shape instance mTriggerStates) struct Trigger { enum { StateOn = 1 << 31, InvertOnReverse = 1 << 30, StateMask = 0x1f }; U32 state; // see above enum F32 pos; }; // Details are used for render detail selection. As the projected size of the shape changes, // a different node structure can be used (subShape) and a different objectDetail can be selected // for each object drawn. Either of these two parameters can also stay constant, but presumably // not both. If size is negative then the detail level will never be selected by the standard // detail selection process. It will have to be selected by name. Such details are "utility // details" because they exist to hold data (node positions or collision information) but not // normally to be drawn. By default there will always be a "Ground" utility detail. struct Detail { S32 nameIndex; S32 subShapeNum; S32 objectDetailNum; F32 size; F32 averageError; F32 maxError; S32 polyCount; }; // For speeding up buildpolylist and support calls. struct ConvexHullAccelerator { U32 numVerts; Point3F* vertexList; Point3F* normalList; U8** emitStrings; }; ConvexHullAccelerator* getAccelerator(S32 dl); // shape vector data...non-resizable in game ToolVector nodes; ToolVector objects; ToolVector decals; ToolVector iflMaterials; ToolVector objectStates; ToolVector decalStates; ToolVector subShapeFirstNode; ToolVector subShapeFirstObject; ToolVector subShapeFirstDecal; ToolVector detailFirstSkin; ToolVector subShapeNumNodes; ToolVector subShapeNumObjects; ToolVector subShapeNumDecals; ToolVector details; ToolVector defaultRotations; ToolVector defaultTranslations; // set up at load time...but memory allocated along with loaded data ToolVector subShapeFirstTranslucentObject; ToolVector meshes; ToolVector alphaIn; // these vectors describe how to transition between detail ToolVector alphaOut; // levels using alpha..."alpha-in" next detail as intraDL goes // from alphaIn+alphaOut to alphaOut..."alpha-out" current // detail level as intraDL goes from alphaOut to 0. // NOTE: // intraDL is at 1 when if shape were any closer to us we'd be at dl-1, // intraDL is at 0 when if shape were any farther away we'd be at dl+1 // re-sizeable vectors... Vector sequences; Vector nodeRotations; Vector nodeTranslations; Vector nodeUniformScales; Vector nodeAlignedScales; Vector nodeArbitraryScaleRots; Vector nodeArbitraryScaleFactors; Vector groundRotations; Vector groundTranslations; Vector triggers; Vector iflFrameOffTimes; Vector billboardDetails; Vector detailCollisionAccelerators; Vector names; // most vectors are stored in a single memory block // except when compiled using MAX_UTIL defined // in that case, ToolVector becomes Vector<> and the // vectors are resizeable S8 * mMemoryBlock; TSMaterialList * materialList; // bounding information F32 radius; F32 tubeRadius; Point3F center; Box3F bounds; // various... U32 mExporterVersion; F32 mSmallestVisibleSize; // computed at load time from details vector S32 mSmallestVisibleDL; // ditto S32 mReadVersion; // file version that this shape was read from U32 mFlags; // hasTranslucancy, iflInit U32 data; // let the user do whatever with this bool mSequencesConstructed; S32 mVertexBuffer; U32 mCallbackKey; bool mExportMerge; bool mMorphable; Vector mPreviousMerge; S32 mMergeBufferSize; // shape class has few methods -- // just constructor/destructor, io, and lookup methods // constructor/destructor TSShape(); ~TSShape(); void init(); void initMaterialList(); // you can swap in a new material list, but call this if you do void clearDynamicData(); void setupBillboardDetails(); bool getSequencesConstructed() const { return mSequencesConstructed; } void setSequencesConstructed(const bool c) { mSequencesConstructed = c; } // look up animation info -- indexed by keyframe number and offset (which objecct/node/decal // of the animated objects/nodes/decals you want information for). QuatF & getRotation(const Sequence & seq, S32 keyframeNum, S32 rotNum, QuatF *) const; const Point3F & getTranslation(const Sequence & seq, S32 keyframeNum, S32 tranNum) const; F32 getUniformScale(const Sequence & seq, S32 keyframeNum, S32 scaleNum) const; const Point3F & getAlignedScale(const Sequence & seq, S32 keyframeNum, S32 scaleNum) const; TSScale & getArbitraryScale(const Sequence & seq, S32 keyframeNum, S32 scaleNum, TSScale *) const; const ObjectState & getObjectState(const Sequence & seq, S32 keyframeNum, S32 objectNum) const; const DecalState & getDecalState(const Sequence & seq, S32 keyframeNum, S32 decalNum) const; // build LOS collision detail void computeAccelerator(S32 dl); bool buildConvexHull(S32 dl) const; void computeBounds(S32 dl, Box3F & bounds) const; // uses default transforms to compute bounding box around a detail level // see like named method on shapeInstance if you want to use animated transforms // lookup methods S32 findName(const char *) const; const char * getName(S32) const; S32 findNode(S32 nameIndex) const; S32 findNode(const char * name) const { return findNode(findName(name)); } S32 findObject(S32 nameIndex) const; S32 findObject(const char * name) const { return findObject(findName(name)); } S32 findDecal(S32 nameIndex) const; S32 findDecal(const char * name) const { return findDecal(findName(name)); } S32 findIflMaterial(S32 nameIndex) const; S32 findIflMaterial(const char * name) const { return findIflMaterial(findName(name)); } S32 findDetail(S32 nameIndex) const; S32 findDetail(const char * name) const { return findDetail(findName(name)); } S32 findSequence(S32 nameIndex) const; S32 findSequence(const char * name) const { return findSequence(findName(name)); } bool hasTranslucency() const { return mFlags & HasTranslucency; } // these control default values for alpha transitions between detail levels static F32 smAlphaOutLastDetail; static F32 smAlphaInBillboard; static F32 smAlphaOutBillboard; static F32 smAlphaInDefault; static F32 smAlphaOutDefault; // don't load this many of the highest detail levels (although we always // load one renderable detail if there is one) static S32 smNumSkipLoadDetails; // by default we initialize shape when we read... static bool smInitOnRead; // version info // -- smVersion is most recent version...the one we write // -- smReadVersion is version currently being read // smReadVersion is only valid during a read static S32 smVersion; static S32 smReadVersion; static const U32 smMostRecentExporterVersion; // persist methods void write(Stream *); bool read(Stream *); void readOldShape(Stream * s, S32 * &, S16 * &, S8 * &, S32 &, S32 &, S32 &); void writeName(Stream *, S32 nameIndex); S32 readName(Stream *, bool addName); void exportSequences(Stream *); bool importSequences(Stream *); void readIflMaterials(); // persist helper functions static TSShapeAlloc alloc; void fixEndian(S32 *, S16 *, S8 *, S32, S32, S32); // memory buffer transfer methods (uses TSShape::Alloc structure) void assembleShape(); void disassembleShape(); // mem buffer transfer helper (indicate when we don't want to include a particular mesh/decal) bool checkSkip(S32 meshNum, S32 & curObject, S32 & curDecal, S32 skipDL); // used when reading old shapes/sequences void rearrangeKeyframeData(Sequence &, S32 keyframeStart, U8 * pns32 = NULL, U8 * pns16 = NULL, U8 * pos = NULL, U8 * pds = NULL, S32 szNS32=-1, S32 szNS16=-1, S32 szOS32=-1, S32 szDS32=-1); void rearrangeStates(S32 start, S32 rows, S32 cols, U8 * data, S32 size); void fixupOldSkins(S32 numMeshes, S32 numSkins, S32 numDetails, S32 * detailFirstSkin, S32 * detailNumSkins); }; class TSMaterialList : public MaterialList { typedef MaterialList Parent; Vector mFlags; Vector mReflectanceMaps; Vector mBumpMaps; Vector mDetailMaps; Vector mDetailScales; Vector mReflectionAmounts; bool mNamesTransformed; void allocate(U32 sz); public: static const char* csmTSTexturePrefix; // currently "skins/", set in tsShape.cc static const char* csmOldTSTexturePrefix; // currently "", set in tsShape.cc static const char* csmIFLTexturePrefix; public: enum { S_Wrap = 1 << 0, T_Wrap = 1 << 1, Translucent = 1 << 2, Additive = 1 << 3, Subtractive = 1 << 4, SelfIlluminating = 1 << 5, NeverEnvMap = 1 << 6, NoMipMap = 1 << 7, MipMap_ZeroBorder = 1 << 8, IflMaterial = 1 << 27, IflFrame = 1 << 28, DetailMapOnly = 1 << 29, BumpMapOnly = 1 << 30, ReflectanceMapOnly = 1 << 31, AuxiliaryMap = DetailMapOnly | BumpMapOnly | ReflectanceMapOnly }; TSMaterialList(U32 materialCount, const char **materialNames, const U32 * materialFlags, const U32 * reflectanceMaps, const U32 * bumpMaps, const U32 * detailMaps, const F32 * detailScales, const F32 * reflectionAmounts); TSMaterialList(); TSMaterialList(const TSMaterialList*); ~TSMaterialList(); void free(); void tsmlTransform(); void load(U32 index); bool load(TextureHandleType type, bool clampToEdge = false) { return Parent::load(type,clampToEdge); } TextureHandle * getReflectionMap(U32 index) { return mReflectanceMaps[index] == 0xFFFFFFFF ? NULL : &getMaterial(mReflectanceMaps[index]); } F32 getReflectionAmount(U32 index) { return mReflectionAmounts[index]; } TextureHandle * getBumpMap(U32 index) { return mBumpMaps[index] == 0xFFFFFFFF ? NULL : &getMaterial(mBumpMaps[index]); } TextureHandle * getDetailMap(U32 index) { return mDetailMaps[index] == 0xFFFFFFFF ? NULL : &getMaterial(mDetailMaps[index]); } F32 getDetailMapScale(U32 index) { return mDetailScales[index]; } bool reflectionInAlpha(U32 index) { return mReflectanceMaps[index] == index; } U32 getFlags(U32 index); void setFlags(U32 index, U32 value); void remap(U32 toIndex, U32 fromIndex); // support for ifl sequences // pre-load only ... support for ifl sequences void push_back(const char * name, U32 flags, U32 a=0xFFFFFFFF, U32 b=0xFFFFFFFF, U32 c=0xFFFFFFFF, F32 dm=1.0f, F32 em=1.0f); bool write(Stream &); bool read(Stream &); }; extern ResourceInstance *constructTSShape(Stream &stream); #define TSNode TSShape::Node #define TSObject TSShape::Object #define TSDecal TSShape::Decal #define TSSequence TSShape::Sequence #define TSDetail TSShape::Detail inline QuatF & TSShape::getRotation(const Sequence & seq, S32 keyframeNum, S32 rotNum, QuatF * quat) const { return nodeRotations[seq.baseRotation + rotNum*seq.numKeyframes + keyframeNum].getQuatF(quat); } inline const Point3F & TSShape::getTranslation(const Sequence & seq, S32 keyframeNum, S32 tranNum) const { return nodeTranslations[seq.baseTranslation + tranNum*seq.numKeyframes + keyframeNum]; } inline F32 TSShape::getUniformScale(const Sequence & seq, S32 keyframeNum, S32 scaleNum) const { return nodeUniformScales[seq.baseScale + scaleNum*seq.numKeyframes + keyframeNum]; } inline const Point3F & TSShape::getAlignedScale(const Sequence & seq, S32 keyframeNum, S32 scaleNum) const { return nodeAlignedScales[seq.baseScale + scaleNum*seq.numKeyframes + keyframeNum]; } inline TSScale & TSShape::getArbitraryScale(const Sequence & seq, S32 keyframeNum, S32 scaleNum, TSScale * scale) const { nodeArbitraryScaleRots[seq.baseScale + scaleNum*seq.numKeyframes + keyframeNum].getQuatF(&scale->mRotate); scale->mScale = nodeArbitraryScaleFactors[seq.baseScale + scaleNum*seq.numKeyframes + keyframeNum]; return *scale; } inline const TSShape::ObjectState & TSShape::getObjectState(const TSSequence & seq, S32 keyframeNum, S32 objectNum) const { return objectStates[seq.baseObjectState + objectNum*seq.numKeyframes + keyframeNum]; } inline const TSShape::DecalState & TSShape::getDecalState(const TSSequence & seq, S32 keyframeNum, S32 decalNum) const { return decalStates[seq.baseDecalState + decalNum*seq.numKeyframes + keyframeNum]; } #endif