435 lines
14 KiB
C++
435 lines
14 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/>.
|
|
*/
|
|
|
|
/* $Header: /Commando/Code/ww3d2/assetmgr.h 19 12/17/01 7:55p Jani_p $ */
|
|
/***********************************************************************************************
|
|
*** Confidential - Westwood Studios ***
|
|
***********************************************************************************************
|
|
* *
|
|
* Project Name : Commando *
|
|
* *
|
|
* $Archive:: /Commando/Code/ww3d2/assetmgr.h $*
|
|
* *
|
|
* Author:: Greg_h *
|
|
* *
|
|
* $Modtime:: 12/15/01 4:14p $*
|
|
* *
|
|
* $Revision:: 19 $*
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma once
|
|
#endif
|
|
|
|
#ifndef ASSETMGR_H
|
|
#define ASSETMGR_H
|
|
|
|
#include "always.h"
|
|
#include "vector.h"
|
|
#include "htreemgr.h"
|
|
#include "hanimmgr.h"
|
|
#include "slist.h"
|
|
#include "texture.h"
|
|
#include "hashtemplate.h"
|
|
#include "simplevec.h"
|
|
|
|
class HAnimClass;
|
|
class HTreeClass;
|
|
class ChunkLoadClass;
|
|
|
|
class FileClass;
|
|
class FileFactoryClass;
|
|
class PrototypeLoaderClass;
|
|
class Font3DDataClass;
|
|
class Font3DInstanceClass;
|
|
class FontCharsClass;
|
|
class RenderObjClass;
|
|
class HModelClass;
|
|
class PrototypeClass;
|
|
class HTreeManagerClass;
|
|
class HAnimManagerClass;
|
|
class HAnimIterator;
|
|
class TextureIterator;
|
|
class TextureFileCache;
|
|
class StreamingTextureClass;
|
|
struct StreamingTextureConfig;
|
|
class TextureClass;
|
|
class MetalMapManagerClass;
|
|
|
|
/*
|
|
** AssetIterator
|
|
** This object can iterate through the 3D assets which
|
|
** currently exist in the Asset Manager. It tells you the names
|
|
** of the assets which the manager can create for you.
|
|
*/
|
|
class AssetIterator
|
|
{
|
|
|
|
public:
|
|
|
|
virtual ~AssetIterator(void) { };
|
|
virtual void First(void) { Index = 0; }
|
|
virtual void Next(void) { Index ++; }
|
|
virtual bool Is_Done(void) = 0;
|
|
virtual const char * Current_Item_Name(void) = 0;
|
|
|
|
protected:
|
|
|
|
AssetIterator(void) { Index = 0; }
|
|
int Index;
|
|
};
|
|
|
|
/*
|
|
** RenderObjIterator
|
|
** The render obj iterator simply adds a method for determining
|
|
** the class id of a render object prototype in the system.
|
|
*/
|
|
class RenderObjIterator : public AssetIterator
|
|
{
|
|
public:
|
|
virtual int Current_Item_Class_ID(void) = 0;
|
|
};
|
|
|
|
|
|
/*
|
|
|
|
WW3DAssetManager
|
|
|
|
This object is the manager of all of the 3D data. Load your meshes, animations,
|
|
etc etc using the Load_3D_Assets function.
|
|
|
|
WARNING: hierarchy trees should be loaded before the meshes and animations
|
|
which attach to them.
|
|
|
|
-------------------------------------------------------------------------------------
|
|
Dec 11, 1997, Asset Manager Brainstorming:
|
|
|
|
- WW3DAssetManager will be diferentiated from other game data asset managers
|
|
(sounds, strings, etc) because they behave differently and serve different
|
|
purposes
|
|
|
|
- WW3D creates "clones" from the blueprints it has of render objects whereas
|
|
Our commando data asset manager will provide the data (file images) for the
|
|
blueprints. Maybe the CommandoDataManager could deal in MemoryFileClasses.
|
|
Or void * and then the ww3d manager could convert to MemoryFiles...
|
|
|
|
- Future caching: In the case that we want to implement a caching system,
|
|
assets must be "released" when not in use.
|
|
|
|
- CommandoW3d asset manager asks the game data asset manager for assets by name.
|
|
Game data manager must have a "directory" structure which maps each named
|
|
asset to data on disk. It then returns an image of the file once it has
|
|
been loaded into ram.
|
|
|
|
- Assets must be individual files, named with the asset name used in code/scripting
|
|
We will write a tool which chops w3d files up so that all of the individual assets
|
|
are brought out into their own file and named with the actual w3d name.
|
|
|
|
- Data Asset Manager will load the file into ram, give it to us and forget about it
|
|
W3d will release_ref it or delete it and the file image will go away.
|
|
|
|
- Each time the 3d asset manager is requested for an asset, it will look through
|
|
the render objects it has, if the asset isn't found, it will ask for the asset
|
|
from the generic data asset manager. When creating the actual render object,
|
|
the 3d asset manager may find that it needs another asset (such as a hierarchy tree).
|
|
It will then recurse, and ask for that asset.
|
|
|
|
- Copy Mode will go away. It will be internally set based on whether the mesh
|
|
contains vertex animation. All other render objects will simply "Clone".
|
|
|
|
- Commando will derive a Cmdo3DAssetManager which knows about the special chunks
|
|
required for the terrains.
|
|
|
|
-------------------------------------------------------------------------------------
|
|
July 28, 1998
|
|
|
|
- Exposed the prototype system and added prototype loaders (PrototypeClass and
|
|
PrototypeLoaderClass in proto.h). This now allows the user to install his own
|
|
loaders for new render object types.
|
|
|
|
- Simplified the interface by removing the special purpose creation functions,
|
|
leaving only the Create_Render_Obj function.
|
|
|
|
- In certain cases some users need to know what kind of render object was created
|
|
so we added a Class_ID mechanism to RenderObjClass.
|
|
|
|
- Class_ID for render objects is not enough. Need the asset iterator to be able
|
|
to tell you the Class_ID of each asset in the asset manager. This also means that
|
|
the prototype class needs to be able to tell you the class ID. Actually this
|
|
code only seems to be used by tools such as SView but is needed anyway...
|
|
|
|
*/
|
|
|
|
|
|
class WW3DAssetManager
|
|
{
|
|
|
|
public:
|
|
|
|
/*
|
|
** Constructor and destructor
|
|
*/
|
|
WW3DAssetManager(void);
|
|
virtual ~WW3DAssetManager(void);
|
|
|
|
/*
|
|
** Access to the single instance of a WW3DAssetManager. The user
|
|
** can subclass their own asset manager class but should only
|
|
** create one instance. (a violation of this will be caught with
|
|
** a run-time assertion)
|
|
**
|
|
** The "official" way to get at the global asset manager is to
|
|
** use a line of code like this:
|
|
** WW3DAssetManager::Get_Instance();
|
|
*/
|
|
static WW3DAssetManager * Get_Instance(void) { return TheInstance; }
|
|
static void Delete_This(void) { if (TheInstance) delete TheInstance; TheInstance=NULL; }
|
|
|
|
/*
|
|
** Load data from any type of w3d file
|
|
*/
|
|
virtual bool Load_3D_Assets( const char * filename);
|
|
virtual bool Load_3D_Assets(FileClass & assetfile);
|
|
|
|
/*
|
|
** Get rid of all of the currently loaded assets
|
|
*/
|
|
virtual void Free_Assets(void);
|
|
|
|
/*
|
|
** Release any assets that only the asset manager has a reference to.
|
|
*/
|
|
virtual void Release_Unused_Assets(void);
|
|
|
|
/*
|
|
** create me an instance of one of the prototype render objects
|
|
*/
|
|
virtual RenderObjClass * Create_Render_Obj(const char * name);
|
|
|
|
/*
|
|
** query if there is a render object with the specified name
|
|
*/
|
|
virtual bool Render_Obj_Exists(const char * name);
|
|
|
|
/*
|
|
** Iterate through all render objects or through the
|
|
** sub-categories of render objects. NOTE! the user is responsible
|
|
** for releasing the iterator when finished with it!
|
|
*/
|
|
virtual RenderObjIterator * Create_Render_Obj_Iterator(void);
|
|
virtual void Release_Render_Obj_Iterator(RenderObjIterator *);
|
|
|
|
/*
|
|
** Access to HAnims, Used by Animatable3DObj's
|
|
** TODO: make HAnims accessible from the HMODELS (or Animatable3DObj...)
|
|
*/
|
|
virtual AssetIterator * Create_HAnim_Iterator(void);
|
|
virtual HAnimClass * Get_HAnim(const char * name);
|
|
virtual bool Add_Anim (HAnimClass *new_anim) { return HAnimManager.Add_Anim (new_anim); }
|
|
|
|
/*
|
|
** Access to textures
|
|
*/
|
|
// virtual AssetIterator * Create_Texture_Iterator(void);
|
|
|
|
HashTemplateClass<StringClass,TextureClass*>& Texture_Hash() { return TextureHash; }
|
|
|
|
static void Log_Texture_Statistics();
|
|
|
|
virtual TextureClass * Get_Texture(
|
|
const char * filename,
|
|
TextureClass::MipCountType mip_level_count=TextureClass::MIP_LEVELS_ALL,
|
|
WW3DFormat texture_format=WW3D_FORMAT_UNKNOWN,
|
|
bool allow_compression=true);
|
|
|
|
virtual void Release_All_Textures(void);
|
|
virtual void Release_Unused_Textures(void);
|
|
virtual void Release_Texture(TextureClass *);
|
|
virtual void Load_Procedural_Textures();
|
|
virtual MetalMapManagerClass* Peek_Metal_Map_Manager() { return MetalManager; }
|
|
|
|
/*
|
|
** Access to Font3DInstances. (These are not saved, we just use the
|
|
** asset manager as a convienient way to create them.)
|
|
*/
|
|
virtual Font3DInstanceClass * Get_Font3DInstance( const char * name);
|
|
|
|
/*
|
|
** Access to FontChars. Used by Render2DSentenceClass
|
|
*/
|
|
virtual FontCharsClass * Get_FontChars( const char * name, int point_size, bool is_bold = false );
|
|
|
|
/*
|
|
** Access to HTrees, Used by Animatable3DObj's
|
|
*/
|
|
virtual AssetIterator * Create_HTree_Iterator(void);
|
|
virtual HTreeClass * Get_HTree(const char * name);
|
|
|
|
/*
|
|
** Prototype Loaders, The user can register new loaders here. Note that
|
|
** a the pointer to your loader will be stored inside the asset manager.
|
|
** For this reason, your loader should be a static or global object.
|
|
*/
|
|
virtual void Register_Prototype_Loader(PrototypeLoaderClass * loader);
|
|
|
|
/*
|
|
** The Add_Prototype is public so that we can add prototypes for procedurally
|
|
** generated objects to the asset manager.
|
|
*/
|
|
void Add_Prototype(PrototypeClass * newproto);
|
|
void Remove_Prototype(PrototypeClass *proto);
|
|
void Remove_Prototype(const char *name);
|
|
PrototypeClass * Find_Prototype(const char * name);
|
|
|
|
/*
|
|
** Load on Demand
|
|
*/
|
|
bool Get_WW3D_Load_On_Demand( void ) { return WW3D_Load_On_Demand; }
|
|
void Set_WW3D_Load_On_Demand( bool on_off ) { WW3D_Load_On_Demand = on_off; }
|
|
|
|
/*
|
|
** Add fog to objects on load
|
|
*/
|
|
bool Get_Activate_Fog_On_Load( void ) { return Activate_Fog_On_Load; }
|
|
void Set_Activate_Fog_On_Load( bool on_off ) { Activate_Fog_On_Load = on_off; }
|
|
|
|
// Log texture statistics
|
|
void Log_All_Textures();
|
|
|
|
protected:
|
|
|
|
/*
|
|
** Access to Font3DData. (These are privately managed/accessed)
|
|
*/
|
|
virtual AssetIterator * Create_Font3DData_Iterator(void);
|
|
virtual void Add_Font3DData(Font3DDataClass * font);
|
|
virtual void Remove_Font3DData(Font3DDataClass * font);
|
|
virtual Font3DDataClass * Get_Font3DData(const char * name);
|
|
virtual void Release_All_Font3DDatas( void);
|
|
virtual void Release_Unused_Font3DDatas( void);
|
|
|
|
virtual void Release_All_FontChars( void );
|
|
|
|
void Free(void);
|
|
|
|
PrototypeLoaderClass * Find_Prototype_Loader(int chunk_id);
|
|
bool Load_Prototype(ChunkLoadClass & cload);
|
|
|
|
/*
|
|
** Compile time control over the dynamic arrays:
|
|
*/
|
|
enum
|
|
{
|
|
PROTOLOADERS_VECTOR_SIZE = 32,
|
|
PROTOLOADERS_GROWTH_RATE = 16,
|
|
|
|
PROTOTYPES_VECTOR_SIZE = 256,
|
|
PROTOTYPES_GROWTH_RATE = 32,
|
|
};
|
|
|
|
/*
|
|
** Prototype Loaders
|
|
** These objects are responsible for importing certain W3D chunk types and turning
|
|
** them into prototypes.
|
|
*/
|
|
DynamicVectorClass < PrototypeLoaderClass * > PrototypeLoaders;
|
|
|
|
/*
|
|
** Prototypes
|
|
** These objects are abstract factories for named render objects. Prototypes is
|
|
** a dynamic array of pointers to the currently loaded prototypes.
|
|
*/
|
|
DynamicVectorClass < PrototypeClass * > Prototypes;
|
|
|
|
/*
|
|
** Prototype Hash Table
|
|
** This structure is simply used to speed up the name lookup for prototypes
|
|
*/
|
|
enum
|
|
{
|
|
PROTOTYPE_HASH_TABLE_SIZE = 4096,
|
|
PROTOTYPE_HASH_BITS = 12,
|
|
PROTOTYPE_HASH_MASK = 0x00000FFF
|
|
};
|
|
|
|
PrototypeClass * * PrototypeHashTable;
|
|
|
|
/*
|
|
** managers of HTrees, HAnims, Textures....
|
|
*/
|
|
HTreeManagerClass HTreeManager;
|
|
HAnimManagerClass HAnimManager;
|
|
|
|
/*
|
|
** When enabled, this handles all the caching for the texture class.
|
|
** If NULL then textures are not being cached.
|
|
*/
|
|
TextureFileCache * TextureCache;
|
|
|
|
/*
|
|
** list of Font3DDatas
|
|
*/
|
|
SList<Font3DDataClass> Font3DDatas;
|
|
|
|
/*
|
|
** list of FontChars
|
|
*/
|
|
SimpleDynVecClass<FontCharsClass*> FontCharsList;
|
|
|
|
/*
|
|
** Should .W3D be loaded if not in memory
|
|
*/
|
|
bool WW3D_Load_On_Demand;
|
|
|
|
/*
|
|
** Should we activate fog on objects while loading them
|
|
*/
|
|
bool Activate_Fog_On_Load;
|
|
|
|
// Metal Map Manager
|
|
MetalMapManagerClass * MetalManager;
|
|
|
|
/*
|
|
** Texture hash table for quick texture lookups
|
|
*/
|
|
HashTemplateClass<StringClass, TextureClass *> TextureHash;
|
|
|
|
/*
|
|
** The 3d asset manager is a singleton, there should be only
|
|
** one and it is accessible through Get_Instance()
|
|
*/
|
|
static WW3DAssetManager * TheInstance;
|
|
|
|
/*
|
|
** the iterator classes are friends
|
|
*/
|
|
friend class RObjIterator;
|
|
friend class HAnimIterator;
|
|
friend class HTreeIterator;
|
|
friend class Font3DDataIterator;
|
|
friend class TextureIterator;
|
|
|
|
// Font3DInstance need access to the Font3DData
|
|
friend class Font3DInstanceClass;
|
|
};
|
|
|
|
#endif
|