Assets.h

/*

Copyright (c) 2018, Johnathan Corkery. (jcorkery@umich.edu)
All rights reserved.

This file is part of the Dynacoe project (https://github.com/jcorks/Dynacoe)
Dynacoe was released under the MIT License, as detailed below.



Permission is hereby granted, free of charge, to any person obtaining a copy 
of this software and associated documentation files (the "Software"), to deal 
in the Software without restriction, including without limitation the rights 
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 
copies of the Software, and to permit persons to whom the Software is furnished 
to do so, subject to the following conditions:

The above copyright notice and this permission notice shall
be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
DEALINGS IN THE SOFTWARE.



*/

#ifndef H_DASSETS_INCLUDED
#define H_DASSETS_INCLUDED




#include <Dynacoe/AssetID.h>
#include <Dynacoe/Modules/Module.h>
#include <Dynacoe/Modules/Console.h>

#include <vector>
#include <string>
#include <cctype>
#include <stack>
#include <unordered_map>
#include <map>






namespace Dynacoe {
class Image;
class Graphics;
class Particle;
class AudioBlock;
class Sequence;
class Particle;
class FontAsset;
class Decoder;
class Encoder;




class Asset {
    public:
        Asset(const std::string & n) : name{n}{}
        std::string GetAssetName() const {return name;}
        virtual ~Asset() = 0;
    private:
        std::string name;

};



class Assets : public Module {
  public:

    enum class Type {
        Placeholder,    
        Image,          
        Font,           
        Audio,          
        Sequence,       
        Particle,       
        RawData,        
        Model,          
        NoType
    };




    static AssetID Load(const std::string & fileType, const std::string & file, bool  nameOnly=true);


    static AssetID LoadFromBuffer(const std::string & filetype, const std::string & name, const std::vector<uint8_t> & data);


    static std::vector<std::string> SupportedLoadExtensions(Assets::Type type);

    static AssetID Query(Assets::Type type, const std::string & name);

    static AssetID New(Assets::Type type, const std::string & name = "");

    template<typename T>
    static T & Get(AssetID id);

    static bool    Remove(AssetID id);

    static bool    Write(AssetID id, const std::string & encoderExtension, const std::string & outputName);

    static std::vector<std::string> SupportedWriteExtensions(Assets::Type type);

    static std::string Name(AssetID type);






  private:
    friend class Graphics;

    static void notFoundError(Assets::Type, const std::string & name);
    static std::string typeToString(Assets::Type);

    static std::map<std::string, Decoder *> decoders;
    static std::vector<Asset *> errorInstances;
    static std::vector<std::map<std::string, Encoder *>> encoders;
    static AssetID storeGen(const std::string &, Asset *, Assets::Type);
    static void LoadDecoders();
    static void LoadDecoder(Decoder *);
    static Decoder * GetDecoder(const std::string &);
    static void LoadEncoders();
    static void LoadEncoder(Encoder *);
    static bool Encode(int, Asset *, const std::string & ext, const std::string &);

    // all storage buckets
    static std::vector<Asset *> assetList[AssetID::NUMTYPES];
    // zombie buckets of indices
    static std::stack<int> deadList[AssetID::NUMTYPES];
    static std::unordered_map<std::string, AssetID> assetMap[AssetID::NUMTYPES];
    static void storeSystemImages();


    //Attempts to store the image(s) specified by the 32-bit pixel buffer given.
    //
    // Hidden denotes whether
    // or not the compiled Image is stored in the standard image list or
    // the private System one.
    static AssetID storePixels(std::vector<uint32_t*> &, std::string ID, int w, int h, bool hidden);

    static Asset * CreateAsset(Type type, const std::string & str);

    // Dynacoe's Asset Registration Process

    // The string representing the data is
    // hashed and mapped to an index. The index
    // refers to where it is placed in the vector.
    //
    // Registration:
    //      - path is hashed to check is already existed        (O(path.length()))
    //      - if it does AND != -1,
    //                    then done.                            done
    //      - else,
    //          get the next immediate free index.
    //          - if !deadList.empty()                          (O(1))
    //              - then deadList.pop()                       (O(1))
    //              - use this index as the free index
    //              - chunkList[free index] = AudioBlock        (O(1))
    //          - else
    //              - chunkList.push_back(Asset)           (average = O(1), worst = O(n))
    //              - use size() - 1 as the free index
    //      - hash(path, free index)                            (O(path.length()))
    //      - return index
    // Retrieval (index)
    //      - if index < -1, retrun NULL
    //      - return chunkList[index]                           (O(1))
    // Retrieval (string)
    //      - if (hash(path) == DNE || -1) return NULL;         (O(path.length))
    //      - else return index
    // Removal
    //      - hash(string, -1);                                 (O(path.length())
    //      - deadList.push(old index);                         (O(1))
    //      - chunkList[old index] == NULL;                     (O(1))
    //      - * free data *                                     (worst = O(Asset.size())???)



    // Private Members








    static size_t assetCounter;








    // Private Methods


    static void initBase();
    /* Image storage */

    static std::string fSearch(const std::string &);









  public:
    std::string GetName() { return "Asset Manager"; }
    void Init(); void InitAfter(); void RunBefore(); void RunAfter(); void DrawBefore(); void DrawAfter();
    Backend * GetBackend();
};



template<typename T>
T & Assets::Get(AssetID id) {
    if (!id.Valid()) {
        Console::Error() << ("Error getting from cache: Non-existent ID\n");
        return *((T*)errorInstances[id.type]);
    }
    Asset * i;
    i = dynamic_cast<T*>(assetList[id.type][id.handle]);

    if (i) return *((T*)i);
    if (!assetList[id.type][id.handle])
        Console::Error() <<("Error getting from cache: Used deleted ID\n");
    else
        Console::Error() <<("Asset exists, but is a different type than the template given.\n");
    return *((T*)errorInstances[id.type]);
}

}



#endif