texture.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
 
#include "eu/base/size.h"
 
#include "eu/render/opengl_labels.h"
 
#include "eu/core/color.h"
 
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): 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 core::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 core::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);

 
}