Initial commit of Command & Conquer Renegade source code.

Code/Tools/SkeletonHack/SkeletonHack.cpp

@@ -0,0 +1,285 @@
+/*
+**	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;
+}