Changes

File format discovered/decoded by me, L. Spiro.

There are 4 basic structures we will use in decoding the file format.

The header of animation data has been considered to be composed of 3 DWORD’s, 3 WORD’s, and one BYTE, however this is not how the header is really intended to be, despite being aligned correctly.

Cloud’s battle animation file (rtda) has 94 (0x 5E) animations in it.

After this number begins each animation.

I mentioned a type of special animation data set that is in the header file.

1.

typedef struct FF7FrameHeader {

DWORD dwBones; // Bones in the model + 1. 0x00

DWORD dwFrames; // Frames in the animation. 0x04

} * PFF7FrameHeader; // Size = 12 bytes.

2.

typedef struct FF7FrameMiniHeader {

SHORT sBones; // Bones in the animation. 0x00

BYTE bKey; // A key flag used for decoding. 0x04

} * PFF7FrameMiniHeader; // Size = 5 bytes.

This is used for every rotation-decoding scheme (but one). It determines, essentially, the precision of the rotations and the deltas that follow in successive frames.

After decompression, every rotation must be 12 bits, giving it a range from 0 to 4095.

This loss in accuracy is acceptable since rotations work as deltas and usually only change by a small amount.

Most large rotation deltas are things that are spinning, such as the blades on Aero Combatant. These cases are always a nice round number that can be handled with lower precision (in the case of Aero Combatant, it is 90 degrees even).

FF7FrameHeader fhHeader;

DWORD dwBytesRead;

for ( int I = 0; I < iTarget; I++ ) {

if ( fhHeader.dwChunkSize < 11 ) { // If this is a special

CloseHandle( hFile );

return false;

}

CloseHandle( hFile );

return false;

}

// Once we come to this point, we are at the very first byte of the

// animation we want to load. Let’s store it into a BYTE array.

if ( !ReadFile( hFile,

}

BYTE * pbBuffer = new BYTE[fhHeader.dwChunkSize];

// Now pbBuffer holds the actual animation data, including the 5-byte

// “FF7FrameMiniHeader” header.

We now have the animation we want loaded into a BYTE array (remember to delete it later).

3.

typedef struct FF7ShortVec {

SHORT sX, sY, sZ; // Signed short versions. 0x00

FLOAT fX, fY, fZ; // Float version after math. 0x12

} * PFF7ShortRot; // Size = 30 bytes.

Each rotation goes through 3 forms. Firstly, everything is stored as 2-byte SHORT’s. These SHORT’s are stored from 0 to 4096, where 0 = 0 degrees and 4096 = 360 degrees. This is the equation to convert one of these SHORT’s into degrees: (SHORT / 4096 * 360). Each frame is based off the previous frame, using the SHORT value as its basis.

Each SHORT is converted to an INT, which is the exact same as the SHORT version, except always positive.

Finally, the FLOAT gets filled with the final value, using the INT version as its base.

So, the sequence is:

First frame…

Next frame…

Repeat…

To load an entire frame’s work of bones, we need this structure:

4.

typedef struct FF7FrameBuffer {

DWORD dwBones;

FF7ShortVec svPosOffset;

FF7FrameBuffer() {

}

} * PFF7FrameBuffer;

This structure will allocate enough memory for one frame of rotations. Simply call “FF7FrameBuffer.SetBones” with the number of bones in your animation.

First, we need a way to read bits from the BYTE array we have stored.

This is a basic bit-reading function. It reads “dwTotalBits” from “pbBuffer” starting at the “dwStartBit”’th bit.

1.

INT GetBitsFixed( BYTE * pbBuffer, DWORD &dwStartBit,

DWORD dwTotalBits ) {

return iReturn;

}

Now that we can read the bits in the buffer we have made, it’s time to know what we’re doing!

Remember that we stored our animation buffer with a 5-byte “FF7FrameMiniHeader” at the beginning of it? We need this header now!

PFF7FrameMiniHeader pfmhMiniHeader = (PFF7FrameMiniHeader)pbBuffer;

After this cast, “pfmhMiniHeader->bKey” will contain a number, either 0, 2, or 4.

To get these bits, we first need to make a pointer point to the correct location. “pbBuffer” points 5 bytes before this data, so let’s make a pointer that points to this data directly.

BYTE * pbAnimBuffer = &pbBuffer[5];

When we use “GetBitsFixed()” to get the bits.

DWORD dwBitStart = 0; // The bits at which to begin reading in the

// stream.

SHORT sY = GetBitsFixed( pbAnimBuffer, dwBitStart, 16 );

SHORT sZ = GetBitsFixed( pbAnimBuffer, dwBitStart, 16 );

After doing this, we have each of the three offsets, 0, -466, and 0.

For each bone, there are 3 rotations. So, for each bone, we do this:

SHORT sRotX = GetBitsFixed( pbAnimBuffer, dwBitStart,

12 - pfmhMiniHeader->bKey );

sRotY <<= pfmhMiniHeader->bKey;

sRotZ <<= pfmhMiniHeader->bKey;

The first rotation is always 0, 0, 0. This is the root rotation and is not actually counted as part of the bone network of the character.

2.

SHORT GetDynamicFrameOffsetBits( BYTE * pBuffer, DWORD &dwBitStart ) {

DWORD dwFirstByte, dwConsumedBits, dwBitsRemainingToNextByte, dwTemp;

mov ecx, pBuffer

add ecx, dwFirstByte // Go to the first byte that

xor edx, edx

mov dl, byte ptr ds:[ecx]

mov ecx, dwBitStart //

mov edx, [ecx] //

mov eax, dwBitStart //

mov [eax], edx // Increase dwBitStart by 0x8 (8).

mov edx, dwBitStart //

mov [edx], ecx // Increase dwBitStart by 0x11

End :

return sReturn;

}

After the first frame, we know that the positional offsets immediately follow.

So to get the positional deltas for the next frame, we would do this:

SHORT sDeltaX = GetDynamicFrameOffsetBits( pbAnimBuffer, dwBitStart );

SHORT sDeltaY = GetDynamicFrameOffsetBits( pbAnimBuffer, dwBitStart );

SHORT sDeltaZ = GetDynamicFrameOffsetBits( pbAnimBuffer, dwBitStart );

Now we have the change from the previous frame. In our “FF7ShortVec” structure, these are the SHORT values. To get the position of this frame, we add these offsets to the last frame’s position.

If “I” is this frame and “I-1” is the last frame, we could do something like this:

FF7FrameBuffer[I].svPosOffset.sX = FF7FrameBuffer[I-1].svPosOffset.sX + sX;

FF7FrameBuffer[I].svPosOffset.sY = FF7FrameBuffer[I-1].svPosOffset.sY + sY;

FF7FrameBuffer[I].svPosOffset.sZ = FF7FrameBuffer[I-1].svPosOffset.sZ + sZ;

Now all that is left is to decode the rotations.

3.

SHORT GetEncryptedRotationBits( BYTE * pBuffer, DWORD &dwBitStart,

INT iKeyBits ) {

INT iBits = GetBitsFixed( pBuffer, dwBitStart, 1 );

__asm mov eax, iBits // If the first bit is 0, return 0

__asm test eax, eax

__asm jnz SecondTest

__asm mov ecx, dwNumBits

__asm mov dwType, ecx // dwType = ecx = dwNumBits = eax =

__asm cmp dwType, 7

__asm ja ReturnZero // Is dwType above 7? If so, return 0.

// Otherwise, use it in a switch case.

case 0 : {

__asm or eax, 0xFFFFFFFF // After this, EAX will

__asm mov ecx, iKeyBits

__asm mov sReturn, ax // Return that number.

__asm jmp End

case 6 : {

// Get a number of bits equal to the case switch (1,

iTemp = GetBitsFixed( pBuffer, dwBitStart,

__asm mov eax, iTemp

__asm cmp iTemp, 0

// If greater than or equal to 0…

__asm mov ecx, dwNumBits // dwNumBits = (iBits &

__asm mov eax, 1

__asm mov ecx, iTemp

__asm add ecx, eax // iTemp += (1 <<

__asm mov iTemp, ecx

__asm jmp AfterTests

IfLessThanZero :

__asm mov ecx, dwNumBits // dwNumBits = (iBits &

__asm mov edx, 1

__asm mov eax, iTemp // iTemp still has the

__asm sub eax, edx // iTemp - (1 <<

__asm mov iTemp, eax

// Now, whatever we set on iTemp, we need to shift it

AfterTests :

__asm mov eax, iTemp

// Uncompressed bits. Use standard decoding.

iTemp = GetBitsFixed( pBuffer, dwBitStart,

__asm mov ecx, iKeyBits

__asm shl eax, cl // iTemp <<= iKeyBits.

return sReturn;

}

To make life easy, let’s use one function to load an entire frame at a time.

This function will load an entire frame into a “FF7FrameBuffer” structure.

1.

DWORD LoadFrames( PFF7FrameBuffer pfbFrameBuffer,

INT iBones,

delete [] baData;

“GetValueFromStream” is the C/C++ version of my “GetDynamicFrameOffsetBits” and his “GetCompressedDeltaFromStream” is the C++ version of my “GetEncryptedRotationBits”.

short GetValueFromStream( BYTE *pStreamBytes,

DWORD *pdwStreamBitOffset )

*/