OpenGLEngine.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_OPENGL_ENGINE_HPP
#define CSCI441_OPENGL_ENGINE_HPP
 
#include "constants.h"
#include "OpenGLUtils.hpp"
 
#ifdef CSCI441_USE_GLEW
    #include <GL/glew.h>
#else
    #include <glad/gl.h>
#endif
 
#include <GLFW/glfw3.h>
 
#ifdef CSCI441_OPENGL_ENGINE_IMPLEMENTATION
#define STB_IMAGE_WRITE_IMPLEMENTATION
#endif
#include <stb_image_write.h>
 
#include <cstdio>
#include <cstring>
#include <ctime>
#include <set>
#include <string>
#include <memory>
 
namespace CSCI441 {
 
    class OpenGLEngine {
    public:
        OpenGLEngine(const OpenGLEngine&) = delete;
        OpenGLEngine& operator=(const OpenGLEngine&) = delete;
 
        OpenGLEngine(OpenGLEngine&&) noexcept;
        OpenGLEngine& operator=(OpenGLEngine&&) noexcept;
 
        virtual ~OpenGLEngine();
 
        virtual void initialize();
        virtual void run() = 0;
        virtual void shutdown();
 
        [[maybe_unused]] virtual bool saveScreenshot(const char* FILENAME) noexcept final;
 
        [[maybe_unused]] virtual void turnDebuggingOn() noexcept final { DEBUG = true; }
        virtual void turnDebuggingOff() noexcept final { DEBUG = false; }
        [[maybe_unused]] [[nodiscard]] virtual bool isDebuggingEnabled() const noexcept final { return DEBUG; }
 
        [[maybe_unused]] [[nodiscard]] virtual bool isExtensionEnabled(const std::string EXT) const noexcept final { return _extensions.find(EXT) != _extensions.end(); }
 
        virtual void setCurrentWindowSize(const int WINDOW_WIDTH, const int WINDOW_HEIGHT) final { mWindowWidth = WINDOW_WIDTH; mWindowHeight = WINDOW_HEIGHT; }
        [[maybe_unused]] [[nodiscard]] virtual int getWindowHeight() const noexcept final { return mWindowHeight; }
        [[maybe_unused]] [[nodiscard]] virtual int getWindowWidth() const noexcept final { return mWindowWidth; }
        [[maybe_unused]] [[nodiscard]] virtual GLFWwindow* getWindow() const noexcept final { return mpWindow; }
 
        [[maybe_unused]] virtual void setWindowShouldClose() final { glfwSetWindowShouldClose(mpWindow, GLFW_TRUE); }
 
        [[nodiscard]] virtual unsigned short getError() noexcept final {
            const unsigned short storedErrorCode = mErrorCode;  // store current error code
            if (DEBUG && mErrorCode != OPENGL_ENGINE_ERROR_NO_ERROR) {
                fprintf( stderr, "[ERROR]: %s\n", getErrorStringDescription(mErrorCode) );
            }
            mErrorCode = OPENGL_ENGINE_ERROR_NO_ERROR;  // reset error code
            return storedErrorCode;                     // return previously stored error code
        }
 
        static constexpr unsigned short OPENGL_ENGINE_ERROR_NO_ERROR            = 0;
        static constexpr unsigned short OPENGL_ENGINE_ERROR_GLFW_INIT           = 1;
        static constexpr unsigned short OPENGL_ENGINE_ERROR_GLFW_WINDOW         = 2;
        static constexpr unsigned short OPENGL_ENGINE_ERROR_GLEW_INIT           = 3;
        static constexpr unsigned short OPENGL_ENGINE_ERROR_GLAD_INIT           = 4;
        static constexpr unsigned short OPENGL_ENGINE_ERROR_TAKE_SCREENSHOT     = 5;
        static constexpr unsigned short OPENGL_ENGINE_ERROR_UNKNOWN             = 6;
        // note to developers: if more error codes are added, need to update LAST accordingly or
        //                      update UNKNOWN to the last value and shift
        // note to developers: if more error codes are added, need to add description to getErrorStringDescription()
        static constexpr unsigned short OPENGL_ENGINE_ERROR_LAST                = OPENGL_ENGINE_ERROR_UNKNOWN;
        [[maybe_unused]] static constexpr unsigned short OPENGL_ENGINE_ERROR_SIZE          = OPENGL_ENGINE_ERROR_LAST + 1;
 
        static const char* getErrorStringDescription(unsigned short ERROR_CODE) noexcept;
 
    protected:
        OpenGLEngine(int OPENGL_MAJOR_VERSION, int OPENGL_MINOR_VERSION, int WINDOW_WIDTH, int WINDOW_HEIGHT, const char* WINDOW_TITLE, bool WINDOW_RESIZABLE = GLFW_FALSE);
 
        bool DEBUG;
 
        unsigned int mErrorCode;
 
        int mOpenGLMajorVersion;
        int mOpenGLMinorVersion;
        int mOpenGLMajorVersionRequested;
        int mOpenGLMinorVersionRequested;
        int mOpenGLMajorVersionCreated;
        int mOpenGLMinorVersionCreated;
        int mWindowWidth;
        int mWindowHeight;
        bool mWindowResizable;
        char* mWindowTitle;
        GLFWwindow* mpWindow;
 
        static void mErrorCallback(const int error, const char* DESCRIPTION) { fprintf(stderr, "[ERROR]: %d\n\t%s\n", error, DESCRIPTION ); }
 
        static void APIENTRY mDebugMessageCallback(const GLenum source, const GLenum type, const GLuint id, const GLenum severity, const GLsizei length, const GLchar* message, const void* userParam) {
            fprintf( stdout, "[VERBOSE]: Debug Message (%d): source = %s, type = %s, severity = %s, message = %s\n",
                     id,
                     CSCI441::OpenGLUtils::debugSourceToString(source),
                     CSCI441::OpenGLUtils::debugTypeToString(type),
                     CSCI441::OpenGLUtils::debugSeverityToString(severity),
                     message
                     );
        }
 
        static void mWindowResizeCallback(GLFWwindow* pWindow, int width, int height);
 
        virtual void mSetupGLFW();
        virtual void mSetupOpenGL() = 0;
        virtual void mSetupShaders() {};
        virtual void mSetupBuffers() {};
        virtual void mSetupTextures() {}
        virtual void mSetupScene() {};
 
        virtual void mCleanupScene() {};
        virtual void mCleanupTextures() {}
        virtual void mCleanupBuffers() {};
        virtual void mCleanupShaders() {};
        virtual void mCleanupOpenGL() {};
        virtual void mCleanupGLFW();
 
        virtual void mReloadShaders() final;
 
    private:
        void _setupGLFunctions();           // initialize OpenGL functions
        void _cleanupGLFunctions() {}       // nothing to be done at this time
 
        void _cleanupSelf();                // delete internal memory
        void _moveFromSource(OpenGLEngine&);// move members from another instance
 
        bool _isInitialized;                // makes initialization a singleton process
        bool _isCleanedUp;                  // makes cleanup a singleton process
 
        std::set< std::string > _extensions;// set of all available OpenGL extensions
    };
}
 
inline
CSCI441::OpenGLEngine::OpenGLEngine(
    const int OPENGL_MAJOR_VERSION,
    const int OPENGL_MINOR_VERSION,
    const int WINDOW_WIDTH,
    const int WINDOW_HEIGHT,
    const char* WINDOW_TITLE,
    const bool WINDOW_RESIZABLE
) : DEBUG(true),
    mErrorCode(OPENGL_ENGINE_ERROR_NO_ERROR),
    mOpenGLMajorVersion(OPENGL_MAJOR_VERSION),
    mOpenGLMinorVersion(OPENGL_MINOR_VERSION),
    mOpenGLMajorVersionRequested(OPENGL_MAJOR_VERSION),
    mOpenGLMinorVersionRequested(OPENGL_MINOR_VERSION),
    mOpenGLMajorVersionCreated(0),
    mOpenGLMinorVersionCreated(0),
    mWindowWidth(WINDOW_WIDTH),
    mWindowHeight(WINDOW_HEIGHT),
    mWindowResizable(WINDOW_RESIZABLE),
    mWindowTitle(nullptr),
    mpWindow(nullptr),
    _isInitialized(false),
    _isCleanedUp(false)
{
    mWindowTitle = new char[ strlen(WINDOW_TITLE) ];
    strcpy(mWindowTitle, WINDOW_TITLE);
}
 
inline
CSCI441::OpenGLEngine::OpenGLEngine(
    CSCI441::OpenGLEngine&& src
) noexcept :
    DEBUG(true),
    mErrorCode(OPENGL_ENGINE_ERROR_NO_ERROR),
    mOpenGLMajorVersion(0),
    mOpenGLMinorVersion(0),
    mOpenGLMajorVersionRequested(0),
    mOpenGLMinorVersionRequested(0),
    mOpenGLMajorVersionCreated(0),
    mOpenGLMinorVersionCreated(0),
    mWindowWidth(0),
    mWindowHeight(0),
    mWindowResizable(false),
    mWindowTitle(nullptr),
    mpWindow(nullptr),
    _isInitialized(false),
    _isCleanedUp(false)
{
    _moveFromSource(src);
}
 
inline
CSCI441::OpenGLEngine& CSCI441::OpenGLEngine::operator=(
    OpenGLEngine&& src
) noexcept
{
    if (this != &src) {
        _cleanupSelf();
        _moveFromSource(src);
    }
    return *this;
}
 
 
inline
CSCI441::OpenGLEngine::~OpenGLEngine()
{
    _cleanupSelf();
}
 
inline
void CSCI441::OpenGLEngine::_cleanupSelf()
{
    delete[] mWindowTitle;
    mWindowTitle = nullptr;
}
 
inline
void CSCI441::OpenGLEngine::_moveFromSource(
    OpenGLEngine& src
) {
    DEBUG = src.DEBUG;
    src.DEBUG = false;
 
    mErrorCode = src.mErrorCode;
    src.mErrorCode = OPENGL_ENGINE_ERROR_NO_ERROR;
 
    mOpenGLMajorVersion = src.mOpenGLMajorVersion;
    src.mOpenGLMajorVersion = 0;
 
    mOpenGLMinorVersion = src.mOpenGLMinorVersion;
    src.mOpenGLMinorVersion = 0;
 
    mOpenGLMajorVersionRequested = src.mOpenGLMajorVersionRequested;
    src.mOpenGLMajorVersionRequested = 0;
 
    mOpenGLMinorVersionRequested = src.mOpenGLMinorVersionRequested;
    src.mOpenGLMinorVersionRequested = 0;
 
    mOpenGLMajorVersionCreated = src.mOpenGLMajorVersionCreated;
    src.mOpenGLMajorVersionCreated = 0;
 
    mOpenGLMinorVersionCreated = src.mOpenGLMinorVersionCreated;
    src.mOpenGLMinorVersionCreated = 0;
 
    mWindowWidth = src.mWindowWidth;
    src.mWindowWidth = 0;
 
    mWindowHeight = src.mWindowHeight;
    src.mWindowHeight = 0;
 
    mWindowResizable = src.mWindowResizable;
    src.mWindowResizable = false;
 
    mWindowTitle = src.mWindowTitle;
    src.mWindowTitle = nullptr;
 
    mpWindow = src.mpWindow;
    src.mpWindow = nullptr;
 
    _isInitialized = src._isInitialized;
    src._isInitialized = false;
 
    _isCleanedUp = src._isCleanedUp;
    src._isCleanedUp = false;
 
    _extensions = std::move(src._extensions);
}
 
inline
void CSCI441::OpenGLEngine::initialize()
{
    if( !_isInitialized ) {
        if (DEBUG) {
            fprintf(stdout, "[INFO]: Using CSCI441 Library v%d.%d.%d.%d\n", CSCI441::VERSION_MAJOR, CSCI441::VERSION_MINOR, CSCI441::VERSION_REVISION, CSCI441::VERSION_PATCH);
        }
 
        mSetupGLFW();                   // initialize GLFW and set up a window
        _setupGLFunctions();            // create OpenGL function pointers
        mSetupOpenGL();                 // create the OpenGL context
 
        // get OpenGL context information
        if( DEBUG ) {
            // if wanting debug information with Version 4.3 or higher
            if( mOpenGLMajorVersion > 4 || (mOpenGLMajorVersion == 4 && mOpenGLMinorVersion >= 3) ) {
                // check if debug context was created
                int flags; glGetIntegerv(GL_CONTEXT_FLAGS, &flags);
                if (flags & GL_CONTEXT_FLAG_DEBUG_BIT) {
                    // register callback to synchronously print any debug messages without having to call glGetError()
                    glEnable(GL_DEBUG_OUTPUT);
                    glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
                    glDebugMessageCallback(mDebugMessageCallback, nullptr);
                    glDebugMessageControl( GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE );
                }
            }
 
            CSCI441::OpenGLUtils::printOpenGLInfo();
        }
 
        mSetupShaders();                // transfer, compile, link shaders on GPU
        mSetupBuffers();                // register Buffers on GPU
        mSetupTextures();               // register Textures on GPU
        mSetupScene();                  // setup any scene specific information
 
        _isInitialized = true;
        _isCleanedUp = false;
        if (DEBUG) fprintf(stdout, "\n[INFO]: Setup complete\n");
    }
}
 
inline
const char* CSCI441::OpenGLEngine::getErrorStringDescription(
    const unsigned short ERROR_CODE
) noexcept {
    switch (ERROR_CODE) {
        case OPENGL_ENGINE_ERROR_NO_ERROR:          return "No error";
        case OPENGL_ENGINE_ERROR_GLFW_INIT:         return "Error initializing GLFW";
        case OPENGL_ENGINE_ERROR_GLFW_WINDOW:       return "Error initializing GLFW window";
        case OPENGL_ENGINE_ERROR_GLEW_INIT:         return "Error initializing GLEW";
        case OPENGL_ENGINE_ERROR_GLAD_INIT:         return "Error initializing GLAD";
        case OPENGL_ENGINE_ERROR_TAKE_SCREENSHOT:   return "Error saving screenshot";
        default:                                    return "Unknown error code";
    }
}
 
inline
bool CSCI441::OpenGLEngine::saveScreenshot(
    const char* FILENAME
) noexcept {
    // Generate a name based on current timestamp if not provided
    const std::string filename =
        (
            FILENAME == nullptr
            ? "Screenshot_" + std::to_string(time(nullptr)) + ".png"
            : FILENAME
        );
 
    // Get size
    GLint viewport[4];
    glGetIntegerv(GL_VIEWPORT, viewport);
    const GLsizei x = viewport[0], y = viewport[1], width = viewport[2], height = viewport[3];
 
    // Read pixel data
    constexpr int CHANNELS = 4; // RGBA
    const auto bytes = new GLubyte[width*height*CHANNELS];
    glReadPixels(x, y, width, height, GL_RGBA, GL_UNSIGNED_BYTE, bytes);
 
    stbi_flip_vertically_on_write(true);
 
    if( !stbi_write_png(filename.c_str(), width, height, CHANNELS, bytes, width*CHANNELS) ) {
        fprintf(stderr, "[ERROR]: Could not save screenshot\n");
        mErrorCode = OPENGL_ENGINE_ERROR_TAKE_SCREENSHOT;
    } else if(DEBUG) {
        fprintf(stdout, "[INFO]: Screenshot saved to %s\n", filename.c_str());
    }
 
    delete[] bytes;
 
    return (mErrorCode == OPENGL_ENGINE_ERROR_NO_ERROR);
}
 
inline
void CSCI441::OpenGLEngine::mSetupGLFW()
{
    // set what function to use when registering errors
    // this is the ONLY GLFW function that can be called BEFORE GLFW is initialized
    // all other GLFW calls must be performed after GLFW has been initialized
    glfwSetErrorCallback(mErrorCallback);
 
    // initialize GLFW
    if( !glfwInit() ) {
        fprintf( stderr, "[ERROR]: Could not initialize GLFW\n" );
        mErrorCode = OPENGL_ENGINE_ERROR_GLFW_INIT;
    } else {
        if(DEBUG) fprintf( stdout, "[INFO]: GLFW v%d.%d.%d initialized\n", GLFW_VERSION_MAJOR, GLFW_VERSION_MINOR, GLFW_VERSION_REVISION );
 
        glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, mOpenGLMajorVersion );           // request OpenGL vX.
        glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, mOpenGLMinorVersion );           // request OpenGL v .X
        glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE );                       // request forward compatible OpenGL context
        glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE );             // request OpenGL Core Profile context
        glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_TRUE );                              // request double buffering
        glfwWindowHint(GLFW_RESIZABLE, mWindowResizable );                          // set if our window should be able to be resized
 
        // if wanting debug information with Version 4.3 or higher
        if( DEBUG
            && (mOpenGLMajorVersion > 4 || (mOpenGLMajorVersion == 4 && mOpenGLMinorVersion >= 3)) ) {
            glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, true);                        // request a debug context
        }
 
        // create a window for a given size, with a given title
        mpWindow = glfwCreateWindow(mWindowWidth, mWindowHeight, mWindowTitle, nullptr, nullptr );
        if( !mpWindow ) {                                                                       // if the window could not be created, NULL is returned
            fprintf( stderr, "[ERROR]: GLFW Window could not be created\n" );
            glfwTerminate();
            mErrorCode = OPENGL_ENGINE_ERROR_GLFW_WINDOW;
        } else {
            if(DEBUG) fprintf( stdout, "[INFO]: GLFW Window created\n" );
            glfwMakeContextCurrent(mpWindow);                                           // make the created window the current window
            glfwSwapInterval(1);                                                        // update our screen after at least 1 screen refresh
            glfwSetInputMode(mpWindow, GLFW_LOCK_KEY_MODS, GLFW_TRUE);      // track state of Caps Lock and Num Lock keys
            glfwSetWindowUserPointer(mpWindow, (void*)this);
            glfwSetWindowSizeCallback(mpWindow, mWindowResizeCallback);
        }
    }
}
 
inline
void CSCI441::OpenGLEngine::_setupGLFunctions()
{
 
#ifdef CSCI441_USE_GLEW
    glewExperimental = GL_TRUE;
    const GLenum glewResult = glewInit();                                             // initialize GLEW
 
    // check for an error
    if( glewResult != GLEW_OK ) {
        fprintf( stderr, "[ERROR]: Error initializing GLEW\n");
        fprintf( stderr, "[ERROR]: %s\n", reinterpret_cast<const char *>(glewGetErrorString(glewResult)) );
        mErrorCode = OPENGL_ENGINE_ERROR_GLEW_INIT;
    } else {
        if(DEBUG) {
            fprintf(stdout, "[INFO]: GLEW initialized\n");
            fprintf(stdout, "[INFO]: Using GLEW %s\n", reinterpret_cast<const char *>(glewGetString(GLEW_VERSION)));
        }
    }
#else
    int version = gladLoadGL(glfwGetProcAddress);
    if(version == 0) {
        fprintf(stderr, "[ERROR]: Failed to initialize GLAD\n" );
        mErrorCode = OPENGL_ENGINE_ERROR_GLAD_INIT;
    } else {
        if(DEBUG) {
            // Successfully loaded OpenGL
            fprintf(stdout, "[INFO]: GLAD initialized v%d.%d\n", GLAD_VERSION_MAJOR(version), GLAD_VERSION_MINOR(version));
        }
    }
#endif
 
    if(mErrorCode == OPENGL_ENGINE_ERROR_NO_ERROR) {
        glGetIntegerv(GL_MAJOR_VERSION, &mOpenGLMajorVersionCreated);
        glGetIntegerv(GL_MINOR_VERSION, &mOpenGLMinorVersionCreated);
        if(DEBUG) {
            fprintf(stdout, "[INFO]: OpenGL v%d.%d requested\n", mOpenGLMajorVersionRequested, mOpenGLMinorVersionRequested);
            fprintf(stdout, "[INFO]: OpenGL v%d.%d created\n", mOpenGLMajorVersionCreated, mOpenGLMinorVersionCreated);
        }
 
        GLint numExtensions = 0;
        glGetIntegerv(GL_NUM_EXTENSIONS, &numExtensions);
        for (int i = 0; i < numExtensions; i++) {
            _extensions.insert(reinterpret_cast<const char *>(glGetStringi(GL_EXTENSIONS, i)) );
        }
    }
}
 
inline
void CSCI441::OpenGLEngine::mCleanupGLFW()
{
    if(DEBUG) fprintf( stdout, "[INFO]: ...closing window...\n" );
    glfwDestroyWindow(mpWindow );                        // close our window
    mpWindow = nullptr;
    if(DEBUG) fprintf( stdout, "[INFO]: ...closing GLFW.....\n" );
    glfwTerminate();
}
 
inline
void CSCI441::OpenGLEngine::shutdown()
{
    if( !_isCleanedUp ) {
        if (DEBUG) fprintf(stdout, "\n[INFO]: Shutting down.......\n");
        mCleanupShaders();                                  // delete shaders from GPU
        mCleanupBuffers();                                  // delete VAOs/VBOs from GPU
        mCleanupTextures();                                 // delete textures from GPU
        mCleanupScene();                                    // delete scene info from CPU
        mCleanupOpenGL();                                   // cleanup anything OpenGL related
        _cleanupGLFunctions();                              // cleanup anything function pointer related
        mCleanupGLFW();                                     // shut down GLFW to clean up our context
        if (DEBUG) fprintf(stdout, "[INFO]: ..shut down complete!\n");
        _isCleanedUp = true;
        _isInitialized = false;
    }
}
 
inline
void CSCI441::OpenGLEngine::mWindowResizeCallback(
    GLFWwindow* pWindow,
    const int width,
    const int height
) {
    const auto pEngine = static_cast<OpenGLEngine *>(glfwGetWindowUserPointer(pWindow));
    pEngine->setCurrentWindowSize(width, height);
}
 
inline
void CSCI441::OpenGLEngine::mReloadShaders()
{
    if (DEBUG) fprintf(stdout, "\n[INFO]: Removing old shaders...\n");
    mCleanupShaders();
    if (DEBUG) fprintf(stdout, "\n[INFO]: Reloading shaders...\n");
    mSetupShaders();
    if (DEBUG) fprintf(stdout, "\n[INFO]: Shaders reloaded\n");
}
 
#endif //CSCI441_OPENGL_ENGINE_HPP