Texture.hpp

Go to the documentation of this file.

#ifndef DONUT_GRAPHICS_TEXTURE_HPP
#define DONUT_GRAPHICS_TEXTURE_HPP
 
#include <donut/Color.hpp>
#include <donut/UniqueHandle.hpp>
#include <donut/graphics/Handle.hpp>
#include <donut/graphics/Image.hpp>
#include <donut/math.hpp>
 
#include <cstddef>  // std::size_t
#include <cstdint>  // std::int32_t
#include <optional> // std::optional
 
namespace donut::graphics {
 
class Renderer; // Forward declaration, to avoid a circular include of Renderer.hpp.
 
enum class TextureFormat : std::int32_t {
    R8_UNORM = 0x8229,           
    R16_FLOAT = 0x822D,          
    R32_FLOAT = 0x822E,          
    R8G8_UNORM = 0x822B,         
    R16G16_FLOAT = 0x822F,       
    R32G32_FLOAT = 0x8230,       
    R8G8B8_UNORM = 0x8051,       
    R16G16B16_FLOAT = 0x881B,    
    R32G32B32_FLOAT = 0x8815,    
    R8G8B8A8_UNORM = 0x8058,     
    R16G16B16A16_FLOAT = 0x881A, 
    R32G32B32A32_FLOAT = 0x8814, 
};
 
struct TextureOptions {
    bool repeat = true;
 
    bool useLinearFiltering = true;
 
    bool useMipmap = true;
};
 
class Texture {
public:
    static const Texture* const TRANSPARENT;
 
    static const Texture* const BLACK;
 
    static const Texture* const WHITE;
 
    static const Texture* const DEFAULT_SPECULAR;
 
    static const Texture* const DEFAULT_NORMAL;
 
    [[nodiscard]] static std::size_t getChannelCount(TextureFormat internalFormat) noexcept;
 
    [[nodiscard]] static PixelFormat getPixelFormat(TextureFormat internalFormat) noexcept;
 
    [[nodiscard]] static PixelComponentType getPixelComponentType(TextureFormat internalFormat) noexcept;
 
    [[nodiscard]] static TextureFormat getInternalFormat(PixelFormat pixelFormat, PixelComponentType pixelComponentType) noexcept;
 
    Texture() noexcept = default;
 
    Texture(TextureFormat internalFormat, std::size_t width, std::size_t height, PixelFormat pixelFormat, PixelComponentType pixelComponentType, const void* pixels,
        const TextureOptions& options = {});
 
    Texture(TextureFormat internalFormat, std::size_t width, std::size_t height, std::size_t depth, PixelFormat pixelFormat, PixelComponentType pixelComponentType,
        const void* pixels, const TextureOptions& options = {});
 
    Texture(TextureFormat internalFormat, std::size_t width, std::size_t height, const TextureOptions& options = {});
 
    Texture(TextureFormat internalFormat, std::size_t width, std::size_t height, std::size_t depth, const TextureOptions& options = {});
 
    Texture(const ImageView& image, const TextureOptions& options = {});
 
    explicit operator bool() const noexcept {
        return static_cast<bool>(texture);
    }
 
    void setOptions2D(const TextureOptions& newOptions);
 
    void setOptions2DArray(const TextureOptions& newOptions);
 
    void pasteImage2D(std::size_t width, std::size_t height, PixelFormat pixelFormat, PixelComponentType pixelComponentType, const void* pixels, std::size_t x, std::size_t y);
 
    void pasteImage2D(const ImageView& image, std::size_t x, std::size_t y);
 
    void pasteImage2DArray(std::size_t width, std::size_t height, std::size_t depth, PixelFormat pixelFormat, PixelComponentType pixelComponentType, const void* pixels,
        std::size_t x, std::size_t y, std::size_t z);
 
    void pasteImage2DArray(const ImageView& image, std::size_t x, std::size_t y, std::size_t z);
 
    void fill2D(Renderer& renderer, Color color);
 
    void grow2D(Renderer& renderer, std::size_t newWidth, std::size_t newHeight, std::optional<Color> backgroundColor = {});
 
    [[nodiscard]] Texture copy2D(Renderer& renderer) const;
 
    [[nodiscard]] Texture copyGrow2D(Renderer& renderer, std::size_t newWidth, std::size_t newHeight, std::optional<Color> backgroundColor = {}) const;
 
    [[nodiscard]] vec2 getSize2D() const noexcept {
        return {static_cast<float>(width), static_cast<float>(height)};
    }
 
    [[nodiscard]] TextureFormat getInternalFormat() const noexcept {
        return internalFormat;
    }
 
    [[nodiscard]] std::size_t getWidth() const noexcept {
        return width;
    }
 
    [[nodiscard]] std::size_t getHeight() const noexcept {
        return height;
    }
 
    [[nodiscard]] const TextureOptions& getOptions() const noexcept {
        return options;
    }
 
    [[nodiscard]] Handle get() const noexcept {
        return texture.get();
    }
 
private:
    friend Renderer;
 
    static void createSharedTextures();
    static void destroySharedTextures() noexcept;
 
    struct TextureDeleter {
        void operator()(Handle handle) const noexcept;
    };
 
    UniqueHandle<Handle, TextureDeleter> texture{};
    std::size_t width = 0;
    std::size_t height = 0;
    TextureFormat internalFormat = TextureFormat::R8_UNORM;
    TextureOptions options{};
};
 
} // namespace donut::graphics
 
#endif