falso
/
FITD
mirror of https://github.com/yaz0r/FITD.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
FITD/FitdLib/anim.cpp

903 lines
26 KiB
C++
Raw Blame History

#include "common.h"
#include "hybrid.h"
hqrEntryStruct<sAnimation>* HQ_Anims = nullptr;
std::vector<sFrame> BufferAnim;
int SetAnimObjet(int frame, sAnimation* pAnimation, sBody* body)
{
if(frame >= pAnimation->m_numFrames)
{
return(0);
}
int numGroupsInAnimation = pAnimation->m_numGroups;
sFrame& keyframe = pAnimation->m_frames[frame];
animCurrentTime = keyframe.m_timestamp;
animKeyframeLength = animCurrentTime;
if(!(body->m_flags & INFO_ANIM))
{
return(0);
}
body->startAnim = &keyframe;
*(u16*)(body->m_scratchBuffer.data() + 4) = timer;
if(numGroupsInAnimation > body->m_groupOrder.size())
numGroupsInAnimation = body->m_groupOrder.size();
animStepX = keyframe.m_animStep.x;
animStepY = keyframe.m_animStep.y;
animStepZ = keyframe.m_animStep.z;
for(int i=0;i< numGroupsInAnimation;i++)
{
body->m_groups[i].m_state.m_type = keyframe.m_groups[i].m_type;
body->m_groups[i].m_state.m_delta = keyframe.m_groups[i].m_delta;
if(body->m_flags & INFO_OPTIMISE)
{
body->m_groups[i].m_state.m_rotateDelta = keyframe.m_groups[i].m_rotateDelta;
}
}
return(1);
}
int InitAnim(int animNum,int animType, int animInfo)
{
if(animNum == currentProcessedActorPtr->ANIM)
{
if(!(currentProcessedActorPtr->objectType & AF_ANIMATED))
{
if(currentProcessedActorPtr->objectType & AF_BOXIFY)
{
removeFromBGIncrust(currentProcessedActorIdx);
}
currentProcessedActorPtr->objectType |= AF_ANIMATED;
SetAnimObjet(currentProcessedActorPtr->frame, HQR_Get(HQ_Anims,animNum), HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum));
currentProcessedActorPtr->animType = animType;
currentProcessedActorPtr->animInfo = animInfo;
if(g_gameId > AITD1)
{
currentProcessedActorPtr->frame = 0;
}
return 1;
}
else
{
currentProcessedActorPtr->animType = animType;
currentProcessedActorPtr->animInfo = animInfo;
return 0;
}
}
if(animNum == -1)
{
currentProcessedActorPtr->newAnim = -2;
return(1);
}
if(!(currentProcessedActorPtr->objectType & AF_ANIMATED))
{
currentProcessedActorPtr->objectType |= AF_ANIMATED;
if(currentProcessedActorPtr->objectType & AF_BOXIFY)
{
removeFromBGIncrust(currentProcessedActorIdx);
}
SetAnimObjet(0, HQR_Get(HQ_Anims,animNum), HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum));
currentProcessedActorPtr->newAnim = animNum;
currentProcessedActorPtr->newAnimType = animType;
currentProcessedActorPtr->newAnimInfo = animInfo;
if(g_gameId > AITD1)
{
currentProcessedActorPtr->frame = 0;
}
return 1;
}
if(g_gameId == AITD1)
{
if(currentProcessedActorPtr->animType & ANIM_UNINTERRUPTABLE)
return(0);
if(currentProcessedActorPtr->newAnimType & ANIM_UNINTERRUPTABLE)
return(0);
}
else
{
if(currentProcessedActorPtr->animType & ANIM_UNINTERRUPTABLE)
{
if(currentProcessedActorPtr->newAnimType & ANIM_UNINTERRUPTABLE)
{
return 0;
}
else
{
currentProcessedActorPtr->animInfo = animNum;
return 1;
}
}
}
currentProcessedActorPtr->newAnim = animNum;
currentProcessedActorPtr->newAnimType = animType;
currentProcessedActorPtr->newAnimInfo = animInfo;
if(g_gameId != AITD1)
{
currentProcessedActorPtr->frame = 0;
}
return(1);
}
int evaluateReal(RealValue* data)
{
if(!data->numSteps)
return data->endValue;
if(timer - data->memoTicks> (unsigned int)data->numSteps)
{
data->numSteps = 0;
return data->endValue;
}
s32 valueDiff = data->endValue - data->startValue;
s32 currentTime = timer - data->memoTicks;
s32 interpolatedValue = data->startValue + ((valueDiff * currentTime) / data->numSteps);
return interpolatedValue;
}
int manageFall(int actorIdx, ZVStruct* zvPtr)
{
int fallResult = 0;
int i;
int room = ListObjets[actorIdx].room;
for(i=0;i<NUM_MAX_OBJECT;i++)
{
tObject* currentTestedActorPtr = &ListObjets[i];
if(currentTestedActorPtr->indexInWorld != -1 && i != actorIdx)
{
ZVStruct* testedZv = &currentTestedActorPtr->zv;
if(currentTestedActorPtr->room != room)
{
ZVStruct localZv;
CopyZV(zvPtr, &localZv);
AdjustZV(&localZv, room, currentTestedActorPtr->room);
if(CubeIntersect(&localZv, testedZv))
{
ListObjets[i].COL_BY = actorIdx;
fallResult++;
}
}
else
{
if(CubeIntersect(zvPtr, testedZv))
{
ListObjets[i].COL_BY = actorIdx;
fallResult++;
}
}
}
}
return(fallResult);
}
void GereAnim(void)
{
if (currentProcessedActorPtr->objectType & AF_OBJ_2D) {
if ((currentProcessedActorPtr->ANIM != -1) && (currentProcessedActorPtr->bodyNum != -1)) {
sHybrid* pHybrid = HQR_Get(HQ_Hybrides, currentProcessedActorPtr->ANIM);
}
}
int oldStepZ=0;
int oldStepY=0;
int oldStepX=0;
int stepZ=0;
int stepY=0;
int stepX=0;
s16 localTable[3];
ZVStruct zvLocal;
ZVStruct* zvPtr;
int newAnim = currentProcessedActorPtr->newAnim;
if (newAnim != -1) // next anim ?
{
if (newAnim == -2) // completely stop anim and add actor to background
{
addActorToBgInscrust(currentProcessedActorIdx);
currentProcessedActorPtr->newAnim = -1;
currentProcessedActorPtr->newAnimType = 0;
currentProcessedActorPtr->newAnimInfo = -1;
currentProcessedActorPtr->flagEndAnim = 1;
return;
}
else {
if (!(currentProcessedActorPtr->newAnimType & ANIM_RESET)) // Reset
{
if (currentProcessedActorPtr->END_FRAME == 0)
{
currentProcessedActorPtr->worldX += currentProcessedActorPtr->stepX;
currentProcessedActorPtr->roomX += currentProcessedActorPtr->stepX;
currentProcessedActorPtr->worldZ += currentProcessedActorPtr->stepZ;
currentProcessedActorPtr->roomZ += currentProcessedActorPtr->stepZ;
currentProcessedActorPtr->stepX = 0;
currentProcessedActorPtr->stepZ = 0;
currentProcessedActorPtr->animNegX = 0;
currentProcessedActorPtr->animNegY = 0;
currentProcessedActorPtr->animNegZ = 0;
}
// TODO: AITD3 has some extra code here to handle bufferAnimCounter
StockInterAnim(BufferAnim[bufferAnimCounter], HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum));
bufferAnimCounter++;
if (bufferAnimCounter == NB_BUFFER_ANIM)
bufferAnimCounter = 0;
}
else {
ResetStartAnim(HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum));
currentProcessedActorPtr->newAnimType &= ~ANIM_RESET;
}
currentProcessedActorPtr->ANIM = newAnim;
currentProcessedActorPtr->animType = currentProcessedActorPtr->newAnimType;
currentProcessedActorPtr->animInfo = currentProcessedActorPtr->newAnimInfo;
currentProcessedActorPtr->newAnim = -1;
currentProcessedActorPtr->newAnimType = 0;
currentProcessedActorPtr->newAnimInfo = -1;
currentProcessedActorPtr->flagEndAnim = 0;
currentProcessedActorPtr->frame = 0;
currentProcessedActorPtr->numOfFrames = GetNbFramesAnim(HQR_Get(HQ_Anims, newAnim));
}
}
if(currentProcessedActorPtr->ANIM == -1) // no animation
{
currentProcessedActorPtr->END_FRAME = 0;
if(currentProcessedActorPtr->speed == 0)
{
int numObjectCollisions = CheckObjectCol(currentProcessedActorIdx, &currentProcessedActorPtr->zv);
for(int i = 0; i<numObjectCollisions; i++)
{
ListObjets[currentProcessedActorPtr->COL[i]].COL_BY = currentProcessedActorIdx; // collision with current actor
}
oldStepY = 0;
oldStepZ = 0;
stepX = 0;
stepZ = 0;
stepY = 0;
}
else
{
oldStepX = currentProcessedActorPtr->stepX;
oldStepY = currentProcessedActorPtr->stepY;
oldStepZ = currentProcessedActorPtr->stepZ;
animStepY = 0;
animStepX = 0;
animStepZ = evaluateReal(&currentProcessedActorPtr->speedChange);
walkStep(0,animStepZ,currentProcessedActorPtr->beta);
stepX = animMoveX - oldStepX;
stepZ = animMoveZ - oldStepZ;
stepY = 0;
}
}
else // animation
{
oldStepX = currentProcessedActorPtr->stepX;
oldStepY = currentProcessedActorPtr->stepY;
oldStepZ = currentProcessedActorPtr->stepZ;
currentProcessedActorPtr->END_FRAME = SetInterAnimObjet(currentProcessedActorPtr->frame, HQR_Get(HQ_Anims, currentProcessedActorPtr->ANIM), HQR_Get(HQ_Bodys, currentProcessedActorPtr->bodyNum));
walkStep(animStepX,animStepZ,currentProcessedActorPtr->beta);
stepX = animMoveX+currentProcessedActorPtr->animNegX - oldStepX;
stepZ = animMoveZ+currentProcessedActorPtr->animNegZ - oldStepZ;
}
if(currentProcessedActorPtr->YHandler.numSteps) // currently falling ?
{
if(currentProcessedActorPtr->YHandler.numSteps != -1)
{
stepY = evaluateReal(&currentProcessedActorPtr->YHandler) - oldStepY;
}
else // stop falling
{
stepY = currentProcessedActorPtr->YHandler.endValue - oldStepY;
currentProcessedActorPtr->YHandler.numSteps = 0;
currentProcessedActorPtr->YHandler.endValue = 0;
currentProcessedActorPtr->YHandler.startValue = 0;
}
}
else
{
stepY = 0;
}
memcpy(localTable,currentProcessedActorPtr->COL,6);
if(stepX || stepY || stepZ) // start of movement management
{
zvPtr = &currentProcessedActorPtr->zv;
CopyZV(&currentProcessedActorPtr->zv,&zvLocal);
zvLocal.ZVX1 += stepX;
zvLocal.ZVX2 += stepX;
zvLocal.ZVY1 += stepY;
zvLocal.ZVY2 += stepY;
zvLocal.ZVZ1 += stepZ;
zvLocal.ZVZ2 += stepZ;
// check for wall collisions
if(currentProcessedActorPtr->dynFlags & 1) // hard collision enabled for actor ?
{
int numCol = AsmCheckListCol(&zvLocal, &roomDataTable[currentProcessedActorPtr->room]);
for(int i=0;i<numCol;i++)
{
hardColStruct* pHardCol = hardColTable[i];
if(pHardCol->type == 9)
{
currentProcessedActorPtr->HARD_COL = (short)pHardCol->parameter;
}
// climbable wall
if(pHardCol->type == 3)
{
currentProcessedActorPtr->HARD_COL = 255;
}
if (g_gameId >= JACK) {
// monster collision for floor changes
if ((pHardCol->type == 10) && (currentProcessedActorIdx == currentCameraTargetActor))
continue;
}
if(stepX || stepZ) // move on the X or Z axis ? update to avoid entering the hard col
{
//ZVStruct tempZv;
hardColStepX = stepX;
hardColStepZ = stepZ;
GereCollision(zvPtr, &zvLocal, &pHardCol->zv);
currentProcessedActorPtr->animNegX += hardColStepX - stepX;
currentProcessedActorPtr->animNegZ += hardColStepZ - stepZ;
zvLocal.ZVX1 += hardColStepX - stepX;
zvLocal.ZVX2 += hardColStepX - stepX;
zvLocal.ZVZ1 += hardColStepZ - stepZ;
zvLocal.ZVZ2 += hardColStepZ - stepZ;
stepX = hardColStepX;
stepZ = hardColStepZ;
}
if(stepY)
{
//assert(0); //not implemented
}
}
}
else // no hard collision -> just update the flag without performing the position update
{
if(AsmCheckListCol(&zvLocal, &roomDataTable[currentProcessedActorPtr->room]))
{
currentProcessedActorPtr->HARD_COL = 1;
}
else
{
currentProcessedActorPtr->HARD_COL = 0;
}
}
// check for object collisions
// TODO: AITD2 checks flag collision here
int numCol = CheckObjectCol(currentProcessedActorIdx,&zvLocal); // get the number of actor/actor collision
for(int j=0;j<numCol;j++) // process the actor/actor collision
{
int collisionIndex = currentProcessedActorPtr->COL[j];
tObject* actorTouchedPtr = &ListObjets[collisionIndex];
actorTouchedPtr->COL_BY = currentProcessedActorIdx;
ZVStruct* touchedZv = &actorTouchedPtr->zv;
if(actorTouchedPtr->objectType & AF_FOUNDABLE) // takable
{
if(currentProcessedActorPtr->trackMode == 1 /*&& ((gameId == AITD1 && defines.field_1E == 0) || (gameId >= JACK && defines.field_6 == 0))*/) // TODO: check if character isn't dead...
{
FoundObjet(actorTouchedPtr->indexInWorld, 0);
}
continue;
}
{
if(actorTouchedPtr->objectType & AF_MOVABLE) // can be pushed ?
{
ZVStruct localZv2;
bool isPushPossible = true;
CopyZV(touchedZv, &localZv2);
localZv2.ZVX1 += stepX;
localZv2.ZVX2 += stepX;
localZv2.ZVZ1 += stepZ;
localZv2.ZVZ2 += stepZ;
// check pushed object against walls
if(AsmCheckListCol(&localZv2, &roomDataTable[currentProcessedActorPtr->room]))
{
isPushPossible = false;
}
else if (CheckObjectCol(collisionIndex, &localZv2))
{
// if no wall preventing to move object, check is there is a another object in the way
isPushPossible = false;
}
if(!isPushPossible)
{
if(stepX || stepZ) //if we're trying to move
{
if(actorTouchedPtr->room != currentProcessedActorPtr->room)
{
ZVStruct localZv3;
CopyZV(touchedZv, &localZv3);
AdjustZV(&localZv3, actorTouchedPtr->room, currentProcessedActorPtr->room);
hardColStepX = stepX;
hardColStepZ = stepZ;
GereCollision(zvPtr, &zvLocal, &localZv3);
stepX = hardColStepX;
stepZ = hardColStepZ;
}
else
{
hardColStepX = stepX;
hardColStepZ = stepZ;
GereCollision(zvPtr, &zvLocal, touchedZv); // manage as hard collision
stepX = hardColStepX;
stepZ = hardColStepZ;
}
}
}
else // push succeed
{
if(actorTouchedPtr->objectType & AF_BOXIFY)
{
removeFromBGIncrust(collisionIndex);
}
actorTouchedPtr->objectType |= AF_ANIMATED;
actorTouchedPtr->worldX += stepX; // apply push to object
actorTouchedPtr->worldZ += stepZ;
actorTouchedPtr->roomX += stepX;
actorTouchedPtr->roomZ += stepZ;
CopyZV(&localZv2,touchedZv);
}
}
else
{
// can't be pushed
if(currentProcessedActorPtr->dynFlags & 1)
{
if(stepX || stepZ) // if moving
{
if(actorTouchedPtr->room == currentProcessedActorPtr->room) // same room -> easy case
{
hardColStepX = stepX;
hardColStepZ = stepZ;
GereCollision(zvPtr, &zvLocal, touchedZv); // manage as hard collision
stepX = hardColStepX;
stepZ = hardColStepZ;
}
else // different room
{
ZVStruct localZv3;
CopyZV(touchedZv, &localZv3);
AdjustZV(&localZv3, actorTouchedPtr->room, currentProcessedActorPtr->room);
hardColStepX = stepX;
hardColStepZ = stepZ;
GereCollision(zvPtr, &zvLocal, &localZv3); // manage as hard collision
stepX = hardColStepX;
stepZ = hardColStepZ;
}
}
}
}
}
} // end of actor/actor collision
currentProcessedActorPtr->stepX = stepX + oldStepX;
currentProcessedActorPtr->stepY = stepY + oldStepY;
currentProcessedActorPtr->stepZ = stepZ + oldStepZ;
currentProcessedActorPtr->zv.ZVX1 += stepX;
currentProcessedActorPtr->zv.ZVX2 += stepX;
currentProcessedActorPtr->zv.ZVY1 += stepY;
currentProcessedActorPtr->zv.ZVY2 += stepY;
currentProcessedActorPtr->zv.ZVZ1 += stepZ;
currentProcessedActorPtr->zv.ZVZ2 += stepZ;
} // end of movement management
if(!currentProcessedActorPtr->YHandler.numSteps)
{
// fall management ?
currentProcessedActorPtr->worldY += currentProcessedActorPtr->stepY;
currentProcessedActorPtr->roomY += currentProcessedActorPtr->stepY;
currentProcessedActorPtr->stepY = 0;
if(currentProcessedActorPtr->objectType & AF_FALLABLE)
{
zvPtr = &currentProcessedActorPtr->zv;
CopyZV(zvPtr, &zvLocal);
zvLocal.ZVY2 += 100;
if(currentProcessedActorPtr->roomY < -10 && !AsmCheckListCol(&zvLocal,&roomDataTable[currentProcessedActorPtr->room]) && !manageFall(currentProcessedActorIdx,&zvLocal))
{
InitRealValue(0, 2000, 40, &currentProcessedActorPtr->YHandler);
}
else
{
currentProcessedActorPtr->falling = 0;
}
}
}
else
{
if((currentProcessedActorPtr->YHandler.numSteps != -1) && (currentProcessedActorPtr->objectType & AF_FALLABLE))
{
currentProcessedActorPtr->falling = 1;
}
}
for(int i=0; i<3; i++)
{
int collisionIndex = localTable[i];
if(collisionIndex != -1)
{
tObject* actorTouchedPtr = &ListObjets[collisionIndex];
if(actorTouchedPtr->objectType & AF_MOVABLE)
{
int i;
for(i=0;i<3;i++)
{
if(currentProcessedActorPtr->COL[i] == collisionIndex)
break;
}
if(i == 3)
{
actorTouchedPtr->objectType &= ~AF_ANIMATED;
addActorToBgInscrust(collisionIndex);
}
}
}
}
if(currentProcessedActorPtr->END_FRAME) // key frame change
{
currentProcessedActorPtr->frame++;
if(currentProcessedActorPtr->frame >= currentProcessedActorPtr->numOfFrames) // end of anim ?
{
currentProcessedActorPtr->flagEndAnim = 1; // end of anim
currentProcessedActorPtr->frame = 0; // restart anim
if(!(currentProcessedActorPtr->animType & 1) && (currentProcessedActorPtr->newAnim == -1)) // is another anim waiting ?
{
currentProcessedActorPtr->animType &= 0xFFFD;
InitAnim(currentProcessedActorPtr->animInfo, 1, -1);
}
}
currentProcessedActorPtr->worldX += currentProcessedActorPtr->stepX;
currentProcessedActorPtr->roomX += currentProcessedActorPtr->stepX;
currentProcessedActorPtr->worldZ += currentProcessedActorPtr->stepZ;
currentProcessedActorPtr->roomZ += currentProcessedActorPtr->stepZ;
currentProcessedActorPtr->stepX = 0;
currentProcessedActorPtr->stepZ = 0;
currentProcessedActorPtr->animNegX = 0;
currentProcessedActorPtr->animNegY = 0;
currentProcessedActorPtr->animNegZ = 0;
}
else // not the end of anim
{
if((currentProcessedActorPtr->ANIM == -1) && (currentProcessedActorPtr->speed != 0) && (currentProcessedActorPtr->speedChange.numSteps == 0))
{
currentProcessedActorPtr->worldX += currentProcessedActorPtr->stepX;
currentProcessedActorPtr->roomX += currentProcessedActorPtr->stepX;
currentProcessedActorPtr->worldZ += currentProcessedActorPtr->stepZ;
currentProcessedActorPtr->roomZ += currentProcessedActorPtr->stepZ;
currentProcessedActorPtr->stepX = 0;
currentProcessedActorPtr->stepZ = 0;
InitRealValue(0,currentProcessedActorPtr->speed,60,&currentProcessedActorPtr->speedChange);
}
currentProcessedActorPtr->flagEndAnim = 0;
}
}
void StockInterAnim(sFrame& buffer, sBody* bodyPtr)
{
if(bodyPtr->m_flags & INFO_ANIM)
{
*(u16*)(bodyPtr->m_scratchBuffer.data()+4) = (u16)timer;
bodyPtr->startAnim = &buffer;
buffer.m_groups.resize(bodyPtr->m_groups.size());
for (int i = 0; i < bodyPtr->m_groups.size(); i++) {
buffer.m_groups[i] = bodyPtr->m_groups[i].m_state;
}
}
}
void ResetStartAnim(sBody* bodyPtr) {
*(u16*)(bodyPtr->m_scratchBuffer.data() + 4) = (u16)timer; // reset timer
bodyPtr->startAnim = nullptr;
}
s16 GetNbFramesAnim(sAnimation* animPtr)
{
return animPtr->m_numFrames;
}
s16 PatchType(sGroupState* bodyPtr, u16 type) // local
{
bodyPtr->m_type = type;
return(bodyPtr->m_type);
}
void PatchInterAngle(s16* value, s16 previousValue, s16 nextValue, int bp, int bx) // local
{
s16 diff = nextValue - previousValue;
if(diff == 0)
{
*value = nextValue;
}
else
{
if(diff <= 0x200)
{
if(diff >= -0x200)
{
*value = ((diff*bp)/bx) + previousValue;
}
else
{
nextValue += 0x400;
nextValue -= previousValue;
*value = ((nextValue *bp)/bx) + previousValue;
}
}
else
{
previousValue += 0x400;
nextValue -= previousValue;
*value = ((nextValue *bp)/bx) + previousValue;
}
}
}
void PatchInterStep(s16* value, s16 previousValue, s16 nextValue, int bp, int bx) // local
{
s16 cx = previousValue;
s16 ax = nextValue;
if(ax == cx)
{
*value = ax;
}
else
{
*value = (((ax - cx)*bp)/bx) + cx;
}
}
s16 SetInterAnimObjet(int frame, sAnimation* pAnim, sBody* pBody)
{
int numOfBonesInAnim = pAnim->m_numGroups;
u16 keyframeLength;
u16 timeOfKeyframeStart;
int ax;
u16 bx;
u16 time;
int bp;
int flag;
flag = pBody->m_flags;
sFrame* pKeyframe = &pAnim->m_frames[frame];
keyframeLength = pKeyframe->m_timestamp; // keyframe length
if(!(pBody->m_flags & INFO_ANIM)) // do not anim if the model can't be animated
{
return(0);
}
timeOfKeyframeStart = *(u16*)(pBody->m_scratchBuffer.data() + 4); // time of start of keyframe
sFrame* pPreviousKeyframe = pBody->startAnim;
if(!pPreviousKeyframe)
{
pPreviousKeyframe = pKeyframe;
}
if(numOfBonesInAnim > pBody->m_groupOrder.size())
{
numOfBonesInAnim = pBody->m_groupOrder.size();
}
time = (u16)timer - timeOfKeyframeStart;
bx = keyframeLength;
bp = time;
if(time<keyframeLength) // interpolate keyframe
{
if(!(flag&INFO_OPTIMISE))
{
for (int i = 0; i < numOfBonesInAnim; i++)
{
point3dStruct& state = pBody->m_groups[i].m_state.m_delta;
point3dStruct& previousState = pPreviousKeyframe->m_groups[i].m_delta;
point3dStruct& nextState = pKeyframe->m_groups[i].m_delta;
switch(PatchType(&pBody->m_groups[i].m_state, pKeyframe->m_groups[i].m_type))
{
case 0: // rotate
PatchInterAngle(&state.x, previousState.x, nextState.x, bp, bx);
PatchInterAngle(&state.y, previousState.y, nextState.y, bp, bx);
PatchInterAngle(&state.z, previousState.z, nextState.z, bp, bx);
break;
case 1: // translate
case 2: // zoom
PatchInterStep(&state.x, previousState.x, nextState.x, bp, bx);
PatchInterStep(&state.y, previousState.y, nextState.y, bp, bx);
PatchInterStep(&state.z, previousState.z, nextState.z, bp, bx);
break;
}
}
}
else
{
for (int i = 0; i < numOfBonesInAnim; i++)
{
point3dStruct& state = pBody->m_groups[i].m_state.m_delta;
point3dStruct& previousState = pPreviousKeyframe->m_groups[i].m_delta;
point3dStruct& nextState = pKeyframe->m_groups[i].m_delta;
switch (PatchType(&pBody->m_groups[i].m_state, pKeyframe->m_groups[i].m_type))
{
case 0:
break;
case 1:
case 2:
PatchInterStep(&state.x, previousState.x, nextState.x, bp, bx);
PatchInterStep(&state.y, previousState.y, nextState.y, bp, bx);
PatchInterStep(&state.z, previousState.z, nextState.z, bp, bx);
break;
}
{
point3dStruct& state = pBody->m_groups[i].m_state.m_rotateDelta.value();
point3dStruct& previousState = pPreviousKeyframe->m_groups[i].m_rotateDelta.value();
point3dStruct& nextState = pKeyframe->m_groups[i].m_rotateDelta.value();
PatchInterAngle(&state.x, previousState.x, nextState.x, bp, bx);
PatchInterAngle(&state.y, previousState.y, nextState.y, bp, bx);
PatchInterAngle(&state.z, previousState.z, nextState.z, bp, bx);
}
}
}
animStepX = (pKeyframe->m_animStep.x * bp) / bx;
animStepY = (pKeyframe->m_animStep.y * bp) / bx;
animStepZ = (pKeyframe->m_animStep.z * bp) / bx;
animCurrentTime = bx;
animKeyframeLength = bp;
return(0);
}
else // change keyframe
{
for (int i = 0; i < numOfBonesInAnim; i++)
{
sGroupState& nextState = pKeyframe->m_groups[i];
pBody->m_groups[i].m_state = nextState;
};
pBody->startAnim = pKeyframe;
*(u16*)(pBody->m_scratchBuffer.data()+4) = (u16)timer;
animCurrentTime = bx;
animKeyframeLength = bx;
animStepX = pKeyframe->m_animStep.x;
animStepY = pKeyframe->m_animStep.y;
animStepZ = pKeyframe->m_animStep.z;
return(1);
}
}
Reference in New Issue View Git Blame Copy Permalink