cocos引擎并没有提供一套专门资源管理解决方案，仅仅只有一个TextureCache提供了针对Texture2D的（异步）加载、缓存、清理等管理工作，我们可以参照TextureCache的思路设计一个针对常见资源的可扩展的资源管理器ResourceCache，使用引用计数原理来控制每个资源的生命周期。

UML

点击查看【processon】

使用示例

  1. #include <iostream>
  2. #include "ResourceMgr.h"
  4. using namespace std;
  6. // 假设已经扩展了以下几种资源类型:
  7. //         JsonData
  8. //        Mp3Data
  9. //        Mp4Data
  11. void main(){
  12.     // 考虑以下情景：
  13.     // 首先启动游戏，进入到场景1，然后从场景1切换到场景2，场景1、2之间共用了部分资源
  15.     // 场景1的资源列表
  16.     vector<pair<string, string>> data_scene_1{
  17.         { "jsondata_1", JsonData::TYPE },
  18.         { "1.mp3", Mp3Data::TYPE },
  19.         { "1.mp4", Mp4Data::TYPE },
  20.     },
  22.     // 场景2的资源列表
  23.     data_scene2{
  24.         { "jsondata_1", JsonData::TYPE },    // 和场景1共享的资源
  25.         { "2.mp3", Mp3Data::TYPE },
  26.         { "2.mp4", Mp4Data::TYPE },
  27.     }
  29.     ResourceMgr::getInstance()->addResRef(data_scene_1);
  30.     // 当前资源引用计数表：实际还没有加载场景1资源
  31.     // {
  32.     //    "jsondata_1" : 1,
  33.     //    "1.mp3" : 1,
  34.     //    "1.mp4" : 1,
  35.     // }
  37.     // 加载当前资源引用计数表中的资源，即：jsondata_1、1.mp3、1.mp4
  38.     // callback: 加载完成后的回调
  39.     ResourceMgr::getInstance()->updateResRefAsync(callback);
  41.     ResourceMgr::getInstance()->addResRef(data_scene_2);    // 加载场景2的资源
  42.     // 当前资源引用计数表：实际还没有加载场景2资源
  43.     // {
  44.     //    "jsondata_1" : 2,
  45.     //    "1.mp3" : 1,
  46.     //    "1.mp4" : 1,
  47.     //    "2.mp3" : 1,
  48.     //    "2.mp4" : 1,
  49.     //}
  51.     ResourceMgr::getInstance()->removeResRef(data_scene_1);        // 清除上一个场景的资源
  52.     // 当前资源引用计数表：
  53.     // {
  54.     //    "jsondata_1" : 1,
  55.     //    "1.mp3" : 0,
  56.     //    "1.mp4" : 0,
  57.     //    "2.mp3" : 1,
  58.     //    "2.mp4" : 1,
  59.     // }
  61.     ResourceMgr::getInstance()->updateResRefAsync(data_scene_2);    
  62.     //1、卸载引用计数=0的资源，即1.mp3、1.mp4
  63.     //2、加载引用计数!=0且还未加载的资源，即2.mp3、2.mp4
  64.     //
  65.     // 当前缓存的资源如下：
  66.     //{
  67.     //    "jsondata_1" : ...,
  68.     //    "2.mp3" : ...,
  69.     //    "2.mp4" : ...,
  70.     //}
  71. }

代码设计

ResourceMgr

ResourceMgr.h

  2. #ifndef __RESOURCEMGR_H__
  3. #define __RESOURCEMGR_H__
  5. #include "cocos2d.h"
  6. #include "ResourceCache.h"
  8. /**
  9.  * 资源管理的统一（唯一）入口
  10.  */
  11. class ResourceMgr : public cocos2d::Ref {
  12. public:
  13.     static ResourceMgr* getInstance();
  15.     void addResProtocol(ResourceProtocol* data);
  17.     /**
  18.      * 资源引用计数管理API
  19.      *
  20.      * 注意，有两种引用计数：
  21.      *     1、Ref引用计数
  22.      *       2、资源引用计数：ResourceMgr内部定义的引用计数，资源的引用计数+1表示该资源将在下一个场景使用，
  23.      *          资源并不会马上加载，而是在updateResourceReferenceAsync时，才真正加载。
  24.      *
  25.      */
  27.     /**
  28.      * 告知资源管理器将要使用哪些资源(对应资源引用计数+1)
  29.      * 新增加的资源将在下一次调用updateResourceReferenceAsync的时候异步载入
  30.      */
  31.     void addResRef(const std::vector<std::pair<std::string,std::string>>& path_type);
  33.     /**
  34.     * 告知资源管理器哪些资源不再被使用(对应资源引用计数-1)
  35.     * 当资源引用计数为0时将在下次调用updateResourceAsync的时候从内存中释放
  36.     */
  37.     void removeResRef(const std::vector<std::string>&);
  39.     void removeUnusedResRef();
  41.     /** 查询某个资源的引用计数 */
  42.     int getResRef(const std::string& filename);
  44.     /**
  45.      * 资源引用计数 > 0，且资源未加载，则加载资源
  46.      * 资源引用计数 = 0，则清楚该资源缓存
  47.      */
  48.     void updateResRefAsync(const std::function<void()>& callback);
  49.     void updateResRefAsyncHandler(int handler);
  50.     void unupdateResRefAsyncHandler();
  52. private:
  53.     ResourceMgr();
  54.     virtual ~ResourceMgr();
  56. private:
  57.     ResourceCache*            _resourceCache;        // 自定义资源缓存管理，实现原理参考TextureCache
  60.     /**
  61.     * 资源引用计数表
  62.     *
  63.     * key   : resource full path
  64.     * value : resource reference count
  65.     */
  66.     std::unordered_map<std::string, int>                _resRefMap;
  68.     /**
  69.     * 待加载的资源
  70.     *
  71.     * key   : resource full path
  72.     * value : resource type
  73.     */
  74.     std::vector<std::pair<std::string, std::string>>    _resToAdd;
  76.     int        _addHandler;
  77.     int        _updateHandler;
  78.     bool    _isLoading;
  79. };
  81. #endif /* defined(__Resource__) */

ResourceMgr.cpp

  1. #include "ResourceMgr.h"
  2. #include "JsonData.h"
  4. USING_NS_CC;
  5. using namespace std;
  7. static ResourceMgr* _resourceInstance = nullptr;
  9. ResourceMgr* ResourceMgr::getInstance()
  10. {
  11.     if (_resourceInstance == nullptr) {
  12.         _resourceInstance = new ResourceMgr();
  13.     }
  14.     return _resourceInstance;
  15. }
  17. ResourceMgr::ResourceMgr()
  18.     : _resourceCache(nullptr)
  19.     , _updateHandler(0)
  20.     , _addHandler(0)
  21.     , _isLoading(false)
  22. {
  23.     _resourceCache = new ResourceCache();
  24. }
  26. ResourceMgr::~ResourceMgr()
  27. {
  28.     CCLOG("~ResourceMgr");
  29.     unupdateResRefAsyncHandler();
  30. }
  32. void ResourceMgr::addResProtocol(ResourceProtocol* data)
  33. {
  34.     _resourceCache->addResourceProtocol(data);
  35. }
  37. void ResourceMgr::addResRef(const std::vector<std::pair<std::string, std::string>>& path_type)
  38. {
  39.     if (path_type.empty()) {
  40.         return;
  41.     }
  42.     for (auto iter = path_type.cbegin(); iter != path_type.cend(); iter++) {
  43.         auto fullpath = cocos2d::FileUtils::getInstance()->fullPathForFilename(iter->first);
  45.         if (!fullpath.empty()) {
  46.             auto find = _resRefMap.find(fullpath);
  47.             if (find != _resRefMap.end()) {
  48.                 find->second++;
  49.             }
  50.             else {
  51.                 _resRefMap.insert(std::make_pair(fullpath, 1));
  52.                 _resToAdd.push_back(make_pair(fullpath, iter->second));
  53.             }
  54.         }
  55.     }
  57. }
  59. void ResourceMgr::removeResRef(const std::vector<std::string>& files)
  60. {
  61.     for (auto iter = files.cbegin(); iter != files.cend(); iter++) {
  62.         auto fullpath = cocos2d::FileUtils::getInstance()->fullPathForFilename(*iter);
  63.         if (!fullpath.empty()) {
  64.             auto find = _resRefMap.find(fullpath);
  65.             if (find != _resRefMap.end() && find->second > 0) {
  66.                 find->second--;
  67.             }
  68.         }
  69.     }
  70. }
  72. void ResourceMgr::removeUnusedResRef()
  73. {
  74.     for (auto iter = _resRefMap.begin(); iter != _resRefMap.end();) {
  75.         if (iter->second == 0) {
  76.             iter = _resRefMap.erase(iter);
  77.         }
  78.         else {
  79.             iter++;
  80.         }
  81.     }
  82. }
  84. int ResourceMgr::getResRef(const std::string& file)
  85. {
  86.     auto fullpath = cocos2d::FileUtils::getInstance()->fullPathForFilename(file);
  88.     auto find = _resRefMap.find(fullpath);
  89.     if (find != _resRefMap.end()) {
  90.         return find->second;
  91.     }
  93.     return 0;
  94. }
  96. void ResourceMgr::unupdateResRefAsyncHandler()
  97. {
  98.     if (0 != _updateHandler) {
  99.         ScriptEngineManager::getInstance()->getScriptEngine()->removeScriptHandler(_updateHandler);
  100.         _updateHandler = 0;
  101.     }
  102. }
  104. void ResourceMgr::updateResRefAsyncHandler(int handler)
  105. {
  106.     unupdateResRefAsyncHandler();
  107.     _updateHandler = handler;
  109.     auto callback = [this] {
  110. #if CC_ENABLE_SCRIPT_BINDING
  111.         CommonScriptData data(_updateHandler, "", this);
  112.         ScriptEvent event(kCommonEvent, (void*)&data);
  113.         CCLOG("updateResourceReferenceAsyncHandler callback lua.");
  114.         ScriptEngineManager::getInstance()->getScriptEngine()->sendEvent(&event);
  115.         return;
  116. #endif
  117.     };
  119.     updateResRefAsync(callback);
  120. }
  122. void ResourceMgr::updateResRefAsync(const std::function<void()>& callback)
  123. {
  124.     // 第一步：清除资源，资源引用计数=0的资源。
  125.     for (auto iter = _resRefMap.begin(); iter != _resRefMap.end(); iter++) {
  126.         if (iter->second == 0) {
  127.             _resourceCache->removeResourceForKey(iter->first);
  128.         }
  129.     }
  131.     // 第二步：移除资源引用计数，=0的
  132.     removeUnusedResRef();
  134.     // 第三步：异步加载新的资源（引用计数为1的）
  135.     int* reference = new int();
  136.     *reference = _resToAdd.size();
  138. #if COCOS2D_DEBUG
  139.     time_t* t = new time_t();
  140.     time(t);
  141.     int count = _resToAdd.size();
  142. #endif
  144.     //资源全部加载完毕
  145.     auto completed = [reference, callback, this
  146. #if COCOS2D_DEBUG
  147.                                  , t, count
  148. #endif
  149.                ]() {
  150.         if ((*reference) == 0) {
  151.             delete reference;
  152. #if COCOS2D_DEBUG
  153.             time_t now;
  154.             time(&now);
  156.             CCLOG("we spend %f seconds to load {%d} files.", (float)difftime(now, *t), count);
  157.             delete t;
  158. #endif
  160.             _resToAdd.clear();
  161.             _isLoading = true;
  162.             callback();
  163.         }
  164.     };
  166.     CCLOG("we need to load %d files", (int)_resToAdd.size());
  168.     if (_resToAdd.size() == 0) {
  169.         completed();
  170.         return;
  171.     }
  173.     for (auto iter = _resToAdd.begin(); iter != _resToAdd.end(); iter++) {
  174.         _resourceCache->addResourceAsync(iter->first, [&](void* data) {
  175.             (*reference)--;
  176.             if (*reference < 1) {
  177.                 completed();
  178.             }
  179.         }, iter->second);
  180.     }
  181. }

ResourceCache

ResourceCache.h

  1. #ifndef __RESOURCECACHE_H__
  2. #define __RESOURCECACHE_H__
  4. #include <thread>
  5. #include <unordered_map>
  6. #include "cocos2d.h"
  7. #include "ResourceProtocol.h"
  9. class ResourceMgr;
  11. /**
  12.  * 自定义资源缓存
  13.  *
  14.  * 不对外公开，全部private，由友元ResourceMgr代理
  15.  */
  16. class ResourceCache : public cocos2d::Ref {
  17. private:
  18.     ResourceCache();
  19.     virtual ~ResourceCache();
  21.     /**
  22.     * 同步加载资源到缓存
  23.     */
  24.     void* addResource(const std::string& filename, const std::string& type = "Texture2D");
  26.     /**
  27.     * 异步加载资源到缓存
  28.     */
  29.     void addResourceAsync(const std::string& filename, std::function<void(void*)> callback, const std::string& type="Texture2D");
  31.     /**
  32.      * 清除所有自定义资源缓存，类似TextureCache::removeAllTextures
  33.      */
  34.     void removeAllResources();
  36.     /**
  37.      * 清除所有当前未被使用的资源，即Ref引用计数为1，类似TextureCache::removeUnusedTexture
  38.      */
  39.     void removeUnusedResources();
  41.     /**
  42.      * 删除指定资源
  43.      */
  44.     bool removeResource(void* data);
  45.     bool removeResourceForKey(const std::string& key);
  47.     /**
  48.     * 注册一个自定义数据类型及解析器
  49.     */
  50.     void addResourceProtocol(ResourceProtocol* data);
  52. private:
  53.     /**
  54.     * 自定义资源加载完成的回调，schedule update每帧执行，也就是说是在GL thread中执行
  55.     */
  56.     void addResourceAsyncCallback(float dt);
  58.     /**
  59.     * 在子线程中加载自定义资源
  60.     */
  61.     void loadData();
  63. private:
  64.     struct AsyncStruct {
  65.         AsyncStruct(const std::string& fn, std::function<void(ResourceProtocol*)> cb, const std::string& type)
  66.             :filename(fn)
  67.             , callback(cb)
  68.             , resourceType(type)
  69.         {
  71.         }
  73.         std::string filename;
  74.         std::string resourceType;
  75.         std::function<void(ResourceProtocol*)> callback;
  76.     };
  79.     typedef struct _DataInfo {
  80.         AsyncStruct* asyncStruct;
  81.         ResourceProtocol* data;
  82.     } DataInfo;
  84.     std::thread*                _loadingThread;
  86.     std::queue<AsyncStruct*>*    _asyncStructQueue;
  87.     std::deque<DataInfo*>*        _dataInfoQueue;
  89.     std::mutex                    _asyncStructMutex;
  90.     std::mutex                    _dataInfoMutex;
  92.     std::mutex                    _sleepMutex;
  93.     std::condition_variable        _sleepCondition;
  95.     bool    _needQuit;
  96.     int        _asyncRefCount;
  98. private:
  99.     cocos2d::TextureCache                                *_textureCache;
  101.     /** 所有缓存数据 */
  102.     std::unordered_map<std::string, ResourceProtocol*>    _resources;
  104.     /**
  105.      * 自定义资源类型模板
  106.      */
  107.     std::map<std::string, ResourceProtocol*>            _resourceTemplate;
  109.     // 此类的代理
  110.     friend ResourceMgr;
  111. };
  113. #endif /* defined(__ResourceCache__) */

ResourceCache.cpp

  1. #include "ResourceCache.h"
  3. USING_NS_CC;
  5. ResourceCache::ResourceCache()
  6.     : _loadingThread(nullptr)
  7.     , _asyncStructQueue(nullptr)
  8.     , _dataInfoQueue(nullptr)
  9.     , _needQuit(false)
  10.     , _asyncRefCount(0)
  11.     , _textureCache(Director::getInstance()->getTextureCache())
  12. {
  14. }
  16. ResourceCache::~ResourceCache()
  17. {
  18.     for (auto iter = _resources.begin(); iter != _resources.end(); ++iter) {
  19.         iter->second->release();
  20.     }
  22.     for (auto iter = _resourceTemplate.begin(); iter != _resourceTemplate.end(); iter++) {
  23.         iter->second->release();
  24.     }
  25. }
  27. void* ResourceCache::addResource(const std::string& filename, const std::string& type)
  28. {
  29.     CCASSERT(!filename.empty(), "filename cann't be nil.");
  31.     void* resource = nullptr;
  33.     if (type == "Texture2D") {
  34.         resource = _textureCache->addImage(filename);
  35.     }
  36.     else {
  37.         //全路径key
  38.         std::string fullpath = cocos2d::FileUtils::getInstance()->fullPathForFilename(filename);
  39.         if (fullpath.empty()) {
  40.             return nullptr;
  41.         }
  43.         //是否已加载
  44.         auto iter = _resources.find(fullpath);
  45.         if (iter != _resources.end()) {
  46.             resource = iter->second;;
  47.         }
  49.         if (!resource) {
  50.             do {
  51.                 CCLOG("add resource date type: %s", type.c_str());
  53.                 auto iter1 = _resourceTemplate.find(type);
  54.                 if (iter1 != _resourceTemplate.end()) {
  55.                     ResourceProtocol* data = iter1->second->cloneEmpty();
  56.                     if (!data->loadWithFile(filename)) {
  57.                         CC_SAFE_RELEASE(data);
  58.                         CCLOG("ResouceDataDelegate is error: %s", iter1->first.c_str());
  59.                         break;
  60.                     }
  62.                     _resources.insert(std::make_pair(fullpath, data));
  63.                     resource = data;
  64.                 }
  66.             }
  67.             while (0);
  68.         }
  69.     }
  71.     return resource;
  72. }
  74. void ResourceCache::addResourceAsync(const std::string& filename, std::function<void(void*)> callback, const std::string& type)
  75. {
  76.     CCASSERT(!filename.empty(), "filename cann't be nil.");
  78.     if (type == "Texture2D") {
  79.         auto func = [this, filename, callback, type](cocos2d::Texture2D* tex) {
  80.             callback(tex);
  81.         };
  83.         _textureCache->addImageAsync(filename, func);
  84.     }
  85.     else {
  86.         ResourceProtocol* data = nullptr;
  87.         std::string fullpath = FileUtils::getInstance()->fullPathForFilename(filename);
  88.         auto iter = _resources.find(fullpath);
  89.         if (iter != _resources.end()) {
  90.             data = iter->second;
  91.         }
  93.         if (data != nullptr) {
  94.             callback(data);
  95.             return;
  96.         }
  98.         //lazy init
  99.         if (_asyncStructQueue == nullptr) {
  100.             _asyncStructQueue = new std::queue<AsyncStruct*>();
  101.             _dataInfoQueue = new std::deque<DataInfo*>();
  103.             _loadingThread = new std::thread(&ResourceCache::loadData, this);
  104.             _needQuit = false;
  105.         }
  107.         if (_asyncRefCount == 0) {
  108.             Director::getInstance()->getScheduler()->schedule(schedule_selector(ResourceCache::addResourceAsyncCallback), this, 0, false);
  109.         }
  111.         ++_asyncRefCount;
  113.         AsyncStruct* async = new AsyncStruct(fullpath, callback, type);
  115.         _asyncStructMutex.lock();
  116.         _asyncStructQueue->push(async);
  117.         _asyncStructMutex.unlock();
  119.         _sleepCondition.notify_one();
  121.     }
  122. }
  124. void ResourceCache::addResourceAsyncCallback(float dt)
  125. {
  126.     std::deque<DataInfo*>* datasQueue = _dataInfoQueue;
  128.     _dataInfoMutex.lock();
  129.     if (_dataInfoQueue->empty()) {
  130.         _dataInfoMutex.unlock();
  131.     }
  132.     else {
  133.         DataInfo* dataInfo = datasQueue->front();
  134.         datasQueue->pop_front();
  135.         _dataInfoMutex.unlock();
  137.         AsyncStruct* asyncStruct = dataInfo->asyncStruct;
  138.         ResourceProtocol* data = dataInfo->data;
  139.         const std::string& filename = asyncStruct->filename;
  140.         if (data) {
  141.             _resources.insert(std::make_pair(filename, data));
  142.             data->retain();
  143.             data->autorelease();
  144.         }
  145.         else {
  146.             auto iter = _resources.find(asyncStruct->filename);
  147.             if (iter != _resources.end()) {
  148.                 data = iter->second;
  149.             }
  150.         }
  152.         asyncStruct->callback(data);
  153.         delete asyncStruct;
  154.         delete dataInfo;
  156.         --_asyncRefCount;
  157.         if (0 == _asyncRefCount) {
  158.             Director::getInstance()->getScheduler()->unschedule(schedule_selector(ResourceCache::addResourceAsyncCallback), this);
  159.         }
  160.     }
  161. }
  163. void ResourceCache::loadData()
  164. {
  165.     AsyncStruct* asyncStruct = nullptr;
  166.     while (true) {
  167.         std::queue<AsyncStruct*>* pQueue = _asyncStructQueue;
  168.         _asyncStructMutex.lock();
  169.         if (pQueue->empty()) {
  170.             _asyncStructMutex.unlock();
  171.             if (_needQuit) {
  172.                 break;
  173.             }
  174.             else {
  175.                 std::unique_lock<std::mutex> lk(_sleepMutex);
  176.                 _sleepCondition.wait(lk);
  177.                 continue;
  178.             }
  179.         }
  180.         else {
  181.             asyncStruct = pQueue->front();
  182.             pQueue->pop();
  183.             _asyncStructMutex.unlock();
  184.         }
  186.         ResourceProtocol* data = nullptr;
  187.         bool loaded = false;
  189.         auto iter = _resources.find(asyncStruct->filename);
  190.         if (iter == _resources.end()) {
  191.             _dataInfoMutex.lock();
  192.             DataInfo* dataInfo;
  193.             size_t pos = 0;
  194.             size_t infoSize = _dataInfoQueue->size();
  196.             for (; pos < infoSize; pos++) {
  197.                 dataInfo = (*_dataInfoQueue)[pos];
  198.                 if (dataInfo->asyncStruct->filename.compare(asyncStruct->filename)) {
  199.                     break;
  200.                 }
  201.             }
  202.             _dataInfoMutex.unlock();
  203.             if (infoSize == 0 || pos < infoSize) {
  204.                 loaded = true;
  205.             }
  206.         }
  208.         if (loaded) {
  209.             const std::string & filename = asyncStruct->filename;
  210.             auto cloneData = _resourceTemplate.find(asyncStruct->resourceType);
  211.             if (cloneData != _resourceTemplate.end()) {
  212.                 data = cloneData->second->cloneEmpty();
  214.                 if (!data->loadWithFile(filename)) {
  215.                     delete data;
  216.                     CCLOG("load file: %s fail.", filename.c_str());
  217.                     continue;
  218.                 }
  220.                 CCLOG("load file: %s success.", filename.c_str());
  221.             }
  222.             else {
  223.                 CCLOG("load file: %s fail. no parser.", filename.c_str());
  224.                 continue;
  225.             }
  226.         }
  228.         DataInfo* dataInfo = new DataInfo();
  229.         dataInfo->asyncStruct = asyncStruct;
  230.         dataInfo->data = data;
  232.         _dataInfoMutex.lock();
  233.         _dataInfoQueue->push_back(dataInfo);
  234.         _dataInfoMutex.unlock();
  235.     }
  236. }
  238. void ResourceCache::removeAllResources()
  239. {
  240.     for (auto it = _resources.begin(); it != _resources.end(); ++it) {
  241.         (it->second)->release();
  242.     }
  244.     _resources.clear();
  246.     _textureCache->removeAllTextures();
  247. }
  249. void ResourceCache::removeUnusedResources()
  250. {
  251.     for (auto it = _resources.cbegin(); it != _resources.cend(); /* nothing */) {
  252.         ResourceProtocol *tex = it->second;
  253.         if (tex->getReferenceCount() == 1) {
  254.             CCLOG("GX: ResourceCache: removing unused data: %s", it->first.c_str());
  256.             tex->release();
  257.             _resources.erase(it++);
  258.         }
  259.         else {
  260.             ++it;
  261.         }
  262.     }
  264.     _textureCache->removeUnusedTextures();
  265. }
  267. bool ResourceCache::removeResource(void* data)
  268. {
  269.     return false;
  270. }
  272. bool ResourceCache::removeResourceForKey(const std::string& key)
  273. {
  274.     auto it = _resources.find(key);
  276.     if (it == _resources.end()) {
  277.         std::string fullpath = FileUtils::getInstance()->fullPathForFilename(key);
  278.         it = _resources.find(fullpath);
  279.     }
  281.     if (it == _resources.end()) {
  282.         _textureCache->removeTextureForKey(key);
  283.         return true;
  284.     }
  285.     else {
  286.         if (!_resources.empty()) {
  287.             (it->second)->release();
  288.             _resources.erase(it);
  289.             return true;
  290.         }
  292.     }
  294.     return false;
  295. }
  297. void ResourceCache::addResourceProtocol(ResourceProtocol* data)
  298. {
  299.     if (_resourceTemplate.find(data->getType()) == _resourceTemplate.end()) {
  300.         _resourceTemplate.insert(std::make_pair(data->getType(), data));
  301.     }
  302. }

ResourceProtocol

ResourceProtocol.h

  1. #ifndef __RESOURCEPROTOCOL_H__
  2. #define __RESOURCEPROTOCOL_H__
  4. #include "cocos2d.h"
  6. /**
  7. * 自定义数据类型
  8. */
  9. class ResourceProtocol : public cocos2d::Ref {
  11. public:
  12.     ResourceProtocol() {};
  13.     virtual ~ResourceProtocol() {};
  15. public:
  17.     virtual const std::string& getType() const = 0;
  19.     //返回一个空数据的实例，用于创建数据实例
  20.     virtual ResourceProtocol* cloneEmpty() const = 0;
  22.     //必须实现加载数据到内存方式
  23.     virtual bool loadWithFile(const std::string& filename) = 0;
  24. };
  26. #endif

JsonData

JsonData.h

  1. #ifndef __JSONDATA_H__
  2. #define __JSONDATA_H__
  4. #include "ResourceProtocol.h"
  5. #include "json\rapidjson.h"
  7. class JsonData : public ResourceProtocol {
  8. public:
  9.     JsonData();
  10.     ~JsonData();
  12.     const std::string& getType() const override
  13.     {
  14.         return TYPE;
  15.     };
  17.     ResourceProtocol* cloneEmpty() const override;
  18.     bool loadWithFile(const std::string& filename) override;
  20. public:
  21.     static std::string TYPE;
  22.     rapidjson::Document data;
  23. };
  25. #endif /* defined(__JsonData__) */

JsonData.cpp

  1. #include "JsonData.h"
  3. using namespace std;
  4. USING_NS_CC;
  6. std::string JsonData::TYPE = "JsonData";
  8. JsonData::JsonData()
  9. {
  11. }
  13. JsonData::~JsonData()
  14. {
  16. }
  18. ResourceProtocol* JsonData::cloneEmpty() const
  19. {
  20.     return new JsonData();
  21. }
  23. bool JsonData::loadWithFile(const std::string& filename)
  24. {
  25.     bool bRet = false;
  26.     do {
  27.         std::string jsonpath = cocos2d::FileUtils::getInstance()->fullPathForFilename(filename);
  28.         std::string contentStr = cocos2d::FileUtils::getInstance()->getStringFromFile(jsonpath);
  29.         data.Parse<0>(contentStr.c_str());
  30.         CC_BREAK_IF(data.HasParseError());
  31.         bRet = true;
  32.     }
  33.     while (0);
  34.     return bRet;
  35. }