CUTextureLoader.h

//
//  CUTextureLoader.h
//  Cornell Extensions to Cocos2D
//
//  This module provides a specific implementation of the Loader class to load
//  textures. Technically, a texture should be identified by both its source
//  file and its texture parameters.  However, Cocos2D does not allow you to
//  to do that -- each texture can be only loaded once. Refactoring this would
//  be a lot more work than we are comfortable with.
//
//  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_TEXTURE_LOADER__
#define __CU_TEXTURE_LOADER__
#include <unordered_set>
#include <renderer/CCTexture2D.h>
#include "CULoader.h"

NS_CC_BEGIN

class CC_DLL TextureLoader : public Loader<Texture2D> {
private:
    CC_DISALLOW_COPY_AND_ASSIGN(TextureLoader);
    
protected:
#pragma mark -
#pragma mark Texture Coordinator

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

        Texture2D* load(std::string source);
        
        void loadAsync(std::string source, std::function<void(Texture2D* s)> callback);
        
        void allocate(Texture2D* texture, std::string source);
        
        void release(Texture2D* texture);
    };
    
    static Coordinator* _gCoordinator;
    
    
#pragma mark -
#pragma mark Texture Loader

    Texture2D::TexParams _default;
    
    std::unordered_set<std::string> _tqueue;
    
    void allocate(std::string key, Texture2D* texture, const Texture2D::TexParams& params);
    
    
public:
#pragma mark Activation/Deactivation

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

    size_t waitCount() const override { return _tqueue.size(); }
    
    Texture2D* load(std::string key, std::string source) override { return load(key,source,_default); }
    
    Texture2D* load(std::string key, std::string source, const Texture2D::TexParams& params);
    
    void loadAsync(std::string key, std::string source) override { loadAsync(key,source,_default); }

    void loadAsync(std::string key, std::string source, const Texture2D::TexParams& params);

    void unload(std::string key) override;
    
    void unloadAll() override;
    
    
#pragma mark Defaults

    const Texture2D::TexParams& getDefaultParameters() const        { return _default; }
    
    void setDefaultParameters(const Texture2D::TexParams& params)   { _default = params; }
    
    
CC_CONSTRUCTOR_ACCESS:
#pragma mark Initializers

    TextureLoader() : Loader<Texture2D>() {}
    
    virtual ~TextureLoader() { if (_active) { stop(); } }
};

NS_CC_END

#endif /* defined(__CU_TEXTURE_LOADER__) */