411 lines
11 KiB
C++
411 lines
11 KiB
C++
|
|
#include "ShaderUtil.h"
|
|
|
|
#include "SceneInterface.h"
|
|
|
|
#include "PartitionedCube.h"
|
|
|
|
#include "Plane.h"
|
|
|
|
#include <glm/glm.hpp>
|
|
#include <glm/ext.hpp>
|
|
#include <glm/gtx/string_cast.hpp>
|
|
#include <GLFW/glfw3.h>
|
|
#include <iostream>
|
|
|
|
SceneInterface::SceneInterface() {
|
|
|
|
}
|
|
|
|
SceneInterface::~SceneInterface() {
|
|
std::reverse(_entities.begin(), _entities.end());
|
|
|
|
for(Entity* entity : _entities) {
|
|
delete entity;
|
|
}
|
|
|
|
delete currentAction;
|
|
}
|
|
|
|
void SceneInterface::Initialize(GLFWwindow* window) {
|
|
_inputSystem.SetWindow(window);
|
|
|
|
_inputSystem.ObserveKey(GLFW_KEY_SPACE);
|
|
_inputSystem.ObserveKey(GLFW_KEY_UP);
|
|
_inputSystem.ObserveKey(GLFW_KEY_DOWN);
|
|
_inputSystem.ObserveKey(GLFW_KEY_LEFT);
|
|
_inputSystem.ObserveKey(GLFW_KEY_RIGHT);
|
|
|
|
_inputSystem.ObserveKey(GLFW_KEY_LEFT_SHIFT);
|
|
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_1);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_2);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_3);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_4);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_5);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_6);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_7);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_8);
|
|
_inputSystem.ObserveKey(GLFW_KEY_KP_9);
|
|
|
|
_wasMouseDown = false;
|
|
|
|
_debug = new Debug(window);
|
|
|
|
PartitionedCubeMesh::LoadResources();
|
|
|
|
_camera = new Camera(window, &_inputSystem);
|
|
Cube* cube = new Cube();
|
|
_cube = cube;
|
|
|
|
_entities.push_back(_debug);
|
|
_entities.push_back(_camera);
|
|
_entities.push_back(_cube);
|
|
|
|
for(PartitionedCube** cube = _cube->Children();cube != _cube->Children() + _cube->ChildPartitionsCount;cube++) {
|
|
_entities.push_back(*cube);
|
|
}
|
|
|
|
std::cout << "Controls: " << std::endl;
|
|
std::cout << "Numpad 1, 2, 3, 7, 8, 9 + Shift Rotate X Axis Down Up View" << std::endl;
|
|
std::cout << "Numpad 1, 4, 7, 3, 6, 9 Rotate Y Axis Left Right View" << std::endl;
|
|
std::cout << "Arrows Up, Down, Right, Left Rotate Camera relative lookat" << std::endl;
|
|
std::cout << "Space Reset Look Changes" << std::endl;
|
|
std::cout << "Mouse Scroll Vertically Zoom" << std::endl;
|
|
std::cout << "Left Mouse Rotate Cube Planes" << std::endl;
|
|
std::cout << "Right Mouse Rotate Camera" << std::endl;
|
|
}
|
|
|
|
glm::vec3 basisCoordinateVectors[] = {
|
|
glm::vec3(1.0f, 0.0f, 0.0f),
|
|
glm::vec3(0.0f, 1.0f, 0.0f),
|
|
glm::vec3(0.0f, 0.0f, 1.0f)
|
|
};
|
|
|
|
glm::ivec3 orthogonalise(const glm::vec3& value) {
|
|
int minimum = 0;
|
|
for(int i=0;i<3;i++) {
|
|
if (abs(value[i])>abs(value[minimum]))
|
|
minimum = i;
|
|
}
|
|
|
|
glm::ivec3 orthogon = glm::vec3(0.0f);
|
|
|
|
orthogon[minimum] = glm::sign(value[minimum]);
|
|
|
|
return orthogon;
|
|
}
|
|
|
|
void roundAllScalars(glm::mat3& transforms) {
|
|
for(int x=0;x<3;x++) {
|
|
for(int y=0;y<3;y++) {
|
|
transforms[x][y] = round(transforms[x][y]);
|
|
}
|
|
}
|
|
}
|
|
|
|
glm::imat3x3 orthogonaliseMatrix(const glm::mat3& value) {
|
|
glm::mat3 temp = value;
|
|
|
|
roundAllScalars(temp);
|
|
|
|
glm::imat3x3 result;
|
|
|
|
for(int i=0;i<3;i++) {
|
|
result[i] = orthogonalise(value[i]);
|
|
|
|
for(int adjacent=i+1;adjacent<3;adjacent++) {
|
|
result[adjacent] = result[adjacent] * ( glm::abs(result[i]) * - 1 ) + 2;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void IntersectLinePlane(const glm::vec3& lineStart, const glm::vec3& lineDirection, const glm::vec3& planeOrigin, const glm::vec3& planeNormal, float& distance) {
|
|
glm::vec3 w = lineStart - planeOrigin;
|
|
|
|
float intersectionDistance = glm::dot(planeOrigin - lineStart, planeNormal) / glm::dot(lineDirection, planeNormal);
|
|
if (intersectionDistance > 0) {
|
|
distance = intersectionDistance;
|
|
}
|
|
}
|
|
|
|
void SceneInterface::EnqueueAction(Action* action) {
|
|
_actions.push(action);
|
|
}
|
|
|
|
void SceneInterface::Update(float deltaTime) {
|
|
_inputSystem.Update();
|
|
|
|
for(Entity* entity : _entities) {
|
|
entity->Update(deltaTime);
|
|
}
|
|
|
|
|
|
|
|
// int spinIndex = 0;
|
|
|
|
// Gather Axis (+x, +y)
|
|
glm::ivec3 spinAxis;
|
|
if (_inputSystem.IsKeyPressed(GLFW_KEY_LEFT_SHIFT))
|
|
spinAxis = glm::ivec3(1, 0, 0);
|
|
else
|
|
spinAxis = glm::ivec3(0, 1, 0);
|
|
|
|
// Numpad
|
|
int rotationKey = -1;
|
|
for(int i=1;i<10;i++) {
|
|
if (_inputSystem.WasKeyPressed(GLFW_KEY_KP_0 + i)) {
|
|
rotationKey = i;
|
|
}
|
|
}
|
|
|
|
if (rotationKey != -1) {
|
|
bool reverseVertical = spinAxis.x == 1 && (rotationKey == 7 || rotationKey == 8 || rotationKey == 9);
|
|
bool reverseHorizontal = spinAxis.y == 1 && (rotationKey == 1 || rotationKey == 4 || rotationKey == 7);
|
|
|
|
static const int keyToIndex[2][9] = { { -1, 0, 1, 0, 0, 0, -1, 0, 1 }, { -1, 0, -1, 0, 0, 0, 1, 0, 1 } };
|
|
|
|
bool reverse = reverseVertical || reverseHorizontal;
|
|
|
|
// spin which lookup
|
|
int axisIndex = spinAxis.x == 0; // x => 0, y => 1
|
|
int spinIndex = keyToIndex[axisIndex][rotationKey - 1];
|
|
|
|
int reverseSign = reverse ? -1 : 1;
|
|
|
|
spinAxis *= reverseSign;
|
|
spinIndex *= reverseSign;
|
|
|
|
glm::mat3 cubeMat = glm::mat3(_cube->LocalToWorld()) * glm::mat3(_camera->View());
|
|
|
|
glm::mat3 orthogonalized = cubeMat;
|
|
for(int column=0;column<3;column++) {
|
|
int nearestCardinalisedAxis = 0;
|
|
for(int i=0;i<3;i++) {
|
|
if (glm::abs(orthogonalized[column][i]) > glm::abs(orthogonalized[column][nearestCardinalisedAxis])) {
|
|
nearestCardinalisedAxis = i;
|
|
}
|
|
}
|
|
|
|
for(int columnToPlace=0;columnToPlace<3;columnToPlace++) {
|
|
for(int i=0;i<3;i++) {
|
|
if (columnToPlace == column) {
|
|
if (nearestCardinalisedAxis == i) {
|
|
orthogonalized[columnToPlace][i] = glm::sign(orthogonalized[columnToPlace][i]);
|
|
}
|
|
else {
|
|
orthogonalized[columnToPlace][i] = 0.0f;
|
|
}
|
|
}
|
|
else {
|
|
if (nearestCardinalisedAxis == i) {
|
|
orthogonalized[columnToPlace][i] = 0.0f;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
glm::mat3 screenToCube = glm::inverse(orthogonalized);
|
|
|
|
spinAxis = screenToCube * spinAxis;
|
|
int direction = spinAxis.x + spinAxis.y + spinAxis.z;
|
|
|
|
EnqueueAction(new ActionSpinDefault(_cube, spinAxis, spinIndex, 1.0f));
|
|
|
|
// _cube.TransformAnimation(cubeSpinAxis, spinIndex, rotation, 1.0f);
|
|
|
|
std::cout << glm::to_string(spinAxis) << " " << spinIndex << std::endl;
|
|
}
|
|
|
|
if (currentAction == nullptr) {
|
|
if (!_wasMouseDown && _inputSystem.IsLeftMouseDown()) {
|
|
OnDragStart();
|
|
}
|
|
else if (_wasMouseDown && !_inputSystem.IsLeftMouseDown()) {
|
|
OnDragStop();
|
|
}
|
|
else if (_wasMouseDown && _inputSystem.IsLeftMouseDown()) {
|
|
OnDrag(deltaTime);
|
|
}
|
|
|
|
_wasMouseDown = _inputSystem.IsLeftMouseDown();
|
|
}
|
|
|
|
if (currentAction != nullptr) {
|
|
currentAction->duration -= deltaTime;
|
|
}
|
|
|
|
if (currentAction != nullptr && currentAction->duration > 0.0f) {
|
|
return;
|
|
}
|
|
|
|
if (_actions.size() > 0) {
|
|
delete currentAction;
|
|
|
|
Action* action = _actions.front();
|
|
_actions.pop();
|
|
|
|
ApplyAction(action);
|
|
}
|
|
else {
|
|
currentAction = nullptr;
|
|
}
|
|
}
|
|
|
|
void SceneInterface::OnDragStart() {
|
|
_inputSystem.GetMousePos(_initialMouseLocation);
|
|
|
|
glm::vec3 lineStart;
|
|
glm::vec3 lineDirection;
|
|
glm::mat4 viewPerspective = _camera->Projection() * _camera->View();
|
|
|
|
_inputSystem.GetPickingRay(viewPerspective, lineStart, lineDirection);
|
|
|
|
glm::mat4 transform = _cube->LocalToWorld();
|
|
|
|
for(int axis=0;axis<3;axis++) {
|
|
for(int direction=-1;direction<=1;direction+=2) {
|
|
Plane plane(transform, axis, direction);
|
|
|
|
if (glm::dot(plane.Normal(), lineDirection) > 0)
|
|
continue;
|
|
|
|
float intersectionDistance = -1.0f;
|
|
IntersectLinePlane(lineStart, lineDirection, plane.Origin(), plane.Normal(), intersectionDistance);
|
|
|
|
if (intersectionDistance == -1.0f) {
|
|
continue;
|
|
}
|
|
|
|
const glm::mat4& planeTransform = plane.Transform();
|
|
glm::vec4 intersectionPoint = glm::vec4(lineStart + lineDirection * intersectionDistance, 1.0f);
|
|
glm::vec4 intersectionPlane = glm::inverse(planeTransform) * intersectionPoint;
|
|
|
|
bool onPlane = abs(intersectionPlane.x) < 1.501f && abs(intersectionPlane.y) < 1.501f;
|
|
|
|
if (!onPlane) {
|
|
continue;
|
|
}
|
|
|
|
_spinDelta = 0.0f;
|
|
_spinIndex = -1;
|
|
_plane = plane;
|
|
|
|
_mousePositionPlane = intersectionPlane;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SceneInterface::OnDrag(double deltaTime) {
|
|
glm::vec2 currentMousePosition;
|
|
|
|
_inputSystem.GetMousePos(currentMousePosition);
|
|
|
|
glm::vec3 lineStart;
|
|
glm::vec3 lineDirection;
|
|
glm::mat4 transform = _camera->Projection() * _camera->View();
|
|
_inputSystem.GetPickingRay(transform, lineStart, lineDirection);
|
|
|
|
float intersectionDistance = -1.0f;
|
|
IntersectLinePlane(lineStart, lineDirection, _plane.Origin(), _plane.Normal(), intersectionDistance);
|
|
|
|
if (intersectionDistance == -1.0f) {
|
|
return;
|
|
}
|
|
|
|
const glm::mat4& planeTransform = _plane.Transform();
|
|
glm::vec2 intersectionPlane = glm::inverse(planeTransform) * (glm::vec4(lineStart + lineDirection * intersectionDistance, 1.0f));
|
|
glm::vec2 directionPlane = intersectionPlane - _mousePositionPlane;
|
|
|
|
float dragAbsDistance = abs(glm::distance(glm::vec2(0.0f), directionPlane));
|
|
|
|
if (dragAbsDistance >= MIN_DRAG_MAGNITUDE) {
|
|
glm::vec3 mousePosition = planeTransform * glm::vec4(_mousePositionPlane, 0.0f, 1.0f);
|
|
|
|
glm::vec3 direction = glm::inverse(planeTransform) * glm::vec4(directionPlane, 0.0f, 0.0f);
|
|
|
|
direction = glm::normalize(direction);
|
|
|
|
glm::vec3 axisSingle = glm::cross(_plane.Normal(), direction);
|
|
axisSingle = orthogonalise(axisSingle);
|
|
|
|
float projection = glm::dot(mousePosition, axisSingle);
|
|
|
|
int index = floor((projection + 0.5f));
|
|
|
|
glm::ivec3 axis = orthogonalise(axisSingle);
|
|
|
|
_cube->UndoTransformTemp();
|
|
|
|
float angle = glm::radians(90.0f * ( 1.0f / 3.0f ) * abs(glm::distance(glm::vec2(0.0f), directionPlane)));
|
|
|
|
_cube->TransformTemp(axis, index, glm::rotate(glm::mat4(1.0f), angle, axisSingle));
|
|
_spinIndex = index;
|
|
_spinAxis = axis;
|
|
_spinDelta = angle;
|
|
}
|
|
}
|
|
|
|
const float rotations = 2 * glm::pi<float>();
|
|
|
|
const float quarterRotation = rotations * 0.25f;
|
|
|
|
void SceneInterface::OnDragStop() {
|
|
// Undo any temporarilies
|
|
_cube->UndoTransformTemp();
|
|
|
|
if (_spinDelta < 0.001f)
|
|
return;
|
|
|
|
// Transform Instantly to current angle
|
|
_cube->Transform(_spinAxis, _spinIndex, glm::rotate(glm::mat4(1.0f), _spinDelta, glm::vec3(_spinAxis)));
|
|
|
|
float angleNormalized = std::fmodf(_spinDelta, quarterRotation);
|
|
|
|
float remainingAngle = 0.5f - glm::abs(angleNormalized - quarterRotation * 0.5f);
|
|
|
|
float remainingFactor = remainingAngle / quarterRotation;
|
|
|
|
int rotations = round(_spinDelta / quarterRotation);
|
|
|
|
// remaining rotation animating
|
|
if (_spinDelta > 0.0f && rotations > 0) {
|
|
EnqueueAction(new ActionSpinAfterDragging(_cube, _spinAxis, _spinIndex, ( quarterRotation * rotations ) - _spinDelta, rotations, remainingFactor * 1.0f));
|
|
}
|
|
else {
|
|
EnqueueAction(new ActionSpinAfterDragging(_cube, _spinAxis, _spinIndex, -( _spinDelta ), rotations, remainingFactor * 1.0f));
|
|
}
|
|
}
|
|
|
|
void SceneInterface::ApplyAction(Action* action) {
|
|
currentAction = action;
|
|
|
|
action->Invoke();
|
|
}
|
|
|
|
void SceneInterface::Render(float aspectRatio) {
|
|
if (_camera == nullptr)
|
|
return;
|
|
|
|
DefaultUniform uniform;
|
|
uniform.view = _camera->View();
|
|
uniform.projection = _camera->Projection();
|
|
|
|
for(Entity* entity : _entities) {
|
|
uniform.model = entity->LocalToWorld();
|
|
|
|
entity->Render(uniform);
|
|
}
|
|
|
|
// std::cout << "perspective: " << glm::to_string(glm::perspective(glm::radians(45.0f), aspectRatio, 0.1f, 100.0f)) << std::endl;
|
|
// std::cout << "view : " << glm::to_string(glm::lookAt(glm::vec3(0.0f, 0.0f, -3.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f))) << std::endl;
|
|
// std::cout << "model : " << glm::to_string(_cube.Transform()) << std::endl;
|
|
}
|
|
|
|
void SceneInterface::ClearResources() {
|
|
|
|
}
|