You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
176 lines
8.1 KiB
176 lines
8.1 KiB
//===== Copyright © 1996-2005, Valve Corporation, All rights reserved. ======//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $NoKeywords: $
|
|
//
|
|
//===========================================================================//
|
|
|
|
#ifndef IRESOURCESYSTEM_H
|
|
#define IRESOURCESYSTEM_H
|
|
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "appframework/iappsystem.h"
|
|
#include "resourcefile/resourceintrospection.h"
|
|
#include "resourcefile/resourcedictionary.h"
|
|
#include "resourcefile/resourcetype.h"
|
|
#include "tier2/tier2.h"
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class IResourceTypeManager;
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A method used to allow clients to construct + destruct resources based
|
|
// on raw data. Needs to be installed into resource type managers based on
|
|
// resource type
|
|
//-----------------------------------------------------------------------------
|
|
abstract_class IResourceTypeConstructor
|
|
{
|
|
public:
|
|
virtual bool Init( IResourceTypeManager *pTypeManager ) = 0;
|
|
virtual void Shutdown() = 0;
|
|
|
|
// Returns a structure type associated with the permanent data
|
|
virtual void *AllocatePermanentData( const void *pDataFromDisk, size_t nDataSize ) = 0;
|
|
virtual void DeallocatePermanentData( void *pData ) = 0;
|
|
|
|
// Returns the default memory limit
|
|
virtual size_t GetDefaultMemoryLimit() = 0;
|
|
|
|
// Allows the system to compute the actual size of the constructed class
|
|
// based on the permanent data in in the resource system. If the system
|
|
// doesn't know/care, return 0 here.
|
|
virtual size_t ComputeActualSize( void *pPermanentData ) = 0;
|
|
|
|
// NOTE: Resource references in pResourceData have been fixed up to
|
|
// be resource handles at this point
|
|
virtual void *Allocate( const void *pPermanentData, const void *pResourceData, size_t nDataSize, ResourceHandle_t hResourceHandle ) = 0;
|
|
virtual void Deallocate( void *pClass ) = 0;
|
|
|
|
// Fallbacks + errors..
|
|
virtual void *GetErrorResource( const void *pPermanentData ) = 0;
|
|
virtual void *GetFallback( const void *pPermanentData ) = 0;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A resource dictionary to look up resources
|
|
//-----------------------------------------------------------------------------
|
|
abstract_class IResourceTypeManager
|
|
{
|
|
public:
|
|
virtual ResourceHandle_t FindOrCreateResource( const char *pFileName, const char *pSubResourceName ) = 0;
|
|
virtual ResourceHandle_t FindOrCreateProceduralResource( const char *pGroupName, const char *pResourceName, const void *pPermanentData, size_t nDataSize ) = 0;
|
|
virtual void DeleteResource( ResourceHandle_t hResource ) = 0;
|
|
virtual ResourceHandle_t FindResource( ResourceId_t nResourceId ) = 0;
|
|
virtual ResourceType_t GetResourceType() = 0;
|
|
virtual ResourceId_t GetResourceId( ResourceHandle_t hResource ) const = 0;
|
|
|
|
// To bring resources in or out of memory
|
|
virtual void CacheResource( ResourceHandle_t hResource ) = 0;
|
|
virtual void UncacheResource( ResourceHandle_t hResource ) = 0;
|
|
|
|
// Sets the amount of memory to restrict this resource type to using
|
|
virtual void SetMemoryLimit( int nMemoryLimit ) = 0;
|
|
|
|
// Returns the list of cached resources
|
|
virtual int GetResourceCount() const = 0;
|
|
virtual int GetResources( int nFirst, int nCount, ResourceHandle_t *pResources ) = 0;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Methods related to managing resources
|
|
//-----------------------------------------------------------------------------
|
|
abstract_class IResourceSystem : public IAppSystem
|
|
{
|
|
public:
|
|
// Used to indicate globals to update to the current frame counter
|
|
// This counter is controlled by the resource system + set to the
|
|
// resource system's current frame
|
|
virtual void RegisterFrameCounter( uint32 *pFrameCounter ) = 0;
|
|
virtual void UnregisterFrameCounter( uint32 *pFrameCounter ) = 0;
|
|
|
|
// Allows various systems to hook in resource type constructors and class bindings
|
|
virtual void InstallResourceConstructor( ResourceType_t nType, const char *pResourceManagerType, IResourceTypeConstructor *pConstructor ) = 0;
|
|
virtual void RemoveResourceConstructor( IResourceTypeConstructor *pConstructor ) = 0;
|
|
|
|
// FIXME: Should this be in IResourceSystem or CResourceSystem?
|
|
virtual void InstallSchemaClassBinding( class CSchemaClassBindingBase *pBinding ) = 0;
|
|
|
|
// Indicates globals controlled by the client which specify the frame
|
|
// that the clients have finished with, thereby telling the resource system
|
|
// what resources it can free.
|
|
virtual void RegisterFinishedFrameCounter( uint32 *pFrameCounter ) = 0;
|
|
virtual void UnregisterFinishedFrameCounter( uint32 *pFrameCounter ) = 0;
|
|
void MarkFinishedFrameCounter( uint32 *pFrameCounter );
|
|
|
|
// Methods related to resource introspection. Should these go into a separate interface?
|
|
virtual const CResourceStructIntrospection* FindStructIntrospection( ResourceStructureId_t id ) const = 0;
|
|
virtual const CResourceStructIntrospection* FindStructIntrospection( const char *pStructName ) const = 0;
|
|
virtual const CResourceEnumIntrospection* FindEnumIntrospection( ResourceStructureId_t id ) const = 0;
|
|
virtual const CResourceEnumIntrospection* FindEnumIntrospection( const char *pEnumName ) const = 0;
|
|
virtual const CResourceTypedefIntrospection* FindTypedefIntrospection( ResourceStructureId_t id ) const = 0;
|
|
virtual const CResourceTypedefIntrospection* FindTypedefIntrospection( const char *pTypedefName ) const = 0;
|
|
|
|
// Returns the value associated with a particular enumeration
|
|
virtual bool FindEnumeratedValue( void *pValue, const char *pEnumName, const char *pEnumValueName, int nDefaultValue ) const = 0;
|
|
virtual const char *FindEnumerationName( const char *pEnumName, int nValue, const char *pDefaultName ) const = 0;
|
|
|
|
// TODO: Possibly change this to use a StructIntrospectionHandle_t
|
|
virtual const CResourceStructIntrospection* FindStructIntrospectionByBlockType( ResourceBlockId_t nBlockType ) const = 0;
|
|
virtual const CResourceStructIntrospection* FindStructIntrospectionForResourceType( ResourceType_t nType ) const = 0;
|
|
virtual const CResourceStructIntrospection* FindPermanentStructIntrospectionForResourceType( ResourceType_t nType ) const = 0;
|
|
|
|
virtual bool UnpackIntrospectedBlock( const void *pResourceData, size_t nSrcDataSize,
|
|
const CResourceIntrospection *pSrcIntro, const CResourceStructIntrospection* pSrcStructIntro,
|
|
const CResourceStructIntrospection* pDstStructIntro,
|
|
void const **pOutResult, int *pOutResultSize, IntrospectionCompatibilityType_t* pOutCompat ) const = 0;
|
|
|
|
// Utility methods
|
|
virtual void GetResourceMapping( const char *pDmeElementType, ResourceType_t *pType, ResourceStructureId_t *pId ) = 0;
|
|
virtual int GetFieldSize( ResourceFieldType_t nType ) const = 0;
|
|
virtual int GetFieldAlignment( ResourceFieldType_t nType ) const = 0;
|
|
virtual const char* GetFieldName( ResourceFieldType_t nType ) const = 0;
|
|
|
|
// Methods related to a resource dictionary
|
|
|
|
// NOTE: This will become obsolete at some point I believe? It loads a map
|
|
// of resource IDs and possible resource IDs from the specified files.
|
|
virtual void LoadResourceManifest( const char *pFileName ) = 0;
|
|
|
|
// Returns a resource manager for a particular resource type
|
|
virtual IResourceTypeManager *GetResourceManager( ResourceType_t nType ) = 0;
|
|
|
|
// Frame update.. resources are cached in or out here
|
|
virtual void FrameUpdate() = 0;
|
|
|
|
// Block until all type dictionaries are loaded.
|
|
// NOTE: This call is not necessary to make if you are running the game
|
|
// It's only necessary in tools that use IFileSystem instead of IAsyncFileSystem.
|
|
virtual void BlockUntilAllVTDsLoaded() = 0;
|
|
|
|
// Returns the resource manager associated with a particular resource data type
|
|
template < class T > IResourceTypeManager *GetResourceManagerForType( );
|
|
};
|
|
|
|
template < class T >
|
|
inline IResourceTypeManager *IResourceSystem::GetResourceManagerForType( )
|
|
{
|
|
return GetResourceManager( ResourceTypeInfo_t< T >::ResourceType() );
|
|
}
|
|
|
|
inline void IResourceSystem::MarkFinishedFrameCounter( uint32 *pFrameCounter )
|
|
{
|
|
*pFrameCounter = g_nResourceFrameCount;
|
|
}
|
|
|
|
|
|
#endif // IRESOURCESYSTEM_H
|