TSShape Class Reference

#include <tsShape.h>

Detailed Description

TSShape stores generic data for a 3space model.

TSShape and TSShapeInstance act in conjunction to allow the rendering and manipulation of a three dimensional model.

Note:: The material lists are the only thing that is not loaded in TSShape. instead, they are loaded in TSShapeInstance because of a former restriction on the resource manager where only one file could be opened at a time. The resource manager restriction has been resolved, but the material lists are still loaded in TSShapeInstance.

See also:: TSShapeInstance for a further discussion of the 3space system.

Persist Helper Functions

void fixEndian (S32 *, S16 *, S8 *, S32, S32, S32)

static TSShapeAlloc tsalloc

Public Types

UniformScale = BIT(0)

AlignedScale = BIT(1)

ArbitraryScale = BIT(2)

Blend = BIT(3)

Cyclic = BIT(4)

MakePath = BIT(5)

IflInit = BIT(6)

HasTranslucency = BIT(7)

AnyScale = UniformScale | AlignedScale | ArbitraryScale

enum {
  UniformScale = BIT(0),
  AlignedScale = BIT(1),
  ArbitraryScale = BIT(2),
  Blend = BIT(3),
  Cyclic = BIT(4),
  MakePath = BIT(5),
  IflInit = BIT(6),
  HasTranslucency = BIT(7),
  AnyScale = UniformScale | AlignedScale | ArbitraryScale
}

Public Member Functions

TSShape ()

~TSShape ()

void init ()

void initMaterialList ()

you can swap in a new material list, but call this if you do

bool preloadMaterialList (const Torque::Path &path)

called to preload and validate the materials in the mat list

void setupBillboardDetails (TSShapeInstance *shape)

bool getSequencesConstructed () const

void setSequencesConstructed (const bool c)

void computeAccelerator (S32 dl)

build LOS collision detail

bool buildConvexHull (S32 dl) const

void computeBounds (S32 dl, Box3F &bounds) const

bool checkSkip (S32 meshNum, S32 &curObject, S32 skipDL)

mem buffer transfer helper (indicate when we don't want to include a particular mesh/decal)

void fixupOldSkins (S32 numMeshes, S32 numSkins, S32 numDetails, S32 *detailFirstSkin, S32 *detailNumSkins)

Collision Accelerators

For speeding up buildpolylist and support calls.

ConvexHullAccelerator * getAccelerator (S32 dl)

Lookup Animation Info

indexed by keyframe number and offset (which object/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

Lookup Methods

S32 findName (const String &name) const

const String & getName (S32 nameIndex) const

S32 findNode (S32 nameIndex) const

S32 findNode (const String &name) const

S32 findObject (S32 nameIndex) const

S32 findObject (const String &name) const

S32 findIflMaterial (S32 nameIndex) const

S32 findIflMaterial (const String &name) const

S32 findDetail (S32 nameIndex) const

S32 findDetail (const String &name) const

S32 findSequence (S32 nameIndex) const

S32 findSequence (const String &name) const

bool hasTranslucency () const

Persist Methods

Methods for saving/loading shapes to/from streams

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 createEmptyShape ()

Initializes our TSShape to be ready to receive put mesh data.

bool readMD2 (Stream *)

void exportSequences (Stream *)

bool importSequences (Stream *)

void readIflMaterials (const char *shapePath)

Memory Buffer Transfer Methods

uses TSShape::Alloc structure

void assembleShape ()

void disassembleShape ()

Public Attributes

S8 * mMemoryBlock

Memory block for data storage.

TSMaterialList * materialList

U32 mExporterVersion

F32 mSmallestVisibleSize

Computed at load time from details vector.

S32 mSmallestVisibleDL

S32 mReadVersion

File version that this shape was read from.

U32 mFlags

hasTranslucancy, iflInit

U32 data

User-defined data storage.

bool mSequencesConstructed

Shape Vector Data

FixedVector< Node > nodes

FixedVector< Object > objects

FixedVector< IflMaterial > iflMaterials

FixedVector< ObjectState > objectStates

FixedVector< S32 > subShapeFirstNode

FixedVector< S32 > subShapeFirstObject

FixedVector< S32 > detailFirstSkin

FixedVector< S32 > subShapeNumNodes

FixedVector< S32 > subShapeNumObjects

FixedVector< Detail > details

FixedVector< Quat16 > defaultRotations

FixedVector< Point3F > defaultTranslations

FixedVector< S32 > subShapeFirstTranslucentObject

These are set up at load time, but memory is allocated along with loaded data.

FixedVector< TSMesh * > meshes

Alpha Vectors

these vectors describe how to transition between detail 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

FixedVector< F32 > alphaIn

FixedVector< F32 > alphaOut

Resizeable vectors

Vector< Sequence > sequences

Vector< Quat16 > nodeRotations

Vector< Point3F > nodeTranslations

Vector< F32 > nodeUniformScales

Vector< Point3F > nodeAlignedScales

Vector< Quat16 > nodeArbitraryScaleRots

Vector< Point3F > nodeArbitraryScaleFactors

Vector< Quat16 > groundRotations

Vector< Point3F > groundTranslations

Vector< Trigger > triggers

Vector< F32 > iflFrameOffTimes

Vector< TSLastDetail * > billboardDetails

Vector< ConvexHullAccelerator * > detailCollisionAccelerators

Vector< String > names

Bounding

F32 radius

F32 tubeRadius

Point3F center

Box3F bounds

Static Public Attributes

static S32 smNumSkipLoadDetails

don't load this many of the highest detail levels (although we always load one renderable detail if there is one)

static bool smInitOnRead

by default we initialize shape when we read...

Alpha Transitions

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

Version Info

static S32 smVersion

Most recent version...the one we write.

static S32 smReadVersion

Version currently being read, only valid during read.

static const U32 smMostRecentExporterVersion

Classes

struct ConvexHullAccelerator

struct Detail

Details are used for render detail selection. More...

struct IflMaterial

IFL Materials are used to animate material lists -- i.e., run through a series of frames of a material. More...

struct Node

Nodes hold the transforms in the shape's tree. They are the bones of the skeleton. More...

struct Object

Objects hold renderable items (in particular meshes). More...

struct ObjectState

Describes state of an individual object. More...

struct Sequence

A Sequence holds all the information necessary to perform a particular animation (sequence). More...

struct Trigger

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. More...

Member Enumeration Documentation

anonymous enum

Enumerator:

UniformScale
AlignedScale
ArbitraryScale
Blend
Cyclic
MakePath
IflInit
HasTranslucency
AnyScale

Constructor & Destructor Documentation

TSShape::TSShape ( )

TSShape::~TSShape ( )

Member Function Documentation

ConvexHullAccelerator* TSShape::getAccelerator ( S32 dl )

void TSShape::init ( )

void TSShape::initMaterialList ( )

you can swap in a new material list, but call this if you do

bool TSShape::preloadMaterialList ( const Torque::Path & path )

called to preload and validate the materials in the mat list

void TSShape::setupBillboardDetails ( TSShapeInstance * shape )

bool TSShape::getSequencesConstructed ( ) const [inline]

void TSShape::setSequencesConstructed ( const bool c ) [inline]

QuatF & TSShape::getRotation	(	const Sequence &	seq,
		S32	keyframeNum,
		S32	rotNum,
		QuatF *
	)			const `[inline]`

const Point3F & TSShape::getTranslation	(	const Sequence &	seq,
		S32	keyframeNum,
		S32	tranNum
	)			const `[inline]`

F32 TSShape::getUniformScale	(	const Sequence &	seq,
		S32	keyframeNum,
		S32	scaleNum
	)			const `[inline]`

const Point3F & TSShape::getAlignedScale	(	const Sequence &	seq,
		S32	keyframeNum,
		S32	scaleNum
	)			const `[inline]`

TSScale & TSShape::getArbitraryScale	(	const Sequence &	seq,
		S32	keyframeNum,
		S32	scaleNum,
		TSScale *
	)			const `[inline]`

const TSShape::ObjectState & TSShape::getObjectState	(	const Sequence &	seq,
		S32	keyframeNum,
		S32	objectNum
	)			const `[inline]`

void TSShape::computeAccelerator ( S32 dl )

build LOS collision detail

bool TSShape::buildConvexHull ( S32 dl ) const

void TSShape::computeBounds	(	S32	dl,
		Box3F &	bounds
	)			const

S32 TSShape::findName ( const String & name ) const

const String& TSShape::getName ( S32 nameIndex ) const

S32 TSShape::findNode ( S32 nameIndex ) const

S32 TSShape::findNode ( const String & name ) const [inline]

S32 TSShape::findObject ( S32 nameIndex ) const

S32 TSShape::findObject ( const String & name ) const [inline]

S32 TSShape::findIflMaterial ( S32 nameIndex ) const

S32 TSShape::findIflMaterial ( const String & name ) const [inline]

S32 TSShape::findDetail ( S32 nameIndex ) const

S32 TSShape::findDetail ( const String & name ) const [inline]

S32 TSShape::findSequence ( S32 nameIndex ) const

S32 TSShape::findSequence ( const String & name ) const [inline]

bool TSShape::hasTranslucency ( ) const [inline]

void TSShape::write ( Stream * )

bool TSShape::read ( Stream * )

void TSShape::readOldShape	(	Stream *	s,
		S32 *&	,
		S16 *&	,
		S8 *&	,
		S32 &	,
		S32 &	,
		S32 &
	)

void TSShape::writeName	(	Stream *	,
		S32	nameIndex
	)

S32 TSShape::readName	(	Stream *	,
		bool	addName
	)

void TSShape::createEmptyShape ( )

Initializes our TSShape to be ready to receive put mesh data.

bool TSShape::readMD2 ( Stream * )

void TSShape::exportSequences ( Stream * )

bool TSShape::importSequences ( Stream * )

void TSShape::readIflMaterials ( const char * shapePath )

void TSShape::fixEndian	(	S32 *	,
		S16 *	,
		S8 *	,
		S32	,
		S32	,
		S32
	)

void TSShape::assembleShape ( )

void TSShape::disassembleShape ( )

bool TSShape::checkSkip	(	S32	meshNum,
		S32 &	curObject,
		S32	skipDL
	)

mem buffer transfer helper (indicate when we don't want to include a particular mesh/decal)

void TSShape::fixupOldSkins	(	S32	numMeshes,
		S32	numSkins,
		S32	numDetails,
		S32 *	detailFirstSkin,
		S32 *	detailNumSkins
	)

Member Data Documentation

FixedVector<Node> TSShape::nodes

FixedVector<Object> TSShape::objects

FixedVector<IflMaterial> TSShape::iflMaterials

FixedVector<ObjectState> TSShape::objectStates

FixedVector<S32> TSShape::subShapeFirstNode

FixedVector<S32> TSShape::subShapeFirstObject

FixedVector<S32> TSShape::detailFirstSkin

FixedVector<S32> TSShape::subShapeNumNodes

FixedVector<S32> TSShape::subShapeNumObjects

FixedVector<Detail> TSShape::details

FixedVector<Quat16> TSShape::defaultRotations

FixedVector<Point3F> TSShape::defaultTranslations

FixedVector<S32> TSShape::subShapeFirstTranslucentObject

These are set up at load time, but memory is allocated along with loaded data.

FixedVector<TSMesh*> TSShape::meshes

FixedVector<F32> TSShape::alphaIn

FixedVector<F32> TSShape::alphaOut

Vector<Sequence> TSShape::sequences

Vector<Quat16> TSShape::nodeRotations

Vector<Point3F> TSShape::nodeTranslations

Vector<F32> TSShape::nodeUniformScales

Vector<Point3F> TSShape::nodeAlignedScales

Vector<Quat16> TSShape::nodeArbitraryScaleRots

Vector<Point3F> TSShape::nodeArbitraryScaleFactors

Vector<Quat16> TSShape::groundRotations

Vector<Point3F> TSShape::groundTranslations

Vector<Trigger> TSShape::triggers

Vector<F32> TSShape::iflFrameOffTimes

Vector<TSLastDetail*> TSShape::billboardDetails

Vector<ConvexHullAccelerator*> TSShape::detailCollisionAccelerators

Vector<String> TSShape::names

S8* TSShape::mMemoryBlock

Memory block for data storage.

Most vectors are stored in a single memory block except when compiled using TORQUE_MAX_LIB defined.

in that case, ToolVector becomes Vector<> and the vectors are resizeable

TSMaterialList* TSShape::materialList

F32 TSShape::radius

F32 TSShape::tubeRadius

Point3F TSShape::center

Box3F TSShape::bounds

U32 TSShape::mExporterVersion

F32 TSShape::mSmallestVisibleSize

Computed at load time from details vector.

S32 TSShape::mSmallestVisibleDL

See also:: mSmallestVisibleSize

S32 TSShape::mReadVersion

File version that this shape was read from.

U32 TSShape::mFlags

hasTranslucancy, iflInit

U32 TSShape::data

User-defined data storage.

bool TSShape::mSequencesConstructed

F32 TSShape::smAlphaOutLastDetail [static]

F32 TSShape::smAlphaInBillboard [static]

F32 TSShape::smAlphaOutBillboard [static]

F32 TSShape::smAlphaInDefault [static]

F32 TSShape::smAlphaOutDefault [static]

S32 TSShape::smNumSkipLoadDetails [static]

don't load this many of the highest detail levels (although we always load one renderable detail if there is one)

bool TSShape::smInitOnRead [static]

by default we initialize shape when we read...

S32 TSShape::smVersion [static]

Most recent version...the one we write.

S32 TSShape::smReadVersion [static]

Version currently being read, only valid during read.

const U32 TSShape::smMostRecentExporterVersion [static]

TSShapeAlloc TSShape::tsalloc [static]