image.hpp

Go to the documentation of this file.

/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#ifndef ANTKEEPER_GL_IMAGE_HPP
#define ANTKEEPER_GL_IMAGE_HPP
 
#include <engine/gl/format.hpp>
#include <engine/gl/image-flag.hpp>
#include <array>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <span>
 
namespace gl {
 
class image
{
public:
    virtual ~image() = 0;
    
    image(const image&) = delete;
    image(image&&) = delete;
    image& operator=(const image&) = delete;
    image& operator=(image&&) = delete;
    
    void read
    (
        std::uint32_t mip_level,
        std::uint32_t offset_x,
        std::uint32_t offset_y,
        std::uint32_t offset_z,
        std::uint32_t width,
        std::uint32_t height,
        std::uint32_t depth,
        gl::format format,
        std::span<std::byte> data
    ) const;
    
    void write
    (
        std::uint32_t mip_level,
        std::uint32_t offset_x,
        std::uint32_t offset_y,
        std::uint32_t offset_z,
        std::uint32_t width,
        std::uint32_t height,
        std::uint32_t depth,
        gl::format format,
        std::span<const std::byte> data
    );
    
    void copy
    (
        std::uint32_t src_mip_level,
        std::uint32_t src_x,
        std::uint32_t src_y,
        std::uint32_t src_z,
        image& dst_image,
        std::uint32_t dst_mip_level,
        std::uint32_t dst_x,
        std::uint32_t dst_y,
        std::uint32_t dst_z,
        std::uint32_t width,
        std::uint32_t height,
        std::uint32_t depth
    ) const;
    
    void generate_mipmaps();
    
    [[nodiscard]] inline constexpr std::uint8_t get_dimensionality() const noexcept
    {
        return m_dimensionality;
    }
    
    [[nodiscard]] inline constexpr bool is_1d() const noexcept
    {
        return m_dimensionality == 1;
    }
    
    [[nodiscard]] inline constexpr bool is_2d() const noexcept
    {
        return m_dimensionality == 2;
    }
    
    [[nodiscard]] inline constexpr bool is_3d() const noexcept
    {
        return m_dimensionality == 3;
    }
    
    [[nodiscard]] inline constexpr format get_format() const noexcept
    {
        return m_format;
    }
    
    [[nodiscard]] inline constexpr const std::array<std::uint32_t, 3>& get_dimensions() const noexcept
    {
        return m_dimensions;
    }
    
    [[nodiscard]] inline constexpr std::uint32_t get_mip_levels() const noexcept
    {
        return m_mip_levels;
    }
    
    [[nodiscard]] inline constexpr std::uint32_t get_array_layers() const noexcept
    {
        return m_array_layers;
    }
    
    [[nodiscard]] inline constexpr std::uint8_t get_flags() const noexcept
    {
        return m_flags;
    }
    
    [[nodiscard]] inline constexpr bool is_cube_compatible() const noexcept
    {
        return m_flags & std::to_underlying(image_flag::cube_compatible);
    }
    
protected:
    image
    (
        std::uint8_t dimensionality,
        gl::format format,
        std::uint32_t width,
        std::uint32_t height,
        std::uint32_t depth,
        std::uint32_t mip_levels,
        std::uint32_t array_layers,
        std::uint32_t flags
    );
    
private:
    unsigned int m_gl_texture_target{0};
    unsigned int m_gl_texture_name{0};
    std::uint8_t m_dimensionality{0};
    format m_format{format::undefined};
    std::array<std::uint32_t, 3> m_dimensions{0, 0, 0};
    std::uint32_t m_mip_levels{0};
    std::uint32_t m_array_layers{0};
    std::uint8_t m_flags{0};
    
    friend class image_view;
};
 
class image_1d: public image
{
public:
    image_1d
    (
        gl::format format,
        std::uint32_t width,
        std::uint32_t mip_levels = 1,
        std::uint32_t array_layers = 1,
        std::uint32_t flags = 0
    );
};
 
class image_2d: public image
{
public:
    image_2d
    (
        gl::format format,
        std::uint32_t width,
        std::uint32_t height,
        std::uint32_t mip_levels = 1,
        std::uint32_t array_layers = 1,
        std::uint32_t flags = 0
    );
};
 
class image_3d: public image
{
public:
    image_3d
    (
        gl::format format,
        std::uint32_t width,
        std::uint32_t height,
        std::uint32_t depth,
        std::uint32_t mip_levels = 1,
        std::uint32_t flags = 0
    );
};
 
class image_cube: public image_2d
{
public:
    image_cube
    (
        gl::format format,
        std::uint32_t width,
        std::uint32_t mip_levels = 1,
        std::uint32_t array_layers = 6
    );
};
 
} // namespace gl
 
#endif // ANTKEEPER_GL_IMAGE_HPP