OpenGL3DEngine.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_OPENGL3D_ENGINE_HPP
#define CSCI441_OPENGL3D_ENGINE_HPP
 
#include "ArcballCam.hpp"
#include "OpenGLEngine.hpp"
 
#include <glm/glm.hpp>
#include <glm/gtc/constants.hpp>
 
namespace CSCI441 {
 
    class OpenGL3DEngine : public OpenGLEngine {
    public:
        OpenGL3DEngine(const OpenGL3DEngine&) = delete;
        OpenGL3DEngine& operator=(const OpenGL3DEngine&) = delete;
 
        [[maybe_unused]] [[nodiscard]] virtual GLboolean isLeftMouseDown() const noexcept final { return mIsLeftMouseDown; }
        [[maybe_unused]] virtual void setLeftMouseDown(GLboolean isDown) final { mIsLeftMouseDown = isDown; }
 
        [[maybe_unused]] [[nodiscard]] virtual GLboolean isShiftDown() const noexcept final { return mIsShiftDown; }
        [[maybe_unused]] virtual void setShiftDown(GLboolean isDown) final { mIsShiftDown = isDown; }
 
        [[maybe_unused]] [[nodiscard]] virtual glm::vec2 getMousePosition() const noexcept final { return mMousePosition; }
        [[maybe_unused]] virtual void setMousePosition(glm::vec2 mousePos) final { mMousePosition = mousePos; }
 
        [[maybe_unused]] virtual void setArcballCameraAngles( glm::vec3 angles ) final {
            mpArcballCamera->setTheta(angles[0] );
            mpArcballCamera->setPhi(angles[1] );
            mpArcballCamera->setRadius(angles[2] );
        }
 
        [[maybe_unused]] [[nodiscard]] virtual glm::vec3 getArcballCameraEyePoint() const noexcept final { return mpArcballCamera->getPosition(); }
 
        [[maybe_unused]] [[nodiscard]] virtual glm::vec3 getArcballCameraLookAtPoint() const noexcept final { return mpArcballCamera->getLookAtPoint(); }
        [[maybe_unused]] virtual void setArcballCameraLookAtPoint( glm::vec3 lookAtPoint ) final { mpArcballCamera->setLookAtPoint(lookAtPoint); }
 
        [[maybe_unused]] [[nodiscard]] virtual glm::vec3 getArcballCameraUpVector() const noexcept final { return mpArcballCamera->getUpVector(); }
        [[maybe_unused]] virtual void setArcballCameraUpVector( glm::vec3 upVector ) final { mpArcballCamera->setUpVector(upVector); }
 
        [[maybe_unused]] [[nodiscard]] virtual glm::mat4 getArcballProjectionMatrix() const final { return mpArcballCamera->getProjectionMatrix(); }
 
        [[maybe_unused]] [[nodiscard]] virtual glm::mat4 getArcballViewMatrix() const final { return mpArcballCamera->getViewMatrix(); }
 
        [[maybe_unused]] virtual void addToArcballCameraAngles( glm::vec3 angleAdditions ) final {
            mpArcballCamera->setTheta(mpArcballCamera->getTheta() + angleAdditions[0] );
            mpArcballCamera->setPhi(mpArcballCamera->getPhi() + angleAdditions[1] );
            mpArcballCamera->moveBackward(angleAdditions[2] );
        }
 
        [[maybe_unused]] virtual void updateArcballCameraDirection() final {
            mpArcballCamera->recomputeOrientation();
        }
 
        [[maybe_unused]] virtual void handleCameraCursorPosEvent(double x, double y) final {
            glm::vec2 currMousePos(x, getWindowHeight() - y);
 
            if( mIsLeftMouseDown ) {
                if( !mIsShiftDown ) {
                    // rotate the camera by the distance the mouse moved
                    mpArcballCamera->rotate((currMousePos.x - mMousePosition.x) * 0.005f,
                                              (mMousePosition.y - currMousePos.y) * 0.005f);
                } else {
                    // otherwise, update our camera angles theta & phi
                    GLfloat totChgSq = (currMousePos.x - mMousePosition.x) + (currMousePos.y - mMousePosition.y);
                    mpArcballCamera->moveForward( totChgSq * 0.05f );
                }
            }
 
            setMousePosition(currMousePos);
        }
 
        [[maybe_unused]] virtual void handleCameraKeyEvent(int key, int scancode, int action, int mods) final {
            if( key == GLFW_KEY_LEFT_SHIFT ) {
                _isLeftShiftDown = (action == GLFW_PRESS || action == GLFW_REPEAT);
            } else if( key == GLFW_KEY_RIGHT_SHIFT ) {
                _isRightShiftDown = (action == GLFW_PRESS || action == GLFW_REPEAT);
            }
            mIsShiftDown = _isLeftShiftDown || _isRightShiftDown;
        }
 
        [[maybe_unused]] virtual void handleCameraMouseButtonEvent(int button, int action, int mods) final {
            if( button == GLFW_MOUSE_BUTTON_LEFT ) {
                mIsLeftMouseDown = (action == GLFW_PRESS);
            }
        }
 
        [[maybe_unused]] virtual void handleCameraScrollEvent(double xOffset, double yOffset) {
            mpArcballCamera->moveForward((GLfloat)yOffset * 0.2f );
        }
 
        [[maybe_unused]] void handleCameraAspectRatioEvent(int width, int height) {
            mpArcballCamera->setAspectRatio( (GLfloat)width / (GLfloat)height );
        }
 
    protected:
        OpenGL3DEngine(int OPENGL_MAJOR_VERSION, int OPENGL_MINOR_VERSION, int WINDOW_WIDTH, int WINDOW_HEIGHT, const char* WINDOW_TITLE, bool WINDOW_RESIZABLE = GLFW_FALSE);
        ~OpenGL3DEngine() override;
 
        CSCI441::ArcballCam* mpArcballCamera;
 
        GLboolean mIsShiftDown;
        GLboolean mIsLeftMouseDown;
        glm::vec2 mMousePosition;
 
    private:
        GLboolean _isLeftShiftDown;
        GLboolean _isRightShiftDown;
    };
}
 
//*****************************************************************************************
 
inline CSCI441::OpenGL3DEngine::OpenGL3DEngine(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)
        : OpenGLEngine(OPENGL_MAJOR_VERSION, OPENGL_MINOR_VERSION, WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE, WINDOW_RESIZABLE),
          mpArcballCamera( new CSCI441::ArcballCam(2.0f, 30.0f, (GLfloat)WINDOW_WIDTH / (GLfloat)WINDOW_HEIGHT) ),
          mIsShiftDown( GL_FALSE ),
          mIsLeftMouseDown( GL_FALSE ),
          mMousePosition( glm::vec2(0.0f, 0.0f) ),
          _isLeftShiftDown(GL_FALSE),
          _isRightShiftDown(GL_FALSE) {
 
}
 
inline CSCI441::OpenGL3DEngine::~OpenGL3DEngine() {
    delete mpArcballCamera;
}
 
#endif // CSCI441_OPENGL3D_ENGINE_HPP