Archive/openmohaa
0
0
Fork 0
mirror of https://github.com/openmoh/openmohaa.git synced 2025-04-28 21:57:57 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions 3
openmohaa/code/skeletor/skeletor_loadanimation.cpp
smallmodel 29f8ff8d71
Set the new frame radius 
This fixes an issue when culling static models as it uses the radius and the radius wasn't initialized
2024-10-22 22:26:55 +02:00

739 lines
29 KiB
C++
Raw Blame History

/*
===========================================================================
Copyright (C) 2024 the OpenMoHAA team
This file is part of OpenMoHAA source code.
OpenMoHAA source code is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
OpenMoHAA source code is distributed in the hope that it will be
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with OpenMoHAA source code; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
===========================================================================
*/
// skeletor_loadanimation.cpp : Responsible of loading animations
#include "q_shared.h"
#include "qcommon.h"
#include "skeletor.h"
qboolean Compress(skelAnimGameFrame_t *current, skelAnimGameFrame_t *last, int channelIndex, int numChannels)
{
float tolerance;
float difference;
int i;
// high-end PC don't need to compress...
return false;
for (i = 0; i < numChannels; i++) {
tolerance = current->pChannels[channelIndex][i];
if (tolerance > -0.000001 && tolerance < 0.000001) {
current->pChannels[channelIndex][i] = 0.0f;
}
}
if (last) {
for (i = 0; i < numChannels; i++) {
difference = last->pChannels[channelIndex][i] - current->pChannels[channelIndex][i];
if (difference < -0.001f || difference >= 0.001f) {
return false;
}
}
}
return true;
}
skelAnimDataGameHeader_t *EncodeFrames(
skelAnimDataGameHeader_t *enAnim,
skelAnimGameFrame_t *m_frame,
qboolean bLog,
skelChannelList_c *channelList,
ChannelNameTable *channelNames
)
{
int endFrameCap;
skanChannelHdr *pChannel;
int i, j;
int frameCnt;
skelAnimGameFrame_t *pCurrFrame;
skelAnimGameFrame_t *pLastFrame;
skanGameFrame *pFrame;
size_t frameSize;
int indexLastFrameAdded;
channelType_t channelType;
pChannel = enAnim->ary_channels;
endFrameCap = enAnim->numFrames - 2;
for (i = 0; i < enAnim->nTotalChannels; i++, pChannel++) {
pLastFrame = NULL;
pCurrFrame = m_frame;
channelType = GetBoneChannelType(enAnim->channelList.ChannelName(channelNames, i));
switch (channelType) {
case CHANNEL_ROTATION:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(vec4_t));
frameCnt = 0;
for (j = 0; j < enAnim->numFrames; j++) {
if (!Compress(pCurrFrame, pLastFrame, i, 4) || j >= endFrameCap) {
frameCnt++;
pLastFrame = pCurrFrame;
}
pCurrFrame++;
}
pChannel->ary_frames = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->nFramesInChannel = frameCnt;
enAnim->nBytesUsed += frameSize * frameCnt;
pLastFrame = NULL;
indexLastFrameAdded = 0;
pCurrFrame = m_frame;
pFrame = pChannel->ary_frames;
for (j = 0; j < enAnim->numFrames; j++) {
if (!Compress(pCurrFrame, pLastFrame, i, 4) || j >= endFrameCap) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = j;
pFrame->nPrevFrameIndex = indexLastFrameAdded;
if (j > 0) {
indexLastFrameAdded++;
}
pFrame->pChannelData[0] = pCurrFrame->pChannels[i][0];
pFrame->pChannelData[1] = pCurrFrame->pChannels[i][1];
pFrame->pChannelData[2] = pCurrFrame->pChannels[i][2];
pFrame->pChannelData[3] = pCurrFrame->pChannels[i][3];
pLastFrame = pCurrFrame;
}
pCurrFrame++;
}
break;
case CHANNEL_POSITION:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(vec3_t));
frameCnt = 0;
for (j = 0; j < enAnim->numFrames; j++) {
if (!Compress(pCurrFrame, pLastFrame, i, 3) || j >= endFrameCap) {
frameCnt++;
pLastFrame = pCurrFrame;
}
pCurrFrame++;
}
pChannel->ary_frames = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->nFramesInChannel = frameCnt;
enAnim->nBytesUsed += frameSize * frameCnt;
pLastFrame = NULL;
indexLastFrameAdded = 0;
pCurrFrame = m_frame;
pFrame = pChannel->ary_frames;
for (j = 0; j < enAnim->numFrames; j++) {
if (!Compress(pCurrFrame, pLastFrame, i, 1) || j >= endFrameCap) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = j;
pFrame->nPrevFrameIndex = indexLastFrameAdded;
if (j > 0) {
indexLastFrameAdded++;
}
pFrame->pChannelData[0] = pCurrFrame->pChannels[i][0];
pFrame->pChannelData[1] = pCurrFrame->pChannels[i][1];
pFrame->pChannelData[2] = pCurrFrame->pChannels[i][2];
pLastFrame = pCurrFrame;
}
pCurrFrame++;
}
break;
case CHANNEL_NONE:
pChannel->ary_frames = NULL;
pChannel->nFramesInChannel = 0;
break;
case CHANNEL_VALUE:
default:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(float));
frameCnt = 0;
for (j = 0; j < enAnim->numFrames; j++) {
if (!Compress(pCurrFrame, pLastFrame, i, 1) || j >= endFrameCap) {
frameCnt++;
pLastFrame = pCurrFrame;
}
pCurrFrame++;
}
pChannel->ary_frames = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->nFramesInChannel = frameCnt;
enAnim->nBytesUsed += frameSize * frameCnt;
pLastFrame = NULL;
indexLastFrameAdded = 0;
pCurrFrame = m_frame;
pFrame = pChannel->ary_frames;
for (j = 0; j < enAnim->numFrames; j++) {
if (!Compress(pCurrFrame, pLastFrame, i, 3) || j >= endFrameCap) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = j;
pFrame->nPrevFrameIndex = indexLastFrameAdded;
if (j > 0) {
indexLastFrameAdded++;
}
pFrame->pChannelData[0] = pCurrFrame->pChannels[i][0];
pLastFrame = pCurrFrame;
}
pCurrFrame++;
}
break;
}
}
return enAnim;
}
skelAnimDataGameHeader_t *
skeletor_c::ConvertSkelFileToGame(skelAnimDataFileHeader_t *pHeader, int iBuffLength, const char *path)
{
int i, j;
skelAnimFileFrame_t *pFileFrame;
skelAnimGameFrame_t *pGameFrame;
skelChannelName_t *pChannelNames;
skelAnimDataGameHeader_t *enAnim;
skelAnimGameFrame_t *oldFrame;
skelAnimGameFrame_t *newFrame;
int channelIndex;
static_assert(sizeof(skelAnimDataFileHeader_t) == 96, "Skeletor anim header size doesn't match!");
static_assert(sizeof(skelAnimFileFrame_t) == 48, "Skeletor anim file frame size doesn't match!");
if (pHeader->numFrames <= 0) {
return NULL;
}
pGameFrame = new skelAnimGameFrame_t[pHeader->numFrames];
pFileFrame = pHeader->frame;
newFrame = pGameFrame;
for (i = 0; i < pHeader->numFrames; i++) {
vec4_t* pChannels;
newFrame->bounds[0][0] = LittleFloat(pFileFrame->bounds[0][0]);
newFrame->bounds[0][1] = LittleFloat(pFileFrame->bounds[0][1]);
newFrame->bounds[0][2] = LittleFloat(pFileFrame->bounds[0][2]);
newFrame->bounds[1][0] = LittleFloat(pFileFrame->bounds[1][0]);
newFrame->bounds[1][1] = LittleFloat(pFileFrame->bounds[1][1]);
newFrame->bounds[1][2] = LittleFloat(pFileFrame->bounds[1][2]);
newFrame->radius = LittleFloat(pFileFrame->radius);
newFrame->delta[0] = LittleFloat(pFileFrame->delta[0]);
newFrame->delta[1] = LittleFloat(pFileFrame->delta[1]);
newFrame->delta[2] = LittleFloat(pFileFrame->delta[2]);
newFrame->angleDelta = LittleFloat(pFileFrame->angleDelta);
//
// Load channels
//
newFrame->pChannels = new vec4_t[pHeader->numChannels];
pChannels = (vec4_t*)((byte*)pHeader + (sizeof(skelAnimDataFileHeader_t) + sizeof(skelAnimFileFrame_t) * (pHeader->numFrames - 1) + sizeof(vec4_t) * pHeader->numChannels * i));
for (j = 0; j < pHeader->numChannels; j++) {
newFrame->pChannels[j][0] = LittleFloat(pChannels[j][0]);
newFrame->pChannels[j][1] = LittleFloat(pChannels[j][1]);
newFrame->pChannels[j][2] = LittleFloat(pChannels[j][2]);
newFrame->pChannels[j][3] = LittleFloat(pChannels[j][3]);
}
AddToBounds(newFrame->bounds, pFileFrame->bounds);
pFileFrame++;
newFrame++;
}
enAnim = skelAnimDataGameHeader_t::AllocRLEChannelData(pHeader->numChannels);
enAnim->flags = pHeader->flags;
enAnim->frameTime = pHeader->frameTime;
enAnim->totalDelta = pHeader->totalDelta;
enAnim->totalAngleDelta = pHeader->totalAngleDelta;
enAnim->numFrames = pHeader->numFrames;
enAnim->nTotalChannels = pHeader->numChannels;
ClearBounds(enAnim->bounds[0], enAnim->bounds[1]);
enAnim->m_frame = (skelAnimGameFrame_t *)Skel_Alloc(pHeader->numFrames * sizeof(skelAnimGameFrame_t));
oldFrame = pGameFrame;
newFrame = enAnim->m_frame;
for (i = 0; i < pHeader->numFrames; i++) {
newFrame->bounds[0] = oldFrame->bounds[0];
newFrame->bounds[1] = oldFrame->bounds[1];
newFrame->radius = oldFrame->radius;
newFrame->delta = oldFrame->delta;
newFrame->angleDelta = oldFrame->angleDelta;
newFrame->pChannels = NULL;
AddToBounds(enAnim->bounds, oldFrame->bounds);
oldFrame++;
newFrame++;
}
enAnim->channelList.ZeroChannels();
pChannelNames = (skelChannelName_t *)((char *)pHeader + pHeader->ofsChannelNames);
for (i = 0; i < pHeader->numChannels; i++) {
channelIndex = m_channelNames.RegisterChannel(*pChannelNames);
enAnim->channelList.AddChannel(channelIndex);
pChannelNames++;
}
enAnim->channelList.PackChannels();
EncodeFrames(enAnim, pGameFrame, qfalse, &enAnim->channelList, &m_channelNames);
if (enAnim->channelList.HasChannel(&m_channelNames, "Bip01 pos")
&& enAnim->channelList.HasChannel(&m_channelNames, "Bip01 R Foot pos")
&& enAnim->channelList.HasChannel(&m_channelNames, "Bip01 L Foot pos")) {
enAnim->bHasDelta = true;
} else {
enAnim->bHasDelta = false;
}
if (enAnim->channelList.HasChannel(&m_channelNames, "Bip01 Spine rot")
&& enAnim->channelList.HasChannel(&m_channelNames, "Bip01 Spine1 rot")) {
enAnim->bHasUpper = true;
} else {
enAnim->bHasUpper = false;
}
if (enAnim->channelList.HasChannel(&m_channelNames, "VISEME_Bump")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Cage_")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Earth")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Fave")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_If")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_New")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Ox")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Roar")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Size")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Though")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Told")
|| enAnim->channelList.HasChannel(&m_channelNames, "VISME_Wet")
|| enAnim->channelList.HasChannel(&m_channelNames, "BROW_frown")
|| enAnim->channelList.HasChannel(&m_channelNames, "BROW_R_lift")
|| enAnim->channelList.HasChannel(&m_channelNames, "BROW_lift")
|| enAnim->channelList.HasChannel(&m_channelNames, "BROW_worry")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYE_blink")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_Excited__")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_L_squint")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_narrow__")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_down")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_left")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_right")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_smile")
|| enAnim->channelList.HasChannel(&m_channelNames, "EYES_up__")
|| enAnim->channelList.HasChannel(&m_channelNames, "JAW_open-closed")
|| enAnim->channelList.HasChannel(&m_channelNames, "JAW_open-open")
|| enAnim->channelList.HasChannel(&m_channelNames, "LIPS_compressed")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_L_smile_closed")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_L_smile_open")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_L_snarl_closed_")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_L_snarl_open")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_grimace")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_smile_closed")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_smile_open")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_Snarl_closed")
|| enAnim->channelList.HasChannel(&m_channelNames, "MOUTH_Snarl_open")) {
enAnim->bHasMorph = true;
} else {
enAnim->bHasMorph = false;
}
for (i = 0; i < pHeader->numFrames; i++) {
if (pGameFrame[i].pChannels) {
delete[] pGameFrame[i].pChannels;
}
}
delete[] pGameFrame;
return enAnim;
}
void WriteEncodedFrames(msg_t *msg, skelAnimDataGameHeader_t *enAnim)
{
skanChannelHdr *pChannel;
skanGameFrame *pFrame;
int i, j;
MSG_WriteLong(msg, enAnim->numFrames);
MSG_WriteShort(msg, enAnim->nTotalChannels);
for (i = 0; i < enAnim->nTotalChannels; i++) {
pChannel = &enAnim->ary_channels[i];
MSG_WriteShort(msg, pChannel->nFramesInChannel);
for (j = 0; j < pChannel->nFramesInChannel; j++) {
vec4_t channelData;
pFrame = &pChannel->ary_frames[i];
MSG_WriteShort(msg, pFrame->nFrameNum);
MSG_WriteShort(msg, pFrame->nPrevFrameIndex);
channelData[0] = LittleFloat(pFrame->pChannelData[0]);
channelData[1] = LittleFloat(pFrame->pChannelData[1]);
channelData[2] = LittleFloat(pFrame->pChannelData[2]);
channelData[3] = LittleFloat(pFrame->pChannelData[3]);
MSG_WriteData(msg, channelData, sizeof(vec4_t));
}
}
MSG_WriteLong(msg, enAnim->nBytesUsed);
}
void skeletor_c::SaveProcessedAnim(
skelAnimDataGameHeader_t *enAnim, const char *path, skelAnimDataFileHeader_t *pHeader
)
{
/*
int i;
skelChannelName_t *pChannelNames;
msg_t msg;
skelAnimGameFrame_t *newFrame;
char npath[ 128 ];
unsigned char buf[ 2000000 ];
// FIXME:
// Write animation
*/
}
void ReadEncodedFrames(msg_t *msg, skelAnimDataGameHeader_t *enAnim)
{
skanChannelHdr *pChannel;
skanGameFrame *pFrame;
size_t frameSize;
int frameCnt;
int i, j;
channelType_t channelType;
vec4_t channelData;
for (i = 0; i < enAnim->nTotalChannels; i++) {
pChannel = &enAnim->ary_channels[i];
channelType = GetBoneChannelType(enAnim->channelList.ChannelName(&skeletor_c::m_channelNames, i));
frameCnt = MSG_ReadShort(msg);
switch (channelType) {
case CHANNEL_ROTATION:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(vec4_t));
pFrame = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->ary_frames = pFrame;
pChannel->nFramesInChannel = frameCnt;
for (j = 0; j < frameCnt; j++) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = MSG_ReadShort(msg);
pFrame->nPrevFrameIndex = MSG_ReadShort(msg);
MSG_ReadData(msg, channelData, sizeof(vec4_t));
pFrame->pChannelData[0] = LittleFloat(channelData[0]);
pFrame->pChannelData[1] = LittleFloat(channelData[1]);
pFrame->pChannelData[2] = LittleFloat(channelData[2]);
pFrame->pChannelData[3] = LittleFloat(channelData[3]);
}
break;
case CHANNEL_POSITION:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(vec3_t));
pFrame = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->ary_frames = pFrame;
pChannel->nFramesInChannel = frameCnt;
for (j = 0; j < frameCnt; j++) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = MSG_ReadShort(msg);
pFrame->nPrevFrameIndex = MSG_ReadShort(msg);
MSG_ReadData(msg, channelData, sizeof(vec4_t));
pFrame->pChannelData[0] = LittleFloat(channelData[0]);
pFrame->pChannelData[1] = LittleFloat(channelData[1]);
pFrame->pChannelData[2] = LittleFloat(channelData[2]);
}
break;
case CHANNEL_NONE:
pChannel->ary_frames = NULL;
pChannel->nFramesInChannel = 0;
for (j = 0; j < frameCnt; j++) {
MSG_ReadShort(msg);
MSG_ReadShort(msg);
MSG_ReadData(msg, channelData, sizeof(vec4_t));
}
break;
case CHANNEL_VALUE:
default:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(float));
pFrame = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->ary_frames = pFrame;
pChannel->nFramesInChannel = frameCnt;
for (j = 0; j < frameCnt; j++) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = MSG_ReadShort(msg);
pFrame->nPrevFrameIndex = MSG_ReadShort(msg);
MSG_ReadData(msg, channelData, sizeof(vec4_t));
pFrame->pChannelData[0] = LittleFloat(channelData[0]);
}
break;
}
}
enAnim->nBytesUsed = MSG_ReadLong(msg);
}
void ReadEncodedFramesEx(msg_t *msg, skelAnimDataGameHeader_t *enAnim)
{
skanChannelHdr *pChannel;
skanGameFrame *pFrame;
size_t frameSize;
int frameCnt;
int i, j;
const char *name;
channelType_t type;
for (i = 0; i < enAnim->nTotalChannels; i++) {
pChannel = &enAnim->ary_channels[i];
name = enAnim->channelList.ChannelName(&skeletor_c::m_channelNames, i);
type = GetBoneChannelType(name);
frameCnt = MSG_ReadShort(msg);
switch (type) {
//
// 4 channels (Quat)
//
case CHANNEL_ROTATION:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(vec4_t));
pFrame = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->ary_frames = pFrame;
pChannel->nFramesInChannel = frameCnt;
for (j = 0; j < pChannel->nFramesInChannel; j++) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = MSG_ReadShort(msg);
pFrame->nPrevFrameIndex = MSG_ReadShort(msg);
pFrame->pChannelData[0] = MSG_ReadFloat(msg);
pFrame->pChannelData[1] = MSG_ReadFloat(msg);
pFrame->pChannelData[2] = MSG_ReadFloat(msg);
pFrame->pChannelData[3] = MSG_ReadFloat(msg);
}
break;
//
// 3 channels (Position)
//
case CHANNEL_POSITION:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(vec3_t));
pFrame = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->ary_frames = pFrame;
pChannel->nFramesInChannel = frameCnt;
for (j = 0; j < pChannel->nFramesInChannel; j++) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = MSG_ReadShort(msg);
pFrame->nPrevFrameIndex = MSG_ReadShort(msg);
pFrame->pChannelData[0] = MSG_ReadFloat(msg);
pFrame->pChannelData[1] = MSG_ReadFloat(msg);
pFrame->pChannelData[2] = MSG_ReadFloat(msg);
}
break;
//
// 1 channel (frame)
//
case CHANNEL_VALUE:
frameSize = (sizeof(skanGameFrame) - sizeof(skanGameFrame::pChannelData) + sizeof(float) * 1);
pFrame = (skanGameFrame *)Skel_Alloc(frameSize * frameCnt);
pChannel->ary_frames = pFrame;
pChannel->nFramesInChannel = frameCnt;
for (j = 0; j < pChannel->nFramesInChannel; j++) {
pFrame = (skanGameFrame *)((byte *)pChannel->ary_frames + j * frameSize);
pFrame->nFrameNum = MSG_ReadShort(msg);
pFrame->nPrevFrameIndex = MSG_ReadShort(msg);
pFrame->pChannelData[0] = MSG_ReadFloat(msg);
}
break;
case CHANNEL_NONE:
// Nothing to do
break;
}
}
}
skelAnimDataGameHeader_t *skeletor_c::LoadProcessedAnim(const char *path, void *buffer, int len, const char *name)
{
skelAnimDataGameHeader_t *enAnim;
int i, j;
msg_t msg;
msg_t msgForAnim;
int numChannels;
skelAnimGameFrame_t *newFrame;
MSG_Init(&msg, (byte *)buffer, len);
msg.cursize = len;
MSG_BeginReading(&msg);
numChannels = MSG_ReadLong(&msg);
enAnim = skelAnimDataGameHeader_t::AllocRLEChannelData(numChannels);
enAnim->flags = MSG_ReadLong(&msg);
enAnim->frameTime = MSG_ReadFloat(&msg);
enAnim->totalDelta[0] = MSG_ReadFloat(&msg);
enAnim->totalDelta[1] = MSG_ReadFloat(&msg);
enAnim->totalDelta[2] = MSG_ReadFloat(&msg);
enAnim->totalAngleDelta = MSG_ReadFloat(&msg);
enAnim->numFrames = MSG_ReadLong(&msg);
enAnim->nTotalChannels = MSG_ReadShort(&msg);
enAnim->bHasDelta = MSG_ReadByte(&msg) != 0;
enAnim->bHasUpper = MSG_ReadByte(&msg) != 0;
enAnim->bHasMorph = MSG_ReadByte(&msg) != 0;
newFrame = (skelAnimGameFrame_t *)Skel_Alloc(enAnim->numFrames * sizeof(skelAnimGameFrame_t));
enAnim->m_frame = newFrame;
for (i = 0; i < enAnim->numFrames; i++) {
newFrame->bounds[0][0] = MSG_ReadFloat(&msg);
newFrame->bounds[0][1] = MSG_ReadFloat(&msg);
newFrame->bounds[0][2] = MSG_ReadFloat(&msg);
newFrame->bounds[1][0] = MSG_ReadFloat(&msg);
newFrame->bounds[1][1] = MSG_ReadFloat(&msg);
newFrame->bounds[1][2] = MSG_ReadFloat(&msg);
newFrame->radius = MSG_ReadFloat(&msg);
newFrame->delta[0] = MSG_ReadFloat(&msg);
newFrame->delta[1] = MSG_ReadFloat(&msg);
newFrame->delta[2] = MSG_ReadFloat(&msg);
newFrame->angleDelta = MSG_ReadFloat(&msg);
newFrame->pChannels = NULL;
newFrame++;
}
enAnim->bounds[0][0] = MSG_ReadFloat(&msg);
enAnim->bounds[0][1] = MSG_ReadFloat(&msg);
enAnim->bounds[0][2] = MSG_ReadFloat(&msg);
enAnim->bounds[1][0] = MSG_ReadFloat(&msg);
enAnim->bounds[1][1] = MSG_ReadFloat(&msg);
enAnim->bounds[1][2] = MSG_ReadFloat(&msg);
enAnim->numFrames = MSG_ReadLong(&msg);
enAnim->nTotalChannels = MSG_ReadShort(&msg);
msgForAnim = msg;
for (i = 0; i < enAnim->nTotalChannels; i++) {
int frameCnt = MSG_ReadShort(&msgForAnim);
vec4_t channelData;
for (j = 0; j < frameCnt; j++) {
MSG_ReadShort(&msgForAnim);
MSG_ReadShort(&msgForAnim);
MSG_ReadData(&msgForAnim, channelData, sizeof(vec4_t));
}
}
enAnim->nBytesUsed = MSG_ReadLong(&msgForAnim);
numChannels = MSG_ReadLong(&msgForAnim);
enAnim->channelList.ZeroChannels();
for (i = 0; i < numChannels; i++) {
const char *name = MSG_ReadString(&msgForAnim);
if (enAnim->channelList.AddChannel(m_channelNames.RegisterChannel(name)) != i) {
Com_Printf("^~^~^ Animation '%s' has duplicate channel '%s'\n", path, name);
}
}
ReadEncodedFrames(&msg, enAnim);
return enAnim;
}
skelAnimDataGameHeader_t *skeletor_c::LoadProcessedAnimEx(const char *path, void *buffer, int len, const char *name)
{
skelAnimDataGameHeader_t *enAnim;
int i;
msg_t msg;
int numChannels;
skelAnimGameFrame_t *newFrame;
MSG_Init(&msg, (byte *)buffer, len);
msg.cursize = len;
MSG_BeginReading(&msg);
numChannels = MSG_ReadShort(&msg);
enAnim = skelAnimDataGameHeader_t::AllocRLEChannelData(numChannels);
enAnim->channelList.ZeroChannels();
enAnim->flags = MSG_ReadLong(&msg);
enAnim->frameTime = MSG_ReadFloat(&msg);
enAnim->totalDelta[0] = MSG_ReadFloat(&msg);
enAnim->totalDelta[1] = MSG_ReadFloat(&msg);
enAnim->totalDelta[2] = MSG_ReadFloat(&msg);
enAnim->totalAngleDelta = MSG_ReadFloat(&msg);
enAnim->numFrames = MSG_ReadLong(&msg);
enAnim->bHasDelta = MSG_ReadByte(&msg) != 0;
enAnim->bHasUpper = MSG_ReadByte(&msg) != 0;
enAnim->bHasMorph = MSG_ReadByte(&msg) != 0;
for (i = 0; i < enAnim->nTotalChannels; i++) {
enAnim->channelList.AddChannel(m_channelNames.RegisterChannel(MSG_ReadString(&msg)));
}
newFrame = (skelAnimGameFrame_t *)Skel_Alloc(enAnim->numFrames * sizeof(skelAnimGameFrame_t));
enAnim->m_frame = newFrame;
for (i = 0; i < enAnim->numFrames; i++) {
newFrame->bounds[0][0] = MSG_ReadFloat(&msg);
newFrame->bounds[0][1] = MSG_ReadFloat(&msg);
newFrame->bounds[0][2] = MSG_ReadFloat(&msg);
newFrame->bounds[1][0] = MSG_ReadFloat(&msg);
newFrame->bounds[1][1] = MSG_ReadFloat(&msg);
newFrame->bounds[1][2] = MSG_ReadFloat(&msg);
newFrame->radius = MSG_ReadFloat(&msg);
newFrame->delta[0] = MSG_ReadFloat(&msg);
newFrame->delta[1] = MSG_ReadFloat(&msg);
newFrame->delta[2] = MSG_ReadFloat(&msg);
newFrame->angleDelta = MSG_ReadFloat(&msg);
newFrame->pChannels = NULL;
newFrame++;
}
enAnim->bounds[0][0] = MSG_ReadFloat(&msg);
enAnim->bounds[0][1] = MSG_ReadFloat(&msg);
enAnim->bounds[0][2] = MSG_ReadFloat(&msg);
enAnim->bounds[1][0] = MSG_ReadFloat(&msg);
enAnim->bounds[1][1] = MSG_ReadFloat(&msg);
enAnim->bounds[1][2] = MSG_ReadFloat(&msg);
ReadEncodedFramesEx(&msg, enAnim);
return enAnim;
}
Reference in a new issue View git blame Copy permalink