controls.cpp

/*
Taken and modified from Tutorials - 6
*/

// Include GLFW
#include <GLFW/glfw3.h>
extern GLFWwindow* window; // The "extern" keyword here is to access the variable "window" declared in tutorialXXX.cpp. This is a hack to keep the tutorials simple. Please avoid this.

// Include GLM
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
using namespace glm;

#include <controls.hpp>

mat4 ViewMatrix;
mat4 ProjectionMatrix;
vec3 position = vec3(0, 1, 0);

mat4 getViewMatrix() {
	return ViewMatrix;
}

mat4 getProjectionMatrix() {
	return ProjectionMatrix;
}

vec3 getCameraPosition() {
	return position;
}

float horizontalAngle = 3.14f; 
float verticalAngle = 0.0f;
float initialFoV = 60.0f;

float speed = 3.0f; // 3 units /sec
float mouseSpeed = 0.005f;

// screen size
int width = 1980, height = 1080;


void computeMatricesFromInputs() {

	// it will run once
	static double lastTime = glfwGetTime();

	double currTime = glfwGetTime();
	float deltaTime = float(currTime - lastTime);
	
	// mouse pos
	double xpos, ypos;
	glfwGetCursorPos(window, &xpos, &ypos);

	// Reset mouse position for next frame
	glfwSetCursorPos(window, 1980 / 2, 1080 / 2);

	// angles 
	horizontalAngle += mouseSpeed * float(width / static_cast<double>(2) - xpos);
	verticalAngle	+= mouseSpeed * float(height / static_cast<double>(2) - ypos);
	
	// Clamp the vertical angle to prevent the camera from flipping
	// 89.9 degrees in radians is about 1.57
	if (verticalAngle > 1.57f) {
		verticalAngle = 1.57f;
	}
	if (verticalAngle < -1.57f) {
		verticalAngle = -1.57f;
	}

	// looking direction 
	vec3 direction(
		cos(verticalAngle) * sin(horizontalAngle),
		sin(verticalAngle),
		cos(verticalAngle) * cos(horizontalAngle)
	);
	
	// right vector
	vec3 right = vec3(
		sin(horizontalAngle - 3.14f / 2.0f),
		0,
		cos(horizontalAngle - 3.14f / 2.0f)
	);
	
	// up vector 
	vec3 up = cross(right, direction);

	// Move forward
	if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS ||
		glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) {
		position += direction * deltaTime * speed;
	}
	// Move backward
	if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS ||
		glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) {
		position -= direction * deltaTime * speed;
	}
	// Strafe right
	if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS ||
		glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) {
		position += right * deltaTime * speed;
	}
	// Strafe left
	if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS ||
		glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) {
		position -= right * deltaTime * speed;
	}
	// move above
	if (glfwGetKey(window, GLFW_KEY_LEFT_SHIFT ) == GLFW_PRESS ||
		glfwGetKey(window, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS) {
		position += up * deltaTime * speed;
	}
	// move down 
	if (glfwGetKey(window, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS ||
		glfwGetKey(window, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS) {
		position -= up * deltaTime * speed;
	}

	float FoV = initialFoV;

	// Projection matrix : fov Field of View, 16:9 ratio, display range : 0.1 unit <-> 100 units
	ProjectionMatrix = glm::perspective(glm::radians(FoV), 16.0f / 9.0f, 0.1f, 100.0f);
	// Camera matrix
	ViewMatrix = glm::lookAt(
		position,				// Camera is here
		position + direction,	// and looks here : at the same position, plus "direction"
		up						// Head is up (set to 0,-1,0 to look upside-down)
	);

	// For the next frame, the "last time" will be "now"
	lastTime = currTime;
}