CUFontLoader.h

//
//  CUFontLoader.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a specific implementation of the Loader class to load
//  True Type fonts. Because of how Cocos2D renders fonts, a font is defined by
//  both its source file and its size.  Fonts of different size are always
//  different fonts.
//
//  As with all of our loaders, this loader is designed to be attached to a scene.
//  This is the natural was to do things, as Cocos2d is scene based.  However,
//  its asset loading is typically done through the director, which is global.
//  This makes is hard to determine when it is safe to unload an asset.  Even
//  though the current scene many not need it, it may be used by another active
//  scene. Unloading the asset would corrupt that scene.
//
//  This loader solves this problem by have a static coordinator behind the
//  scenes.  This coordinate is shared across all loader instances.  It decides
//  When an asset is truly ready to be unloaded.
//
//  Author: Walker White
//  Version: 12/10/15
//
#ifndef __CU_FONT_LOADER__
#define __CU_FONT_LOADER__
#include <unordered_set>
#include <mutex>
#include "CULoader.h"
#include "CUTTFont.h"
#include "CUThreadPool.h"


NS_CC_BEGIN

#define DEFAULT_SIZE 12.0f

class CC_DLL FontLoader : public Loader<TTFont> {
private:
    CC_DISALLOW_COPY_AND_ASSIGN(FontLoader);
    
protected:
#pragma mark -
#pragma mark Font Coordinator

    class Coordinator {
    private:
        std::unordered_map<std::string,TTFont*> _objects;
        std::unordered_map<std::string, int> _refcnts;
        std::unordered_map<std::string,std::vector<std::function<void(TTFont* s)>>> _callbacks;
        
        ThreadPool* _threads;
        std::mutex _mutex;
        
    public:
        size_t instances;
        
        Coordinator();
        
        ~Coordinator();
        
        bool isLoaded(std::string id)  const { return _objects.find(id) != _objects.end(); }
        
        bool isPending(std::string id) const { return _callbacks.find(id) != _callbacks.end(); }
        
        
#pragma mark Allocation Methods

        TTFont* load(std::string source, float size);
        
        void loadAsync(std::string source, float size, std::function<void(TTFont* s)> callback);
        
        TTFont* allocateSync(TTFont* texture);

        void allocateAsync(TTFont* texture, FontAtlas* atlas);

        void release(TTFont* font);
    };
    
    static Coordinator* _gCoordinator;
    
#pragma mark -
#pragma mark Font Loader

    float _default;
    
    std::unordered_set<std::string> _fqueue;
    
    void allocate(std::string key, TTFont* font);
    
    
public:
#pragma mark Activation/Deactivation

    static FontLoader* create();
    
    void start() override;
    
    void stop() override;
    
    
#pragma mark Loading/Unloading

    size_t waitCount() const override { return _fqueue.size(); }
    
    TTFont* load(std::string key, std::string source) override { return load(key,source,_default); }
    
    TTFont* load(std::string key, std::string source, float size);
    
    void loadAsync(std::string key, std::string source) override { loadAsync(key,source,_default); }
    
    void loadAsync(std::string key, std::string source, float size);
    
    void unload(std::string key) override;
    
    void unloadAll() override;
    
    
#pragma mark Default Parameters

    float getDefaultSize() const    { return _default; }
    
    void setDefaultSize(float size) { _default = size; }
    
    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    FontLoader() : Loader<TTFont>(), _default(DEFAULT_SIZE) {}
    
    virtual ~FontLoader() { if (_active) { stop(); } }
    
};

NS_CC_END

#endif /* defined(__CU_FONT_LOADER__) */