GLImage.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 "GLStateManager.hpp"
#include "OpenGL.hpp"
 
#include "CeresEngine/DataTypes.hpp"
 
#include "CeresEngine/RenderAPI/GPUImage.hpp"
 
namespace CeresEngine {
    class GPUBuffer;
    struct GPUSamplerDescriptor;
} // namespace CeresEngine
 
namespace CeresEngine {
 
    struct GLImageState final {
        template<auto F, typename T, auto P> inline auto parameter() {
            return +[](GLuint id, T value) constexpr { return (*F)(id, P, value); };
        }
 
        GLObjectState<GLuint, void(GLenum)> wrapS;
        GLObjectState<GLuint, void(GLenum)> wrapT;
        GLObjectState<GLuint, void(GLenum)> wrapR;
 
        GLObjectState<GLuint, void(GLenum)> minFilter;
        GLObjectState<GLuint, void(GLenum)> magFilter;
        GLObjectState<GLuint, void(GLfloat)> maxAnisotropy;
 
        GLObjectState<GLuint, void(GLfloat)> minLOD;
        GLObjectState<GLuint, void(GLfloat)> maxLOD;
        GLObjectState<GLuint, void(GLfloat)> lodBias;
 
        GLObjectState<GLuint, void(GLenum)> compareMode;
        GLObjectState<GLuint, void(GLenum)> compareFunc;
 
        GLObjectState<GLuint, void(const GLfloat*)> borderColor;
 
        explicit GLImageState(const GLuint image)
                : wrapS(image, parameter<&glTextureParameteri, GLenum, GL_TEXTURE_WRAP_S>()),
                  wrapT(image, parameter<&glTextureParameteri, GLenum, GL_TEXTURE_WRAP_T>()),
                  wrapR(image, parameter<&glTextureParameteri, GLenum, GL_TEXTURE_WRAP_R>()),
 
                  minFilter(image, parameter<&glTextureParameteri, GLenum, GL_TEXTURE_MIN_FILTER>()),
                  magFilter(image, parameter<&glTextureParameteri, GLenum, GL_TEXTURE_MAG_FILTER>()),
                  maxAnisotropy(image, parameter<&glTextureParameterf, GLfloat, GL_TEXTURE_MAX_ANISOTROPY_EXT>()),
 
                  minLOD(image, parameter<&glTextureParameterf, GLfloat, GL_TEXTURE_MIN_LOD>()),
                  maxLOD(image, parameter<&glTextureParameterf, GLfloat, GL_TEXTURE_MAX_LOD>()),
                  lodBias(image, parameter<&glTextureParameterf, GLfloat, GL_TEXTURE_LOD_BIAS>()),
 
                  compareMode(image, parameter<&glTextureParameteri, GLenum, GL_TEXTURE_COMPARE_MODE>()),
                  compareFunc(image, parameter<&glTextureParameteri, GLenum, GL_TEXTURE_COMPARE_FUNC>()),
 
                  borderColor(image, parameter<&glTextureParameterfv, const GLfloat*, GL_TEXTURE_BORDER_COLOR>()) {}
    };
 
    class GLImage final : public GPUImage, public GLDeviceObject<GLImage, GPUImage> {
    private:
        GLObjectHandle<&glGenTextures, &glDeleteTextures> textureID{};
 
        GLImageState objectState;
 
        GPUImageDescriptor mDescriptor;
 
    public:
        GLImage(GLDevicePtr device, const GPUImageDescriptor& descriptor);
        ~GLImage() final;
 
    public:
        GPUImageViewPtr createView(const GPUImageViewDescriptor& descriptor) final;
 
    public:
        [[nodiscard]] GPUImageType type() const { return mDescriptor.type; }
 
    public:
        [[nodiscard]] GLuint handle() const { return textureID; }
 
    public:
        void updateState(const GPUSamplerDescriptor& samplerDescriptor);
    };
 
} // namespace CeresEngine