GPUFormat.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/DataTypes.hpp"
#include "CeresEngine/Macros.hpp"
 
#include "CeresEngine/Foundation/Container/Tuple.hpp"
 
#include "CeresEngine/Texture/TextureFormat.hpp"
 
#include <cstdint>
#include <tuple>
 
namespace CeresEngine {
 
    enum class CE_SCRIPT_EXPORT() Precision {
        Uint8,
 
        Float16,
 
        Float32
    };
 
    //    /// The image format
    //    class Format {
    //    public:
    //        /// The image format type
    //        enum class Type {
    //            /// A undefined format type
    //                    undefined,
    //
    //            /// A image that has a color buffer with up to 4 color
    //            channels.
    //                    color,
    //
    //            /// A image that has a depth buffer attached to it.
    //                    depth
    //        };
    //
    //        Type type = Type::undefined;
    //        Precision precision = Precision::uint8;
    //        int channels = 4;
    //
    //    public:
    //        Format() = default;
    //        Format(const Format&) = default;
    //
    //        explicit Format(Type type = Type::color,
    //                               Precision precision = Precision::uint8,
    //                               int channels = 4)
    //                : type(type),
    //                  precision(precision),
    //                  channels(channels) {}
    //
    //    public:
    //        /// A image that has a color buffer with up to 4 color channels.
    //        static Format undefined() {
    //            return Format(Type::undefined);
    //        }
    //
    //        /// A image that has a color buffer with up to 4 color channels.
    //        static Format color8(int channels = 4) {
    //            return Format{Type::color, Precision::uint8, channels};
    //        }
    //
    //        /// A image that has a color buffer with up to 4 color channels.
    //        static Format colorFloat16(int channels = 4) {
    //            return Format{Type::color, Precision::float16, channels};
    //        }
    //
    //        /// A image that has a color buffer with up to 4 color channels.
    //        static Format colorFloat32(int channels = 4) {
    //            return Format{Type::color, Precision::float32, channels};
    //        }
    //
    //        /// A image that has a color buffer with up to 4 color channels.
    //        static Format color(Precision precision = Precision::uint8, int
    //        channels = 4) {
    //            return Format{Type::color, precision, channels};
    //        }
    //
    //        /// A image that has a depth buffer attached to it.
    //        static Format depthFloat16() {
    //            return Format{Type::depth, Precision::float16, 1};
    //        }
    //
    //        /// A image that has a depth buffer attached to it.
    //        static Format depthFloat32() {
    //            return Format{Type::depth, Precision::float32, 1};
    //        }
    //
    //        /// A image that has a depth buffer attached to it.
    //        static Format depth(Precision precision = Precision::float16) {
    //            return Format{Type::depth, precision, 1};
    //        }
    //
    //    };
 
    enum class CE_SCRIPT_EXPORT() DataType {
        Int8, 
        UInt8, 
 
        Int16, 
        UInt16, 
 
        Int32, 
        UInt32, 
 
        Float16, 
        Float32, 
        Float64, 
    };
 
    [[nodiscard]] UInt32 formatBitSize(Format format) noexcept;
 
    [[nodiscard]] Tuple<DataType, UInt32> splitFormat(Format format) noexcept;
 
    [[nodiscard]] bool isCompressedFormat(Format format) noexcept;
 
    [[nodiscard]] bool isDepthStencilFormat(Format format) noexcept;
 
    [[nodiscard]] bool isDepthFormat(Format format) noexcept;
 
    [[nodiscard]] bool isStencilFormat(Format format) noexcept;
 
    [[nodiscard]] bool isNormalizedFormat(Format format) noexcept;
 
    [[nodiscard]] bool isIntegralFormat(Format format) noexcept;
 
    [[nodiscard]] bool isFloatFormat(Format format) noexcept;
 
    [[nodiscard]] UInt32 dataTypeSize(DataType dataType) noexcept;
 
    [[nodiscard]] bool isIntDataType(DataType dataType) noexcept;
 
    [[nodiscard]] bool isUIntDataType(DataType dataType) noexcept;
 
    [[nodiscard]] bool isFloatDataType(DataType dataType) noexcept;
 
} // namespace CeresEngine