Refactor SpriteFrameCache to use uint64_t as map key (#2444)

Author: halx99

core/2d/SpriteFrame.h

@@ -39,7 +39,7 @@ namespace ax
 {
 
 class Texture2D;
-
+class SpriteFrameCache;
 /**
  * @addtogroup _2d
  * @{
@@ -60,6 +60,8 @@ class Texture2D;
  */
 class AX_DLL SpriteFrame : public Object, public Clonable
 {
+    friend class SpriteFrameCache;
+
 public:
     /** Create a SpriteFrame with a texture filename, rect in points.
      It is assumed that the frame was not trimmed.
@@ -302,7 +304,12 @@ class AX_DLL SpriteFrame : public Object, public Clonable
                                  const Vec2& offset,
                                  const Vec2& originalSize);
 
+    // @since axmol-2.5.0
+    std::string_view getName() { return _name; }
+
 protected:
+    void setName(std::string_view name) { _name = name; }
+    
     Vec2 _offset;
     Vec2 _anchorPoint;
     Vec2 _originalSize;
@@ -313,6 +320,7 @@ class AX_DLL SpriteFrame : public Object, public Clonable
     Vec2 _offsetInPixels;
     Vec2 _originalSizeInPixels;
     Texture2D* _texture;
+    std::string _name;
     std::string _textureFilename;
     PolygonInfo _polygonInfo;
 };

core/2d/SpriteFrameCache.cpp

@@ -41,6 +41,7 @@ THE SOFTWARE.
 #include "base/Director.h"
 #include "renderer/Texture2D.h"
 #include "base/NinePatchImageParser.h"
+#include "xxhash.h"
 
 using namespace std;
 
@@ -49,6 +50,11 @@ namespace ax
 
 static SpriteFrameCache* _sharedSpriteFrameCache = nullptr;
 
+static uint64_t computeHash(const std::string_view& v)
+{
+    return XXH64(v.data(), v.length(), 0);
+}
+
 SpriteFrameCache* SpriteFrameCache::getInstance()
 {
     if (!_sharedSpriteFrameCache)
@@ -121,15 +127,16 @@ void SpriteFrameCache::addSpriteFramesWithFileContent(const Data& content,
 
 bool SpriteFrameCache::isSpriteFramesWithFileLoaded(std::string_view plist) const
 {
-    return isSpriteSheetInUse(plist) && isPlistFull(plist);
+    auto sheetId = computeHash(plist);
+    return isSpriteSheetInUse(sheetId) && isPlistFull(sheetId);
 }
 
 void SpriteFrameCache::addSpriteFrame(SpriteFrame* frame, std::string_view frameName)
 {
     AXASSERT(frame, "frame should not be nil");
 
-    const std::string name = "by#addSpriteFrame()";
-    auto&& itr             = _spriteSheets.find(name);
+    const auto name = computeHash("by#addSpriteFrame()");
+    auto&& itr      = _spriteSheets.find(name);
     if (itr != _spriteSheets.end())
     {
         insertFrame(itr->second, frameName, frame);
@@ -150,7 +157,7 @@ void SpriteFrameCache::removeSpriteFrames()
 void SpriteFrameCache::removeUnusedSpriteFrames()
 {
     auto removed = false;
-    std::vector<std::string_view> toRemoveFrames;
+    std::vector<uint64_t> toRemoveFrames;
 
     const auto& frames = getSpriteFrames();
     for (auto&& iter : frames)
@@ -173,13 +180,13 @@ void SpriteFrameCache::removeUnusedSpriteFrames()
 
 void SpriteFrameCache::removeUnusedSpriteSheets()
 {
-    std::vector<std::string_view> willRemoveSpriteSheetFileNames;
+    std::vector<uint64_t> willRemoveSpriteSheetFileNames;
     for (auto&& it : _spriteSheets)
     {
         bool isUsed = false;
         for (auto&& frame : it.second->frames)
         {
-            auto spriteFrame = getSpriteFrameByName(frame);
+            auto spriteFrame = findFrame(frame);
             if (spriteFrame && spriteFrame->getReferenceCount() > 1)
             {
                 isUsed = true;
@@ -191,10 +198,10 @@ void SpriteFrameCache::removeUnusedSpriteSheets()
             willRemoveSpriteSheetFileNames.push_back(it.first);
     }
 
-    for (auto& spriteSheetFileName : willRemoveSpriteSheetFileNames)
+    for (auto& sheetId : willRemoveSpriteSheetFileNames)
     {
-        AXLOGD("SpriteFrameCache: removing unused sprite sheet file : {}", spriteSheetFileName);
-        removeSpriteSheet(spriteSheetFileName);
+        AXLOGD("SpriteFrameCache: removing unused sprite sheet file : {}", sheetId);
+        removeSpriteSheet(sheetId);
     }
 }
 
@@ -219,7 +226,7 @@ void SpriteFrameCache::removeSpriteFramesFromFile(std::string_view atlasPath)
     // removeSpriteFramesFromDictionary(dict);
 
     // remove it from the cache
-    removeSpriteSheet(atlasPath);
+    removeSpriteSheet(computeHash(atlasPath));
 }
 
 void SpriteFrameCache::removeSpriteFramesFromFileContent(std::string_view plist_content)
@@ -240,13 +247,14 @@ void SpriteFrameCache::removeSpriteFramesFromDictionary(ValueMap& dictionary)
         return;
 
     const auto& framesDict = dictionary["frames"].asValueMap();
-    std::vector<std::string_view> keysToRemove;
+    std::vector<uint64_t> keysToRemove;
 
     for (const auto& iter : framesDict)
     {
-        if (findFrame(iter.first))
+        auto frameId = computeHash(iter.first);
+        if (findFrame(frameId))
         {
-            keysToRemove.emplace_back(iter.first);
+            keysToRemove.emplace_back(frameId);
         }
     }
 
@@ -255,7 +263,7 @@ void SpriteFrameCache::removeSpriteFramesFromDictionary(ValueMap& dictionary)
 
 void SpriteFrameCache::removeSpriteFramesFromTexture(Texture2D* texture)
 {
-    std::vector<std::string_view> keysToRemove;
+    std::vector<uint64_t> keysToRemove;
 
     for (auto&& iter : getSpriteFrames())
     {
@@ -282,19 +290,18 @@ SpriteFrame* SpriteFrameCache::getSpriteFrameByName(std::string_view name)
 bool SpriteFrameCache::reloadTexture(std::string_view spriteSheetFileName)
 {
     AXASSERT(!spriteSheetFileName.empty(), "plist filename should not be nullptr");
-
-    const auto spriteSheetItr = _spriteSheets.find(spriteSheetFileName);
+    auto sheetId              = computeHash(spriteSheetFileName);
+    const auto spriteSheetItr = _spriteSheets.find(sheetId);
     if (spriteSheetItr == _spriteSheets.end())
     {
         return false;  // Sprite sheet wasn't loaded, so don't reload it
     }
 
     const auto format = spriteSheetItr->second->format;
 
-    if (isSpriteSheetInUse(spriteSheetFileName))
+    if (isSpriteSheetInUse(sheetId))
     {
-        removeSpriteSheet(
-            spriteSheetFileName);  // we've removed the associated entry, so spriteSheetItr is no longer valid
+        removeSpriteSheet(sheetId);  // we've removed the associated entry, so spriteSheetItr is no longer valid
     }
     else
     {
@@ -314,28 +321,35 @@ void SpriteFrameCache::insertFrame(const std::shared_ptr<SpriteSheet>& spriteShe
                                    std::string_view frameName,
                                    SpriteFrame* spriteFrame)
 {
-    spriteSheet->frames.emplace(frameName);
-    _spriteFrames.insert(frameName, spriteFrame);  // add SpriteFrame
-    _spriteSheets[spriteSheet->path] = spriteSheet;
-    hlookup::set_item(_spriteFrameToSpriteSheetMap, frameName,
-                      spriteSheet);  // _spriteFrameToSpriteSheetMap[frameName] = spriteSheet;  // insert
-                                     // index frameName->plist
+    auto frameId = computeHash(frameName);
+    spriteFrame->setName(frameName);
+    spriteSheet->frames.emplace(frameId);
+    _spriteFrames.insert(frameId, spriteFrame);  // add SpriteFrame
+    if (spriteSheet->pathId == (uint64_t)-1)
+        spriteSheet->pathId = computeHash(spriteSheet->path);
+    hlookup::set_item(_spriteSheets, spriteSheet->pathId, spriteSheet);
+    hlookup::set_item(_spriteFrameToSpriteSheetMap, frameId, spriteSheet);
 }
 
 bool SpriteFrameCache::eraseFrame(std::string_view frameName)
+{
+    return eraseFrame(computeHash(frameName));
+}
+
+bool SpriteFrameCache::eraseFrame(uint64_t frameId)
 {
     // drop SpriteFrame
-    const auto itFrame = _spriteFrameToSpriteSheetMap.find(frameName);
-    bool found = itFrame != _spriteFrameToSpriteSheetMap.end();
+    const auto itFrame = _spriteFrameToSpriteSheetMap.find(frameId);
+    bool found         = itFrame != _spriteFrameToSpriteSheetMap.end();
     if (found)
     {
         auto& spriteSheet = itFrame->second;
         spriteSheet->full = false;
-        spriteSheet->frames.erase(frameName);
+        spriteSheet->frames.erase(frameId);
 
         if (spriteSheet->frames.empty())
         {
-            _spriteSheets.erase(spriteSheet->path);
+            _spriteSheets.erase(computeHash(spriteSheet->path));
         }
 
         _spriteFrameToSpriteSheetMap.erase(itFrame);  // update index frame->plist
@@ -346,11 +360,11 @@ bool SpriteFrameCache::eraseFrame(std::string_view frameName)
         //    _spriteSheets.clear();
         //}
     }
-    _spriteFrames.erase(frameName);
+    _spriteFrames.erase(frameId);
     return found;
 }
 
-bool SpriteFrameCache::eraseFrames(const std::vector<std::string_view>& frames)
+bool SpriteFrameCache::eraseFrames(const std::vector<uint64_t>& frames)
 {
     auto ret = false;
     for (const auto& frame : frames)
@@ -361,9 +375,9 @@ bool SpriteFrameCache::eraseFrames(const std::vector<std::string_view>& frames)
     return ret;
 }
 
-bool SpriteFrameCache::removeSpriteSheet(std::string_view spriteSheetFileName)
+bool SpriteFrameCache::removeSpriteSheet(uint64_t sheetId)
 {
-    auto it = _spriteSheets.find(spriteSheetFileName);
+    auto it = _spriteSheets.find(sheetId);
     if (it == _spriteSheets.end())
         return false;
 
@@ -375,7 +389,7 @@ bool SpriteFrameCache::removeSpriteSheet(std::string_view spriteSheetFileName)
         _spriteFrames.erase(f);
         _spriteFrameToSpriteSheetMap.erase(f);  // erase plist frame frameName->plist
     }
-    _spriteSheets.erase(spriteSheetFileName);  // update index plist->[frameNames]
+    _spriteSheets.erase(sheetId);  // update index plist->[frameNames]
 
     return true;
 }
@@ -387,40 +401,28 @@ void SpriteFrameCache::clear()
     _spriteFrames.clear();
 }
 
-bool SpriteFrameCache::hasFrame(std::string_view frame) const
+bool SpriteFrameCache::isSpriteSheetInUse(uint64_t sheetId) const
 {
-    return _spriteFrameToSpriteSheetMap.find(frame) != _spriteFrameToSpriteSheetMap.end();
-}
-
-bool SpriteFrameCache::isSpriteSheetInUse(std::string_view spriteSheetFileName) const
-{
-    const auto spriteSheetItr = _spriteSheets.find(spriteSheetFileName);
+    const auto spriteSheetItr = _spriteSheets.find(sheetId);
     return spriteSheetItr != _spriteSheets.end() && !spriteSheetItr->second->frames.empty();
 }
 
 SpriteFrame* SpriteFrameCache::findFrame(std::string_view frame)
 {
-    return _spriteFrames.at(frame);
+    return _spriteFrames.at(computeHash(frame));
 }
 
-std::string_view SpriteFrameCache::getSpriteFrameName(SpriteFrame* frame)
+SpriteFrame* SpriteFrameCache::findFrame(uint64_t frameId)
 {
-    for (auto& it : _spriteFrames)
-    {
-        if (it.second == frame)
-        {
-            return it.first;
-        }
-    }
-    return "";
+    return _spriteFrames.at(frameId);
 }
 
 void SpriteFrameCache::addSpriteFrameCapInset(SpriteFrame* spriteFrame, const Rect& capInsets, Texture2D* texture)
 {
     texture->addSpriteFrameCapInset(spriteFrame, capInsets);
 }
 
-StringMap<SpriteFrame*>& SpriteFrameCache::getSpriteFrames()
+const ax::Map<uint64_t, SpriteFrame*>& SpriteFrameCache::getSpriteFrames()
 {
     return _spriteFrames;
 }
@@ -457,4 +459,4 @@ ISpriteSheetLoader* SpriteFrameCache::getSpriteSheetLoader(uint32_t spriteSheetF
     return nullptr;
 }
 
-}
+}  // namespace ax

core/2d/SpriteFrameCache.h

@@ -249,7 +249,8 @@ class AX_DLL SpriteFrameCache
 
     SpriteFrame* findFrame(std::string_view frame);
 
-    std::string_view getSpriteFrameName(SpriteFrame* frame);
+    // @DEPRECATED, use frame->getName() instead
+    std::string_view getSpriteFrameName(SpriteFrame* frame) { return frame->getName(); }
 
     /**  Record SpriteFrame with plist and frame name, add frame name
      *    and plist to index
@@ -261,7 +262,7 @@ class AX_DLL SpriteFrameCache
     /** Delete frame from cache, rebuild index
      */
     bool eraseFrame(std::string_view frameName);
-
+    
     void addSpriteFrameCapInset(SpriteFrame* spriteFrame, const Rect& capInsets, Texture2D* texture);
 
     void registerSpriteSheetLoader(std::shared_ptr<ISpriteSheetLoader> loader);
@@ -273,45 +274,47 @@ class AX_DLL SpriteFrameCache
     // MARMALADE: Made this protected not private, as deriving from this class is pretty useful
     SpriteFrameCache() {}
 
+    SpriteFrame* findFrame(uint64_t frameId);
+    bool eraseFrame(uint64_t frameId);
+
     /** Removes multiple Sprite Frames from Dictionary.
      * @since v0.99.5
      */
     void removeSpriteFramesFromDictionary(ValueMap& dictionary);
 
     /** Delete a list of frames from cache, rebuild index
      */
-    bool eraseFrames(const std::vector<std::string_view>& frame);
+    bool eraseFrames(const std::vector<uint64_t>& frame);
     /** Delete frame from index and SpriteFrame is kept.
      */
-    bool removeSpriteSheet(std::string_view spriteSheetFileName);
+    bool removeSpriteSheet(uint64_t sheetId);
     /** Clear index and all SpriteFrames.
      */
     void clear();
 
-    inline bool hasFrame(std::string_view frame) const;
-    inline bool isSpriteSheetInUse(std::string_view spriteSheetFileName) const;
+    inline bool isSpriteSheetInUse(uint64_t sheetId) const;
 
-    inline StringMap<SpriteFrame*>& getSpriteFrames();
+    inline const ax::Map<uint64_t, SpriteFrame*>& getSpriteFrames();
 
-    void markPlistFull(std::string_view spriteSheetFileName, bool full)
+    void markPlistFull(uint64_t sheetId, bool full)
     {
         // _spriteSheets[spriteSheetFileName]->full = full;
-        auto it = _spriteSheets.find(spriteSheetFileName);
+        auto it = _spriteSheets.find(sheetId);
         if (it != _spriteSheets.end())
         {
             it.value()->full = full;
         }
     }
-    bool isPlistFull(std::string_view spriteSheetFileName) const
+    bool isPlistFull(uint64_t sheetId) const
     {
-        auto it = _spriteSheets.find(spriteSheetFileName);
-        return it == _spriteSheets.end() ? false : it->second->full;
+        auto it = _spriteSheets.find(sheetId);
+        return it != _spriteSheets.end() && it->second->full;
     }
 
 private:
-    StringMap<SpriteFrame*> _spriteFrames;
-    hlookup::string_map<std::shared_ptr<SpriteSheet>> _spriteSheets;
-    hlookup::string_map<std::shared_ptr<SpriteSheet>> _spriteFrameToSpriteSheetMap;
+    ax::Map<uint64_t, SpriteFrame*> _spriteFrames;
+    tsl::robin_map<uint64_t, std::shared_ptr<SpriteSheet>> _spriteSheets;
+    tsl::robin_map<uint64_t, std::shared_ptr<SpriteSheet>> _spriteFrameToSpriteSheetMap;
 
     std::map<uint32_t, std::shared_ptr<ISpriteSheetLoader>> _spriteSheetLoaders;
 };