csci441/_open_g_l_engine_8hpp_source.html

#ifndef CSCI441_OPENGL_ENGINE_HPP

#define CSCI441_OPENGL_ENGINE_HPP


#include "constants.h"

#include "FontUtils.hpp"

#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 <chrono>

#include <cstdio>

#include <cstring>

#include <ctime>

#include <deque>

#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; }

        virtual void setCurrentFramebufferSize(const int FRAMEBUFFER_WIDTH, const int FRAMEBUFFER_HEIGHT) final { mFramebufferWidth = FRAMEBUFFER_WIDTH; mFramebufferHeight = FRAMEBUFFER_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;

        int mFramebufferWidth;

        int mFramebufferHeight;

        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 mSetupFonts() {}

        virtual void mSetupScene() {};


        virtual void mCleanupScene() {};

        virtual void mCleanupFonts() {}

        virtual void mCleanupTextures() {}

        virtual void mCleanupBuffers() {};

        virtual void mCleanupShaders() {};

        virtual void mCleanupOpenGL() {};

        virtual void mCleanupGLFW();


        virtual void mReloadShaders() final;


        virtual GLdouble clockFrame() final;


        virtual GLdouble fpsAverage() 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


        GLdouble _lastFrameTime;

        std::deque<GLdouble> _frameTimes;

        GLint _numFrames;

    };

}


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),

    mFramebufferWidth(WINDOW_WIDTH),

    mFramebufferHeight(WINDOW_HEIGHT),

    mWindowResizable(WINDOW_RESIZABLE),

    mWindowTitle(nullptr),

    mpWindow(nullptr),

    _isInitialized(false),

    _isCleanedUp(false),

    _lastFrameTime(0),

    _numFrames(0)

{

    mWindowTitle = new char[ strlen(WINDOW_TITLE) + 1 ];

    strncpy(mWindowTitle, WINDOW_TITLE, strlen(WINDOW_TITLE) + 1);

    mWindowTitle[strlen(WINDOW_TITLE)] = '\0';


    CSCI441::FontUtils::setWindowSize(WINDOW_WIDTH, WINDOW_HEIGHT);

    CSCI441::FontUtils::setFontSize(1.0f / static_cast<GLfloat>(WINDOW_WIDTH), 1.0f / static_cast<GLfloat>(WINDOW_HEIGHT) );

}


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),

    mFramebufferWidth(0),

    mFramebufferHeight(0),

    mWindowResizable(false),

    mWindowTitle(nullptr),

    mpWindow(nullptr),

    _isInitialized(false),

    _isCleanedUp(false),

    _lastFrameTime(0),

    _numFrames(0)

{

    _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 ) {

        const std::chrono::steady_clock::time_point initBegin = std::chrono::steady_clock::now();


        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);

        }


        const std::chrono::steady_clock::time_point glfwBegin = std::chrono::steady_clock::now();

        mSetupGLFW();                   // initialize GLFW and set up a window

        glfwGetFramebufferSize( mpWindow, &mFramebufferWidth, &mFramebufferHeight );

        const std::chrono::steady_clock::time_point glfwEnd = std::chrono::steady_clock::now();


        const std::chrono::steady_clock::time_point openGLBegin = std::chrono::steady_clock::now();

        _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();

        }

        const std::chrono::steady_clock::time_point openGLEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mSetupOpenGL()");


        const std::chrono::steady_clock::time_point shadersBegin = std::chrono::steady_clock::now();

        mSetupShaders();                // transfer, compile, link shaders on GPU

        const std::chrono::steady_clock::time_point shadersEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mSetupShaders()");


        const std::chrono::steady_clock::time_point buffersBegin = std::chrono::steady_clock::now();

        mSetupBuffers();                // register Buffers on GPU

        const std::chrono::steady_clock::time_point buffersEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mSetupBuffers()");


        const std::chrono::steady_clock::time_point texturesBegin = std::chrono::steady_clock::now();

        mSetupTextures();               // register Textures on GPU

        const std::chrono::steady_clock::time_point texturesEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mSetupTextures()");


        const std::chrono::steady_clock::time_point fontsBegin = std::chrono::steady_clock::now();

        mSetupFonts();                  // register Fonts on GPU

        const std::chrono::steady_clock::time_point fontsEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mSetupFonts()");


        const std::chrono::steady_clock::time_point sceneBegin = std::chrono::steady_clock::now();

        mSetupScene();                  // setup any scene specific information

        const std::chrono::steady_clock::time_point sceneEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mSetupScene()");


        _isInitialized = true;

        _isCleanedUp = false;


        const std::chrono::steady_clock::time_point initEnd = std::chrono::steady_clock::now();

        if (DEBUG) {

            fprintf(stdout, "\n[INFO]: Setup complete\n");

            fprintf(stdout, "[INFO]: Init Time:    %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(initEnd     - initBegin    ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tGLFW:     %2.3fs\n",   static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(glfwEnd     - glfwBegin    ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tOpenGL:   %2.3fs\n",   static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(openGLEnd   - openGLBegin  ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tShaders:  %2.3fs\n",   static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(shadersEnd  - shadersBegin ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tBuffers:  %2.3fs\n",   static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(buffersEnd  - buffersBegin ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tTextures: %2.3fs\n",   static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(texturesEnd - texturesBegin).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tFonts:    %2.3fs\n",   static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(fontsEnd    - fontsBegin   ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tScene:    %2.3fs\n",   static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(sceneEnd    - sceneBegin   ).count() ) / 1000000.0);


        }

    }

}


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 ) {

        const std::chrono::steady_clock::time_point shutdownBegin = std::chrono::steady_clock::now();

        if (DEBUG) fprintf(stdout, "\n[INFO]: Shutting down.......\n");


        const std::chrono::steady_clock::time_point sceneBegin = std::chrono::steady_clock::now();

        mCleanupScene();                                    // delete scene info from CPU

        const std::chrono::steady_clock::time_point sceneEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mCleanupScene()");


        const std::chrono::steady_clock::time_point fontsBegin = std::chrono::steady_clock::now();

        mCleanupFonts();                                    // delete textures from GPU

        const std::chrono::steady_clock::time_point fontsEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mCleanupFonts()");


        const std::chrono::steady_clock::time_point texturesBegin = std::chrono::steady_clock::now();

        mCleanupTextures();                                 // delete textures from GPU

        const std::chrono::steady_clock::time_point texturesEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mCleanupTextures()");


        const std::chrono::steady_clock::time_point buffersBegin = std::chrono::steady_clock::now();

        mCleanupBuffers();                                  // delete VAOs/VBOs from GPU

        const std::chrono::steady_clock::time_point buffersEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mCleanupBuffers()");


        const std::chrono::steady_clock::time_point shadersBegin = std::chrono::steady_clock::now();

        mCleanupShaders();                                  // delete shaders from GPU

        const std::chrono::steady_clock::time_point shadersEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mCleanupShaders()");


        const std::chrono::steady_clock::time_point openGLBegin = std::chrono::steady_clock::now();

        mCleanupOpenGL();                                   // cleanup anything OpenGL related

        _cleanupGLFunctions();                              // cleanup anything function pointer related

        const std::chrono::steady_clock::time_point openGLEnd = std::chrono::steady_clock::now();

        CSCI441::OpenGLUtils::checkOpenGLErrors("post mCleanupOpenGL()");


        const std::chrono::steady_clock::time_point glfwBegin = std::chrono::steady_clock::now();

        mCleanupGLFW();                                     // shut down GLFW to clean up our context

        const std::chrono::steady_clock::time_point glfwEnd = std::chrono::steady_clock::now();


        const std::chrono::steady_clock::time_point shutdownEnd = std::chrono::steady_clock::now();

        if (DEBUG) {

            fprintf(stdout, "[INFO]: ..shut down complete!\n");

            fprintf(stdout, "[INFO]: Shutdown:   %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(shutdownEnd - shutdownBegin).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tScene:    %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(sceneEnd    - sceneBegin   ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tFonts:    %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(fontsEnd    - fontsBegin   ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tTextures: %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(texturesEnd - texturesBegin).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tBuffers:  %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(buffersEnd  - buffersBegin ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tShaders:  %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(shadersEnd  - shadersBegin ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tOpenGL:   %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(openGLEnd   - openGLBegin  ).count() ) / 1000000.0);

            fprintf(stdout, "[INFO]: \tGLFW:     %2.3fs\n", static_cast<double>( std::chrono::duration_cast<std::chrono::microseconds>(glfwEnd     - glfwBegin    ).count() ) / 1000000.0);

        }

        _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);

    CSCI441::FontUtils::setWindowSize(width, height);

    CSCI441::FontUtils::setFontSize(1.0f / static_cast<GLfloat>(width), 1.0f / static_cast<GLfloat>(height) );


    GLint framebufferWidth, framebufferHeight;

    glfwGetFramebufferSize( pEngine->getWindow(), &framebufferWidth, &framebufferHeight );

    pEngine->setCurrentFramebufferSize(framebufferWidth, framebufferHeight);

}


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");

}


inline

GLdouble CSCI441::OpenGLEngine::clockFrame() {

    const GLdouble currentTime = glfwGetTime();

    ++_numFrames;

    GLdouble fps = ( !_frameTimes.empty() ? _frameTimes.back() : 0.0 );

    if (currentTime - _lastFrameTime > 0.1667) {

        fps = static_cast<GLdouble>(_numFrames)/(currentTime - _lastFrameTime);

        _numFrames = 0;

        _lastFrameTime = currentTime;


        if (_frameTimes.size() >= 10) _frameTimes.pop_front();

        _frameTimes.push_back( fps );

    }

    return fps;

}


inline

GLdouble CSCI441::OpenGLEngine::fpsAverage() {

    GLdouble totalFPS = 0;

    for( const auto& fpsUnit : _frameTimes ) {

        totalFPS += fpsUnit;

    }

    return totalFPS / static_cast<GLdouble>(_frameTimes.size());

}


#endif //CSCI441_OPENGL_ENGINE_HPP

OpenGLUtils.hpp
Helper functions to work with OpenGL 3.0+.

CSCI441::OpenGLEngine
Abstract Class to run an OpenGL application. The following methods must be overridden:
Definition: OpenGLEngine.hpp:52

CSCI441::OpenGLEngine::mSetupOpenGL
virtual void mSetupOpenGL()=0
override to enable specific OpenGL features

CSCI441::OpenGLEngine::isExtensionEnabled
virtual bool isExtensionEnabled(const std::string EXT) const noexcept final
Returns if OpenGL extension exists.
Definition: OpenGLEngine.hpp:125

CSCI441::OpenGLEngine::DEBUG
bool DEBUG
if information should be printed to console while running
Definition: OpenGLEngine.hpp:241

CSCI441::OpenGLEngine::operator=
OpenGLEngine & operator=(const OpenGLEngine &)=delete
do not allow engines to be copied

CSCI441::OpenGLEngine::mFramebufferWidth
int mFramebufferWidth
the framebuffer height of the requested GLFW window
Definition: OpenGLEngine.hpp:293

CSCI441::OpenGLEngine::mOpenGLMinorVersion
int mOpenGLMinorVersion
the minor version of the requested OpenGL context
Definition: OpenGLEngine.hpp:257

CSCI441::OpenGLEngine::mOpenGLMajorVersion
int mOpenGLMajorVersion
the major version of the requested OpenGL context
Definition: OpenGLEngine.hpp:252

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_NO_ERROR
static constexpr unsigned short OPENGL_ENGINE_ERROR_NO_ERROR
no error is present, everything is currently working
Definition: OpenGLEngine.hpp:178

CSCI441::OpenGLEngine::saveScreenshot
virtual bool saveScreenshot(const char *FILENAME) noexcept final
Save a PNG screenshot of the viewport.
Definition: OpenGLEngine.hpp:720

CSCI441::OpenGLEngine::setCurrentWindowSize
virtual void setCurrentWindowSize(const int WINDOW_WIDTH, const int WINDOW_HEIGHT) final
Stores the new window size.
Definition: OpenGLEngine.hpp:135

CSCI441::OpenGLEngine::initialize
virtual void initialize()
Initialize everything needed for OpenGL Rendering. This includes in order: GLFW, function pointers,...
Definition: OpenGLEngine.hpp:622

CSCI441::OpenGLEngine::shutdown
virtual void shutdown()
Cleanup everything needed for OpenGL Rendering. This includes freeing memory for data used in: any Sc...
Definition: OpenGLEngine.hpp:859

CSCI441::OpenGLEngine::getError
virtual unsigned short getError() noexcept final
Return current value of error code and clear the error code back to no error.
Definition: OpenGLEngine.hpp:166

CSCI441::OpenGLEngine::mSetupTextures
virtual void mSetupTextures()
override to register any textures with the GPU
Definition: OpenGLEngine.hpp:387

CSCI441::OpenGLEngine::getWindowHeight
virtual int getWindowHeight() const noexcept final
Return the height of the window.
Definition: OpenGLEngine.hpp:148

CSCI441::OpenGLEngine::isDebuggingEnabled
virtual bool isDebuggingEnabled() const noexcept final
Returns if logging is enabled.
Definition: OpenGLEngine.hpp:118

CSCI441::OpenGLEngine::mWindowResizeCallback
static void mWindowResizeCallback(GLFWwindow *pWindow, int width, int height)
Definition: OpenGLEngine.hpp:918

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_GLAD_INIT
static constexpr unsigned short OPENGL_ENGINE_ERROR_GLAD_INIT
an error occurred while initializing GLAD
Definition: OpenGLEngine.hpp:194

CSCI441::OpenGLEngine::mCleanupBuffers
virtual void mCleanupBuffers()
override to cleanup any buffer objects from the GPU
Definition: OpenGLEngine.hpp:420

CSCI441::OpenGLEngine::mCleanupScene
virtual void mCleanupScene()
override to cleanup any scene specific information
Definition: OpenGLEngine.hpp:405

CSCI441::OpenGLEngine::mSetupFonts
virtual void mSetupFonts()
override to register any fonts with the GPU
Definition: OpenGLEngine.hpp:393

CSCI441::OpenGLEngine::setCurrentFramebufferSize
virtual void setCurrentFramebufferSize(const int FRAMEBUFFER_WIDTH, const int FRAMEBUFFER_HEIGHT) final
Stores the framebuffer size.
Definition: OpenGLEngine.hpp:144

CSCI441::OpenGLEngine::mCleanupShaders
virtual void mCleanupShaders()
override to cleanup any shaders from the GPU
Definition: OpenGLEngine.hpp:425

CSCI441::OpenGLEngine::mCleanupTextures
virtual void mCleanupTextures()
override to cleanup any textures from the GPU
Definition: OpenGLEngine.hpp:415

CSCI441::OpenGLEngine::clockFrame
virtual GLdouble clockFrame() final
measures the amount of time elapsed since the last time this method was called
Definition: OpenGLEngine.hpp:944

CSCI441::OpenGLEngine::mWindowResizable
bool mWindowResizable
if the GLFW window can be resized while open
Definition: OpenGLEngine.hpp:302

CSCI441::OpenGLEngine::mOpenGLMinorVersionRequested
int mOpenGLMinorVersionRequested
the minor version of the requested OpenGL context
Definition: OpenGLEngine.hpp:269

CSCI441::OpenGLEngine::OpenGLEngine
OpenGLEngine(const OpenGLEngine &)=delete
do not allow engines to be copied

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_TAKE_SCREENSHOT
static constexpr unsigned short OPENGL_ENGINE_ERROR_TAKE_SCREENSHOT
an error occurred while taking a screenshot
Definition: OpenGLEngine.hpp:198

CSCI441::OpenGLEngine::mFramebufferHeight
int mFramebufferHeight
the framebuffer width of the requested GLFW window
Definition: OpenGLEngine.hpp:297

CSCI441::OpenGLEngine::turnDebuggingOn
virtual void turnDebuggingOn() noexcept final
Enable logging to command line.
Definition: OpenGLEngine.hpp:109

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_GLEW_INIT
static constexpr unsigned short OPENGL_ENGINE_ERROR_GLEW_INIT
an error occurred while initializing GLEW
Definition: OpenGLEngine.hpp:190

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_GLFW_WINDOW
static constexpr unsigned short OPENGL_ENGINE_ERROR_GLFW_WINDOW
an error occurred while creating the GLFW window
Definition: OpenGLEngine.hpp:186

CSCI441::OpenGLEngine::mCleanupFonts
virtual void mCleanupFonts()
override to cleanup any fonts from the GPU
Definition: OpenGLEngine.hpp:410

CSCI441::OpenGLEngine::mOpenGLMajorVersionRequested
int mOpenGLMajorVersionRequested
the major version of the requested OpenGL context
Definition: OpenGLEngine.hpp:263

CSCI441::OpenGLEngine::mErrorCallback
static void mErrorCallback(const int error, const char *DESCRIPTION)
We will register this function as GLFW's error callback. When an error within OpenGL occurs,...
Definition: OpenGLEngine.hpp:318

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_LAST
static constexpr unsigned short OPENGL_ENGINE_ERROR_LAST
stores the error code number of the last possible error, this corresponds to the max error code value...
Definition: OpenGLEngine.hpp:210

CSCI441::OpenGLEngine::mErrorCode
unsigned int mErrorCode
tracks the current status of the OpenGL engine via error codes
Definition: OpenGLEngine.hpp:246

CSCI441::OpenGLEngine::run
virtual void run()=0
Initiate the draw loop.

CSCI441::OpenGLEngine::mDebugMessageCallback
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)
callback called whenever a debug message is signaled
Definition: OpenGLEngine.hpp:323

CSCI441::OpenGLEngine::mWindowTitle
char * mWindowTitle
the title of the GLFW window
Definition: OpenGLEngine.hpp:306

CSCI441::OpenGLEngine::mWindowHeight
int mWindowHeight
the window height of the requested GLFW window
Definition: OpenGLEngine.hpp:289

CSCI441::OpenGLEngine::fpsAverage
virtual GLdouble fpsAverage() final
Definition: OpenGLEngine.hpp:960

CSCI441::OpenGLEngine::setWindowShouldClose
virtual void setWindowShouldClose() final
Tell our engine's window to close.
Definition: OpenGLEngine.hpp:161

CSCI441::OpenGLEngine::mOpenGLMajorVersionCreated
int mOpenGLMajorVersionCreated
the major version of the created OpenGL context
Definition: OpenGLEngine.hpp:274

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_SIZE
static constexpr unsigned short OPENGL_ENGINE_ERROR_SIZE
stores the number of unique error codes that can be generated
Definition: OpenGLEngine.hpp:214

CSCI441::OpenGLEngine::mReloadShaders
virtual void mReloadShaders() final
calls mCleanupShaders() followed by mSetupShaders() to reload shader source code from file
Definition: OpenGLEngine.hpp:934

CSCI441::OpenGLEngine::mSetupShaders
virtual void mSetupShaders()
override to register any shaders with the GPU
Definition: OpenGLEngine.hpp:375

CSCI441::OpenGLEngine::mpWindow
GLFWwindow * mpWindow
pointer to the GLFW window object
Definition: OpenGLEngine.hpp:310

CSCI441::OpenGLEngine::turnDebuggingOff
virtual void turnDebuggingOff() noexcept final
Disable logging to command line.
Definition: OpenGLEngine.hpp:114

CSCI441::OpenGLEngine::getErrorStringDescription
static const char * getErrorStringDescription(unsigned short ERROR_CODE) noexcept
Returns a string describing what the error code corresponds to.
Definition: OpenGLEngine.hpp:705

CSCI441::OpenGLEngine::getWindowWidth
virtual int getWindowWidth() const noexcept final
Return the width of the window.
Definition: OpenGLEngine.hpp:152

CSCI441::OpenGLEngine::mSetupBuffers
virtual void mSetupBuffers()
override to register any buffer objects with the GPU
Definition: OpenGLEngine.hpp:381

CSCI441::OpenGLEngine::~OpenGLEngine
virtual ~OpenGLEngine()
cleans up our OpenGL Engine by destroying the OpenGL context, GLFW window, and cleaning up all GPU re...
Definition: OpenGLEngine.hpp:557

CSCI441::OpenGLEngine::mCleanupGLFW
virtual void mCleanupGLFW()
Destroys the associated GLFW window and terminates the GLFW instance.
Definition: OpenGLEngine.hpp:849

CSCI441::OpenGLEngine::mOpenGLMinorVersionCreated
int mOpenGLMinorVersionCreated
the minor version of the created OpenGL context
Definition: OpenGLEngine.hpp:279

CSCI441::OpenGLEngine::mWindowWidth
int mWindowWidth
the window width of the requested GLFW window
Definition: OpenGLEngine.hpp:284

CSCI441::OpenGLEngine::mCleanupOpenGL
virtual void mCleanupOpenGL()
override to cleanup any specific OpenGL features
Definition: OpenGLEngine.hpp:430

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_GLFW_INIT
static constexpr unsigned short OPENGL_ENGINE_ERROR_GLFW_INIT
an error occurred while initializing GLFW
Definition: OpenGLEngine.hpp:182

CSCI441::OpenGLEngine::mSetupGLFW
virtual void mSetupGLFW()
Used to setup everything GLFW related. This includes the OpenGL context and our window....
Definition: OpenGLEngine.hpp:756

CSCI441::OpenGLEngine::mSetupScene
virtual void mSetupScene()
override to setup any scene specific information
Definition: OpenGLEngine.hpp:399

CSCI441::OpenGLEngine::OPENGL_ENGINE_ERROR_UNKNOWN
static constexpr unsigned short OPENGL_ENGINE_ERROR_UNKNOWN
a new error that does not correspond to a predefined scenario has occurred
Definition: OpenGLEngine.hpp:202

CSCI441::OpenGLEngine::getWindow
virtual GLFWwindow * getWindow() const noexcept final
Return the window object.
Definition: OpenGLEngine.hpp:156

CSCI441::FontUtils::setFontSize
void setFontSize(GLfloat scaleX, GLfloat scaleY)
set the amount to scale font when drawing
Definition: FontUtils.hpp:180

CSCI441::FontUtils::setWindowSize
void setWindowSize(GLint width, GLint height)
store the size of the window
Definition: FontUtils.hpp:172

CSCI441
CSCI441 Helper Functions for OpenGL.
Definition: ArcballCam.hpp:17