Controller.cpp

#include "Controller.h"
#include "CameraBehaviors.hpp"
#include "GLFW/glfw3.h"
#include "TextRendering.hpp"
#include "sgraph/IScenegraph.h"
#include "sgraph/Scenegraph.h"
#include "sgraph/GroupNode.h"
#include "sgraph/LeafNode.h"
#include "sgraph/ScaleTransform.h"
#include "ObjImporter.h"

using namespace sgraph;

#include <iostream>

using namespace std;

#include "sgraph/ScenegraphExporter.h"
#include "sgraph/ScenegraphImporter.h"

#include <glm/ext/quaternion_trigonometric.hpp>

Controller::Controller(istream &scenegraphFile, Model &m, View &v) : model(m), view(v) {
    initScenegraph(scenegraphFile);

    globalCamera = new StationaryCamera(glm::vec3(0.0, 0.0, 30.0));
    globalCamera->LookAt(glm::vec3(0.0, 0.0, 0.0));
    cameras.push_back(globalCamera);

    helicopterCamera = new HelicopterCamera(175, 150, glm::radians(30.0), 25);
    cameras.push_back(helicopterCamera);

    firstPersonCamera = new FirstPersonCamera(glm::vec3{0, 30, 75}, 10, glm::radians(60.0));
    cameras.push_back(firstPersonCamera);
}

void Controller::initScenegraph(istream &scenegraphFile) {
    sgraph::ScenegraphImporter importer;

    //read in the file of commands
    IScenegraph *scenegraph = importer.parse(scenegraphFile);
    //scenegraph->setMeshes(meshes);
    model.setScenegraph(scenegraph);
    cout << "Scenegraph made" << endl;

    TextRendering tr;
    scenegraph->getRoot()->accept((sgraph::SGNodeVisitor *) &tr);
}

Controller::~Controller() {
    if (globalCamera) delete globalCamera;
    if (helicopterCamera) delete helicopterCamera;
    if (firstPersonCamera) delete firstPersonCamera;
}

void Controller::run() {
    sgraph::IScenegraph *scenegraph = model.getScenegraph();
    map<string, util::PolygonMesh<VertexAttrib> > meshes = scenegraph->getMeshes();

    view.init(this, model);

    float deltaTime = 0;
    while (!view.shouldWindowClose()) {
        for (auto &camera: cameras) {
            camera->Update(deltaTime);
        }

        deltaTime = view.display(scenegraph, cameras, cameras[activeCameraIndex]);
        if (deltaTime < 0) break;
    }
    view.closeWindow();
    exit(EXIT_SUCCESS);
}

void Controller::onkey(int key, int scancode, int action, int mods) {
    // cout << (char)key << " pressed" << endl;

    switch (key) {
        // Camera Switching
        case GLFW_KEY_1:
            if (action == GLFW_PRESS) activeCameraIndex = 0;
            break;
        case GLFW_KEY_2:
            if (action == GLFW_PRESS) activeCameraIndex = 1;
            break;
        case GLFW_KEY_3:
            if (action == GLFW_PRESS) activeCameraIndex = 2;
            break;

            // FPS Camera Movement
        case GLFW_KEY_MINUS:
            if (action == GLFW_PRESS)
                firstPersonCamera->PressedButton(FirstPersonCamera::Input::MoveBackward);
            else if (action == GLFW_RELEASE)
                firstPersonCamera->ReleasedButton(FirstPersonCamera::Input::MoveBackward);
            break;
        case GLFW_KEY_EQUAL:
            if (action == GLFW_PRESS)
                firstPersonCamera->PressedButton(FirstPersonCamera::Input::MoveForward);
            else if (action == GLFW_RELEASE)
                firstPersonCamera->ReleasedButton(FirstPersonCamera::Input::MoveForward);
            break;
        case GLFW_KEY_UP:
            if (action == GLFW_PRESS)
                firstPersonCamera->PressedButton(FirstPersonCamera::Input::LookUp);
            else if (action == GLFW_RELEASE)
                firstPersonCamera->ReleasedButton(FirstPersonCamera::Input::LookUp);
            break;
        case GLFW_KEY_DOWN:
            if (action == GLFW_PRESS)
                firstPersonCamera->PressedButton(FirstPersonCamera::Input::LookDown);
            else if (action == GLFW_RELEASE)
                firstPersonCamera->ReleasedButton(FirstPersonCamera::Input::LookDown);
            break;
        case GLFW_KEY_LEFT:
            if (action == GLFW_PRESS)
                firstPersonCamera->PressedButton(FirstPersonCamera::Input::LookLeft);
            else if (action == GLFW_RELEASE)
                firstPersonCamera->ReleasedButton(FirstPersonCamera::Input::LookLeft);
            break;
        case GLFW_KEY_RIGHT:
            if (action == GLFW_PRESS)
                firstPersonCamera->PressedButton(FirstPersonCamera::Input::LookRight);
            else if (action == GLFW_RELEASE)
                firstPersonCamera->ReleasedButton(FirstPersonCamera::Input::LookRight);
            break;

        case GLFW_KEY_R:
            if (action == GLFW_PRESS) firstPersonCamera->Reset();
            break;

        case GLFW_KEY_P:
            if (action == GLFW_PRESS)
                view.output_raytrace(model.getScenegraph(), cameras[activeCameraIndex]);

    }
}

void Controller::mousePosition(double xpos, double ypos) {
    // cout << xpos << ',' << ypos << endl;
    glm::vec2 currentDelta = glm::vec2(xpos, ypos) - currentMousePos;

    currentMousePos.x = xpos;
    currentMousePos.y = ypos;

    if (isMousePressed) {
        if (currentDelta == currentMousePos) return;
        glm::vec3 rotAxis = glm::vec3(currentDelta.y, currentDelta.x, 0);
        rotAxis = glm::normalize(rotAxis);
        // cout << "deltaMousePos: " << deltaMousePos.x << ", " << deltaMousePos.y << endl;
    }
}

void Controller::reshape(int width, int height) {
    cout << "Window reshaped to width=" << width << " and height=" << height << endl;
    view.resize();
}

void Controller::dispose() {
    view.closeWindow();
}

void Controller::error_callback(int error, const char *description) {
    fprintf(stderr, "Error: %s\n", description);
}

void Controller::mouseButton(int button, int action, int mods) {
    if (button != GLFW_MOUSE_BUTTON_LEFT) return;

    // cout << "button: " << button << " action: " << action << " mods: " << mods << endl;

    // Left click pressed.
    if (action == GLFW_PRESS)
        isMousePressed = true;
        // Left click released.
    else if (action == GLFW_RELEASE)
        isMousePressed = false;

    // cout << "isMousePressed: " << isMousePressed << endl;
}