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"
 
namespace CSCI441 {
 
    class OpenGL3DEngine : public OpenGLEngine {
    public:
        OpenGL3DEngine(const OpenGL3DEngine&) = delete;
        OpenGL3DEngine& operator=(const OpenGL3DEngine&) = delete;
 
        OpenGL3DEngine(OpenGL3DEngine&&) noexcept;
        OpenGL3DEngine& operator=(OpenGL3DEngine&&) noexcept;
 
        [[maybe_unused]] [[nodiscard]] virtual GLboolean isLeftMouseDown() const noexcept final { return mIsLeftMouseDown; }
        [[maybe_unused]] virtual void setLeftMouseDown(const GLboolean isDown) final { mIsLeftMouseDown = isDown; }
 
        [[maybe_unused]] [[nodiscard]] virtual GLboolean isShiftDown() const noexcept final { return mIsShiftDown; }
        [[maybe_unused]] virtual void setShiftDown(const GLboolean isDown) final { mIsShiftDown = isDown; }
 
        [[maybe_unused]] [[nodiscard]] virtual glm::vec2 getMousePosition() const noexcept final { return mMousePosition; }
        [[maybe_unused]] virtual void setMousePosition(const glm::vec2 mousePos) final { mMousePosition = mousePos; }
 
        [[maybe_unused]] virtual void setArcballCameraAngles( const 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(const 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( const 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( const 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(const double x, const double y) final {
            const 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
                    const GLfloat totChgSq = (currMousePos.x - mMousePosition.x) + (currMousePos.y - mMousePosition.y);
                    mpArcballCamera->moveForward( totChgSq * 0.05f );
                }
            }
 
            setMousePosition(currMousePos);
        }
 
        [[maybe_unused]] virtual void handleCameraKeyEvent(const int key, const int scancode, const int action, const 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(const int button, const int action, const int mods) final {
            if( button == GLFW_MOUSE_BUTTON_LEFT ) {
                mIsLeftMouseDown = (action == GLFW_PRESS);
            }
        }
 
        [[maybe_unused]] virtual void handleCameraScrollEvent(const double xOffset, const double yOffset) {
            mpArcballCamera->moveForward(static_cast<GLfloat>(yOffset) * 0.2f );
        }
 
        [[maybe_unused]] void handleCameraAspectRatioEvent(const int width, const int height) {
            mpArcballCamera->setAspectRatio( static_cast<GLfloat>(width) / static_cast<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, GLushort NUM_SAMPLES = 0);
        ~OpenGL3DEngine() override;
 
        CSCI441::PerspectiveCamera* mpArcballCamera;
 
        GLboolean mIsShiftDown;
        GLboolean mIsLeftMouseDown;
        glm::vec2 mMousePosition;
 
    private:
        GLboolean _isLeftShiftDown;
        GLboolean _isRightShiftDown;
 
        void _cleanupChildSelf();
        void _moveFromSource(OpenGL3DEngine& src);
    };
}
 
//*****************************************************************************************
 
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, const GLushort NUM_SAMPLES)
        : OpenGLEngine(OPENGL_MAJOR_VERSION, OPENGL_MINOR_VERSION, WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_TITLE, WINDOW_RESIZABLE, NUM_SAMPLES),
          mpArcballCamera( new CSCI441::ArcballCam(2.0f, 30.0f, static_cast<GLfloat>(WINDOW_WIDTH) / static_cast<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() {
    _cleanupChildSelf();
}
 
inline CSCI441::OpenGL3DEngine::OpenGL3DEngine(
    CSCI441::OpenGL3DEngine&& src
) noexcept : CSCI441::OpenGLEngine( std::move(src) ),
    mpArcballCamera(nullptr),
    mIsShiftDown(GL_FALSE),
    mIsLeftMouseDown(GL_FALSE),
    mMousePosition( glm::vec2(0.0f, 0.0f) ),
    _isLeftShiftDown(GL_FALSE),
    _isRightShiftDown(GL_FALSE)
{
    _moveFromSource( src );
}
 
inline CSCI441::OpenGL3DEngine& CSCI441::OpenGL3DEngine::operator=(CSCI441::OpenGL3DEngine&& src) noexcept {
    if (this != &src) {
        _cleanupChildSelf();
        _moveFromSource(src);
    }
 
    OpenGLEngine::operator=( std::move(src) );
 
    return *this;
}
 
inline void CSCI441::OpenGL3DEngine::_cleanupChildSelf() {
    delete mpArcballCamera;
    mpArcballCamera = nullptr;
}
 
inline void CSCI441::OpenGL3DEngine::_moveFromSource(OpenGL3DEngine& src) {
    mpArcballCamera = src.mpArcballCamera;
    src.mpArcballCamera = nullptr;
 
    mIsShiftDown = src.mIsShiftDown;
    src.mIsShiftDown = GL_FALSE;
 
    mIsLeftMouseDown = src.mIsLeftMouseDown;
    src.mIsLeftMouseDown = GL_FALSE;
 
    mMousePosition = src.mMousePosition;
    src.mMousePosition = glm::vec2(0.0f, 0.0f);
 
    _isLeftShiftDown = src._isLeftShiftDown;
    src._isLeftShiftDown = GL_FALSE;
 
    _isRightShiftDown = src._isRightShiftDown;
    src._isRightShiftDown = GL_FALSE;
}
 
#endif // CSCI441_OPENGL3D_ENGINE_HPP