/* ** 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 . */ /*********************************************************************************************** *** 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 #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; }