ImageDescriptor.h

Go to the documentation of this file.

 
#ifndef LLUVIA_CORE_IMAGE_IMAGE_DESCRIPTOR_H_
#define LLUVIA_CORE_IMAGE_IMAGE_DESCRIPTOR_H_
 
#include "lluvia/core/enums/enums.h"
#include "lluvia/core/error.h"
#include "lluvia/core/image/ImageTiling.h"
#include "lluvia/core/image/ImageUsageFlags.h"
#include "lluvia/core/types.h"
 
#include <array>
#include <cstdint>
#include <string>
#include <tuple>
#include <type_traits>
 
#include "lluvia/core/vulkan/vulkan.hpp"
 
namespace ll {
 
// FIXME: move enums to their own file.
enum class ChannelType : ll::enum_t {
    Uint8 = 0, 
    Int8  = 1, 
    Uint16  = 2, 
    Int16   = 3, 
    Float16 = 4, 
    Uint32  = 5, 
    Int32   = 6, 
    Float32 = 7, 
    Uint64  = 8, 
    Int64   = 9, 
    Float64 = 10 
};
 
enum class ChannelCount : ll::enum_t {
    C1 = 1,
    C2 = 2,
    C3 = 3,
    C4 = 4
};
 
namespace impl {
 
    constexpr const std::array<std::tuple<const char*, ll::ChannelType>, 11> ChannelTypeStrings {{
        std::make_tuple("Uint8", ll::ChannelType::Uint8),
        std::make_tuple("Int8", ll::ChannelType::Int8),
 
        std::make_tuple("Uint16", ll::ChannelType::Uint16),
        std::make_tuple("Int16", ll::ChannelType::Int16),
        std::make_tuple("Float16", ll::ChannelType::Float16),
 
        std::make_tuple("Uint32", ll::ChannelType::Uint32),
        std::make_tuple("Int32", ll::ChannelType::Int32),
        std::make_tuple("Float32", ll::ChannelType::Float32),
 
        std::make_tuple("Uint64", ll::ChannelType::Uint64),
        std::make_tuple("Int64", ll::ChannelType::Int64),
        std::make_tuple("Float64", ll::ChannelType::Float64),
    }};
 
    constexpr const std::array<std::tuple<const char*, ll::ChannelCount>, 4> ChannelCountStrings {{std::make_tuple("C1", ll::ChannelCount::C1),
        std::make_tuple("C2", ll::ChannelCount::C2),
        std::make_tuple("C3", ll::ChannelCount::C3),
        std::make_tuple("C4", ll::ChannelCount::C4)}};
 
} // namespace impl
 
template <typename T = std::string>
inline T channelTypeToString(ll::ChannelType&& value) noexcept
{
    return ll::impl::enumToString<ll::ChannelType, ll::impl::ChannelTypeStrings.size(), impl::ChannelTypeStrings>(std::forward<ll::ChannelType>(value));
}
 
template <typename T = std::string>
inline T channelTypeToString(const ll::ChannelType& value) noexcept
{
    return ll::impl::enumToString<ll::ChannelType, ll::impl::ChannelTypeStrings.size(), impl::ChannelTypeStrings>(value);
}
 
template <typename T>
inline ll::ChannelType stringToChannelType(T&& stringValue)
{
    return impl::stringToEnum<ll::ChannelType, T, ll::impl::ChannelTypeStrings.size(), impl::ChannelTypeStrings>(std::forward<T>(stringValue));
}
 
template <typename T = uint32_t>
ll::ChannelCount castChannelCount(T c)
{
    static_assert(std::is_integral<T>::value, "T must be an integral type.");
 
    const auto casted = static_cast<std::underlying_type<ll::ChannelCount>::type>(c);
 
    constexpr const auto minValue = static_cast<std::underlying_type<ll::ChannelCount>::type>(ll::ChannelCount::C1);
    constexpr const auto maxValue = static_cast<std::underlying_type<ll::ChannelCount>::type>(ll::ChannelCount::C4);
 
    ll::throwSystemErrorIf(
        casted < minValue || casted > maxValue,
        ll::ErrorCode::BadEnumCasting,
        "Error casting integral value " + std::to_string(c) + " to ll::ChannelCount. " + "Expected value must be within range [" + std::to_string(minValue) + ", " + std::to_string(maxValue) + "].");
 
    return static_cast<ll::ChannelCount>(c);
}
 
uint64_t getChannelTypeSize(ll::ChannelType type);
 
vk::Format getVulkanImageFormat(ll::ChannelCount channelCount, ll::ChannelType channelType) noexcept;
 
class ImageDescriptor {
 
public:
    ImageDescriptor()                                  = default;
    ImageDescriptor(const ImageDescriptor& descriptor) = default;
    ImageDescriptor(ImageDescriptor&& descriptor)      = default;
 
    ImageDescriptor(const uint32_t depth,
        const uint32_t             height,
        const uint32_t             width,
        const ll::ChannelCount     channelCount,
        const ll::ChannelType      channelType);
 
    ImageDescriptor(const uint32_t depth,
        const uint32_t             height,
        const uint32_t             width,
        const ll::ChannelCount     channelCount,
        const ll::ChannelType      channelType,
        const ll::ImageUsageFlags  usageFlags,
        const ll::ImageTiling      tiling);
 
    ~ImageDescriptor() = default;
 
    ImageDescriptor& operator=(const ImageDescriptor& descriptor) = default;
    ImageDescriptor& operator=(ImageDescriptor&& descriptor)      = default;
 
    ImageDescriptor& setChannelType(const ll::ChannelType type) noexcept;
 
    ImageDescriptor& setChannelCount(const ll::ChannelCount count) noexcept;
 
    ImageDescriptor& setWidth(const uint32_t width) noexcept;
 
    ImageDescriptor& setHeight(const uint32_t height) noexcept;
 
    ImageDescriptor& setDepth(const uint32_t depth) noexcept;
 
    ImageDescriptor& setShape(const ll::vec3ui& shape) noexcept;
 
    ImageDescriptor& setUsageFlags(const ll::ImageUsageFlags flags) noexcept;
 
    ImageDescriptor& setUsageFlagsUnsafe(const uint32_t flags) noexcept;
 
    ImageDescriptor& setTiling(const ll::ImageTiling tTiling) noexcept;
 
    ll::ChannelType getChannelType() const noexcept;
 
    template <typename T = ll::ChannelCount>
    T getChannelCount() const noexcept
    {
        return static_cast<T>(m_channelCount);
    }
 
    uint32_t getWidth() const noexcept;
 
    uint32_t getHeight() const noexcept;
 
    uint32_t getDepth() const noexcept;
 
    uint64_t getSize() const noexcept;
 
    ll::vec3ui getShape() const noexcept;
 
    vk::ImageType getImageType() const noexcept;
 
    vk::Format getFormat() const noexcept;
 
    ll::ImageUsageFlags getUsageFlags() const noexcept;
 
    ll::ImageTiling getTiling() const noexcept;
 
    uint32_t getUsageFlagsUnsafe() const noexcept;
 
private:
    ll::ChannelType  m_channelType {ll::ChannelType::Uint8};
    ll::ChannelCount m_channelCount {ll::ChannelCount::C1};
 
    // dimensions along each axis
    // x : width
    // y : height
    // z : depth
    ll::vec3ui m_shape {1, 1, 1};
 
    ll::ImageTiling     m_tiling {ll::ImageTiling::Optimal};
    ll::ImageUsageFlags m_usageFlags {ll::ImageUsageFlagBits::Storage | ll::ImageUsageFlagBits::Sampled | ll::ImageUsageFlagBits::TransferSrc | ll::ImageUsageFlagBits::TransferDst};
};
 
} // namespace ll
 
#endif /* LLUVIA_CORE_IMAGE_IMAGE_DESCRIPTOR_H_ */