tb_texture_manager.hpp

 
#ifndef TurtleBrains_TextureManager_hpp
#define TurtleBrains_TextureManager_hpp
 
#include <turtle_brains/core/tb_noncopyable.hpp>
#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_types.hpp>
#include <turtle_brains/core/tb_resource_handle.hpp>
 
#include <cstddef>
 
namespace TurtleBrains::Graphics
{
    namespace Implementation { class TextureManagerCreator; class TextureHandleSaver {}; }
 
 
    using TexelSpace = float;
 
    using PixelSpace = tbCore::uint16;
 
    using TextureHandle = TurtleBrains::Core::ResourceHandle<Implementation::TextureHandleSaver>;
 
    TextureHandle InvalidTexture(void);
 
    extern const TextureHandle& kBlankTexture;
 
    enum class TextureFormat : tbCore::uint8
    {
        ColorARGB8, 
 
        FloatRGB10A2,
        FloatR11G11B10,
        FloatARGB16, // <64 bits per pixel, colored texture with alpha, red, green, blue, channels each having 16 bit floats.
 
        Depth16,    
        Depth24,    
 
        Depth24_Stencil8,
 
        InvalidFormat,
    };
 
    enum class TextureWrapMode : tbCore::uint8
    {
        Repeat, 
        MirroredRepeat, 
        ClampToEdge 
    };
 
    enum class TextureFilter : tbCore::uint8
    {
        Closest,
        Linear,
        DepthCompare, 
    };
 
    class TextureManager : public tbCore::Noncopyable
    {
    public:
        static void PreMultiplyAlpha(tbCore::byte* imageData, const PixelSpace& imageWidth, const PixelSpace& imageHeight);
 
        TextureHandle CreateTextureFromFile(const String& filename, const bool mipmapped = true);
 
        TextureHandle CreateTextureFromFileData(const unsigned char* fileDataInMemory, const tbCore::uint32 fileSizeInBytes, const bool mipmapped = true);
 
        TextureHandle CreateTextureFromPixelData(const PixelSpace& textureWidth, const PixelSpace& textureHeight,
            const TextureFormat& format, const unsigned char* pixelData, const bool mipmapped = true);
 
        TextureHandle CreateTextureEmpty(const PixelSpace& textureWidth, const PixelSpace& textureHeight,
            const TextureFormat& format = TextureFormat::ColorARGB8);
 
        TextureHandle CreateTextureReference(const TextureHandle& textureHandle);
 
        void DestroyTexture(const TextureHandle& textureHandle);
 
        void BindTexture(const TextureHandle& textureHandle);
 
        void BindTexture(const TextureHandle& textureHandle, tbCore::uint8 textureUnit);
 
        PixelSpace GetTextureWidth(const TextureHandle& textureHandle) const;
 
        PixelSpace GetTextureHeight(const TextureHandle& textureHandle) const;
 
        void SetTextureWrapMode(const TextureHandle& textureHandle, TextureWrapMode wrapMode);
 
        void SetTextureWrapMode(const TextureHandle& textureHandle, TextureWrapMode wrapModeU, TextureWrapMode wrapModeV);
 
        void SetTextureFiltering(const TextureHandle& textureHandle, TextureFilter filter);
 
        void CheckAndReloadTextures(void);
 
        void Unstable_RunSoftwareShader(const TextureHandle& textureHandle, std::function<tbCore::uint32(PixelSpace x, PixelSpace y, tbCore::uint32)> shader);
 
        tbCore::uint64 ComputeMemoryUsage(void) const;
 
        void CreateGraphicsContext(void);
 
        void DestroyGraphicsContext(void);
 
    private:
        explicit TextureManager(void);
 
        ~TextureManager(void);
 
        friend class Implementation::TextureManagerCreator;
    };
 
    extern TextureManager& theTextureManager;
 
}; /* namespace TurtleBrains::Graphics */
 
namespace tbGraphics = TurtleBrains::Graphics;
 
#endif /* TurtleBrains_TextureManager_hpp */