Texture.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "Forward.hpp"
#include "CeresEngine/RenderAPI/Forward.hpp"
 
#include "Bitmap.hpp"
#include "TextureFormat.hpp"
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
 
#include "CeresEngine/Math/Extent.hpp"
#include "CeresEngine/Resource/Resource.hpp"
 
namespace CeresEngine {
 
    using BitmapResource = ResourceObject<Bitmap>;
 
    using HBitmap = ResourceHandle<BitmapResource>;
 
    enum class TextureType {
        Texture1D,
 
        Texture2D,
 
        Texture3D,
 
        TextureCube,
    };
 
    struct TextureProperties final {
        TextureType type = TextureType::Texture2D;
 
        Format format = Format::RGBA8UNorm;
 
        TExtent3<UInt32> extent = {1, 1, 1};
 
        CE_SCRIPT_EXPORT()
        UInt32 arrayLayers = 1;
 
        CE_SCRIPT_EXPORT()
        UInt32 mipLevels = 1;
    };
 
    using TexturePixelStream = ResourceInputStream;
 
    class Texture : public TResource<Texture> {
        using super = TResource<Texture>;
        CE_META_CLASS_FRIEND(Texture);
 
    protected:
        TextureProperties mProperties;
 
    public:
        using super::super;
 
        explicit Texture(const TextureProperties& properties);
 
        explicit Texture(ResourceData& resourceData, const TextureProperties& properties);
 
        ~Texture() noexcept override;
        
    public:
        [[nodiscard]] bool isStreaming() const noexcept;
 
    public:
        [[nodiscard]] const TextureProperties& getProperties() const noexcept { return mProperties; }
 
        [[nodiscard]] const TExtent3<UInt32>& getExtent() const noexcept { return mProperties.extent; }
 
        [[nodiscard]] Format getFormat() const noexcept { return mProperties.format; }
 
    public:
        [[nodiscard]] virtual Async<Bitmap> getBitmap(UInt32 layer = 0, UInt32 mip = 0) const = 0;
 
        virtual Async<> setBitmap(const Bitmap& bitmap, UInt32 layer = 0, UInt32 mip = 0) = 0;
    };
 
    class MemoryTexture final : public TResource<MemoryTexture, Texture> {
        using super = TResource<MemoryTexture, Texture>;
        CE_META_CLASS_FRIEND(MemoryTexture);
 
    public: // Resource data
        struct MipData {
            SPtr<Bitmap> bitmap = nullptr;
        };
 
        struct LayerData {
            Vector<MipData> mips;
        };
 
    private:
        Vector<LayerData> mLayers;
 
    public:
        using super::super;
 
        explicit MemoryTexture(TExtent3<UInt32> extent, Format format = Format::RGBA8UNorm);
 
        explicit MemoryTexture(const Bitmap& bitmap);
 
    public:
        [[nodiscard]] Async<Bitmap> getBitmap(UInt32 layer = 0, UInt32 mip = 0) const override;
 
        Async<> setBitmap(const Bitmap& bitmap, UInt32 layer = 0, UInt32 mip = 0) override;
    };
 
    class StreamingTexture final : public TResource<StreamingTexture, Texture> {
        using super = TResource<StreamingTexture, Texture>;
        CE_META_CLASS_FRIEND(StreamingTexture);
 
    public: // Streaming data
        struct MipData {
            Format format = Format::RGBA8UInt;
 
            BitmapExtent extents;
 
            SPtr<HResourceStream> stream;
        };
 
        struct LayerData {
//            Bitmap preview;
 
            Vector<MipData> mips;
        };
 
    private:
        Vector<LayerData> mLayers;
 
    public:
        using super::super;
 
        explicit StreamingTexture(ResourceData& resourceData, TExtent3<UInt32> extent, Format format = Format::RGBA8UNorm);
 
        explicit StreamingTexture(ResourceData& resourceData, const Bitmap& bitmap);
 
        explicit StreamingTexture(ResourceData& resourceData, const Texture& other);
 
    public:
        [[nodiscard]] Async<Bitmap> getBitmap(UInt32 layer = 0, UInt32 mip = 0) const override;
 
        Async<> setBitmap(const Bitmap& bitmap, UInt32 layer = 0, UInt32 mip = 0) override;
 
        [[nodiscard]] Async<TexturePixelStream> getPixelStream(UInt32 layer = 0, UInt32 mip = 0) const;
    };
 
    class GPUTexture final : public TResource<GPUTexture, Texture> {
        using super = TResource<GPUTexture, Texture>;
        CE_META_CLASS_FRIEND(GPUTexture);
 
    private:
        GPUImagePtr mImage;
 
    public:
        using super::super;
 
        explicit GPUTexture(const GPUImagePtr& image);
 
    public:
        [[nodiscard]] const GPUImagePtr& getImage() const noexcept { return mImage; }
 
    public:
        [[nodiscard]] Async<Bitmap> getBitmap(UInt32 layer = 0, UInt32 mip = 0) const override;
 
        Async<> setBitmap(const Bitmap& bitmap, UInt32 layer = 0, UInt32 mip = 0) override;
    };
 
} // namespace CeresEngine