Main Page | Alphabetical List | Compound List | File List | Compound Members | File Members

QKFrame.h File Reference

#include "TKArray.h"
#include "Quatern.h"
#include "vfile.h"

Go to the source code of this file.

Enumerations

enum  geQKFrame_InterpolationType { QKFRAME_LINEAR, QKFRAME_SLERP, QKFRAME_SQUAD }

Functions

geTKArray *GENESISCC geQKFrame_LinearCreate (void)
geTKArray *GENESISCC geQKFrame_SlerpCreate ()
geTKArray *GENESISCC geQKFrame_SquadCreate ()
geBoolean GENESISCC geQKFrame_Insert (geTKArray **KeyList, geTKArray_TimeType Time, const geQuaternion *Q, int *Index)
void GENESISCC geQKFrame_Query (const geTKArray *KeyList, int Index, geTKArray_TimeType *Time, geQuaternion *V)
void GENESISCC geQKFrame_Modify (geTKArray *KeyList, int Index, const geQuaternion *Q)
void GENESISCC geQKFrame_LinearInterpolation (const void *KF1, const void *KF2, geFloat T, void *Result)
void GENESISCC geQKFrame_SlerpInterpolation (const void *KF1, const void *KF2, geFloat T, void *Result)
void GENESISCC geQKFrame_SquadInterpolation (const void *KF1, const void *KF2, geFloat T, void *Result)
void GENESISCC geQKFrame_SquadRecompute (int Looped, geTKArray *KeyList)
void GENESISCC geQKFrame_SlerpRecompute (geTKArray *KeyList)
geBoolean GENESISCC geQKFrame_LinearRead (geVFile *pFile, void *geQKFrame)
geBoolean GENESISCC geQKFrame_SlerpRead (geVFile *pFile, void *geQKFrame)
geBoolean GENESISCC geQKFrame_SquadRead (geVFile *pFile, void *geQKFrame)
geBoolean GENESISCC geQKFrame_WriteToFile (geVFile *pFile, void *geQKFrame, geQKFrame_InterpolationType InterpolationType, int Looping)
geTKArray *GENESISCC geQKFrame_CreateFromFile (geVFile *pFile, geQKFrame_InterpolationType *InterpolationType, int *Looping)
geTKArray *GENESISCC geQKFrame_CreateFromBinaryFile (geVFile *pFile, int *InterpolationType, int *Looping)
geBoolean GENESISCC geQKFrame_WriteToBinaryFile (geVFile *pFile, geTKArray *KeyList, geQKFrame_InterpolationType InterpolationType, int Looping)

Enumeration Type Documentation

enum geQKFrame_InterpolationType
 

Enumeration values:
QKFRAME_LINEAR 
QKFRAME_SLERP 
QKFRAME_SQUAD 

Definition at line 55 of file QKFrame.h.

Referenced by gePath_PathToQKInterpolation(). 

00056 {
00057         QKFRAME_LINEAR,
00058         QKFRAME_SLERP,
00059         QKFRAME_SQUAD
00060 } geQKFrame_InterpolationType;

Function Documentation

geTKArray* GENESISCC geQKFrame_CreateFromBinaryFile (  geVFile *  pFile,
int *  InterpolationType,
int *  Looping
) 
 

Definition at line 964 of file QKFrame.c.

References GE_FALSE, geErrorLog_AddString, geFloat, GENESISCC, geQKFrame_SlerpRecompute(), geQKFrame_SquadRecompute(), geQuaternion_SetFromAxisAngle(), geRam_Allocate, geRam_Free, geTKArray_CreateEmpty(), geTKArray_Element(), geVFile_Read(), geQKFrame_Linear::Key, NULL, QKeyframe::Q, QKFRAME_HINGE_COMPRESSION, QKFRAME_LINEAR, QKFRAME_LINEARTIME_COMPRESSION, QKFRAME_SLERP, QKFRAME_SQUAD, QKeyframe::Time, uint32, geVec3d::X, geVec3d::Y, and geVec3d::Z.

Referenced by gePath_CreateFromBinaryFile(). 

00965 {
00966         uint32 u;
00967         int BlockSize;
00968         int Compression;
00969         int Count,i;
00970         int FieldSize;
00971         char *Block;
00972         geFloat *Data;
00973         geTKArray *KeyList;
00974         geQKFrame_Linear* pLinear0;
00975         geQKFrame_Linear* pLinear;
00976 
00977         assert( pFile != NULL );
00978         assert( InterpolationType != NULL );
00979         assert( Looping != NULL );
00980         
00981         if (geVFile_Read(pFile, &BlockSize, sizeof(int)) == GE_FALSE)
00982                 {
00983                         geErrorLog_AddString(-1,"Failure to read binary QKFrame header", NULL);
00984                         return NULL;
00985                 }
00986         if (BlockSize<0)
00987                 {
00988                         geErrorLog_AddString(-1,"Bad Blocksize", NULL);
00989                         return NULL;
00990                 }
00991                         
00992         Block = geRam_Allocate(BlockSize);
00993         if(geVFile_Read(pFile, Block, BlockSize) == GE_FALSE)
00994                 {
00995                         geErrorLog_AddString(-1,"Failure to read binary QKFrame header", NULL);
00996                         return NULL;
00997                 }
00998         u = *(uint32 *)Block;
00999         *InterpolationType = (u>>16)& 0xFF;
01000         Compression = (u>>8) & 0xFF;
01001         *Looping           = (u & 0x1);         
01002         Count = *(((uint32 *)Block)+1);
01003         
01004         if (Compression > 0xFF)
01005                 {
01006                         geRam_Free(Block);      
01007                         geErrorLog_AddString(-1,"Bad Compression Flag", NULL);
01008                         return NULL;
01009                 }
01010         switch (*InterpolationType)
01011                 {
01012                         case (QKFRAME_LINEAR):
01013                                 FieldSize = sizeof(geQKFrame_Linear);
01014                                 break;
01015                         case (QKFRAME_SLERP):
01016                                 FieldSize = sizeof(geQKFrame_Slerp);
01017                                 break;
01018                         case (QKFRAME_SQUAD):
01019                                 FieldSize = sizeof(geQKFrame_Squad);
01020                                 break;
01021                         default:
01022                                 geRam_Free(Block);
01023                                 geErrorLog_AddString(-1,"Bad InterpolationType", NULL);
01024                                 return NULL;
01025                 }
01026         
01027         KeyList = geTKArray_CreateEmpty(FieldSize,Count);
01028         if (KeyList == NULL)
01029                 {
01030                         geRam_Free(Block);      
01031                         geErrorLog_AddString(-1,"Failed to allocate tkarray", NULL);
01032                         return NULL;
01033                 }
01034 
01035         Data = (geFloat *)(Block + sizeof(uint32)*2);
01036                         
01037         pLinear0 = (geQKFrame_Linear*)geTKArray_Element(KeyList, 0);
01038 
01039         pLinear = pLinear0;
01040 
01041         if (Compression & QKFRAME_LINEARTIME_COMPRESSION)
01042                 {
01043                         geFloat fi;
01044                         geFloat fCount = (geFloat)Count;
01045                         geFloat Time,DeltaTime;
01046                         Time = *(Data++);
01047                         DeltaTime = *(Data++);
01048                         for(fi=0.0f;fi<fCount;fi+=1.0f)
01049                                 {
01050                                         pLinear->Key.Time = Time + fi*DeltaTime;
01051                                         pLinear = (geQKFrame_Linear *)  ( ((char *)pLinear) + FieldSize );
01052                                 }
01053                 }
01054         else
01055                 {
01056                         for(i=0;i<Count;i++)
01057                                 {
01058                                         pLinear->Key.Time = *(Data++);
01059                                         pLinear = (geQKFrame_Linear *)  ( ((char *)pLinear) + FieldSize );
01060                                 }
01061                 }
01062 
01063         pLinear = pLinear0;
01064 
01065         if (Compression & QKFRAME_HINGE_COMPRESSION)
01066                 {
01067                         geVec3d Hinge;
01068                         Hinge.X = *(Data++);
01069                         Hinge.Y = *(Data++);
01070                         Hinge.Z = *(Data++);
01071 
01072                         for(i=0;i<Count;i++)
01073                                 {
01074                                         geQuaternion_SetFromAxisAngle(&(pLinear->Key.Q),&Hinge,*(Data++));
01075                                         pLinear = (geQKFrame_Linear *)  ( ((char *)pLinear) + FieldSize );
01076                                 }
01077                 }
01078         else
01079                 {
01080                         for(i=0;i<Count;i++)
01081                                 {
01082                                         pLinear->Key.Q = *(geQuaternion *)Data;
01083                                         Data += 4;
01084                                         pLinear = (geQKFrame_Linear *)  ( ((char *)pLinear) + FieldSize );
01085                                 }
01086                 }
01087         
01088         switch (*InterpolationType)
01089                 {
01090                         case (QKFRAME_LINEAR):
01091                                         break;
01092                         case (QKFRAME_SLERP):
01093                                 geQKFrame_SlerpRecompute( KeyList);
01094                                         break;
01095                         case (QKFRAME_SQUAD):
01096                                 geQKFrame_SquadRecompute( *Looping, KeyList);
01097                                         break;
01098                         default:
01099                                 assert(0);
01100                 }
01101         geRam_Free(Block);      
01102         return KeyList;                                         
01103 }

geTKArray* GENESISCC geQKFrame_CreateFromFile (  geVFile *  pFile,
geQKFrame_InterpolationType *  InterpolationType,
int *  Looping
) 
 

Referenced by gePath_CreateFromFile().

geBoolean GENESISCC geQKFrame_Insert (  geTKArray **  KeyList,
geTKArray_TimeType  Time,
const geQuaternion *  Q,
int *  Index
) 
 

Definition at line 106 of file QKFrame.c.

References ERR_QKARRAY_INSERT, GE_FALSE, GE_TRUE, geBoolean, geErrorLog_Add, GENESISCC, geTKArray_Element(), geTKArray_ElementSize(), geTKArray_Insert(), NULL, and QKeyframe::Q.

Referenced by gePath_CreateCopy(), and gePath_InsertKeyframe(). 

00112 {
00113         assert( KeyList != NULL );
00114         assert( *KeyList != NULL );
00115         assert( Q != NULL );
00116         assert(   sizeof(geQKFrame_Squad) == geTKArray_ElementSize(*KeyList) 
00117                || sizeof(geQKFrame_Slerp) == geTKArray_ElementSize(*KeyList) 
00118                    || sizeof(geQKFrame_Linear) == geTKArray_ElementSize(*KeyList) );
00119 
00120         if (geTKArray_Insert(KeyList, Time, Index) == GE_FALSE)
00121                 {
00122                         geErrorLog_Add(ERR_QKARRAY_INSERT, NULL);
00123                         return GE_FALSE;
00124                 }
00125         else
00126                 {
00127                         QKeyframe *KF;
00128                         KF = (QKeyframe *)geTKArray_Element(*KeyList,*Index);
00129                         KF->Q = *Q;
00130                         return GE_TRUE;
00131                 }
00132 }

geTKArray* GENESISCC geQKFrame_LinearCreate (  void   ) 
 

Definition at line 86 of file QKFrame.c.

References GENESISCC, and geTKArray_Create().

Referenced by gePath_ReadChannel_F0_(), and gePath_SetupRotationKeyList(). 

00088 {
00089         return geTKArray_Create(sizeof(geQKFrame_Linear) );
00090 }

void GENESISCC geQKFrame_LinearInterpolation (  const void *  KF1,
const void *  KF2,
geFloat  T,
void *  Result
) 
 

Definition at line 176 of file QKFrame.c.

References geFloat, GENESISCC, geQuaternion_Normalize(), geQuaternion_SetNoRotation(), LINEAR_BLEND, NULL, geQuaternion::W, geQuaternion::X, geQuaternion::Y, and geQuaternion::Z. 

00185 {
00186         geQuaternion *Q1,*Q2;
00187         geQuaternion *QNew = (geQuaternion *)Result;
00188         
00189         assert( Result != NULL );
00190         assert( KF1 != NULL );
00191         assert( KF2 != NULL );
00192         
00193         assert( T >= (geFloat)0.0f );
00194         assert( T <= (geFloat)1.0f );
00195         
00196         if ( KF1 == KF2 )
00197                 {
00198                         *QNew = ((geQKFrame_Linear *)KF1)->Key.Q;
00199                         return;
00200                 }
00201 
00202         Q1 = &( ((geQKFrame_Linear *)KF1)->Key.Q);
00203         Q2 = &( ((geQKFrame_Linear *)KF2)->Key.Q);
00204         
00205         QNew->X = LINEAR_BLEND(Q1->X,Q2->X,T);
00206         QNew->Y = LINEAR_BLEND(Q1->Y,Q2->Y,T);
00207         QNew->Z = LINEAR_BLEND(Q1->Z,Q2->Z,T);
00208         QNew->W = LINEAR_BLEND(Q1->W,Q2->W,T);
00209         if (geQuaternion_Normalize(QNew)==0.0f)
00210                 {
00211                         geQuaternion_SetNoRotation(QNew);
00212                 }
00213 
00214 }

geBoolean GENESISCC geQKFrame_LinearRead (  geVFile *  pFile,
void *  geQKFrame
) 
 

Definition at line 497 of file QKFrame.c.

References CHECK_FOR_READ, ERR_PATH_FILE_READ, ERR_PATH_FILE_VERSION, GE_FALSE, GE_TRUE, geBoolean, geErrorLog_Add, GENESISCC, geVFile_GetS(), geVFile_Read(), geQKFrame_Linear::Key, NULL, QKeyframe::Q, QKFRAME_LINEAR_ASCII_FILE, uint32, geQuaternion::W, geQuaternion::X, geQuaternion::Y, and geQuaternion::Z.

Referenced by gePath_ReadChannel_F0_(). 

00498 {
00499         uint32  u;
00500         char    QKeyString[64];
00501         geQKFrame_Linear* pLinear = (geQKFrame_Linear*)geQKFrame;
00502 
00503         assert( pFile != NULL );
00504         assert( geQKFrame != NULL );
00505 
00506         // Read the format/version flag
00507         if(geVFile_Read(pFile, &u, sizeof(u)) == GE_FALSE)
00508         {
00509                 geErrorLog_Add(ERR_PATH_FILE_READ, NULL);
00510                 return GE_FALSE;
00511         }
00512 
00513         if(u != QKFRAME_LINEAR_ASCII_FILE)
00514         {
00515                 geErrorLog_Add(ERR_PATH_FILE_VERSION, NULL);
00516                 return GE_FALSE;
00517         }
00518 
00519         if      (geVFile_GetS(pFile, QKeyString, sizeof(QKeyString)) == GE_FALSE)
00520         {
00521                 geErrorLog_Add(ERR_PATH_FILE_READ, NULL);
00522                 return GE_FALSE;
00523         }
00524 
00525         u = sscanf(QKeyString, "%f %f %f %f\n", &pLinear->Key.Q.W,
00526                                                                                         &pLinear->Key.Q.X,
00527                                                                                         &pLinear->Key.Q.Y,
00528                                                                                         &pLinear->Key.Q.Z);
00529         CHECK_FOR_READ(u, 4);
00530 
00531         return GE_TRUE;
00532 }

void GENESISCC geQKFrame_Modify (  geTKArray *  KeyList,
int  Index,
const geQuaternion *  Q
) 
 

Definition at line 156 of file QKFrame.c.

References GENESISCC, geTKArray_Element(), geTKArray_ElementSize(), geTKArray_NumElements(), NULL, and QKeyframe::Q.

Referenced by gePath_ModifyKeyframe(). 

00160 {
00161         QKeyframe *KF;
00162         assert( KeyList != NULL );
00163         assert( Q != NULL );
00164         assert( Index < geTKArray_NumElements(KeyList) );
00165         assert( Index >= 0 );
00166         assert(   sizeof(geQKFrame_Squad) == geTKArray_ElementSize(KeyList) 
00167                || sizeof(geQKFrame_Slerp) == geTKArray_ElementSize(KeyList) 
00168                    || sizeof(geQKFrame_Linear) == geTKArray_ElementSize(KeyList) );
00169         
00170         KF = (QKeyframe *)geTKArray_Element(KeyList,Index);
00171         KF->Q  = *Q;
00172 }

void GENESISCC geQKFrame_Query (  const geTKArray *  KeyList,
int  Index,
geTKArray_TimeType *  Time,
geQuaternion *  V
) 
 

Definition at line 134 of file QKFrame.c.

References GENESISCC, geTKArray_Element(), geTKArray_ElementSize(), geTKArray_NumElements(), NULL, QKeyframe::Q, and QKeyframe::Time.

Referenced by gePath_CreateCopy(), and gePath_GetKeyframe(). 

00140 {
00141         QKeyframe *KF;
00142         assert( KeyList != NULL );
00143         assert( Time != NULL );
00144         assert( Q != NULL );
00145         assert( Index < geTKArray_NumElements(KeyList) );
00146         assert( Index >= 0 );
00147         assert(   sizeof(geQKFrame_Squad) == geTKArray_ElementSize(KeyList) 
00148                || sizeof(geQKFrame_Slerp) == geTKArray_ElementSize(KeyList) 
00149                    || sizeof(geQKFrame_Linear) == geTKArray_ElementSize(KeyList) );
00150         
00151         KF = (QKeyframe *)geTKArray_Element(KeyList,Index);
00152         *Time = KF->Time;
00153         *Q    = KF->Q;
00154 }

geTKArray* GENESISCC geQKFrame_SlerpCreate (   ) 
 

Definition at line 93 of file QKFrame.c.

References GENESISCC, and geTKArray_Create().

Referenced by gePath_ReadChannel_F0_(), and gePath_SetupRotationKeyList(). 

00095 {
00096         return geTKArray_Create(sizeof(geQKFrame_Slerp) );
00097 }

void GENESISCC geQKFrame_SlerpInterpolation (  const void *  KF1,
const void *  KF2,
geFloat  T,
void *  Result
) 
 

Definition at line 218 of file QKFrame.c.

References geFloat, GENESISCC, geQuaternion_SlerpNotShortest(), and NULL. 

00227 {
00228         geQuaternion *Q1,*Q2;
00229         geQuaternion *QNew = (geQuaternion *)Result;
00230         
00231         assert( Result != NULL );
00232         assert( KF1 != NULL );
00233         assert( KF2 != NULL );
00234         
00235         assert( T >= (geFloat)0.0f );
00236         assert( T <= (geFloat)1.0f );
00237         
00238         if ( KF1 == KF2 )
00239                 {
00240                         *QNew = ((geQKFrame_Slerp *)KF1)->Key.Q;
00241                         return;
00242                 }
00243  
00244         Q1 = &( ((geQKFrame_Slerp *)KF1)->Key.Q);
00245         Q2 = &( ((geQKFrame_Slerp *)KF2)->Key.Q);
00246         geQuaternion_SlerpNotShortest(Q1,Q2,T,QNew);
00247 }

geBoolean GENESISCC geQKFrame_SlerpRead (  geVFile *  pFile,
void *  geQKFrame
) 
 

Definition at line 534 of file QKFrame.c.

References CHECK_FOR_READ, ERR_PATH_FILE_READ, ERR_PATH_FILE_VERSION, GE_FALSE, GE_TRUE, geBoolean, geErrorLog_Add, GENESISCC, geVFile_GetS(), geVFile_Read(), geQKFrame_Slerp::Key, NULL, QKeyframe::Q, QKFRAME_SLERP_ASCII_FILE, uint32, geQuaternion::W, geQuaternion::X, geQuaternion::Y, and geQuaternion::Z.

Referenced by gePath_ReadChannel_F0_(). 

00535 {
00536         uint32  u;
00537         char    QKeyString[64];
00538         geQKFrame_Slerp* pSlerp = (geQKFrame_Slerp*)geQKFrame;
00539 
00540         assert( pFile != NULL );
00541         assert( geQKFrame != NULL );
00542 
00543         // Read the format/version flag
00544         if(geVFile_Read(pFile, &u, sizeof(u)) == GE_FALSE)
00545         {
00546                 geErrorLog_Add(ERR_PATH_FILE_READ, NULL);
00547                 return GE_FALSE;
00548         }
00549 
00550         if(u != QKFRAME_SLERP_ASCII_FILE)
00551         {
00552                 geErrorLog_Add(ERR_PATH_FILE_VERSION, NULL);
00553                 return GE_FALSE;
00554         }
00555 
00556         if      (geVFile_GetS(pFile, QKeyString, sizeof(QKeyString)) == GE_FALSE)
00557         {
00558                 geErrorLog_Add(ERR_PATH_FILE_READ, NULL);
00559                 return GE_FALSE;
00560         }
00561 
00562         u = sscanf(QKeyString, "%f %f %f %f\n", &pSlerp->Key.Q.W,
00563                                                                                         &pSlerp->Key.Q.X,
00564                                                                                         &pSlerp->Key.Q.Y,
00565                                                                                         &pSlerp->Key.Q.Z);
00566         CHECK_FOR_READ(u, 4);
00567 
00568         return GE_TRUE;
00569 }

void GENESISCC geQKFrame_SlerpRecompute (  geTKArray *  KeyList  ) 
 

Definition at line 461 of file QKFrame.c.

References count, GENESISCC, geQKFrame_ChooseBestQuat(), geTKArray_Element(), geTKArray_NumElements(), geQKFrame_Slerp::Key, NULL, and QKeyframe::Q.

Referenced by gePath_Recompute(), geQKFrame_CreateFromBinaryFile(), and geQKFrame_CreateFromFile(). 

00466 {
00467 
00468         int i;
00469         geQKFrame_Slerp *QList;
00470         int count;
00471         assert( KeyList != NULL );
00472 
00473         count = geTKArray_NumElements(KeyList);
00474 
00475         if (count > 0)
00476                 {
00477                         QList = (geQKFrame_Slerp  *)geTKArray_Element(KeyList,0);
00478                         for (i =0; i< count-1; i++)
00479                                 {
00480                                         geQKFrame_ChooseBestQuat(&(QList[i].Key.Q),&(QList[i+1].Key.Q) );
00481                                 }
00482                 }
00483 }

geTKArray* GENESISCC geQKFrame_SquadCreate (   ) 
 

Definition at line 99 of file QKFrame.c.

References GENESISCC, and geTKArray_Create().

Referenced by gePath_ReadChannel_F0_(), and gePath_SetupRotationKeyList(). 

00101 {
00102         return geTKArray_Create(sizeof(geQKFrame_Squad) );
00103 }

void GENESISCC geQKFrame_SquadInterpolation (  const void *  KF1,
const void *  KF2,
geFloat  T,
void *  Result
) 
 

Definition at line 252 of file QKFrame.c.

References B2, GE_TRUE, geFloat, GENESISCC, geQuaternion_IsUnit(), geQuaternion_SlerpNotShortest(), and NULL. 

00261 {
00262         geQuaternion *Q1,*Q2;
00263         geQuaternion *QNew = (geQuaternion *)Result;
00264         
00265         assert( Result != NULL );
00266         assert( KF1 != NULL );
00267         assert( KF2 != NULL );
00268         
00269         assert( T >= (geFloat)0.0f );
00270         assert( T <= (geFloat)1.0f );
00271         
00272         if ( KF1 == KF2 )
00273                 {
00274                         *QNew = ((geQKFrame_Squad *)KF1)->Key.Q;
00275                         return;
00276                 }
00277 
00278         Q1 = &( ((geQKFrame_Squad *)KF1)->Key.Q);
00279         Q2 = &( ((geQKFrame_Squad *)KF2)->Key.Q);
00280         
00281         {
00282                 geQuaternion *A1,*B2;
00283                 geQuaternion SL1,SL2;
00284                                 
00285                 A1 = &( ((geQKFrame_Squad *)KF1)->QuadrangleCorner);
00286                 B2 = &( ((geQKFrame_Squad *)KF2)->QuadrangleCorner);
00287 
00288                 geQuaternion_SlerpNotShortest(Q1,   Q2,   T, &SL1);
00289                                 assert( geQuaternion_IsUnit(&SL1) == GE_TRUE);
00290                 geQuaternion_SlerpNotShortest(A1,   B2,   T, &SL2);
00291                                 assert( geQuaternion_IsUnit(&SL2) == GE_TRUE);
00292                 geQuaternion_SlerpNotShortest(&SL1, &SL2, (2.0f*T*(1.0f-T)), QNew);
00293                                 assert( geQuaternion_IsUnit(QNew) == GE_TRUE);
00294         }
00295 }

geBoolean GENESISCC geQKFrame_SquadRead (  geVFile *  pFile,
void *  geQKFrame
) 
 

Definition at line 572 of file QKFrame.c.

References CHECK_FOR_READ, ERR_PATH_FILE_READ, ERR_PATH_FILE_VERSION, GE_FALSE, GE_TRUE, geBoolean, geErrorLog_Add, GENESISCC, geVFile_GetS(), geVFile_Read(), geQKFrame_Squad::Key, NULL, QKeyframe::Q, QKFRAME_SQUAD_ASCII_FILE, geQKFrame_Squad::QuadrangleCorner, uint32, geQuaternion::W, geQuaternion::X, geQuaternion::Y, and geQuaternion::Z.

Referenced by gePath_ReadChannel_F0_(). 

00573 {
00574         uint32  u;
00575         char    SQuadKeyString[128];
00576         geQKFrame_Squad* pSquad = (geQKFrame_Squad*)geQKFrame;
00577 
00578         assert( pFile != NULL );
00579         assert( geQKFrame != NULL );
00580 
00581         // Read the format/version flag
00582         if(geVFile_Read(pFile, &u, sizeof(u)) == GE_FALSE)
00583         {
00584                 geErrorLog_Add(ERR_PATH_FILE_READ, NULL);
00585                 return GE_FALSE;
00586         }
00587 
00588         if(u != QKFRAME_SQUAD_ASCII_FILE)
00589         {
00590                 geErrorLog_Add(ERR_PATH_FILE_VERSION, NULL);
00591                 return GE_FALSE;
00592         }
00593 
00594         if      (geVFile_GetS(pFile, SQuadKeyString, sizeof(SQuadKeyString)) == GE_FALSE)
00595         {
00596                 geErrorLog_Add(ERR_PATH_FILE_READ, NULL);
00597                 return GE_FALSE;
00598         }
00599 
00600         u = sscanf(SQuadKeyString, "%f %f %f %f %f %f %f %f\n", &pSquad->Key.Q.W,
00601                                                                                                                         &pSquad->Key.Q.X,
00602                                                                                                                         &pSquad->Key.Q.Y,
00603                                                                                                                         &pSquad->Key.Q.Z,
00604                                                                                                                         &pSquad->QuadrangleCorner.W,
00605                                                                                                                         &pSquad->QuadrangleCorner.X,
00606                                                                                                                         &pSquad->QuadrangleCorner.Y,
00607                                                                                                                         &pSquad->QuadrangleCorner.Z);
00608         CHECK_FOR_READ(u, 8);
00609 
00610         return GE_TRUE;
00611 }

void GENESISCC geQKFrame_SquadRecompute (  int  Looped,
geTKArray *  KeyList
) 
 

Definition at line 371 of file QKFrame.c.

References count, GE_TRUE, GENESISCC, geQKFrame_ChooseBestQuat(), geQKFrame_QuadrangleCorner(), geQuaternion_Copy(), geTKArray_Element(), geTKArray_NumElements(), geQKFrame_Squad::Key, NULL, QKeyframe::Q, and geQKFrame_Squad::QuadrangleCorner.

Referenced by gePath_Recompute(), geQKFrame_CreateFromBinaryFile(), and geQKFrame_CreateFromFile(). 

00375 {
00376 
00377         // compute the extra interpolation points at each keyframe
00378         // see Advanced Animation and Rendering Techniques 
00379         //     by Alan Watt and Mark Watt, pg 366
00380         int i;
00381         geQKFrame_Squad *QList=NULL;
00382         int count;
00383 
00384         int Index0,Index1,Index2;
00385         assert( KeyList != NULL );
00386 
00387         count = geTKArray_NumElements(KeyList);
00388 
00389         if (count > 0)
00390                 {
00391                         QList = (geQKFrame_Squad *)geTKArray_Element(KeyList,0);
00392 
00393                         for (i =0; i< count-1; i++)
00394                                 {
00395                                         geQKFrame_ChooseBestQuat(&(QList[i].Key.Q),&(QList[i+1].Key.Q) );
00396                                 }
00397                 }
00398 
00399         if (count<3)
00400                 {
00401                         Looped = 0;
00402                         // cant compute 'slopes' without enough points to loop. 
00403                         // so treat path as non-looped.
00404                 }
00405         for (i =0; i< count; i++)
00406                 {
00407                         Index0 = i-1;
00408                         Index1 = i;
00409                         Index2 = i+1;
00410 
00411                         if (Index1 == 0)
00412                                 {
00413                                         if (Looped != GE_TRUE)
00414                                                 {
00415                                                         Index0 = 0;
00416                                                 }
00417                                         else
00418                                                 {
00419                                                         Index0 = count-2;
00420                                                 }
00421                                 }
00422 
00423                         if (Index2 == count)
00424                                 {
00425                                         if (Looped != GE_TRUE)
00426                                                 {
00427                                                         Index2 = count-1;
00428                                                 }
00429                                         else
00430                                                 {
00431                                                         Index2 = 1;
00432                                                 }
00433                                 }
00434 
00435                         if (( Looped != GE_TRUE) && (Index1 == 0) )
00436                                 {
00437                                         geQuaternion_Copy(
00438                                                 &(QList[i].Key.Q),
00439                                                 &(QList[i].QuadrangleCorner) );
00440                                 }
00441                         else if (( Looped != GE_TRUE) && (Index1 == count-1))
00442                                 {
00443                                         geQuaternion_Copy(
00444                                                 &(QList[i].Key.Q),
00445                                                 &(QList[i].QuadrangleCorner) );
00446                                 }
00447                         else
00448                         {
00449                                 geQKFrame_QuadrangleCorner( 
00450                                         &(QList[Index0].Key.Q),
00451                                         &(QList[Index1].Key.Q),
00452                                         &(QList[Index2].Key.Q),
00453                                         &(QList[i].QuadrangleCorner) );
00454         
00455                         }
00456                 }       
00457 }

geBoolean GENESISCC geQKFrame_WriteToBinaryFile (  geVFile *  pFile,
geTKArray *  KeyList,
geQKFrame_InterpolationType  InterpolationType,
int  Looping
) 
 

Definition at line 1105 of file QKFrame.c.

References GE_FALSE, GE_TRUE, geBoolean, geFloat, GENESISCC, geQKFrame_ComputeBlockSize(), geQKFrame_DetermineCompressionType(), geQuaternion_GetAxisAngle(), geTKArray_Element(), geTKArray_ElementTime(), geTKArray_NumElements(), geVec3d_Normalize(), geVFile_Write(), geQKFrame_Linear::Key, NULL, QKeyframe::Q, QKFRAME_HINGE_COMPRESSION, QKFRAME_LINEARTIME_COMPRESSION, and uint32.

Referenced by gePath_WriteToBinaryFile(). 

01107 {
01108         #define WBERREXIT  {geErrorLog_AddString( ERR_PATH_FILE_WRITE,"Failure to write binary key data", NULL);return GE_FALSE;}
01109         uint32 u,BlockSize;
01110         int Compression;
01111         int Count,i;
01112         geFloat Time,DeltaTime;
01113         assert( pFile != NULL );
01114         assert( InterpolationType < 0xFF);
01115         assert( (Looping == 0) || (Looping == 1) );
01116 
01117 
01118         Compression = geQKFrame_DetermineCompressionType(KeyList);
01119         u = (InterpolationType << 16) | (Compression << 8) |  Looping;
01120         
01121         BlockSize = geQKFrame_ComputeBlockSize(KeyList,Compression);
01122 
01123         if (geVFile_Write(pFile, &BlockSize,sizeof(uint32)) == GE_FALSE)
01124                 WBERREXIT;
01125         
01126         if (geVFile_Write(pFile, &u, sizeof(uint32)) == GE_FALSE)
01127                 WBERREXIT;
01128         
01129         Count = geTKArray_NumElements(KeyList);
01130         if (geVFile_Write(pFile, &Count, sizeof(uint32)) == GE_FALSE)
01131                 WBERREXIT;
01132         
01133         if (Compression & QKFRAME_LINEARTIME_COMPRESSION)
01134                 {
01135                         Time = geTKArray_ElementTime(KeyList, 0);
01136                         DeltaTime = geTKArray_ElementTime(KeyList, 1)- Time;
01137                         if (geVFile_Write(pFile, &Time,sizeof(geFloat)) == GE_FALSE)
01138                                 WBERREXIT;
01139                         if (geVFile_Write(pFile, &DeltaTime,sizeof(geFloat)) == GE_FALSE)
01140                                 WBERREXIT;
01141                 }
01142         else
01143                 {
01144                         for(i=0;i<Count;i++)
01145                                 {
01146                                         Time = geTKArray_ElementTime(KeyList, i);
01147                                         if (geVFile_Write(pFile, &Time,sizeof(geFloat)) == GE_FALSE)
01148                                                 WBERREXIT;
01149                                 }
01150                 }
01151 
01152         if (Compression & QKFRAME_HINGE_COMPRESSION)
01153                 {
01154                         geVec3d Hinge;
01155                         geFloat Angle;
01156 
01157                         geQKFrame_Linear* pLinear = (geQKFrame_Linear*)geTKArray_Element(KeyList, 0);
01158                         geQuaternion_GetAxisAngle(&(pLinear->Key.Q),&Hinge,&Angle);
01159                         geVec3d_Normalize(&Hinge);
01160                         if (geVFile_Write(pFile, &Hinge,sizeof(geVec3d)) == GE_FALSE)
01161                                 WBERREXIT;
01162 
01163                         for(i=0;i<Count;i++)
01164                                 {
01165                                         geQKFrame_Linear* pLinear = (geQKFrame_Linear*)geTKArray_Element(KeyList, i);
01166                                         geQuaternion_GetAxisAngle(&(pLinear->Key.Q),&Hinge,&Angle);
01167                                         if (geVFile_Write(pFile, &Angle,sizeof(geFloat)) == GE_FALSE)
01168                                                 WBERREXIT;
01169                                 }
01170                 }
01171         else
01172                 {
01173                         for(i=0;i<Count;i++)
01174                                 {
01175                                         geQKFrame_Linear* pLinear = (geQKFrame_Linear*)geTKArray_Element(KeyList, i);
01176                                         if (geVFile_Write(pFile, &(pLinear->Key.Q),sizeof(geQuaternion)) == GE_FALSE)
01177                                                 WBERREXIT;
01178                                 }
01179                 }
01180                 
01181         return GE_TRUE;
01182 }

geBoolean GENESISCC geQKFrame_WriteToFile (  geVFile *  pFile,
void *  geQKFrame,
geQKFrame_InterpolationType  InterpolationType,
int  Looping
) 
 

Referenced by gePath_WriteToFile().

Generated on Tue Sep 30 12:37:58 2003 for GTestAndEngine by doxygen 1.3.2