Initial commit of Command & Conquer Renegade source code.

Code/Tools/ChunkView/ChunkFileImage.cpp

@@ -0,0 +1,223 @@
+/*
+**	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/>.
+*/
+
+/***********************************************************************************************
+ ***              C O N F I D E N T I A L  ---  W E S T W O O D  S T U D I O S               ***
+ ***********************************************************************************************
+ *                                                                                             *
+ *                 Project Name : ChunkView                                                    *
+ *                                                                                             *
+ *                     $Archive:: /Commando/Code/Tools/ChunkView/ChunkFileImage.cpp           $*
+ *                                                                                             *
+ *                       Author:: Greg Hjelstrom                                               *
+ *                                                                                             *
+ *                     $Modtime:: 9/28/99 9:48a                                               $*
+ *                                                                                             *
+ *                    $Revision:: 2                                                           $*
+ *                                                                                             *
+ *---------------------------------------------------------------------------------------------*
+ * Functions:                                                                                  *
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+
+
+#include "stdafx.h"
+#include <assert.h>
+#include "ChunkFileImage.h"
+#include "rawfile.h"
+#include "chunkio.h"
+
+
+
+ChunkFileImageClass::ChunkFileImageClass(void) :
+	RootNode(NULL)
+{
+}
+
+ChunkFileImageClass::~ChunkFileImageClass(void)
+{
+	Reset();
+}
+
+
+void ChunkFileImageClass::Reset(void)
+{
+	// have to handle the fact that there isn't one root node,
+	ChunkImageClass * node_to_delete = RootNode;
+	while (node_to_delete) {
+		ChunkImageClass * sibling = node_to_delete->Sibling;
+		delete node_to_delete;
+		node_to_delete = sibling;
+	}
+}
+
+void ChunkFileImageClass::Load(const char * filename)
+{
+	RawFileClass file(filename);
+	file.Open();
+	ChunkLoadClass cload(&file);
+	
+	cload.Open_Chunk();
+	RootNode = new ChunkImageClass;
+	RootNode->Load(cload);
+	cload.Close_Chunk();
+
+	// while we have more top-level chunks, load them and link them
+	// to the root through its sibling pointer
+	while (cload.Open_Chunk()) {
+		ChunkImageClass * root_sibling = new ChunkImageClass;
+		root_sibling->Load(cload);
+		RootNode->Add_Sibling(root_sibling);
+		cload.Close_Chunk();
+	}
+
+	file.Close();
+}
+
+
+ChunkImageClass::ChunkImageClass(void) :
+	Child(NULL),
+	Sibling(NULL),
+	Data(NULL),
+	ID(0),
+	Length(0)
+{
+}
+
+ChunkImageClass::~ChunkImageClass(void)
+{
+	// Delete our children
+	ChunkImageClass * child = Child;
+	while (child) {
+		ChunkImageClass * child_sibling = child->Sibling;
+		delete child;
+		child = child_sibling;
+	}
+
+	// Delete our data
+	if (Data != NULL) {
+		delete Data;
+	}
+}
+
+
+void ChunkImageClass::Load(ChunkLoadClass & cload)
+{
+	ID = cload.Cur_Chunk_ID();
+	Length = cload.Cur_Chunk_Length();
+
+	if (cload.Contains_Chunks()) {
+
+		while (cload.Open_Chunk()) {
+			ChunkImageClass * new_child = new ChunkImageClass;
+			new_child->Load(cload);
+			Add_Child(new_child);
+			cload.Close_Chunk();
+		}
+
+	} else {
+		
+		if (Length > 0) {
+			Data = new uint8[Length];
+			cload.Read(Data,Length);
+		}
+	
+	}
+}
+
+
+void ChunkImageClass::Add_Child(ChunkImageClass * new_child)
+{
+	assert(new_child != NULL);
+	assert(new_child->Sibling == NULL);
+
+	// need to add to the tail...
+	if (Child == NULL) {
+		Child = new_child;
+	} else {
+		Child->Add_Sibling(new_child);
+	}
+}
+
+void ChunkImageClass::Add_Sibling(ChunkImageClass * new_sibling)
+{
+	// Need to add to the tail so we display chunks in 
+	// the same order they appear in the file, so we
+	// search for the tail.
+	ChunkImageClass * tail = this;
+	while (tail->Sibling != NULL) {
+		tail = tail->Sibling;
+	}
+	tail->Sibling = new_sibling;
+	assert(new_sibling->Sibling == NULL);
+}
+
+
+int ChunkImageClass::Get_Child_Count(void) const
+{
+	int count = 0;
+
+	ChunkImageClass * child = Child;
+	while (child != NULL) {
+		count++;	
+		child = child->Sibling;
+	}
+	return count;	
+}
+
+const ChunkImageClass * ChunkImageClass::Get_Child(int i) const
+{
+	int count = 0;
+
+	ChunkImageClass * child = Child;
+	while (child != NULL && count < i) {
+		count++;	
+		child = child->Sibling;
+	}
+	
+	assert(count == i);
+	return child;
+}
+
+int ChunkImageClass::Get_Sibling_Count(void) const
+{
+	// NOTE: counts 'this' as a sibling.
+	int count = 0;
+
+	const ChunkImageClass * sibling = this;
+	while (sibling != NULL) {
+		count++;	
+		sibling = sibling->Sibling;
+	}
+	return count;	
+}
+
+const ChunkImageClass * ChunkImageClass::Get_Sibling(int i) const
+{
+	// NOTE: sibling(0) is 'this' (just makes some other code simpler...)
+	int count = 0;
+
+	const ChunkImageClass * sibling = this;
+	while (sibling != NULL && count < i) {
+		count++;	
+		sibling = sibling->Sibling;
+	}
+
+	assert(count == i);
+	return sibling;
+}
+