texture.h

Go to the documentation of this file.

#pragma once
 
#include "base/size.h"
 
#include "render/opengl_labels.h"
 
#include <cstdint>
 
namespace eu::render
{
 
enum class TextureEdge
{
    clamp,
    repeat
};
 
 
enum class TextureRenderStyle
{
    pixel,
    mipmap,
    linear
};
 
 
enum class Transparency
{
    include,
    exclude
};
 
enum class ColorData
{
    color_data,
 
    // todo(Gustav): should this be more specific so we could define better default colors if the load fails?
    non_color_data,
 
    dont_care
};
 
// todo(Gustav): move to colors.h?
enum class SingleColor : std::uint32_t {};
 
constexpr SingleColor color_from_rgba(uint8_t r, uint8_t g, uint8_t b, uint8_t a) {
    return static_cast<SingleColor>((static_cast<uint32_t>(a) << 24) |
           (static_cast<uint32_t>(b) << 16) |
           (static_cast<uint32_t>(g) << 8)  |
           (static_cast<uint32_t>(r)));
}
 
// todo(Gustav): this doesn't do anything except allow code reuse, remove?
struct BaseTexture
{
    unsigned int id;
 
    BaseTexture();
    ~BaseTexture();
 
    BaseTexture(const BaseTexture&) = delete;
    void operator=(const BaseTexture&) = delete;
 
    BaseTexture(BaseTexture&&) noexcept;
    BaseTexture& operator=(BaseTexture&&) noexcept;
 
    void unload();
};
 
struct Texture2d : BaseTexture
{
    Texture2d() = delete;
 
    Texture2d(DEBUG_LABEL_ARG_MANY const void* pixel_data, unsigned int pixel_format, int w, int h, TextureEdge te, TextureRenderStyle trs, Transparency t, ColorData cd);
};
 
Texture2d load_image_from_color(DEBUG_LABEL_ARG_MANY SingleColor pixel, TextureEdge te, TextureRenderStyle trs, Transparency t, ColorData cd);
 
// todo(Gustav): turn into an enum?
constexpr std::size_t cubemap_size = 6;
 
struct TextureCubemap : BaseTexture
{
    TextureCubemap() = delete;
 
    TextureCubemap(DEBUG_LABEL_ARG_MANY const std::array<void*, cubemap_size>& pixel_data, int width, int height, ColorData cd);
};
 
TextureCubemap load_cubemap_from_color(DEBUG_LABEL_ARG_MANY SingleColor pixel, ColorData cd);
 
 
 
struct FrameBuffer : BaseTexture
{
    FrameBuffer(unsigned int f, const Size& s);
    ~FrameBuffer();
 
    FrameBuffer(const FrameBuffer&) = delete;
    FrameBuffer(FrameBuffer&&) = delete;
    void operator=(const FrameBuffer&) = delete;
    void operator=(FrameBuffer&&) = delete;
 
    Size size;
 
    unsigned int fbo = 0;
    unsigned int rbo = 0;
 
    bool debug_is_msaa = false;
};
 
enum class DepthBits
{
    use_none,
    use_16, use_24, use_32
};
 
enum class ColorBitsPerPixel
{
    use_depth,
    use_8, use_16, use_32
};
 
 
std::shared_ptr<FrameBuffer> build_simple_framebuffer(DEBUG_LABEL_ARG_MANY const Size& size);
 
 
std::shared_ptr<FrameBuffer> build_msaa_framebuffer(DEBUG_LABEL_ARG_MANY const Size& size, int msaa_samples, ColorBitsPerPixel bits_per_pixel);
 
 
std::shared_ptr<FrameBuffer> build_hdr_floating_framebuffer(DEBUG_LABEL_ARG_MANY const Size& size, ColorBitsPerPixel bits_per_pixel);
 
 
std::shared_ptr<FrameBuffer> build_shadow_framebuffer(DEBUG_LABEL_ARG_MANY const Size& size);
 
 
struct BoundFbo
{
    std::shared_ptr<FrameBuffer> fbo;
 
    BoundFbo(const BoundFbo&) = delete;
    BoundFbo(BoundFbo&&) = delete;
    void operator=(const BoundFbo&) = delete;
    void operator=(BoundFbo&&) = delete;
 
    explicit BoundFbo(std::shared_ptr<FrameBuffer> f);
    ~BoundFbo();
};
 
void resolve_multisampled_buffer(const FrameBuffer& src, FrameBuffer* dst);
 
}