Tribes2/engine
1
0
Fork 0
mirror of https://github.com/tribes2/engine.git synced 2026-01-21 12:14:46 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
engine/ts/tsShapeInstance.h
loop ff569bd2ae t2 engine svn checkout
2024-01-07 04:36:33 +00:00

674 lines
25 KiB
C++
Raw Permalink Blame History

//-----------------------------------------------------------------------------
// V12 Engine
//
// Copyright (c) 2001 GarageGames.Com
// Portions Copyright (c) 2001 by Sierra Online, Inc.
//-----------------------------------------------------------------------------
#ifndef _TSSHAPEINSTANCE_H_
#define _TSSHAPEINSTANCE_H_
#ifndef _PLATFORM_H_
#include "platform/platform.h"
#endif
#ifndef _TSSHAPE_H_
#include "ts/tsShape.h"
#endif
#ifndef _TSINTEGERSET_H_
#include "ts/tsIntegerSet.h"
#endif
#ifndef _CONSOLE_H_
#include "console/console.h"
#endif
#ifndef _GBITMAP_H_
#include "dgl/gBitmap.h"
#endif
class RenderItem;
class TSThread;
class ConvexFeature;
//-------------------------------------------------------------------------------------
// Instance versions of shape objects
//-------------------------------------------------------------------------------------
struct TSVertex
{
Point3F p;
ColorI color;
Point2F t1;
Point2F t2;
};
class TSShapeInstance
{
public:
struct ObjectInstance;
friend class TSThread;
friend class TSPartInstance;
static void init();
static void destroy();
// An objectInstance points to the renderable items in the shape...
struct ObjectInstance
{
// this needs to be set before using an objectInstance...tells us where to
// look for the transforms...gets set be shape instance 'setStatics' method
static MatrixF * smTransforms;
S32 nodeIndex;
MatrixF * getTransform();
virtual void render(S32 objectDetail, TSMaterialList *);
virtual void renderEnvironmentMap(S32 objectDetail, TSMaterialList *);
virtual void renderDetailMap(S32 objectDetail, TSMaterialList *);
virtual void renderFog(S32 objectDetail, TSMaterialList*);
// collision routines...
virtual bool buildPolyList(S32 objectDetail, AbstractPolyList *, U32 & surfaceKey);
virtual bool getFeatures(S32 objectDetail, const MatrixF& mat, const Point3F& n, ConvexFeature*, U32 & surfaceKey);
virtual void support(S32 od, const Point3F& v, F32* currMaxDP, Point3F* currSupport);
virtual bool castRay(S32 objectDetail, const Point3F & start, const Point3F & end, RayInfo *);
};
// these are set up by default based on shape data
struct MeshObjectInstance : ObjectInstance
{
TSMesh * const * meshList; // one mesh per detail level...Null entries allowed
const TSObject * object;
S32 frame;
S32 matFrame;
F32 visible;
S32 getSizeVB(S32 size);
bool hasMergeIndices();
void fillVB(S32 vb, TSMaterialList *materials);
void morphVB(S32 vb, S32 &previousMerge, S32 objectDetail, TSMaterialList *materials);
void renderVB(S32 vb, S32 objectDetail, TSMaterialList *materials);
void render(S32 objectDetail, TSMaterialList *); // this just selects the right detail level (mesh) and calls meshes render
void renderEnvironmentMap(S32 objectDetail, TSMaterialList *);
void renderDetailMap(S32 objectDetail, TSMaterialList *);
void renderShadow(S32 objectDetail, const MatrixF & mat, S32 dim, U32 * bits, TSMaterialList *);
void renderFog(S32 objectDetail, TSMaterialList*);
TSMesh * getMesh(S32 num) const { return num<object->numMeshes ? *(meshList+num) : NULL; }
// collision routines...
bool buildPolyList(S32 objectDetail, AbstractPolyList *, U32 & surfaceKey);
bool getFeatures(S32 objectDetail, const MatrixF& mat, const Point3F& n, ConvexFeature*, U32 & surfaceKey);
void support(S32 od, const Point3F& v, F32* currMaxDP, Point3F* currSupport);
bool castRay(S32 objectDetail, const Point3F & start, const Point3F & end, RayInfo *);
};
// also set up based on shape data...they refer to mesh object instances
struct DecalObjectInstance : ObjectInstance
{
TSDecalMesh * const * decalList;
const MeshObjectInstance * targetObject;
const TSShape::Decal * decalObject;
S32 frame;
void render(S32 objectDetail, TSMaterialList *);
TSDecalMesh * getDecalMesh(S32 num) const { return num<decalObject->numMeshes ? *(decalList+num) : NULL; }
// we don't do these things...
// void renderEnvironmentMap(S32,TSMaterialList*) {}
// void renderDecalMap(S32,TSMaterialList*) {}
// bool getFeatures(S32 objectDetail, const MatrixF& mat, const Point3F& n, ConvexFeature*, U32 & surfaceKey);
bool buildPolyList(S32, AbstractPolyList *, U32 &) { return false; }
bool castRay(S32, const Point3F &, const Point3F &, RayInfo *) { return false; }
};
// ifl objects ... controlled by animation but also can be controlled by user
struct IflMaterialInstance
{
const TSShape::IflMaterial * iflMaterial;
S32 frame;
};
//-------------------------------------------------------------------------------------
// Lists used for storage of transforms, nodes, objects, etc...
//-------------------------------------------------------------------------------------
public:
Vector<MeshObjectInstance> mMeshObjects;
Vector<DecalObjectInstance> mDecalObjects;
Vector<IflMaterialInstance> mIflMaterialInstances;
// storage space for node transforms
Vector<MatrixF> mNodeTransforms;
// reference transform vectors -- unused until first transition
Vector<Quat16> mNodeReferenceRotations;
Vector<Point3F> mNodeReferenceTranslations;
Vector<F32> mNodeReferenceUniformScales;
Vector<Point3F> mNodeReferenceScaleFactors;
Vector<Quat16> mNodeReferenceArbitraryScaleRots;
// workspace for node transforms
static Vector<QuatF> smNodeCurrentRotations;
static Vector<Point3F> smNodeCurrentTranslations;
static Vector<F32> smNodeCurrentUniformScales;
static Vector<Point3F> smNodeCurrentAlignedScales;
static Vector<TSScale> smNodeCurrentArbitraryScales;
// keep track of who controls what on currently animating shape
static Vector<TSThread*> smRotationThreads;
static Vector<TSThread*> smTranslationThreads;
static Vector<TSThread*> smScaleThreads;
//-------------------------------------------------------------------------------------
// Misc.
//-------------------------------------------------------------------------------------
protected:
// ground transform data
MatrixF mGroundTransform;
TSThread * mGroundThread;
bool mScaleCurrentlyAnimated;
S32 mCurrentDetailLevel;
F32 mCurrentIntraDetailLevel; // 0-1, how far along from current to next (higher) detail level...
// 0=at this dl, 1=at higher detail level, where higher means bigger size on screen
// for dl=0, we use twice detail level 0's size as the size of the "next" dl
Resource<TSShape> hShape;
TSShape * mShape;
TSMaterialList* mMaterialList; // by default, points to hShape material list
bool mOwnMaterialList;
TextureHandle mEnvironmentMap;
bool mEnvironmentMapOn;
F32 mEnvironmentMapAlpha;
bool mAllowTwoPassEnvironmentMap;
bool mAlphaIsReflectanceMap;
bool mAllowTwoPassDetailMap;
S32 mMaxEnvironmentMapDL;
S32 mMaxDetailMapDL;
bool mAlphaAlways;
F32 mAlphaAlwaysValue;
bool mDrawFog;
bool mBalloonShape;
F32 mBalloonValue;
bool mUseOverrideTexture;
TextureHandle mOverrideTexture;
U32 debrisRefCount;
// the threads...
Vector<TSThread*> mThreadList;
Vector<TSThread*> mTransitionThreads;
// keep track of nodes that are involved in a transition
// Note: this only tracks nodes we're transitioning from...
// nodes we're transitioning to are implicitly handled
// (i.e., we don't need to keep track of them)
TSIntegerSet mTransitionRotationNodes;
TSIntegerSet mTransitionTranslationNodes;
TSIntegerSet mTransitionScaleNodes;
// keep track of nodes with animation restrictions put on them
TSIntegerSet mMaskRotationNodes;
TSIntegerSet mMaskPosXNodes;
TSIntegerSet mMaskPosYNodes;
TSIntegerSet mMaskPosZNodes;
TSIntegerSet mDisableBlendNodes;
TSIntegerSet mHandsOffNodes;
TSIntegerSet mCallbackNodes;
// state variables
U32 mTriggerStates;
bool initGround();
void addPath(TSThread * gt, F32 start, F32 end, MatrixF * mat = NULL);
// environment/detail map methods
void setupTexturing(S32 dl, F32 intraDL);
bool twoPassEnvironmentMap();
bool twoPassDetailMap();
bool twoPassFog();
void renderEnvironmentMap();
void renderDetailMap();
void renderFog();
// directX render
bool renderMeshesX(S32 ss, S32 od);
bool renderDecalsX(S32 ss, S32 od);
public:
TSShape* getShape() { return mShape; }
// set non-rendering static variables used for accessing shape data
void setStatics(S32 dl = 0, F32 interDL = 0.0f, const Point3F * shapeScale = NULL);
void clearStatics();
TSMaterialList* getMaterialList() { return mMaterialList; }
void setMaterialList(TSMaterialList*); // we won't own the material list unless we clone it (see below)
void cloneMaterialList(); // call this to own the material list -- i.e., we'll make a copy of the currently
// set material list and be responsible for deleting it...if we don't own the list,
// then the application better not delete the set list out from under us (all this
// is handled automatically when using the shape's original list).
bool ownMaterialList() const { return mOwnMaterialList; }
enum
{
MaskNodeRotation = 0x01,
MaskNodePosX = 0x02,
MaskNodePosY = 0x04,
MaskNodePosZ = 0x08,
MaskNodeBlend = 0x10,
MaskNodeAll = MaskNodeRotation|MaskNodePosX|MaskNodePosY|MaskNodePosZ|MaskNodeBlend,
MaskNodeAllButBlend = MaskNodeRotation|MaskNodePosX|MaskNodePosY|MaskNodePosZ,
MaskNodeAllButRotation = MaskNodePosX|MaskNodePosY|MaskNodePosZ|MaskNodeBlend,
MaskNodeAllButPosX = MaskNodeRotation|MaskNodePosY|MaskNodePosZ|MaskNodeBlend,
MaskNodeAllButPosY = MaskNodeRotation|MaskNodePosX|MaskNodePosZ|MaskNodeBlend,
MaskNodeAllButPosZ = MaskNodeRotation|MaskNodePosX|MaskNodePosY|MaskNodeBlend,
MaskNodeHandsOff = 0x20, // meaning, don't even set to default, programmer controls it (blend still applies)
MaskNodeCallback = 0x40 // meaning, get local transform via callback function (see setCallback)
// callback data2 is node index, callback return value is pointer to local transform
// Note: won't get this callback everytime you animate...application responsibility
// to make sure matrix pointer continues to point to valid and updated local transform
};
// set node masking...
void setNodeAnimationState(S32 nodeIndex, U32 animationState);
U32 getNodeAnimationState(S32 nodeIndex);
// check trigger values
bool getTriggerState(U32 stateNum, bool clearState = true);
void setTriggerState(U32 stateNum, bool on);
void setTriggerStateBit(U32 stateBit, bool on);
// callback functions...
enum CallbackPurpose { LocalTransformCallback = 0 };
typedef void * (*CallbackFunction)(CallbackPurpose, U32 data1, U32 data2);
CallbackFunction mCallback;
U32 mCallbackData;
void setCallback(CallbackFunction cb, U32 data1) { mCallback = cb; mCallbackData = data1; }
// debris management...
void incDebrisRefCount();
void decDebrisRefCount();
U32 getDebrisRefCount();
// alpha always
void setAlphaAlways(F32 value) { mAlphaAlways = (value<0.99f); mAlphaAlwaysValue = value; }
F32 getAlphaAlwaysValue() { return mAlphaAlways ? mAlphaAlwaysValue : 1.0f; }
bool getAlphaAlways() { return mAlphaAlways; }
// Balloon value
void setShapeBalloon(F32 value) { mBalloonShape = value > 1; mBalloonValue = value; }
F32 getBalloonValue() const { return mBalloonShape ? mBalloonValue : 1.0f; }
// Override texture
void setOverrideTexture(TextureHandle override) { mOverrideTexture = override; mUseOverrideTexture = true; }
void clearOverrideTexture() { mOverrideTexture = NULL; mUseOverrideTexture = false; }
enum
{
NO_ENVIRONMENT_MAP, // don't render environment map
ENVIRONMENT_MAP_MULTI_1, // render with multi-texturing (+1 texture units), shape alpha = reflectance map
ENVIRONMENT_MAP_MULTI_3, // render with multi-texturing (+3 texture units), reflectance map separate texture
ENVIRONMENT_MAP_TWO_PASS, // render in two passes -- mAllowTwoPassEnvironmentMap must be true
// Note: if reflectance map is separate from shape texture then won't render unless card has 4 texture units
// However, translucency won't work quite right if reflection map not separated -- probably ok though.
// Bottom line: previous 2 items probably only used for special shapes...
NO_DETAIL_MAP,
DETAIL_MAP_MULTI_1,
DETAIL_MAP_MULTI_2,
DETAIL_MAP_TWO_PASS,
NO_FOG,
FOG_MULTI_1,
FOG_MULTI_1_TEXGEN,
FOG_TWO_PASS,
FOG_TWO_PASS_TEXGEN
};
const TextureHandle & getEnvironmentMap() { return mEnvironmentMap; }
F32 getEnvironmentMapAlpha() { return mEnvironmentMapAlpha; }
void setEnvironmentMap(const TextureHandle& map) { mEnvironmentMap = map; }
void setEnvironmentMapOn(bool on, F32 alpha = 0.25f) { mEnvironmentMapOn = on; mEnvironmentMapAlpha = alpha; }
//-------------------------------------------------------------------------------------
// private methods for setting up and affecting animation
//-------------------------------------------------------------------------------------
private:
void updateTransitions();
void handleDefaultScale(S32 a, S32 b, TSIntegerSet & scaleBeenSet);
void handleTransitionNodes(S32 a, S32 b);
void handleNodeScale(S32 a, S32 b);
void handleAnimatedScale(TSThread *, S32 a, S32 b, TSIntegerSet &);
void handleMaskedPositionNode(TSThread *, S32 nodeIndex, S32 offset);
void handleBlendSequence(TSThread *, S32 a, S32 b);
void checkScaleCurrentlyAnimated();
//-------------------------------------------------------------------------------------
// animate, render, & detail control
//-------------------------------------------------------------------------------------
public:
struct RenderData
{
MatrixF * currentTransform;
S32 detailLevel;
F32 intraDetailLevel;
S32 environmentMapMethod;
S32 detailMapMethod;
S32 detailMapTE;
S32 environmentMapTE;
F32 environmentMapAlpha;
U32 environmentMapGLName;
S32 baseTE;
F32 detailTextureScale;
F32 detailMapAlpha;
bool fadeSet;
bool lightingOn;
bool alwaysAlpha;
F32 alwaysAlphaValue;
bool balloonShape;
F32 balloonValue;
U32 materialFlags;
S32 materialIndex;
const Point3F * objectScale;
bool fogOn;
S32 fogMethod;
S32 fogTE;
Point4F fogColor;
Point4F fogTexGenS;
Point4F fogTexGenT;
TextureHandle * fogMapHandle; // used by texgen fog
bool useOverride;
TextureHandle override;
bool textureMatrixPushed;
bool fogTexture;
GBitmap *fogBitmap;
TextureHandle *fogHandle;
bool renderDecals;
struct VertexAlpha
{
// track various contributors to vertex alpha
F32 vis;
F32 emap;
F32 fog;
F32 always;
// current result...
F32 current;
void init() { current=vis=emap=fog=always=1.0f; }
bool set() { F32 old = current; current =vis*emap*fog*always; return (mFabs(old-current)>0.001f); }
} vertexAlpha;
};
static RenderData smRenderData;
// if true, skip these objects
static bool smNoRenderTranslucent;
static bool smNoRenderNonTranslucent;
// when taking hiQuality snapshot, scale intermediate bitmaps up to this amount
static S32 smMaxSnapshotScale;
// scale pixel size by this amount when selecting detail levels
static F32 smDetailAdjust;
// a different error metrix used by newer shapes (screen error from hi detail)
static F32 smScreenError;
// never choose detail level number below this value (except if
// only way to get a visible detail)
static S32 smNumSkipRenderDetails;
static bool smSkipFirstFog;
static bool smSkipFog;
virtual void render(const Point3F * objectScale = NULL);
virtual void render(S32 dl, F32 intraDL = 0.0f, const Point3F * objectScale = NULL);
void renderShadow(S32 dl, const MatrixF & mat, S32 dim, U32 * bits);
void setupFog(F32 fogAmount, const ColorF & fogColor);
void setupFog(F32 fogAmount, TextureHandle * fogMap, Point4F & s, Point4F & t);
GBitmap * snapshot(U32 width, U32 height, bool mipmap, MatrixF & cameraMatrix, bool hiQuality);
static GBitmap * snapshot(TSShape *, U32 width, U32 height, bool mipmap, MatrixF & cameraMatrix, S32 dl, F32 intraDL = 0.0f, bool hiQuality = false);
void animate();
void animate(S32 dl);
void animateNodes(S32 ss);
void animateVisibility(S32 ss);
void animateFrame(S32 ss);
void animateMatFrame(S32 ss);
void animateDecals(S32 ss);
void animateIfls();
void animateSubtrees(bool forceFull = true);
void animateNodeSubtrees(bool forceFull = true);
bool hasTranslucency();
bool hasSolid();
// query about animated scale
bool animatesScale() { return (mShape->mFlags & TSShape::AnyScale) != 0; }
bool animatesUniformScale() { return (mShape->mFlags & TSShape::UniformScale) != 0; }
bool animatesAlignedScale() { return (mShape->mFlags & TSShape::AlignedScale) != 0; }
bool animatesArbitraryScale() { return (mShape->mFlags & TSShape::ArbitraryScale) != 0; }
bool scaleCurrentlyAnimated() { return mScaleCurrentlyAnimated; }
//
bool inTransition() { return !mTransitionThreads.empty(); }
// open up mAlphaIsReflectanceMap for custom rendering
bool queryAlphaIsReflectanceMap(){ return mAlphaIsReflectanceMap; }
void setAlphaIsReflectanceMap( bool val ){ mAlphaIsReflectanceMap = val; }
void animateGround(); // clears previous ground transform
MatrixF & getGroundTransform() { return mGroundTransform; }
void deltaGround(TSThread *, F32 start, F32 end, MatrixF * mat = NULL);
void deltaGround1(TSThread *, F32 start, F32 end, MatrixF& mat);
U32 getNumDetails();
S32 getCurrentDetail();
F32 getCurrentIntraDetail();
void setCurrentDetail(S32 dl, F32 intraDL=1.0f);
S32 selectCurrentDetail(bool ignoreScale = false);
S32 selectCurrentDetail(Point3F offset, F32 invScale = 1.0f);
S32 selectCurrentDetail(F32 pixelSize);
S32 selectCurrentDetail2(F32 adjustedDist);
// fancy detail selection -- uses screen error
S32 selectCurrentDetailEx(bool ignoreScale = false);
S32 selectCurrentDetail2Ex(F32 adjustedDist);
S32 selectCurrentDetailEx(F32 errorTOL);
enum
{
TransformDirty = 1 << 0,
VisDirty = 1 << 1,
FrameDirty = 1 << 2,
MatFrameDirty = 1 << 3,
DecalDirty = 1 << 4,
IflDirty = 1 << 5,
ThreadDirty = 1 << 6,
AllDirtyMask = TransformDirty | VisDirty | FrameDirty | MatFrameDirty | DecalDirty | IflDirty | ThreadDirty
};
U32 * mDirtyFlags;
void setDirty(U32 dirty);
void clearDirty(U32 dirty);
//-------------------------------------------------------------------------------------
// collision interface routines
//-------------------------------------------------------------------------------------
public:
bool buildPolyList(AbstractPolyList *, S32 dl);
bool getFeatures(const MatrixF& mat, const Point3F& n, ConvexFeature*, S32 dl);
bool castRay(const Point3F & start, const Point3F & end, RayInfo *,S32 dl);
bool quickLOS(const Point3F & start, const Point3F & end, S32 dl) { return castRay(start,end,NULL,dl); }
Point3F support(const Point3F & v, S32 dl);
void computeBounds(S32 dl, Box3F & bounds); // uses current transforms to compute bounding box around a detail level
// see like named method on shape if you want to use default transforms
//-------------------------------------------------------------------------------------
// Thread Control
//-------------------------------------------------------------------------------------
public:
TSThread * addThread();
TSThread * getThread(S32 threadNumber); // Note: threads can change order, best to hold
// onto a thread from the start
void destroyThread(TSThread * thread);
S32 threadCount();
void setSequence(TSThread *, S32 seq, F32 pos);
void transitionToSequence(TSThread *, S32 seq, F32 pos, F32 duration, bool continuePlay);
void clearTransition(TSThread *);
S32 getSequence(TSThread *);
void setBlendEnabled(TSThread *, bool blendOn);
bool getBlendEnabled(TSThread *);
F32 getTime(TSThread * thread);
F32 getPos(TSThread * thread);
void setTime(TSThread * thread, F32 time);
void setPos(TSThread * thread, F32 pos);
bool isInTransition(TSThread * thread);
F32 getTimeScale(TSThread * thread);
void setTimeScale(TSThread * thread, F32);
F32 getDuration(TSThread * thread);
F32 getScaledDuration(TSThread * thread);
S32 getKeyframeCount(TSThread * thread);
S32 getKeyframeNumber(TSThread * thread);
void setKeyframeNumber(TSThread * thread, S32 kf);
void advanceTime(F32 delta, TSThread *); // advance time on a particular thread
void advanceTime(F32 delta); // advance time on all threads
void advancePos(F32 delta, TSThread *); // advance pos on a particular thread
void advancePos(F32 delta); // advance pos on all threads
//-------------------------------------------------------------------------------------
// constructors, destructors, initialization, io
//-------------------------------------------------------------------------------------
TSShapeInstance( const Resource<TSShape> & shape, bool loadMaterials = true);
TSShapeInstance( TSShape * pShape, bool loadMaterials = true);
~TSShapeInstance();
void buildInstanceData(TSShape *, bool loadMaterials);
void dump(Stream &);
void dumpNode(Stream &, S32 level, S32 nodeIndex, Vector<S32> & detailSizes);
void dumpDecals(Stream &, S32 indent, MeshObjectInstance *);
U32 mData; // available for use by app...initialized to 0
};
inline MatrixF * TSShapeInstance::ObjectInstance::getTransform()
{
return nodeIndex<0 ? NULL : smTransforms + nodeIndex;
}
//-------------------------------------------------------------------------------------
// Thread class
//-------------------------------------------------------------------------------------
// An animation thread: runtime data associated with a single sequence that is
// running (or two sequences if in transition between them).
// A shape can have multiple threads running...when multiple threads are running,
// which thread/sequence controls which node or object is determined based
// on priority of the sequence.
// Note: all thread data and methods are private (but shapeInstance is a friend).
// Users should treat thread pointers like keys -- they are used to id
// the thread when interfacing with the shape, but are not manipulated
// by anything but the shapeInstance. See "Thread control" methods
// for more info on controlling threads.
class TSThread
{
friend class TSShapeInstance;
S32 priority;
TSShapeInstance * mShapeInstance;
const TSSequence * sequence;
F32 pos;
F32 timeScale;
S32 keyNum1;
S32 keyNum2;
F32 keyPos;
bool blendDisabled;
// if in transition...
struct TransitionData
{
bool inTransition;
F32 duration;
F32 pos;
F32 direction;
F32 targetScale; // time scale for sequence we are transitioning to (during transition only)
// this is either 1 or 0 (if 1 target sequence plays as we transition, if 0 it doesn't)
TSIntegerSet oldRotationNodes; // nodes controlled by this thread pre-transition
TSIntegerSet oldTranslationNodes; // nodes controlled by this thread pre-transition
TSIntegerSet oldScaleNodes; // nodes controlled by this thread pre-transition
S32 oldSequence; // sequence that was set before transition began
F32 oldPos; // position of sequence before transition began
} transitionData;
struct
{
F32 start;
F32 end;
S32 loop;
} path;
bool makePath;
void selectKeyframes(F32 pos, const TSSequence * seq, S32 * k1, S32 * k2, F32 * kpos);
void getGround(F32 p, MatrixF * pMat);
// called by advancePos
void animateTriggers();
void activateTriggers(F32 a, F32 b);
// methods -- accessible through shape only
void setSequence(S32 seq, F32 pos);
void transitionToSequence(S32 seq, F32 pos, F32 duration, bool continuePlay);
void advanceTime(F32 delta);
void advancePos(F32 delta);
F32 getTime();
F32 getPos();
void setTime(F32);
void setPos(F32);
bool isInTransition();
F32 getTimeScale();
void setTimeScale(F32);
F32 getDuration();
F32 getScaledDuration();
S32 getKeyframeCount();
S32 getKeyframeNumber();
void setKeyframeNumber(S32 kf);
TSThread(TSShapeInstance*);
TSThread() {}
public:
S32 operator<(const TSThread &) const;
};
typedef TSShapeInstance::ObjectInstance TSObjectInstance;
#endif
Reference in a new issue View git blame Copy permalink