285 lines
6.8 KiB
C++
285 lines
6.8 KiB
C++
/*
|
|
** Command & Conquer Renegade(tm)
|
|
** Copyright 2025 Electronic Arts Inc.
|
|
**
|
|
** This program 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 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** This program 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 this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
// SkeletonHack.cpp : Defines the entry point for the console application.
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
|
|
|
|
|
|
class HTreeHackClass
|
|
{
|
|
public:
|
|
HTreeHackClass(void);
|
|
~HTreeHackClass(void);
|
|
|
|
void Load_W3D(ChunkLoadClass & cload);
|
|
void Save_W3D(ChunkSaveClass & csave);
|
|
|
|
int Num_Pivots(void) { return Header.NumPivots; }
|
|
|
|
// Skeleton Modification: moves a bone to the end of the array. Use to make
|
|
// skeletons compatible with existing anims by moving all new bones to the end of the array.
|
|
void Move_Bone_To_End(int bone_index);
|
|
|
|
protected:
|
|
|
|
bool read_pivots(ChunkLoadClass & cload);
|
|
bool read_pivot_fixups(ChunkLoadClass & cload);
|
|
bool write_pivots(ChunkSaveClass & csave);
|
|
bool write_pivot_fixups(ChunkSaveClass & csave);
|
|
|
|
void move_single_bone_to_end(unsigned int bone_index);
|
|
int find_first_bad_bone(void);
|
|
|
|
W3dHierarchyStruct Header;
|
|
W3dPivotStruct * Pivots;
|
|
W3dPivotFixupStruct * PivotFixups;
|
|
};
|
|
|
|
|
|
|
|
void Print_Usage(void)
|
|
{
|
|
printf("USAGE: SkeletonHack <W3D Filename> <BoneIndex>\r\n");
|
|
printf("WARNING: This program only works on w3d files that contain a skeleton *ONLY*\r\n");
|
|
printf("WARNING: This program modifies the input file.\r\n");
|
|
}
|
|
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
// See if we got the proper number of arguments
|
|
if (argc != 3) {
|
|
Print_Usage();
|
|
return 0;
|
|
}
|
|
|
|
// Try to open the file,
|
|
char * filename = argv[1];
|
|
int bone_index = atoi(argv[2]);
|
|
|
|
RawFileClass in_file(filename);
|
|
if (!in_file.Is_Available()) {
|
|
printf("Unable to open file: %s\r\n",filename);
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Open the file, read the first chunk, and verify that it is an HTree
|
|
in_file.Open();
|
|
ChunkLoadClass cload(&in_file);
|
|
cload.Open_Chunk();
|
|
if (cload.Cur_Chunk_ID() != W3D_CHUNK_HIERARCHY) {
|
|
printf("Other chunks encountered in file: %s\r\n",filename);
|
|
cload.Close_Chunk();
|
|
in_file.Close();
|
|
return 0;
|
|
}
|
|
|
|
|
|
// Read the hierarchy tree into memory and close the file.
|
|
HTreeHackClass htree;
|
|
htree.Load_W3D(cload);
|
|
cload.Close_Chunk();
|
|
in_file.Close();
|
|
|
|
// Validate the bone_index parameter
|
|
if ((bone_index < 0) || (bone_index >= htree.Num_Pivots())) {
|
|
printf("Invalid bone index requested: %d\r\n",bone_index);
|
|
return 0;
|
|
}
|
|
|
|
// Edit the HTree, moving the specified bone to the end of the tree
|
|
htree.Move_Bone_To_End(bone_index);
|
|
|
|
// Write the hierarchy tree out again.
|
|
RawFileClass out_file(filename);
|
|
if (out_file.Open(FileClass::WRITE) == false) {
|
|
printf("Failed to open %s for writing. Is the file read-only?\r\n",filename);
|
|
return 0;
|
|
}
|
|
|
|
ChunkSaveClass csave(&out_file);
|
|
csave.Begin_Chunk(W3D_CHUNK_HIERARCHY);
|
|
htree.Save_W3D(csave);
|
|
csave.End_Chunk();
|
|
out_file.Close();
|
|
|
|
printf("Moved bone %d and all of its children to the end of the bone array.\r\n",bone_index);
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
HTreeHackClass::HTreeHackClass(void) :
|
|
Pivots(NULL),
|
|
PivotFixups(NULL)
|
|
{
|
|
}
|
|
|
|
HTreeHackClass::~HTreeHackClass(void)
|
|
{
|
|
delete[] Pivots;
|
|
delete[] PivotFixups;
|
|
}
|
|
|
|
void HTreeHackClass::Load_W3D(ChunkLoadClass & cload)
|
|
{
|
|
/*
|
|
** Read the first chunk, it should be the hierarchy header
|
|
*/
|
|
cload.Open_Chunk();
|
|
assert(cload.Cur_Chunk_ID() == W3D_CHUNK_HIERARCHY_HEADER);
|
|
cload.Read(&Header,sizeof(W3dHierarchyStruct));
|
|
cload.Close_Chunk();
|
|
|
|
/*
|
|
** Allocate the array of pivots
|
|
*/
|
|
if (Header.NumPivots > 0) {
|
|
Pivots = new W3dPivotStruct[Header.NumPivots];
|
|
PivotFixups = new W3dPivotFixupStruct[Header.NumPivots];
|
|
}
|
|
|
|
/*
|
|
** Now, read in all of the other chunks for this hierarchy.
|
|
*/
|
|
while (cload.Open_Chunk()) {
|
|
|
|
switch (cload.Cur_Chunk_ID()) {
|
|
|
|
case W3D_CHUNK_PIVOTS:
|
|
read_pivots(cload);
|
|
break;
|
|
case W3D_CHUNK_PIVOT_FIXUPS:
|
|
read_pivot_fixups(cload);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
cload.Close_Chunk();
|
|
}
|
|
}
|
|
|
|
bool HTreeHackClass::read_pivots(ChunkLoadClass & cload)
|
|
{
|
|
for (unsigned int pidx=0; pidx < Header.NumPivots; pidx++) {
|
|
if (cload.Read(&Pivots[pidx],sizeof(W3dPivotStruct)) != sizeof(W3dPivotStruct)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HTreeHackClass::read_pivot_fixups(ChunkLoadClass & cload)
|
|
{
|
|
for (unsigned int pidx=0; pidx < Header.NumPivots; pidx++) {
|
|
if (cload.Read(&PivotFixups[pidx],sizeof(W3dPivotFixupStruct)) != sizeof(W3dPivotFixupStruct)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
void HTreeHackClass::Save_W3D(ChunkSaveClass & csave)
|
|
{
|
|
csave.Begin_Chunk(W3D_CHUNK_HIERARCHY_HEADER);
|
|
csave.Write(&Header,sizeof(W3dHierarchyStruct));
|
|
csave.End_Chunk();
|
|
|
|
csave.Begin_Chunk(W3D_CHUNK_PIVOTS);
|
|
write_pivots(csave);
|
|
csave.End_Chunk();
|
|
|
|
csave.Begin_Chunk(W3D_CHUNK_PIVOT_FIXUPS);
|
|
write_pivot_fixups(csave);
|
|
csave.End_Chunk();
|
|
}
|
|
|
|
bool HTreeHackClass::write_pivots(ChunkSaveClass & csave)
|
|
{
|
|
for (unsigned int pidx=0; pidx < Header.NumPivots; pidx++) {
|
|
if (csave.Write(&Pivots[pidx],sizeof(W3dPivotStruct)) != sizeof(W3dPivotStruct)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool HTreeHackClass::write_pivot_fixups(ChunkSaveClass & csave)
|
|
{
|
|
for (unsigned int pidx=0; pidx < Header.NumPivots; pidx++) {
|
|
if (csave.Write(&PivotFixups[pidx],sizeof(W3dPivotFixupStruct)) != sizeof(W3dPivotFixupStruct)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void HTreeHackClass::Move_Bone_To_End(int bone_index)
|
|
{
|
|
move_single_bone_to_end(bone_index);
|
|
|
|
int bad_bone = find_first_bad_bone();
|
|
while (bad_bone != -1) {
|
|
move_single_bone_to_end(bad_bone);
|
|
bad_bone = find_first_bad_bone();
|
|
}
|
|
}
|
|
|
|
void HTreeHackClass::move_single_bone_to_end(unsigned int bone_index)
|
|
{
|
|
if (bone_index >= Header.NumPivots) {
|
|
return;
|
|
}
|
|
|
|
// move entries at 'bone_index' to the ends of their arrays
|
|
W3dPivotStruct tmp_pivot = Pivots[bone_index];
|
|
W3dPivotFixupStruct tmp_fixup = PivotFixups[bone_index];
|
|
|
|
for (unsigned int i=bone_index; i<Header.NumPivots-1; i++) {
|
|
Pivots[i] = Pivots[i+1];
|
|
PivotFixups[i] = PivotFixups[i+1];
|
|
}
|
|
Pivots[Header.NumPivots-1] = tmp_pivot;
|
|
PivotFixups[Header.NumPivots-1] = tmp_fixup;
|
|
|
|
// adjust all parent indices to reflect the change
|
|
for (i=bone_index; i<Header.NumPivots-1; i++) {
|
|
if (Pivots[i].ParentIdx > bone_index) {
|
|
Pivots[i].ParentIdx--;
|
|
} else if (Pivots[i].ParentIdx == bone_index) {
|
|
Pivots[i].ParentIdx = Header.NumPivots-1;
|
|
}
|
|
}
|
|
}
|
|
|
|
int HTreeHackClass::find_first_bad_bone(void)
|
|
{
|
|
for (unsigned int i=1; i<Header.NumPivots; i++) {
|
|
if (Pivots[i].ParentIdx > i) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|