最近在看《Real Time 3D Terrain Engines Using C++And DirectX 9》，不过是看网上翻译的版本叫《实时地形引擎》，看英文实在蛋疼，还好有翻译版的，要多多感谢承天一大哥！这本书讲解了地形制作的一些技术，更吸引人的是实现了一个小型的渲染引擎，对于我这样的游戏引擎初学者很适合。gaia正是书中构建的引擎的名字。这里来写写一些简单的分析，作为学习笔记。

 

（一）资源管理

1、 data_pool.h

cPoolGroup:模板类，池组，顾名思义，就是装载一组数据的对象

 

template 
     
       class cPoolGroup {
   public:     cPoolGroup(uint16 maxCount);     ~cPoolGroup(){}; void        create(); void        destroy();     uint16        addMember(const T& member);     uint16        nextMember(); void        release(uint16 index);     uint16        totalOpen()const;     uint16        totalUsed()const;     uint16        firstOpen()const; bool        isOpen(uint16 index)const;     T&            member(uint16 index); const T&    member(uint16 index)const;     T*            memberPtr(uint16 index); const T*    memberPtr(uint16 index)const; private:     uint16            m_totalOpen;     uint16            m_firstOpen;     uint16            m_maxCount;     uint16*            m_nextOpenList;     T*                m_memberList;//数据对象链表 };
     

 

 

 

 

cDataPoolInterface：数据池接口，抽象类

class cDataPoolInterface {
   public:     typedef void (*MEMBER_CALLBACK)(cDataPoolInterface* pPool, cPoolHandle handle, void* member);     cDataPoolInterface():m_initialized(false){}; virtual ~cDataPoolInterface(){}; virtual void initialize(uint16 growSize)=0;; virtual void destroy()=0;; virtual void clear()=0; virtual cPoolHandle nextHandle()=0; virtual void release(cPoolHandle* pHandle)=0; virtual void forEach(MEMBER_CALLBACK function)=0; virtual void* getGenericPtr(cPoolHandle index)=0; bool isInitialized()const {
   return m_initialized;} protected: bool m_initialized; };

 

 

cDataPool：模板类，继承自cDataPoolInterface，数据池，它包括了若干个cPoolGroup

 

template 
     
       class cDataPool : public cDataPoolInterface {
   public: // Data Types & Constants...     typedef T DATA_TYPE;     typedef cPoolGroup
      
        MemberGroup;     typedef std::list
       
         MemberGroupList;     typedef cDataPoolInterface::MEMBER_CALLBACK MEMBER_CALLBACK; // Creators...     cDataPool();     ~cDataPool(); void initialize(uint16 growSize); void destroy(); const T& operator[](cPoolHandle handle)const {
   return get(handle);}     T& operator[](cPoolHandle handle) {
   return get(handle);} // Mutators...     cPoolHandle add(const T& member); void clear();     cPoolHandle nextHandle(); void release(cPoolHandle* pHandle); void forEach(MEMBER_CALLBACK function); // Accessors...     bool isHandleValid(cPoolHandle index)const; const T& get(cPoolHandle index)const;     T* getPtr(cPoolHandle index); void* getGenericPtr(cPoolHandle index);     uint16 totalMembers()const {
   return m_totalMembers;}     uint16 totalOpen()const {
   return m_totalOpen;}     uint16 totalUsed()const {
   return m_totalMembers-m_totalOpen;} private: // Private Data...     MemberGroupList m_groupList;// cPoolGroup链表     uint16            m_totalMembers;     uint16            m_totalOpen;     uint16            m_groupCount;     uint32            m_indexMask; int                m_indexShift; // Private Functions...     explicit cDataPool(const cDataPool& Src);     cDataPool& operator=(const cDataPool& Src);     cPoolGroup
        
         *    addGroup();     cPoolGroup
         
          *    findOpenGroup(unsigned* groupNumber);     cPoolGroup
          
           * getGroup(unsigned index); const cPoolGroup
           
            * getGroup(unsigned index)const; int getGroupNumber(cPoolHandle handle)const; int getItemIndex(cPoolHandle handle)const; cPoolHandle buildHandle(int group, int index)const; };
           
          
         
        
       
      
     

 

 

2、 resource_pool.h

 

 

cResourcePoolInterface：资源池接口，抽象类

class cResourcePoolInterface {
   public:     union FILE_EXTENSION     {
   char ext[4];         uint32 fourcc;     };     typedef std::map
     
       NAME_LOOKUP_MAP;     cResourcePoolInterface(); virtual ~cResourcePoolInterface(){}; // these functions must be proviided in the derived class (cResourceType)     virtual void initialize(uint16 growSize)=0; virtual void destroy()=0; virtual bool isInitialized()const=0; virtual void destroyAll()=0; virtual void disableAll()=0; virtual void restoreAll()=0; virtual void clean()=0;     cResourcePoolItem* createResource(const cString& resourceName);     cResourcePoolItem* loadResource(const cString& filename);     cResourcePoolItem* getResource(cPoolHandle handle);     cResourcePoolItem* findResource(const cString& Name); void destroyResource(cResourcePoolItem* pResource); bool saveResource(cResourcePoolItem* pResource);     cPoolHandle findResourceHandle(const cString& Name); const cString* findResourceName(cPoolHandle handle)const; void setResourceName(cPoolHandle handle, const tchar* name); void registerResourcePool(cResourceCode code); void unregisterResourcePool();     cResourceCode registrationCode()const; protected:     cResourceCode m_registrationCode;     NAME_LOOKUP_MAP m_nameMap; private: // Private Functions...     virtual cPoolHandle internalCreateResource(const cString& resourceName)=0; virtual void internalDestroyResource(cPoolHandle handle)=0; virtual cResourcePoolItem* internalGetResource(cPoolHandle handle)=0; };
     

 

cResourcePool：模板类，资源池，继承自cResourcePoolInterface，成员中有一个DataPool可以看做是DataPool的扩充。

 

template 
     
       class cResourcePool : public cResourcePoolInterface {
   public:     typedef T DataType;     typedef cDataPool
      
        DataPool; // Creators...     cResourcePool(){};     ~cResourcePool(){}; // Base Class Overrides...     void initialize(uint16 growSize); void destroy(); bool isInitialized()const; void destroyAll(); void disableAll(); void restoreAll(); void clean(); // delete items no longer referenced     DataType* createResource(const cString& resourceName);     DataType* loadResource(const cString& filename);     DataType* getResource(cPoolHandle handle);     DataType* findResource(const cString& Name); // static data pool callbacks     static void callbackDestroy(cDataPoolInterface* pPool, cPoolHandle handle, void* resource); static void callbackRestore(cDataPoolInterface* pPool, cPoolHandle handle, void* resource); static void callbackDisable(cDataPoolInterface* pPool, cPoolHandle handle, void* resource); static void callbackClean(cDataPoolInterface* pPool, cPoolHandle handle, void* resource); private: // Data...     DataPool        m_dataPool; // Private Functions...     cPoolHandle internalCreateResource(const cString& resourceName); void internalDestroyResource(cPoolHandle handle);     cResourcePoolItem* internalGetResource(cPoolHandle handle); // Nonexistant Functions...     cResourcePool( const cResourcePool& Src);     cResourcePool& operator=( const cResourcePool& Src); };
      
     

 

 

cResourcePoolItem：资源池对象继承自cReferenceCounter

 

关于cReferenceCounter上一段英文：

 

/*    cResourcePoolItem

 

------------------------------------------------------------------------------------------

 

      

 

       A cResourcePoolItem is a simple base class for a shared resource such as a texture,

 

       animation or vertex buffer.

 

 

 

       Note that cResourcePoolItem is derived from cReferenceCounter. The cResourcePoolManager uses

 

       the value of the cReferenceCounter to decide when objects are no longer in use and can

 

       be destroyed during the cResourcePoolManager::clean() function. This means the application

 

       must update the reference count of the cResourcePoolItem whenever links between objects

 

       are created or removed between objects. The cReferenceCounter base class provides the

 

       functionality to manipulate the reference count.

 

      

 

------------------------------------------------------------------------------------------

 

*/

 

class cResourcePoolItem : public cReferenceCounter {
   public: // Data Types & Constants...     enum     {
           nCreated=0,    // the resource has been created         nLoaded,    // the resource is filled with data and ready for use         nDisabled,    // the resource is currently disabled for use         nAltered,    // the resource has been altered since loaded         nTotalResourceFlags     }; // Creators...     cResourcePoolItem(); virtual ~cResourcePoolItem(); // User Functions // These function prototypes are to be used by resources that use volatile or system-specific resources. // Examples would be video-memory resident textures or hardware vertex buffers.     virtual bool createResource()=0;                    // innitialize the resource (called once)     virtual bool destroyResource()=0;                    // destroy the resource     virtual bool disableResource()=0;                    // purge the resource from volatile memory     virtual bool restoreResource()=0;                    // restore the resource to volatile memory     virtual bool loadResource(const tchar* filename=0)=0; // load the resource from a file (or NULL to use the resource name)     virtual bool saveResource(const tchar* filename=0)=0;    // save the resource to a file (or NULL to use the resource name) // Accessors...     cResourceCode            resourceCode()const;     cResourcePoolInterface* resourcePool()const;     cPoolHandle                resourceHandle()const;     u32Flags                resourceFlags()const; bool isResourceCreated()const; bool isResourceDisabled()const; bool isResourceLoaded()const; const cString* findResourceName()const; void setResourceName(const tchar* name); void setAlteredFlag(bool onOff); bool alteredFlag()const; // mimic COM interfaces     virtual int32 Release(); protected: // only derrived classes are permitted to modify internal members     void setResourceCode(cResourceCode code); void setResourcePool(cResourcePoolInterface* interfaePtr); void setResourceHandle(cPoolHandle handle); void setResourceFlag(int flagBit, bool Setting); void notifyCreated(); void notifyDisabled(); void notifyLoaded(); void notifyUnloaded(); void notifyRestored(); void notifyDestroyed(); void notifySaved(); private: // Data...     cResourceCode            m_resourceCode;     cResourcePoolInterface* m_resourcePool;     cPoolHandle                m_resourceHandle;     u32Flags                m_resourceFlags; // Private Functions... // Nonexistant Functions...     cResourcePoolItem( const cResourcePoolItem& Src);     cResourcePoolItem& operator=( const cResourcePoolItem& Src);     friend cResourcePoolInterface; };

 

cReferenceCounter：。。（我没太理解它的作用，望大虾指点。。）

 

/*    cReferenceCounter

 

-----------------------------------------------------------------

 

   

 

       A cReferenceCounter is a base class which allows the program

 

       to count open instances.

 

      

 

-----------------------------------------------------------------

 

*/

 

class cReferenceCounter {
   public: // Construction and Destruction...     cReferenceCounter()     {
           m_nReferenceCount = 0;     }     cReferenceCounter( const cReferenceCounter& Src)     {
   // Reference counts are tied to a specific instance // i.e. they are never copied         m_nReferenceCount = 0;     } virtual ~cReferenceCounter()     {
   // assert if this object is still in use         assert(m_nReferenceCount == 0);     } // Operators...     cReferenceCounter& operator=(const cReferenceCounter& Src)     {
   // this function is provided in order to allow // derived classes to provide copy operators. // the reference count itself is never copied.         return *this;     } // Mutators...     virtual int32 AddRef()     {
           assert(m_nReferenceCount != MAX_INT32);         ++m_nReferenceCount; return(m_nReferenceCount);     }; virtual int32 Release()     {
           assert(m_nReferenceCount > 0);         --m_nReferenceCount; return(m_nReferenceCount);     } // Accessors...     int32 referenceCount()const {
   return m_nReferenceCount;} private: // the internal reference count, stored in 32bits     int32 m_nReferenceCount; };

 

cResourcePoolManager：单件类，资源管理器，负责申请资源池，找到资源等资源管理功能。

 

 

class cResourcePoolManager : public cSingleton
     
       {
   public:     typedef std::map
      
        ResourcePoolTypeMap;     typedef std::list
       
         ResourcePoolFamilyList; // Creators...     cResourcePoolManager();     ~cResourcePoolManager(){}; // registration of resource manager interfaces     void registerResourcePool(cResourceCode code, cResourcePoolInterface* pInterface);     cResourcePoolInterface*  unregisterResourcePool(cResourceCode code); // operations for all resource types     void destroyAll(); void disableAll(); void restoreAll(); void clean(); // delete items no longer referenced // operations on specific resource types     void destroyResourceFamily(int family); void disableResourceFamily(int family); void restoreResourceFamily(int family); void cleanResourceFamily(int family); void destroyResourceType(cResourceCode code); void disableResourceType(cResourceCode code); void restoreResourceType(cResourceCode code); void cleanResourceType(cResourceCode code);     cResourcePoolInterface* findResourcePool(cResourceCode code)const;     cPoolHandle findResourceHandle(cResourceCode code, const cString& Name)const;     cResourcePoolItem* findResource(cResourceCode code, const cString& Name)const;     cResourcePoolItem* findResource(cResourceCode code, cPoolHandle handle)const; private:     ResourcePoolFamilyList m_resourceFamilyList[k_nTotalResourceFamilies];     ResourcePoolTypeMap    m_resourceTypeMap; };
       
      
     

 

引擎中所有的资源都派生自cResourcePoolItem，也可以说是对D3D资源类的封装。例如：texture.h里的cTexture：

 

class cTexture : public cResourcePoolItem {
   public: // Data Types & Constants...     enum eTextureFlags     {
           k_cubeMap=0,         k_dynamicTexture,         k_renderTarget,         k_paletized,         k_mipMaps,     }; enum eForcedFormatFlags     {
           k_forceMipLevels=0,         k_forceFormat,         k_forceSize,     }; // Creators...     cTexture();     ~cTexture(); // base resource overrides     bool createResource();                    // innitialize the resource (called once)     bool destroyResource();                    // destroy the resource     bool disableResource();                    // purge the resource from volatile memory     bool restoreResource();                    // prepare the resource for use (create any volatile memory objects needed)     bool loadResource(const tchar* filename=0); // load the resource from a file (or NULL to use the resource name)     bool saveResource(const tchar* filename=0);    // save the resource to a file (or NULL to use the resource name) bool createTexture(uint32 width, uint32 height, uint32 mipLevels, uint32 usage, D3DFORMAT Format, D3DPOOL pool); bool createCubeTexture(uint32 size, uint32 mipLevels, uint32 usage, D3DFORMAT Format, D3DPOOL pool); void generateMidpointNoise(float falloff); void generatePerlinNoise(float scale, int octaves, float falloff); bool generateNormalMap(LPDIRECT3DTEXTURE9 heightMap, uint32 channel, uint32 flags, float amplitude); bool generateNormalizationCubeMap(); bool maskWithImage(cImage* pImage); void releaseTexture(); bool convertToNormalMap(         uint32 channel,         uint32 flags, float amplitude); // Accessors...     LPDIRECT3DTEXTURE9        getTexture()const; bool uploadImage(const cImage* pImage, bool copyAll = true); bool uploadCubeFace(const cImage* pImage, D3DCUBEMAP_FACES face, bool copyAll = true);     uint32        width()const{
   return m_width;}     uint32        height()const{
   return m_height;}     uint32        mipLevels()const{
   return m_mipLevels;}     uint32        d3dUsage()const{
   return m_d3dUsage;}     D3DFORMAT    d3dFormat()const{
   return m_d3dFormat;}     D3DPOOL        d3dPool()const{
   return m_d3dPool;} bool    getSurfaceLevel(int level, LPDIRECT3DSURFACE9* ppSurface); private: // Data...     uint32                    m_width;     uint32                    m_height;     uint32                    m_mipLevels;     uint32                    m_d3dUsage;     D3DFORMAT                m_d3dFormat;     D3DPOOL                    m_d3dPool;     DWORD                    m_d3dFilter;     DWORD                    m_d3dMipFilter;     D3DCOLOR                m_d3dColorKey;     D3DXIMAGE_INFO            m_d3dImageInfo;     PALETTEENTRY*            m_pPalette;     LPDIRECT3DTEXTURE9        m_pTexture;     LPDIRECT3DCUBETEXTURE9    m_pCubeTexture; bool loadFromResourceFile(cFile& InputFile); bool configureImageSettings(); bool checkTextureRequirements(); bool checkCubeTextureRequirements(); bool loadTextureFromImageFile(const tchar* filename); bool loadTextureFromMemory(uint8* memory, uint32 size); bool loadCubeTextureFromImageFile(const tchar* filename); bool loadCubeTextureFromMemory(uint8* memory, uint32 size); // Nonexistant Functions...     cTexture( const cTexture& Src);     cTexture& operator=( const cTexture& Src); }; typedef cResourcePool
     
       cTextureManager;
     

 

 

此外还有vertex_buffer.h中的cVertexBuffer和model_resource.h中的cModelResource

 

P56有资源的使用示例

 

 

类关系图：

 

由cResourcePoolManager统一管理。

 

 

书的第四章gaia引擎总览有提到资源管理相关的内容，但是并没用对源码进行过多的解释，这部分还是要自己硬着头皮看啊。。。

不过看了这些基本理解了资源管理的原理和整个模块的结构，受益匪浅。。

UML:

ps：突然发现一个奇怪的问题，gaia中虽然定义了cResourcePoolManager，但是自己的程序里面并没有使用，而是在displayManager里面直接有几个cResourcePool对资源进行管理。。

如下：

 

class cDisplayManager {
   。。。。。。 protected: // Private Data...     bool    m_bEnabled; bool    m_bClearEachFrame; // true to clear each frame to black before rendering // device-bound resource pools     cTextureManager            m_texturePool;     cSurfaceMaterialManager m_surfaceMaterialPool;     cEffectFileManager        m_effectFilePool;     cRenderMethodManager    m_renderMethodPool;     cVertexBufferManager    m_vertexBufferPool;     cIndexBufferManager        m_indexBufferPool;     cModelManager            m_modelPool;     cImageManager            m_imagePool; 。。。。。。 };