OpenGL.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/Material/Forward.hpp"
#include "CeresEngine/RenderAPI/Forward.hpp"
 
#include "GLLoader.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/Foundation/SmartPtr.hpp"
 
#include "CeresEngine/Mesh/VertexDeclaration.hpp"
 
#define CE_GL_SAFE_CAST
 
namespace CeresEngine {
    enum class Format;
}
 
namespace CeresEngine {
#define CE_GL_RENDER_API_OBJECT_FORWARD(N) \
    class GL##N;                           \
    using GL##N##Ptr = RC<GL##N>;
    CE_RENDER_API_OBJECT_EACH(CE_GL_RENDER_API_OBJECT_FORWARD);
#undef CE_GL_RENDER_API_OBJECT_FORWARD
 
    template<typename ChildTypeName, typename ParentType = void> class GLObject {
    public:
        static RC<ChildTypeName> cast(const RC<ParentType>& ptr) {
#if defined(CE_GL_SAFE_CAST)
            return RC<ChildTypeName>(static_cast<ChildTypeName*>(ptr.get()));
#else
            return safeCast<ChildTypeName>(ptr);
#endif
        }
 
        static RC<ChildTypeName> safeCast(const RC<ParentType>& ptr) { return RC<ChildTypeName>(dynamic_cast<ChildTypeName*>(ptr.get())); }
 
        static ChildTypeName& cast(ParentType& object) {
#if defined(CE_GL_SAFE_CAST)
            return static_cast<ChildTypeName&>(object);
#else
            return dynamic_cast<ChildTypeName&>(object);
#endif
        }
 
        static const ChildTypeName& cast(const ParentType& object) {
#if defined(CE_GL_SAFE_CAST)
            return static_cast<const ChildTypeName&>(object);
#else
            return dynamic_cast<const ChildTypeName&>(object);
#endif
        }
 
        static ChildTypeName* cast(ParentType* object) {
#if defined(CE_GL_SAFE_CAST)
            return static_cast<ChildTypeName*>(object);
#else
            return safeCast<ChildTypeName*>(object);
#endif
        }
 
        static const ChildTypeName* cast(const ParentType* object) {
#if defined(CE_GL_SAFE_CAST)
            return static_cast<const ChildTypeName*>(object);
#else
            return safeCast<const ChildTypeName*>(object);
#endif
        }
 
        static ChildTypeName* safeCast(ParentType* object) { return dynamic_cast<ChildTypeName*>(object); }
 
        static const ChildTypeName* safeCast(const ParentType* object) { return dynamic_cast<const ChildTypeName*>(object); }
    };
 
    template<typename ChildTypeName> class GLObject<ChildTypeName, void> {};
 
    template<typename ChildTypeName, typename ParentType = void> class GLDeviceObject : public GLObject<ChildTypeName, ParentType> {
    protected:
        GLDevice& deviceGL;
 
    protected:
        explicit GLDeviceObject(GLDevicePtr device) : deviceGL(*device) {}
    };
 
    void GLThrowIfFailed(const char* info);
 
    template<auto Alloc, auto Dealloc, bool BatchAlloc = true, bool BatchDealloc = BatchAlloc> struct GLObjectHandle final {
        GLuint raw;
 
        template<typename... Args> explicit GLObjectHandle(Args&&... args) {
            glGetError();
            if constexpr(BatchAlloc) {
                (*Alloc)(1, &raw, args...);
            } else {
                raw = (*Alloc)(args...);
            }
            GLThrowIfFailed("handle allocation");
        }
        ~GLObjectHandle() {
            if constexpr(BatchDealloc) {
                (*Dealloc)(1, &raw);
            } else {
                (*Dealloc)(raw);
            }
        }
 
        explicit GLObjectHandle(std::nullptr_t) : raw(0) {}
        explicit GLObjectHandle(bool, const GLuint raw) : raw(raw) {}
 
        GLObjectHandle(const GLObjectHandle&) = delete;
        GLObjectHandle& operator=(const GLObjectHandle&) = delete;
 
        GLObjectHandle(GLObjectHandle&&) noexcept = default;
        GLObjectHandle& operator=(GLObjectHandle&&) noexcept = default;
 
        operator GLuint() const { // NOLINT(google-explicit-constructor,hicpp-explicit-conversions)
            return raw;
        }
    };
 
    void GLNotImplemented();
 
    bool GLHasExtension(GLuint extension);
 
    GLenum GLMap(ShaderType shaderType);
    GLenum GLMap(Format format);
    GLenum GLMapOrZero(Format format);
    GLenum GLMap(DataType dataType);
    GLenum GLMap(VertexElementComponentType componentType);
    GLenum GLMap(GPUImageType ImageType);
    GLenum GLMap(GPUBufferType bufferType);
    GLenum GLMap(PrimitiveTopology primitiveTopology);
    GLenum GLMap(GPUPolygonMode polygonMode);
    GLenum GLMap(GPUCullMode cullMode);
    GLenum GLMap(GPUCompareOp compareOp);
    GLenum GLMap(GPUStencilOp stencilOp);
    GLenum GLMap(GPULogicOp logicOp);
    GLenum GLMap(GPUBlendOp blendOp);
    GLenum GLMap(GPUBlendArithmetic blendArithmetic);
    GLenum GLMap(GPUSamplerAddressMode addressMode);
    GLenum GLMap(GPUSamplerFilter imageFilter);
    GLenum GLMap(GPUSamplerFilter imageMinFilter, GPUSamplerFilter imageMipMapFilter);
    GLenum GLMap(IndexType indexType);
 
    GLenum GLMapInternalFormat(Format format);
 
    GLenum toImageCubeMap(UInt32 arrayLayer) noexcept;
 
    GLenum toColorAttachment(UInt32 attachmentIndex) noexcept;
 
    //    void convert(VkViewport& dst, const Viewport& src );
    //    void convert(VkRect2&   dst, const Scissor&  src );
    //    void convert(VkRect2&   dst, const Viewport& src );
 
    // Converts the boolean value into a VkBool322 value.
    inline constexpr GLboolean GLBoolean(const bool value) noexcept { return (value ? GL_TRUE : GL_FALSE); }
 
} // namespace CeresEngine