mirror of
https://github.com/electronicarts/CnC_Renegade.git
synced 2026-06-17 18:57:44 +02:00
Initial commit of Command & Conquer Renegade source code.
This commit is contained in:
LFeenanEA
223
Code/wwsaveload/saveload.h
Normal file
223
Code/wwsaveload/saveload.h
Normal file
@@ -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 : WWSaveLoad *
|
||||
* *
|
||||
* $Archive:: /Commando/Code/wwsaveload/saveload.h $*
|
||||
* *
|
||||
* Author:: Greg Hjelstrom *
|
||||
* *
|
||||
* $Modtime:: 9/19/01 4:13p $*
|
||||
* *
|
||||
* $Revision:: 12 $*
|
||||
* *
|
||||
*---------------------------------------------------------------------------------------------*
|
||||
* Functions: *
|
||||
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
||||
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef SAVELOAD_H
|
||||
#define SAVELOAD_H
|
||||
|
||||
#include "always.h"
|
||||
#include "pointerremap.h"
|
||||
#include "bittype.h"
|
||||
#include "slist.h"
|
||||
|
||||
class RefCountClass;
|
||||
class SaveLoadSubSystemClass;
|
||||
class PersistFactoryClass;
|
||||
class PersistClass;
|
||||
class PostLoadableClass;
|
||||
class ChunkSaveClass;
|
||||
class ChunkLoadClass;
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// WWSaveLoad
|
||||
//
|
||||
// The WWSaveLoad library is a framework for saving and loading. The main
|
||||
// goals that we attempted to achieve in designing this system are:
|
||||
//
|
||||
// - Save things in a form that could adapt as our code evolves. We want
|
||||
// to be able to load files which were created with a previous version of the
|
||||
// application into the current version.
|
||||
// - Use the same framework throughout all of our libraries with as small an
|
||||
// impact on them as possible
|
||||
// - Automate as much of the implementation of save-load as possible.
|
||||
// - Make this a generic hunk of code which contains no commando-specific parts
|
||||
// so that it can be used by other applications.
|
||||
// - Make this system capable of generating the file formats for our level editor,
|
||||
// the game's level definition file, and player save files.
|
||||
//
|
||||
// To achive this, we developed several core concepts:
|
||||
//
|
||||
// - Persistant Objects: Most of the state of the game is contained in the objects
|
||||
// active at any given time. PersistClass is an abstract interface which will allow
|
||||
// objects to be used with the save-load system. It was also important to keep the
|
||||
// overhead caused by inheriting this class to an absolute minimum.
|
||||
//
|
||||
// - PersistFactories: We need an automatic "virtual-constructor" or "abstract-factory"
|
||||
// system for all objects that get saved. This is the PersistFactoryClass and the
|
||||
// automated SimplePersistFactory template. All objects that "persist" are derived from
|
||||
// PersistClass and all concrete derived PersistClasses have an associated static
|
||||
// instance of a PersistFactory which handles their saving and construction upon encountering
|
||||
// them while loading. In certain cases these PersistFactories can also serve as
|
||||
// a "shortcut" where we cheat by not actually telling the object to save but simply save
|
||||
// a small piece of data that allows us to recreate an identical object when we load. This
|
||||
// is used in WW3D sometimes; we just save a render object name and then ask the WW3D asset
|
||||
// manager to recreate that model for us.
|
||||
//
|
||||
// - SaveLoadSubSystems: The overall file structure will be governed by many sub-systems
|
||||
// (derived from SaveLoadSubSystemClass). The application in-effect creates file formats
|
||||
// by simply having the sub-systems that it wants write into a file. In this way you can
|
||||
// achieve things like saving only static data into one file and dynamic into another, etc.
|
||||
// All persistant objects that get saved will be told to save by some sub-system. For
|
||||
// example: in Commando, I have a PhysicsDynamicDataSubSystem which saves all of the
|
||||
// dynamic physics objects. In saving those objects I use the built-in PersistFactories
|
||||
// and am therefore completely safe from new object types being added to the system, it will just
|
||||
// automatically work
|
||||
//
|
||||
// - Pointer re-mapping: A pointer remaping system is built into the save-load system. There
|
||||
// are several things that happen in this system. Each object, as it is saved and loaded,
|
||||
// registers with the system its old address and its new address. (the old address is saved
|
||||
// and the new address is available once the object is created). This is automated by the
|
||||
// SimplePersistFactory for all but classes that use multiple inheritance. During the load
|
||||
// process a table is built which contains all of these pointer pairs (old address, new address).
|
||||
// Whenever an object loads a pointer, it gives a "pointer to that pointer" to the save load system.
|
||||
// Then, after all of the objects have been loaded, the system goes through that list of pointers
|
||||
// and finds them in the pointer pair table. NOTE: use the macros for re-mapping your
|
||||
// pointers to enable automatic debugging information when you build with WWDEBUG defined.
|
||||
//
|
||||
// - Chunks: The file format will be chunk based since that gives us the flexibility to
|
||||
// add new data and remove obsolete data without necessarily losing the ability
|
||||
// to read old files. We will use a "high-granularity" of chunks. In many cases, each
|
||||
// member variable will be in its own chunk for maximum flexibility. To help soften
|
||||
// the memory usage for this approach, we developed the concept of "micro-chunks".
|
||||
// Micro-chunks are just like chunks in that they have an id and a size but
|
||||
// each of these fields are only a single byte and they are never hierarchical.
|
||||
//
|
||||
// - ChunkID's: The chunk ID's used by Subsystems and PersistFactories must be unique
|
||||
// but all others can be considered local to the object that is saving itself. Unique
|
||||
// ids for the subsystems and factories are achieved by saveloadids.h defining ranges
|
||||
// of ids for various libraries and then those libraries maintaining a single header
|
||||
// file internally which gives unique id's within that range to all of their sub-systems
|
||||
// and persist factories. Never re-use an id or you will break compatibility with older
|
||||
// versions of your files...
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
// SaveLoadSystemClass
|
||||
//
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
class SaveLoadSystemClass
|
||||
{
|
||||
public:
|
||||
|
||||
/*
|
||||
** Save-Load interface. To create a file, ask each sub-system to save itself.
|
||||
** To load a file just open it and pass it to the load method.
|
||||
*/
|
||||
static bool Save (ChunkSaveClass &csave, SaveLoadSubSystemClass & subsystem);
|
||||
static bool Load (ChunkLoadClass &cload,bool auto_post_load = true);
|
||||
static bool Post_Load_Processing (void(*network_callback)(void));
|
||||
/*
|
||||
** Look up the persist factory for a given chunk id
|
||||
*/
|
||||
static PersistFactoryClass * Find_Persist_Factory(uint32 chunk_id);
|
||||
|
||||
/*
|
||||
** Post-Load interface. An object being loaded can ask for a callback after
|
||||
** all objects have been loaded and pointers re-mapped.
|
||||
*/
|
||||
static void Register_Post_Load_Callback(PostLoadableClass * obj);
|
||||
|
||||
/*
|
||||
** Pointer Remapping interface. NOTE: use the macros defined below to
|
||||
** get debug info with your pointers when doing a debug build.
|
||||
*/
|
||||
static void Register_Pointer (void *old_pointer, void *new_pointer);
|
||||
|
||||
#ifdef WWDEBUG
|
||||
static void Request_Pointer_Remap (void **pointer_to_convert,const char * file = NULL,int line = 0);
|
||||
static void Request_Ref_Counted_Pointer_Remap (RefCountClass **pointer_to_convert,const char * file = NULL,int line = 0);
|
||||
#else
|
||||
static void Request_Pointer_Remap (void **pointer_to_convert);
|
||||
static void Request_Ref_Counted_Pointer_Remap (RefCountClass **pointer_to_convert);
|
||||
#endif
|
||||
|
||||
protected:
|
||||
|
||||
/*
|
||||
** Internal SaveLoadSystem functions
|
||||
*/
|
||||
static void Register_Sub_System (SaveLoadSubSystemClass * subsys);
|
||||
static void Unregister_Sub_System (SaveLoadSubSystemClass * subsys);
|
||||
static SaveLoadSubSystemClass * Find_Sub_System (uint32 chunk_id);
|
||||
|
||||
static void Register_Persist_Factory(PersistFactoryClass * factory);
|
||||
static void Unregister_Persist_Factory(PersistFactoryClass * factory);
|
||||
|
||||
static void Link_Sub_System(SaveLoadSubSystemClass * subsys);
|
||||
static void Unlink_Sub_System(SaveLoadSubSystemClass * subsys);
|
||||
static void Link_Factory(PersistFactoryClass * factory);
|
||||
static void Unlink_Factory(PersistFactoryClass * factory);
|
||||
|
||||
static bool Is_Post_Load_Callback_Registered(PostLoadableClass * obj);
|
||||
|
||||
static SaveLoadSubSystemClass * SubSystemListHead;
|
||||
static PersistFactoryClass * FactoryListHead;
|
||||
static PointerRemapClass PointerRemapper;
|
||||
static SList<PostLoadableClass> PostLoadList;
|
||||
|
||||
/*
|
||||
** these are friends so that they can register themselves at construction time.
|
||||
*/
|
||||
friend class SaveLoadSubSystemClass;
|
||||
friend class PersistFactoryClass;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
** Use the following macros to automatically enable pointer-remap DEBUG code. Remember that
|
||||
** in all cases you submit a pointer to the pointer you want re-mapped.
|
||||
*/
|
||||
#ifdef WWDEBUG
|
||||
#define REQUEST_POINTER_REMAP(pp) SaveLoadSystemClass::Request_Pointer_Remap(pp,__FILE__,__LINE__)
|
||||
#define REQUEST_REF_COUNTED_POINTER_REMAP(pp) SaveLoadSystemClass::Request_Ref_Counted_Pointer_Remap(pp,__FILE__,__LINE__)
|
||||
#else
|
||||
#define REQUEST_POINTER_REMAP(pp) SaveLoadSystemClass::Request_Pointer_Remap(pp)
|
||||
#define REQUEST_REF_COUNTED_POINTER_REMAP(pp) SaveLoadSystemClass::Request_Ref_Counted_Pointer_Remap(pp)
|
||||
#endif
|
||||
|
||||
|
||||
#endif //SAVELOAD_H
|
||||
|
||||
Reference in New Issue
Block a user