The main Expression Class.

Public Fields

	Pointers to the meshes that the system controls
	Data used for the channels of data
EXPMAP	expMap associative map for looking up expressions
	tags lists data
	muscle list data
	current animation and editing values
	expressions

Public Methods

	constructors
	Event handing
	animation functions
	special functions for extra channels
	drawing functions
	for query interface for talking to outside world

Documentation

The main Expression Class. expHead Holds all data for the facial animation system.

Pointers to the meshes that the system controls

ExpMeshAdapter* face

pointer to the face mesh interface

ExpMeshAdapter* jawroot

pointer to the dummy object that acts as the root of the jaw rotation

ExpMeshAdapter* tounge

pointer to the tounge interface

ExpMeshAdapter* righteye

pointer to the right eye interface

ExpMeshAdapter* lefteye

pointer to the left eye interface

Data used for the channels of data

int NUM_ADDED_CHANNELS

the number of additional channels in addition to the muscle channels

EXPMAP channelMap

associative map for looking up channels

int jaw_ID

id for the jaw open/close channel

int jaw_slide_ID

id for the jaw right/left rotation channel

int tounge_ID

id for the tounge up/down rotation channel

int right_eyelid_ID

id for the right eyelid rotation channel

int left_eyelid_ID

id for the rotation channel

int right_eyex_ID

id for the right eye's x rotation channel

int right_eyey_ID

id for the right eye's y rotation channel

int left_eyex_ID

id for the left eye's x rotation channel

int left_eyey_ID

id for the left eye's y rotation channel

int headx_ID

id for the head's x rotation channel

int heady_ID

id for the head's y rotation channel

int headz_ID

id for the head's z rotation channel

EXPMAP expMap

associative map for looking up expressions

tags lists data

std::vector<Tag> jawtags

list of jaw tags

std::vector<Tag> eyelidtagR

list of eyelid

std::vector<Tag> eyelidtagL

list of eyelid

muscle list data

std::vector<Muscle *> muscles

vector of muscles

current animation and editing values

int current_muscle

the current muscle to be activated

int current_exp

numerical val of exp activated usefull for cycling thought the expressions

int nmuscles

number of muscles in the face

std::string musclefile

name of muscle file so I can reload the file

Expression* curExp

the current layer 1 facial expression

Expression* curExpLayer2

the current layer 2 facial expression

Expression* curExpLayer3

the current layer 3 facial expression

Expression* outputExp

the current layer 1 output expression

Expression* outputLayer2

the current layer 2 output expression

Expression* outputLayer3

the current layer 3 output expression

expressions

int nexpressions

number of expressions in the face

std::vector<Expression *> expressions

vector of expressions

std::vector<cExpression *> compexp

vector of compound expressions

constructors

expHead(ExpMeshAdapter* head, ExpMeshAdapter* righteye, ExpMeshAdapter* lefteye, ExpMeshAdapter* itounge, ExpMeshAdapter* ijawroot, char* tags, char* muscle, std::vector <Morpher* >* morphlist, char* exp, char* compexp )

Constructor used with morph targets

expHead(ExpMeshAdapter* head, ExpMeshAdapter* righteye, ExpMeshAdapter* lefteye, ExpMeshAdapter* itounge, ExpMeshAdapter* ijawroot, char* tags, char* muscle, char* exp, char* compexp )

Constructor used without a set of morph targets

expHead(ExpMeshAdapter* head, ExpMeshAdapter* righteye, ExpMeshAdapter* lefteye, ExpMeshAdapter* itounge, ExpMeshAdapter* ijawroot, char* muscle)

Constructor used without animation data

~expHead()

Destructor

Event handing

int Event(expEvent* current)

the event processing function

animation functions

void reset(void )

resets all current data

void ResetGeom(void )

resets all geometry

void ActivateCurrentState()

composites layer data and deforms mesh

void ActivateThisState(const Expression* state, bool compositeLayers)

deforms mesh based on state compositeLayers controls whether or not the other layers are composited in

void InterpolateExpression(Expression* res, const Expression* start, const Expression* end, float percent)

void OverlayExpression(Expression* res, const Expression* start, const Expression* end)

compositing code currently just adds and maxs most data

void InterpolateKeyframes(Expression* res, cExpression* keyframes, float percent)

used for interpolating compound expressions

special functions for extra channels

int LocateExp(char* name)

Function used for locating a expression returns -1 on error

int LocateChannel(char* name)

Function used for locating a animated channel returns -1 on error

void RotateJaw(float vertical, float horizontal)

void RotateRightEyelid(float angle)

void RotateLeftEyelid(float angle)

void RightEyeLookAt(int state, float w, float h)

void LeftEyeLookAt(int state, float w, float h)

drawing functions

void DrawMuscles( void)

void DrawTagged(void)

for query interface for talking to outside world

Vertex* GetHeadRotation()

used if you are hooking system up into a skeletal animation system

void PrintCurrentExpression(void)

output function prints the current channel values to stdout

int GetNumberOfMuscles()

Gets the number of muscles

int GetNumberOfExp()

Gets the number of Expressions

int GetNumberOfCompoundExp()

Gets the number of compound Expressions

std::string GetMuscleName(int i)

Gets the name of muscle number i

std::string GetExpName(int i)

Gets the name of Expression number i

std::string GetCompoundExpName( int i)

Gets the name of compound Expression number i

This class has no child classes.

Alphabetic index HTML hierarchy of classes or Java