int GetMatrix(struct AnimationList *al, char* name, float time,
float m[4][4])
{
int x, y;
void* a = FindAnimation(name, al);
Animation* anim = (Animation*) a;
if(a)
{
_GetMatrix(anim, time, m);
return TRUE;
}
/* Otherwise, return identity matrix. */
for(x = 0; x < 4; x++)
{
for(y = 0; y < 4; y++)
{
if(x == y)
{
m[x][y] = 1.0;
}
else
{
m[x][y] = 0.0;
}
}
}
return FALSE;
}
void CTestContainer::ShowAnimationL(TAnimationFlag aAnimationType)
{
TInt index = FindAnimation(aAnimationType);
if (index == KErrNotFound)
return;
else
StartAnimationL(index);
}
bool ExportScene::AddAnimation( ExportAnimation* pAnimation )
{
if( !pAnimation )
return false;
if( FindAnimation( pAnimation->GetName() ) )
return false;
m_vAnimations.push_back( pAnimation );
return true;
}
bool Animator::SwitchAnimation(std::string const& name)
{
auto animation = FindAnimation(name);
if (animation != nullptr)
{
SwitchAnimation(animation);
return true;
}
return false;
}
/*----------------------------------------------------------------------
GetScale()
Purpose: gets the scale of an animated object with a certain name
In parameters:
al - the linked list of Animations
name - the name of the Animation
time - the time of the wanted scale
Out parameters:
Sout - the scale in the x-, y-, and z-directions at time
Returns:
TRUE if there was a scale with "name", else FALSE (and the
scale is then (1,1,1)
Note: this routine does not check if the object is visible or not.
----------------------------------------------------------------------*/
int GetScale(Stack<Animation*> *al,char* name, double time, double Sout[3])
{
Animation* a = FindAnimation(name,al);
if(a)
{
_GetScale(a, time, Sout);
return TRUE;
}
Sout[0]=Sout[1]=Sout[2]=1.0;
return FALSE;
}
/*----------------------------------------------------------------------
GetTranslation()
Purpose: gets the translation of an animated object with a certain name
In parameters:
al - the linked list of Animations
name - the name of the Animation
time - the time of the wanted translation
Out parameters:
Tout - the translation at time
Returns:
TRUE if there was a translation with "name", else FALSE (and the
translation is (0,0,0)
Note: this routine does not check if the object is visible or not.
----------------------------------------------------------------------*/
int GetTranslation(Stack<Animation*> *al,char* name, double time, double Tout[3])
{
Animation * a = FindAnimation(name,al);
if(a)
{
_GetTranslation(a, time, Tout);
return TRUE;
}
Tout[0]=Tout[1]=Tout[2]=0.0;
return FALSE;
}
/*----------------------------------------------------------------------
GetRotation()
Purpose: gets the rotation of an animated object with a certain name
In parameters:
al - the linked list of Animations
name - the name of the Animation
time - the time of the wanted rotation
Out parameters:
Rout - the rotation at time. (Rout[0],Rout[1],Rout[2]) is the
rotation axis, and Rout[3] is the rotation angle (in radians)
about that axis
Returns:
TRUE if there was a rotation with "name", else FALSE (and the
axis is (1,0,0) and the angle is 0.0
Note: this routine does not check if the object is visible or not.
----------------------------------------------------------------------*/
int GetRotation(Stack<Animation*> *al,char* name, double time, double Rout[4])
{
Animation* a = FindAnimation(name,al);
if(a)
{
_GetRotation(a, time, Rout);
return TRUE;
}
Rout[0]=1.0; Rout[1]=0.0; Rout[2]=0.0; Rout[3]=0.0;
return FALSE;
}
// Remove animation resource
bool ResourceManager::RemoveAnimation(const GTString& name)
{
GTString keyName = name;
keyName.ToLower();
GSpriteAnimationCocos2dx* pAnimation = FindAnimation(keyName);
if(pAnimation)
{
m_ResAnimationList.Remove(keyName.ToCharString());
return true;
}
return false;
}
int GetVisibility(struct AnimationList *al, char *name, double time)
{
void* a = FindAnimation(name, al);
Animation* anim = (Animation*) a;
if(a)
{
return _GetVisibility(anim, time);
}
return 1;
}
//-----------------------------------------------------------------------------
CPUTAnimation * CPUTAssetLibrary::GetAnimation( const cString &name, bool nameIsFullPathAndFilename )
{
cString animationFileName;
CPUTFileSystem::ResolveAbsolutePathAndFilename( nameIsFullPathAndFilename? name + _L(".anm") : (mAnimationSetDirectoryName + name + _L(".anm")), &animationFileName);
// If we already have one by this name, then return it
CPUTAnimation *pAnimation = FindAnimation(animationFileName,true);
if(pAnimation == NULL)
{
return CPUTAnimation::CreateAnimation(animationFileName);
}
pAnimation->AddRef();
return pAnimation;
}
int GetScale(struct AnimationList *al, char* name, double time,
double Sout[3])
{
void* a = FindAnimation(name, al);
Animation* anim = (Animation*) a;
if(a)
{
_GetScale(anim, time, Sout);
return TRUE;
}
Sout[0] = Sout[1] = Sout[2] = 1.0;
return FALSE;
}
int GetTranslation(struct AnimationList *al, char* name, double time,
double Tout[3])
{
void* a = FindAnimation(name, al);
Animation* anim = (Animation*) a;
if(a)
{
_GetTranslation(anim, time, Tout);
return TRUE;
}
Tout[0] = Tout[1] = Tout[2] = 0.0;
return FALSE;
}
/*----------------------------------------------------------------------
GetCamera()
Purpose: to get the position, the view direction and the up vector
of the camera if it is animated. The name of the animation for
the camera is "camera".
In parameters:
al - the linked list of Animations
time - the time of the wanted transformation
Out parameters:
gotPosition - by the end of the call, this will be 1 if there was a
position for the camera, else 0
viewPos - the camera position (only set if gotPosition returns 1)
gotDirection - by the end of the call, this will be 1 if there was a
view direction and up vector for the camera, else 0
viewDir - the camera direction (only set if gotDirection returns 1)
viewUp - the camera up vector (only set if gotDirection returns 1)
Returns:
void
----------------------------------------------------------------------*/
void GetCamera(Stack<Animation*> *al,double time,
int *gotPosition,double viewPos[3],
int *gotDirection, double viewDir[3], double viewUp[3])
{
Animation *a;
/* is there an animation called "camera", then use it to animate the camera */
a=FindAnimation("camera",al);
if(a)
{
double m[4][4];
/* get position of the camera, if any */
if(a->translations)
{
_GetTranslation(a,time,viewPos);
*gotPosition=1;
}
else *gotPosition=0;
/* get view direction and up vector, if any */
if(a->rotations)
{
/* get matrix (we use only the upper 3x3 matrix to extract dir, and up */
_GetMatrix(a,time,m);
/* the viewer looks along the negative z-axis, with the y-axis up */
viewDir[0]=-m[0][2];
viewDir[1]=-m[1][2];
viewDir[2]=-m[2][2];
/* the y-axis is up */
viewUp[0]=m[0][1];
viewUp[1]=m[1][1];
viewUp[2]=m[2][1];
*gotDirection=1;
}
else *gotDirection=0;
}
else
{
/* we did not find any position nor a direction */
*gotPosition=0;
*gotDirection=0;
}
}
//-----------------------------------------------------------------------------
CPUTAnimation * CPUTAssetLibrary::GetAnimation( const std::string &name, bool nameIsFullPathAndFilename )
{
std::string animationFileName;
CPUTFileSystem::ResolveAbsolutePathAndFilename( nameIsFullPathAndFilename? name + ".anm" : (mAnimationSetDirectoryName + name + ".anm"), &animationFileName);
// If we already have one by this name, then return it
CPUTAnimation *pAnimation = FindAnimation(animationFileName,true);
if(pAnimation == NULL)
{
CPUTAnimation *pAnimation = CPUTAnimation::Create(animationFileName);
LIBRARY_ASSERT(pAnimation, "Could not create animation " + animationFileName);
if (pAnimation != NULL)
AddAnimationSet(animationFileName, "", "", pAnimation);
return pAnimation;
}
pAnimation->AddRef();
return pAnimation;
}
int GetRotation(struct AnimationList *al, char* name, double time,
double Rout[4])
{
void* a = FindAnimation(name, al);
Animation* anim = (Animation*) a;
if(a)
{
_GetRotation(anim, time, Rout);
return TRUE;
}
Rout[0] = 1.0;
Rout[1] = 0.0;
Rout[2] = 0.0;
Rout[3] = 0.0;
return FALSE;
}
/*----------------------------------------------------------------------
GetMatrix()
Purpose: gets the full matrix( including scaling, rotation, and
translation) of an animated object with a certain name
This function can be used instead calling GetScale, GetRotation,
and GetTranslation and then concatenate these transforms.
In parameters:
al - the linked list of Animations
name - the name of the Animation
time - the time of the wanted transformation
Out parameters:
m - the matrix at time, the matrix is of column major form,
i.e., the translation is in the right most column of the matrix
So, in order to use it with OpenGl, you have to transpose the
matrix.
Returns:
TRUE if we could find an animation with "name", else FALSE, and
the matrix will be an identity matrix
Note: this routine does not check if the object is visible or not.
----------------------------------------------------------------------*/
int GetMatrix(Stack<Animation*> *al,char* name, double time, double m[4][4])
{
int x,y;
Animation * a = FindAnimation(name,al);
if(a)
{
_GetMatrix(a, time, m);
return TRUE;
}
/* return identity matrix */
for(x=0;x<4;x++)
{
for(y=0;y<4;y++)
{
if(x==y) m[x][y]=1.0;
else m[x][y]=0.0;
}
}
return FALSE;
}
void GetCamera(struct AnimationList *al, double time, int *gotPosition,
double viewPos[3], int *gotDirection, double viewDir[3],
double viewUp[3])
{
/* If there is an animation called "camera", then use it to animate
* the camera. */
Animation *a;
char *animName = new char[7];
strcpy(animName, "camera");
a = FindAnimation(animName, al);
Animation* anim = (Animation*) a;
delete[] animName;
if(a)
{
double m[4][4];
/* Get position of the camera, if there is any. */
if(a->translations)
{
_GetTranslation(anim, time, viewPos);
*gotPosition = 1;
}
else
{
*gotPosition = 0;
}
/* Get view direction and up vector, if there is any. */
if(anim->rotations)
{
/* Get matrix (we use only the upper 3x3 cells of the matrix to
* extract dir, and up). */
_GetMatrix(anim, time, m);
/* The viewer looks along the negative z-axis, with the y-axis
* up. */
viewDir[0] = -m[0][2];
viewDir[1] = -m[1][2];
viewDir[2] = -m[2][2];
/* The y-axis is up. */
viewUp[0] = m[0][1];
viewUp[1] = m[1][1];
viewUp[2] = m[2][1];
*gotDirection=1;
}
else
{
*gotDirection=0;
}
}
else
{
/* We did not find any position nor a direction. */
*gotPosition = 0;
*gotDirection = 0;
}
}
/*----------------------------------------------------------------------
GetVisibility()
Purpose: to determine whether an object is visible at a certain time
In parameters:
al - the linked list of Animations
name - the name of the Animation
time - the time of the wanted visibility
Out parameters:
None
Returns:
returns 0 if the object is invisible, if visible it returns a
non-zero number
----------------------------------------------------------------------*/
int GetVisibility(Stack<Animation*> *al, char *name, double time)
{
Animation* a = FindAnimation(name,al);
if(a) return _GetVisibility(a, time);
return 1; /* visible by default */
}
