Camera.cpp

#include "Defines.h"
#include "Camera.h"

#include <cstdint>
#include <iomanip>

Camera::Camera()
	:pitch(0), yaw(0), rotationSpeed(0), speed(0)
{
	this->right = { 1,0,0 };//x
	this->up = { 0,1,0 };//y
	this->forward = { 0,0,1 };//z
	
	// Builds a view matrix for a left-handed coordinate system using a camera position, an up direction, and a focal point, XMLoadFloat3 = Loads an XMFLOAT3 into an XMVECTOR
	this->viewMatrix = XMMatrixLookAtLH(XMLoadFloat3(&pos), forward, up);
	// Builds a left-handed perspective projection matrix based on a field of view, XM_PIDIV4 =  π/4
	perspectiveMatrix = XMMatrixPerspectiveFovLH(XM_PIDIV4, (float)1024 / float(576), 0.1f, 100.0f);

	this->direction = forward;
}


Camera::Camera(float fov, float aspectRatio, float nearZ, float farZ, float rotationSpeed, float speed, XMFLOAT3 pos)
	:pos(pos), pitch(0), yaw(-XM_PIDIV2), rotationSpeed(rotationSpeed), speed(speed)
{

	this->up = { 0,1,0 };		 // Y
	this->forward = { 0, 0, 1 }; // Z
	this->right = { 1,0,0 };	 // X
	this->viewMatrix = XMMatrixLookAtLH(XMLoadFloat3(&pos), forward, up);

	this->perspectiveMatrix = XMMatrixPerspectiveFovLH(fov, aspectRatio, nearZ, farZ);

	this->direction = forward;

	this->fov = fov;
	this->aspectRatio = aspectRatio;
	this->nearZ = nearZ;
	this->farZ = farZ;
}

void Camera::MoveRight(float dt)
{
	XMVECTOR forwardVec = XMVector3Transform(forward, XMMatrixRotationRollPitchYaw(pitch, yaw, 0.0f) * XMMatrixScaling(speed, speed, speed));

	XMVECTOR rightVec = XMVector3Cross(up, forwardVec);
	rightVec = XMVector3Normalize(rightVec);
	XMFLOAT3 rightFloat;
	XMStoreFloat3(&rightFloat, rightVec);

	pos.x += rightFloat.x * dt * speed;
	pos.y += rightFloat.y * dt * speed;
	pos.z += rightFloat.z * dt * speed;
}



void Camera::MoveForward(float dt)
{
	XMVECTOR forwardVec = XMVector3Transform(forward,
		XMMatrixRotationRollPitchYaw(pitch, yaw, 0.0f) *
		XMMatrixScaling(speed, speed, speed));

	forwardVec = XMVector3Normalize(forwardVec);
	XMFLOAT3 forwardFloat;

	XMStoreFloat3(&forwardFloat, forwardVec);

	pos.x += forwardFloat.x * dt * speed;
	pos.y += forwardFloat.y * dt * speed;
	pos.z += forwardFloat.z * dt * speed;
}

void Camera::MoveUpDown(float dt)
{
	XMVECTOR upDownVec = XMVector3Transform(moveUp,
		XMMatrixRotationRollPitchYaw(pitch, yaw, 0.0f) *
		XMMatrixScaling(speed, speed, speed));

	upDownVec = XMVector3Normalize(upDownVec);
	XMFLOAT3 upDownFloat;

	XMStoreFloat3(&upDownFloat, upDownVec);

	//position.x += upDownFloat.x * dt * speed;
	pos.y += upDownFloat.y * dt * speed;
	//position.z += upDownFloat.z * dt * speed;
}

void Camera::Rotate(float dx, float dy)
{
	cubeX = dx;
	cubeY = dy; //make get func for these
	yaw = (yaw + dx * rotationSpeed);
	yaw = (float)fmod((double)yaw + XM_PI, XM_2PI);
	if (yaw < 0)
		yaw += XM_2PI;
	yaw -= XM_PI;
	
	pitch = std::clamp(pitch + dy * rotationSpeed, 0.995f * -XM_PIDIV2, 0.995f * XM_PIDIV2);
	//Clamps a variable to a given range[high – low].
}

void Camera::Update(float dt)
{
	// Move and change the camera on key press

	if (GetAsyncKeyState('W'))
	{
		MoveForward(dt);

	}
	if (GetAsyncKeyState('S'))
	{
		MoveForward(-dt);
	}
	if (GetAsyncKeyState('A'))
	{
		MoveRight(-dt);
	}
	if (GetAsyncKeyState('D'))
	{
		MoveRight(dt);
	}

	if (GetAsyncKeyState(VK_CONTROL))
	{
		MoveUpDown(dt);
	}

	if (GetAsyncKeyState(VK_SPACE))
	{
		MoveUpDown(-dt);
	}

	if (GetAsyncKeyState(VK_RIGHT))
	{
		Rotate(dt, 0);
	}
	if (GetAsyncKeyState(VK_LEFT))
	{
		Rotate(-dt, 0);
	}

	if (GetAsyncKeyState(VK_UP))
	{
		Rotate(0, -dt);
	}
	if (GetAsyncKeyState(VK_DOWN))
	{
		Rotate(0, dt);
	}

	const XMVECTOR lookAtVec = XMVector3Transform(forward, XMMatrixRotationRollPitchYaw(pitch, yaw, 0.0f));
	const XMVECTOR target = XMLoadFloat3(&pos) + lookAtVec;
	direction = XMVector3Normalize(lookAtVec);

	this->viewMatrix = XMMatrixLookAtLH(XMLoadFloat3(&pos), target, up);
}

void Camera::SetTargetPosition(float x, float y, float z)
{
	this->lookAt = XMVectorSet(x, y, z, 1.0f);
}

void Camera::SetViewMatrixForCube(XMVECTOR eye, XMVECTOR lookAt, XMVECTOR upVec)
{
	this->viewMatrix = XMMatrixLookAtLH(eye, lookAt, upVec);
}

void Camera::SetUpvector(float x, float y, float z)
{
	this->upVector = XMVectorSet(x, y, z, 0.0f);
}

void Camera::SetPos(XMFLOAT3 pos)
{
	this->pos = pos;
}

XMMATRIX Camera::ViewProj()const
{
	return XMMatrixMultiply(this->viewMatrix, this->perspectiveMatrix);
}

XMFLOAT3 Camera::GetPosition()const
{
	return this->pos;
}

float Camera::GetNearZ() 
{ 
	return this->nearZ; 
};
float Camera::GetFarZ()  
{ 
	return this->farZ; 
};
float Camera::GetRatio()  
{ 
	return this->aspectRatio; 
};
float Camera::GetFov()  
{ 
	return this->fov; 
};
XMVECTOR Camera::GetUpVector()  
{ 
	return this->up; 
};
XMFLOAT3 Camera::GetPosition()  
{ 
	return this->pos; 
}
XMMATRIX Camera::GetViewMatrix()  
{ 
	return this->viewMatrix; 
};
XMMATRIX Camera::GetPerspectiveMatrix()  
{ 
	return this->perspectiveMatrix; 
};


void Camera::LookAt(FXMVECTOR position, FXMVECTOR target, FXMVECTOR worldUp)
{
	XMVECTOR L = XMVector3Normalize(XMVectorSubtract(target, position));
	XMVECTOR R = XMVector3Normalize(XMVector3Cross(worldUp, L));
	XMVECTOR U = XMVector3Cross(L, R);

	XMStoreFloat3(&pos, position);
	this->lookAt= L; //maybe this works?
	this->right = R;
	this->up = U;
}

void Camera::LookAt(const XMFLOAT3& pos, const XMFLOAT3& target, const XMFLOAT3& up)
{
	XMVECTOR P = XMLoadFloat3(&pos);
	XMVECTOR T = XMLoadFloat3(&target);
	XMVECTOR U = XMLoadFloat3(&up);

	LookAt(P, T, U);
}



void Camera::SetLens(float fovY, float aspect, float zn, float zf)
{
	// cache properties
	this->fov = fovY;
	this->aspectRatio = aspect;
	this->nearZ = zn;
	this->farZ = zf;

	//mNearWindowHeight = 2.0f * mNearZ * tanf(0.5f * mFovY);
	//mFarWindowHeight = 2.0f * mFarZ * tanf(0.5f * mFovY);

	XMMATRIX P = XMMatrixPerspectiveFovLH(this->fov, this->aspectRatio, this->nearZ, this->farZ);
	this->perspectiveMatrix = P;
}



void Camera::UpdateViewMatrix()
{
	XMVECTOR R = right;
	XMVECTOR U = up;
	XMVECTOR L = lookAt;
	XMVECTOR P = XMLoadFloat3(&pos);

	// Keep camera's axes orthogonal to each other and of unit length.
	L = XMVector3Normalize(L);
	U = XMVector3Normalize(XMVector3Cross(L, R));

	// U, L already ortho-normal, so no need to normalize cross product.
	R = XMVector3Cross(U, L);

	// Fill in the view matrix entries.
	float x = -XMVectorGetX(XMVector3Dot(P, R));
	float y = -XMVectorGetX(XMVector3Dot(P, U));
	float z = -XMVectorGetX(XMVector3Dot(P, L));

	this->right = R;
	this->up = U;
	this->lookAt = L;

	XMFLOAT4X4 tempView;
	XMFLOAT3 tempRight, tempUp, tempLook;
	XMStoreFloat3(&tempRight, right);
	XMStoreFloat3(&tempUp, up);
	XMStoreFloat3(&tempLook, lookAt);

	tempView(0, 0) = tempRight.x;
	tempView(1, 0) = tempRight.y;
	tempView(2, 0) = tempRight.z;
	tempView(3, 0) = x;

	tempView(0, 1) = tempUp.x;
	tempView(1, 1) = tempUp.y;
	tempView(2, 1) = tempUp.z;
	tempView(3, 1) = y;

	tempView(0, 2) = tempLook.x;
	tempView(1, 2) = tempLook.y;
	tempView(2, 2) = tempLook.z;
	tempView(3, 2) = z;

	tempView(0, 3) = 0.0f;
	tempView(1, 3) = 0.0f;
	tempView(2, 3) = 0.0f;
	tempView(3, 3) = 1.0f;

	viewMatrix = XMLoadFloat4x4(&tempView);
}