CUFontLoader.h

//
//  CUFontLoader.h
//  Cornell University Game Library (CUGL)
//
//  This module provides a specific implementation of the Loader class to load
//  fonts. A font asset is identified by both its source file and its size.
//  The size is required as load time.  Hence you may wish to load the same
//  font file several times.
//
//  As with all of our loaders, this loader is designed to be attached to an
//  asset manager.  In addition, this class uses our standard shared-pointer
//  architecture.
//
//  1. The constructor does not perform any initialization; it just sets all
//     attributes to their defaults.
//
//  2. All initialization takes place via init methods, which can fail if an
//     object is initialized more than once.
//
//  3. All allocation takes place via static constructors which return a shared
//     pointer.
//
//
//  CUGL zlib License:
//      This software is provided 'as-is', without any express or implied
//      warranty.  In no event will the authors be held liable for any damages
//      arising from the use of this software.
//
//      Permission is granted to anyone to use this software for any purpose,
//      including commercial applications, and to alter it and redistribute it
//      freely, subject to the following restrictions:
//
//      1. The origin of this software must not be misrepresented; you must not
//      claim that you wrote the original software. If you use this software
//      in a product, an acknowledgment in the product documentation would be
//      appreciated but is not required.
//
//      2. Altered source versions must be plainly marked as such, and must not
//      be misrepresented as being the original software.
//
//      3. This notice may not be removed or altered from any source distribution.
//
//  Author: Walker White
//  Version: 1/7/16
//
#ifndef __CU_FONT_LOADER_H__
#define __CU_FONT_LOADER_H__
#include <cugl/assets/CULoader.h>
#include <cugl/2d/CUFont.h>

namespace cugl {
    
class FontLoader : public Loader<Font> {
private:
    CU_DISALLOW_COPY_AND_ASSIGN(FontLoader);
    
protected:
    int _fontsize;
    std::string _charset;
    
#pragma mark Asset Loading

    std::shared_ptr<Font> preload(const std::string& source, const std::string& charset, int size);
    
    void materialize(const std::string& key, const std::shared_ptr<Font>& font, LoaderCallback callback);
    
    bool read(const std::string& key, const std::string& source,
              LoaderCallback callback, bool async) override {
        return read(key,source,_fontsize,callback,async);
    }

    bool read(const std::string& key, const std::string& source, int size,
              LoaderCallback callback, bool async);

    bool read(const std::shared_ptr<JsonValue>& json, LoaderCallback callback, bool async) override;
    
    
public:
#pragma mark -
#pragma mark Constructors

    FontLoader();
    
    void dispose() override {
        _assets.clear();
        _loader = nullptr;
    }

    static std::shared_ptr<FontLoader> alloc() {
        std::shared_ptr<FontLoader> result = std::make_shared<FontLoader>();
        return (result->init() ? result : nullptr);
    }
    
    static std::shared_ptr<FontLoader> alloc(const std::shared_ptr<ThreadPool>& threads) {
        std::shared_ptr<FontLoader> result = std::make_shared<FontLoader>();
        return (result->init(threads) ? result : nullptr);
    }
    
#pragma mark -
#pragma mark Loading Interface

    bool load(const std::string& key, const std::string& source, int size) {
        return read(key, source, size, nullptr, false);
    }

    bool load(const char* key, const std::string& source, int size) {
        return read(std::string(key), source, size, nullptr, false);
    }

    bool load(const std::string& key, const char* source, int size) {
        return read(key, std::string(source), size, nullptr, false);
    }

    bool load(const char* key, const char* source, int size) {
        return read(std::string(key), std::string(source), size, nullptr, false);
    }

    void loadAsync(const std::string& key, const std::string& source, int size,
                   LoaderCallback callback) {
        read(key, source, size, callback, true);
    }

    void loadAsync(const char* key, const std::string& source, int size,
                   LoaderCallback callback) {
        read(std::string(key), source, size, callback, true);
    }

    void loadAsync(const std::string& key, const char* source, int size,
                   LoaderCallback callback) {
        read(key, std::string(source), size, callback, true);
    }

    void loadAsync(const char* key, const char* source, int size,
                   LoaderCallback callback) {
        read(std::string(key), std::string(source), size, callback, true);
    }
    
#pragma mark -
#pragma mark Properties

    float getFontSize() const    { return _fontsize; }
    
    void setDefaultSize(float size) { _fontsize = size; }

    const std::string& getCharacterSet() const { return _charset; }
    
    void setCharacterSet(const std::string& charset) { _charset = charset; }
};

}

#endif /* __CU_FONT_LOADER_H__ */