From 56858ab1577f39840fb72b8ad5c4773a5925af96 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Mon, 10 Jul 2023 00:57:27 -0400 Subject: [PATCH 01/13] Oritentation fixed progress --- Nuake/src/Core/Physics/DynamicWorld.cpp | 12 ++++++++++-- Nuake/src/Scene/Scene.cpp | 7 ------- Nuake/src/Scene/Systems/TransformSystem.cpp | 16 ++++++++++------ 3 files changed, 20 insertions(+), 15 deletions(-) diff --git a/Nuake/src/Core/Physics/DynamicWorld.cpp b/Nuake/src/Core/Physics/DynamicWorld.cpp index bb5fa6ae..64175d82 100644 --- a/Nuake/src/Core/Physics/DynamicWorld.cpp +++ b/Nuake/src/Core/Physics/DynamicWorld.cpp @@ -289,8 +289,16 @@ namespace Nuake settings->mShape = GetJoltShape(cc->Shape); settings->mGravityFactor = 0.0f; - auto& joltPos = JPH::Vec3(cc->Position.x, cc->Position.y, cc->Position.z); - JPH::Character* character = new JPH::Character(settings, joltPos, JPH::Quat::sIdentity(), cc->GetEntity().GetID() , _JoltPhysicsSystem.get()); + auto& joltPosition = JPH::Vec3(cc->Position.x, cc->Position.y, cc->Position.z); + + Quat& bodyRotation = cc->Rotation; + + // We need to add 180 degrees because our forward is -Z. + const auto& yOffset = Vector3(0.0f, Rad(180.0), 0.0f); + bodyRotation = glm::normalize(bodyRotation * Quat(yOffset)); + + const auto& joltRotation = JPH::Quat(bodyRotation.x, bodyRotation.y, bodyRotation.z, bodyRotation.w); + JPH::Character* character = new JPH::Character(settings, joltPosition, joltRotation, cc->GetEntity().GetID() , _JoltPhysicsSystem.get()); character->AddToPhysicsSystem(JPH::EActivation::Activate); diff --git a/Nuake/src/Scene/Scene.cpp b/Nuake/src/Scene/Scene.cpp index 4172cbcf..3f0bc5d6 100644 --- a/Nuake/src/Scene/Scene.cpp +++ b/Nuake/src/Scene/Scene.cpp @@ -142,13 +142,6 @@ namespace Nuake { { auto [transform, camera, parent] = view.get(e); cam = camera.CameraInstance; - - cam->Translation = transform.GetGlobalPosition(); - - const Vector3& forward = QuatToDirection(transform.GetGlobalRotation()); - cam->SetDirection(forward); - - camTransform = transform.GetGlobalTransform(); break; } } diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index 5ea67f1f..3747f533 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -1,13 +1,14 @@ #include "TransformSystem.h" #include "src/Core/Maths.h" - #include "src/Scene/Scene.h" -#include -#include -#include -#include "src/Vendors/glm/gtx/matrix_decompose.hpp" -namespace Nuake { +#include "src/Scene/Components/TransformComponent.h" +#include "src/Scene/Components/CameraComponent.h" +#include "src/Scene/Components/ParentComponent.h" + + +namespace Nuake +{ TransformSystem::TransformSystem(Scene* scene) { m_Scene = scene; @@ -43,6 +44,9 @@ namespace Nuake { Matrix4 cameraTransform = camera.CameraInstance->GetTransformRotation(); camera.CameraInstance->Translation = transform.GlobalTranslation; + + // We need to invert forward direction since its -1.0f in nuake. + camera.CameraInstance->SetDirection(QuatToDirection(transform.GetGlobalRotation())); } // Calculate all local transforms From 07002f0d4a8957e4be6e5611b5c5640a0e26eb9a Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Mon, 10 Jul 2023 17:36:17 -0400 Subject: [PATCH 02/13] Better maths --- Editor/src/Misc/GizmoDrawer.cpp | 2 +- Nuake/src/Core/Maths.cpp | 4 +-- Nuake/src/Core/Physics/DynamicWorld.cpp | 23 ++++++--------- Nuake/src/Scene/Scene.cpp | 13 ++++++++- Nuake/src/Scene/Systems/TransformSystem.cpp | 31 ++++++++++----------- 5 files changed, 39 insertions(+), 34 deletions(-) diff --git a/Editor/src/Misc/GizmoDrawer.cpp b/Editor/src/Misc/GizmoDrawer.cpp index a33cbcc9..3a9524ee 100644 --- a/Editor/src/Misc/GizmoDrawer.cpp +++ b/Editor/src/Misc/GizmoDrawer.cpp @@ -36,7 +36,7 @@ GizmoDrawer::GizmoDrawer() _gizmos = std::map>(); _gizmos["cam"] = loader.LoadModel("resources/Models/Camera.gltf"); _gizmos["light"] = loader.LoadModel("resources/Models/Light.gltf"); - _gizmos["player"] = loader.LoadModel("resources/Models/Player.gltf"); + _gizmos["player"] = loader.LoadModel("resources/Models/Camera.gltf"); } void GizmoDrawer::GenerateSphereGizmo() diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index e0889bce..d8e19a87 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -4,10 +4,10 @@ using namespace Nuake; Quat Nuake::QuatFromEuler(float x, float y, float z) { - return Quat(Vector3(Rad(z), Rad(y), Rad(x))); + return Quat(Vector3(Rad(x), Rad(y), Rad(z))); } Vector3 Nuake::QuatToDirection(const Quat& quat) { - return glm::rotate(glm::inverse(quat), glm::vec3(1.0, 0.0, 0.0)); + return quat * Vector3(0, 0, -1); } \ No newline at end of file diff --git a/Nuake/src/Core/Physics/DynamicWorld.cpp b/Nuake/src/Core/Physics/DynamicWorld.cpp index e6804e18..a5b18354 100644 --- a/Nuake/src/Core/Physics/DynamicWorld.cpp +++ b/Nuake/src/Core/Physics/DynamicWorld.cpp @@ -445,29 +445,24 @@ namespace Nuake SyncCharactersTransforms(); } - void DynamicWorld::Clear() { _stepCount = 0; - if (_registeredBodies.empty()) + if (!_registeredBodies.empty()) { - return; + _JoltBodyInterface->RemoveBodies(reinterpret_cast(_registeredBodies.data()), _registeredBodies.size()); + _registeredBodies.clear(); } - _JoltBodyInterface->RemoveBodies(reinterpret_cast(_registeredBodies.data()), _registeredBodies.size()); - _registeredBodies.clear(); - - if (_registeredCharacters.empty()) + if (!_registeredCharacters.empty()) { - return; + for (auto& character : _registeredCharacters) + { + character.second->RemoveFromPhysicsSystem(); + } + _registeredCharacters.clear(); } - - for (auto& character : _registeredCharacters) - { - character.second->RemoveFromPhysicsSystem(); - } - _registeredCharacters.clear(); } void DynamicWorld::MoveAndSlideCharacterController(const Entity& entity, const Vector3 velocity) diff --git a/Nuake/src/Scene/Scene.cpp b/Nuake/src/Scene/Scene.cpp index 3f0bc5d6..83105bbb 100644 --- a/Nuake/src/Scene/Scene.cpp +++ b/Nuake/src/Scene/Scene.cpp @@ -142,6 +142,13 @@ namespace Nuake { { auto [transform, camera, parent] = view.get(e); cam = camera.CameraInstance; + + cam->Translation = transform.GetGlobalPosition(); + + //const Vector3& forward = QuatToDirection(transform.GetGlobalRotation()); + //cam->SetDirection(forward); + + //camTransform = transform.GetGlobalTransform(); break; } } @@ -151,6 +158,10 @@ namespace Nuake { return; } + float x = cam->GetDirection().x; + float y = cam->GetDirection().y; + float z = cam->GetDirection().z; + Logger::Log("DIRECTION: (" + std::to_string(x) + ", " + std::to_string(y) + ", " + std::to_string(z) + ")"); mSceneRenderer->BeginRenderScene(cam->GetPerspective(), cam->GetTransform(), cam->Translation); mSceneRenderer->RenderScene(*this, framebuffer); } @@ -237,7 +248,7 @@ namespace Nuake { Ref Scene::GetCurrentCamera() { - if (Engine::IsPlayMode) + if (Engine::IsPlayMode()) { Ref cam = nullptr; { diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index 3747f533..6ddb3740 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -2,10 +2,9 @@ #include "src/Core/Maths.h" #include "src/Scene/Scene.h" -#include "src/Scene/Components/TransformComponent.h" -#include "src/Scene/Components/CameraComponent.h" -#include "src/Scene/Components/ParentComponent.h" - +#include +#include +#include namespace Nuake { @@ -37,18 +36,6 @@ namespace Nuake void TransformSystem::UpdateTransform() { - auto camView = m_Scene->m_Registry.view(); - for (auto e : camView) - { - auto [transform, camera] = camView.get(e); - Matrix4 cameraTransform = camera.CameraInstance->GetTransformRotation(); - - camera.CameraInstance->Translation = transform.GlobalTranslation; - - // We need to invert forward direction since its -1.0f in nuake. - camera.CameraInstance->SetDirection(QuatToDirection(transform.GetGlobalRotation())); - } - // Calculate all local transforms auto localTransformView = m_Scene->m_Registry.view(); for (auto tv : localTransformView) @@ -114,5 +101,17 @@ namespace Nuake transform.SetGlobalScale(globalScale); transform.SetGlobalTransform(globalTransform); } + + auto camView = m_Scene->m_Registry.view(); + for (auto& e : camView) + { + auto [transform, camera] = camView.get(e); + Matrix4 cameraTransform = camera.CameraInstance->GetTransformRotation(); + camera.CameraInstance->Translation = transform.GlobalTranslation; + + const auto& globalRotation = transform.GetGlobalRotation(); + const auto& forward = QuatToDirection(globalRotation); + camera.CameraInstance->SetDirection(forward); + } } } From cc1b3237a54b653bc47fa2f6d661fa9369336864 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Tue, 11 Jul 2023 00:39:09 -0400 Subject: [PATCH 03/13] Partial fix --- Nuake/src/Core/Maths.cpp | 5 +++-- Nuake/src/Rendering/Camera.cpp | 2 +- Nuake/src/Scene/Systems/TransformSystem.cpp | 3 ++- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index d8e19a87..563770d1 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -4,10 +4,11 @@ using namespace Nuake; Quat Nuake::QuatFromEuler(float x, float y, float z) { - return Quat(Vector3(Rad(x), Rad(y), Rad(z))); + return Quat(Vector3(Rad(z), Rad(y), Rad(x))); } Vector3 Nuake::QuatToDirection(const Quat& quat) { - return quat * Vector3(0, 0, -1); + //return quat * Vector3(0, 0, -1); + return glm::rotate(glm::inverse(quat), glm::vec3(-1.0, 0.0, 0.0)); } \ No newline at end of file diff --git a/Nuake/src/Rendering/Camera.cpp b/Nuake/src/Rendering/Camera.cpp index 42557112..5b3249e6 100644 --- a/Nuake/src/Rendering/Camera.cpp +++ b/Nuake/src/Rendering/Camera.cpp @@ -52,7 +52,7 @@ namespace Nuake //cam->cameraRight = glm::normalize(glm::cross(cam->up, cam->cameraFront)); Direction = glm::normalize(direction); Right = glm::normalize(glm::cross(Vector3(0, 1, 0), Direction)); - //Up = glm::normalize(glm::cross(Direction, Right)) + //Up = glm::normalize(glm::cross(Direction, Right)); } Vector3 Camera::GetTranslation() { diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index 6ddb3740..c9e776ae 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -110,7 +110,8 @@ namespace Nuake camera.CameraInstance->Translation = transform.GlobalTranslation; const auto& globalRotation = transform.GetGlobalRotation(); - const auto& forward = QuatToDirection(globalRotation); + auto& forward = QuatToDirection(globalRotation); + //forward *= -1.0; camera.CameraInstance->SetDirection(forward); } } From 9ad09ff74931823794ed886e4af4c4da4e9a53e9 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Tue, 11 Jul 2023 16:32:01 -0400 Subject: [PATCH 04/13] FIxed gizmo --- Editor/src/Windows/EditorInterface.cpp | 32 +++++++++---------- Nuake/src/Core/Maths.cpp | 2 +- .../src/Scene/Components/TransformComponent.h | 1 + Nuake/src/Scene/Scene.cpp | 24 ++++---------- 4 files changed, 24 insertions(+), 35 deletions(-) diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index 292dbe6b..de1c716b 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -182,48 +182,48 @@ namespace Nuake { if (Selection.Type == EditorSelectionType::Entity && !Engine::IsPlayMode()) { TransformComponent& tc = Selection.Entity.GetComponent(); - ParentComponent& parent = Selection.Entity.GetComponent(); Matrix4 transform = tc.GetGlobalTransform(); - - auto editorCam = Engine::GetCurrentScene()->GetCurrentCamera(); + const auto& editorCam = Engine::GetCurrentScene()->GetCurrentCamera(); Matrix4 cameraView = editorCam->GetTransform(); Matrix4 cameraProjection = editorCam->GetPerspective(); + // Imguizmo calculates the delta from the gizmo, ImGuizmo::Manipulate( glm::value_ptr(cameraView), glm::value_ptr(cameraProjection), CurrentOperation, CurrentMode, glm::value_ptr(transform) ); - Matrix4 oldTransform = transform; + if (ImGuizmo::IsUsing()) { - Vector3 globalPos = Vector3(); - Entity currentParent = Selection.Entity; + // Since imguizmo returns a transform in global space and we want the local transform, + // we need to multiply by the inverse of the parent's global transform in order to revert + // the changes from the parent transform. + Matrix4 localTransform = transform; + ParentComponent& parent = Selection.Entity.GetComponent(); if (parent.HasParent) { Matrix4 inverseParent = glm::inverse(parent.Parent.GetComponent().GetGlobalTransform()); - oldTransform *= inverseParent; + localTransform = inverseParent * localTransform; } + // Decompose local transform Vector3 scale = Vector3(); Quat rotation = Quat(); Vector3 pos = Vector3(); - Vector3 skew = Vector3(); - Vector4 pesp = Vector4(); - glm::decompose(oldTransform, scale, rotation, pos, skew, pesp); - + ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(localTransform), glm::value_ptr(pos), glm::value_ptr(rotation), glm::value_ptr(scale)); + tc.Translation = pos; - tc.Rotation = rotation; + //tc.Rotation = rotation; tc.Scale = scale; - tc.LocalTransform = oldTransform; + tc.LocalTransform = localTransform; + // Decompose global trasnform Vector3 gscale = Vector3(); Quat grotation = Quat(); Vector3 gpos = Vector3(); - Vector3 gskew = Vector3(); - Vector4 gpesp = Vector4(); - glm::decompose(transform, gscale, grotation, gpos, skew, pesp); + ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(transform), glm::value_ptr(gpos), glm::value_ptr(grotation), glm::value_ptr(gscale)); tc.SetGlobalPosition(gpos); tc.SetGlobalRotation(grotation); diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index 563770d1..f77709c5 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -10,5 +10,5 @@ Quat Nuake::QuatFromEuler(float x, float y, float z) Vector3 Nuake::QuatToDirection(const Quat& quat) { //return quat * Vector3(0, 0, -1); - return glm::rotate(glm::inverse(quat), glm::vec3(-1.0, 0.0, 0.0)); + return glm::rotate(glm::inverse(quat), glm::vec3(0.0, 0.0, 1.0)); } \ No newline at end of file diff --git a/Nuake/src/Scene/Components/TransformComponent.h b/Nuake/src/Scene/Components/TransformComponent.h index 146263e2..2cdea3fd 100644 --- a/Nuake/src/Scene/Components/TransformComponent.h +++ b/Nuake/src/Scene/Components/TransformComponent.h @@ -73,6 +73,7 @@ namespace Nuake LocalTransform = Matrix4(1); GlobalTransform = Matrix4(1); + this->Dirty = true; return true; } }; diff --git a/Nuake/src/Scene/Scene.cpp b/Nuake/src/Scene/Scene.cpp index 83105bbb..3979488f 100644 --- a/Nuake/src/Scene/Scene.cpp +++ b/Nuake/src/Scene/Scene.cpp @@ -135,22 +135,14 @@ namespace Nuake { void Scene::Draw(FrameBuffer& framebuffer) { Ref cam = nullptr; - Matrix4 camTransform = Matrix4(); + const auto& view = m_Registry.view(); + for (const auto& e : view) { - auto view = m_Registry.view(); - for (auto e : view) - { - auto [transform, camera, parent] = view.get(e); - cam = camera.CameraInstance; + auto [transform, camera, parent] = view.get(e); + cam = camera.CameraInstance; - cam->Translation = transform.GetGlobalPosition(); - - //const Vector3& forward = QuatToDirection(transform.GetGlobalRotation()); - //cam->SetDirection(forward); - - //camTransform = transform.GetGlobalTransform(); - break; - } + cam->Translation = transform.GetGlobalPosition(); + break; } if (!cam) @@ -158,10 +150,6 @@ namespace Nuake { return; } - float x = cam->GetDirection().x; - float y = cam->GetDirection().y; - float z = cam->GetDirection().z; - Logger::Log("DIRECTION: (" + std::to_string(x) + ", " + std::to_string(y) + ", " + std::to_string(z) + ")"); mSceneRenderer->BeginRenderScene(cam->GetPerspective(), cam->GetTransform(), cam->Translation); mSceneRenderer->RenderScene(*this, framebuffer); } From a466065ac6d3580a7081f6ed4e6dcf76771d34b8 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Wed, 12 Jul 2023 01:21:47 -0400 Subject: [PATCH 05/13] Progress towards finding transform corruption when drawing after loading scene --- Editor/resources/Models/Camera.gltf | 67 ++++++++++++++----- Editor/src/Misc/GizmoDrawer.cpp | 2 +- Editor/src/Windows/EditorInterface.cpp | 2 +- Nuake/src/Core/Physics/DynamicWorld.cpp | 7 +- Nuake/src/Rendering/Camera.cpp | 24 ++++++- Nuake/src/Rendering/Camera.h | 1 + .../src/Scene/Components/TransformComponent.h | 33 ++++++++- Nuake/src/Scene/Systems/TransformSystem.cpp | 9 ++- 8 files changed, 117 insertions(+), 28 deletions(-) diff --git a/Editor/resources/Models/Camera.gltf b/Editor/resources/Models/Camera.gltf index b1df5287..472b79b8 100644 --- a/Editor/resources/Models/Camera.gltf +++ b/Editor/resources/Models/Camera.gltf @@ -8,7 +8,8 @@ { "name" : "Scene", "nodes" : [ - 0 + 0, + 1 ] } ], @@ -16,6 +17,12 @@ { "mesh" : 0, "name" : "Cube", + "rotation" : [ + 0, + 0, + 0.027799464762210846, + 0.9996135234832764 + ], "scale" : [ 0.21287661790847778, 0.14901362359523773, @@ -26,12 +33,26 @@ 0, 0 ] + }, + { + "name" : "Camera", + "rotation" : [ + 0.483536034822464, + 0.33687159419059753, + -0.20870360732078552, + 0.7804827094078064 + ], + "translation" : [ + 7.358891487121582, + 4.958309173583984, + 6.925790786743164 + ] } ], "materials" : [ { "doubleSided" : true, - "name" : "Material", + "name" : "Material.001", "pbrMetallicRoughness" : { "baseColorFactor" : [ 0.800000011920929, @@ -46,15 +67,16 @@ ], "meshes" : [ { - "name" : "Cube", + "name" : "Cube.001", "primitives" : [ { "attributes" : { "POSITION" : 0, "NORMAL" : 1, - "TEXCOORD_0" : 2 + "TANGENT" : 2, + "TEXCOORD_0" : 3 }, - "indices" : 3, + "indices" : 4, "material" : 0 } ] @@ -64,7 +86,7 @@ { "bufferView" : 0, "componentType" : 5126, - "count" : 143, + "count" : 170, "max" : [ 0.2293514609336853, 0.20000004768371582, @@ -80,17 +102,23 @@ { "bufferView" : 1, "componentType" : 5126, - "count" : 143, + "count" : 170, "type" : "VEC3" }, { "bufferView" : 2, "componentType" : 5126, - "count" : 143, - "type" : "VEC2" + "count" : 170, + "type" : "VEC4" }, { "bufferView" : 3, + "componentType" : 5126, + "count" : 170, + "type" : "VEC2" + }, + { + "bufferView" : 4, "componentType" : 5123, "count" : 204, "type" : "SCALAR" @@ -99,29 +127,34 @@ "bufferViews" : [ { "buffer" : 0, - "byteLength" : 1716, + "byteLength" : 2040, "byteOffset" : 0 }, { "buffer" : 0, - "byteLength" : 1716, - "byteOffset" : 1716 + "byteLength" : 2040, + "byteOffset" : 2040 }, { "buffer" : 0, - "byteLength" : 1144, - "byteOffset" : 3432 + "byteLength" : 2720, + "byteOffset" : 4080 + }, + { + "buffer" : 0, + "byteLength" : 1360, + "byteOffset" : 6800 }, { "buffer" : 0, "byteLength" : 408, - "byteOffset" : 4576 + "byteOffset" : 8160 } ], "buffers" : [ { - "byteLength" : 4984, - "uri" : "data:application/octet-stream;base64,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" + "byteLength" : 8568, + "uri" : "data:application/octet-stream;base64,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" } ] } diff --git a/Editor/src/Misc/GizmoDrawer.cpp b/Editor/src/Misc/GizmoDrawer.cpp index 3a9524ee..2618377b 100644 --- a/Editor/src/Misc/GizmoDrawer.cpp +++ b/Editor/src/Misc/GizmoDrawer.cpp @@ -259,7 +259,7 @@ void GizmoDrawer::DrawGizmos(Ref scene) flatShader->SetUniformVec4("u_Color", Vector4(0.0f, 1.0f, 0.4f, 1.0f)); const auto scaledTransform = glm::scale(transformComponent.GetGlobalTransform(), Vector3(0.25f, 0.25f, 0.25f)); - renderList.AddToRenderList(_gizmos["player"]->GetMeshes()[0], scaledTransform); + //renderList.AddToRenderList(_gizmos["player"]->GetMeshes()[0], scaledTransform); renderList.Flush(flatShader, true); } diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index de1c716b..dd0d65c5 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -215,7 +215,7 @@ namespace Nuake { ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(localTransform), glm::value_ptr(pos), glm::value_ptr(rotation), glm::value_ptr(scale)); tc.Translation = pos; - //tc.Rotation = rotation; + tc.Rotation = rotation; tc.Scale = scale; tc.LocalTransform = localTransform; diff --git a/Nuake/src/Core/Physics/DynamicWorld.cpp b/Nuake/src/Core/Physics/DynamicWorld.cpp index a5b18354..1d674c8a 100644 --- a/Nuake/src/Core/Physics/DynamicWorld.cpp +++ b/Nuake/src/Core/Physics/DynamicWorld.cpp @@ -370,17 +370,16 @@ namespace Nuake transformComponent.SetLocalPosition(pos); transformComponent.SetLocalRotation(Quat(bodyRotation.GetW(), bodyRotation.GetX(), bodyRotation.GetY(), bodyRotation.GetZ())); transformComponent.SetLocalTransform(transform); - transformComponent.Dirty = false; + transformComponent.Dirty = true; } } - + void DynamicWorld::SyncCharactersTransforms() { // TODO(ANTO): Finish this to connect updated jolt transforms back to the entity. // The problem was that I dont know yet how to go from jolt body ptr to the entity // Combinations of find and iterators etc. I do not have the brain power rn zzz. // const auto& bodyInterface = _JoltPhysicsSystem->GetBodyInterface(); - for (const auto& e : _registeredCharacters) { Entity entity { (entt::entity)e.first, Engine::GetCurrentScene().get()}; @@ -407,7 +406,7 @@ namespace Nuake transformComponent.SetLocalPosition(pos); transformComponent.SetLocalRotation(Quat(bodyRotation.GetW(), bodyRotation.GetX(), bodyRotation.GetY(), bodyRotation.GetZ())); transformComponent.SetLocalTransform(transform); - transformComponent.Dirty = false; + transformComponent.Dirty = true; } } diff --git a/Nuake/src/Rendering/Camera.cpp b/Nuake/src/Rendering/Camera.cpp index 5b3249e6..0910ad3e 100644 --- a/Nuake/src/Rendering/Camera.cpp +++ b/Nuake/src/Rendering/Camera.cpp @@ -55,6 +55,20 @@ namespace Nuake //Up = glm::normalize(glm::cross(Direction, Right)); } + void Camera::SetDirection(const Quat& direction) + { + //cam->cameraDirection.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch)); + //cam->cameraDirection.y = sin(glm::radians(Pitch)); + //cam->cameraDirection.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch)); + //cam->cameraFront = glm::normalize(cam->cameraDirection); + //cam->cameraRight = glm::normalize(glm::cross(cam->up, cam->cameraFront)); + + //glm::quatLookAt(); + //Direction = glm::normalize(direction); + //Right = glm::normalize(glm::cross(Vector3(0, 1, 0), Direction)); + //Up = glm::normalize(glm::cross(Direction, Right)); + } + Vector3 Camera::GetTranslation() { return Translation; } @@ -72,7 +86,7 @@ namespace Nuake Matrix4 Camera::GetTransform() { - glm::mat4 tr = lookAt(Translation, Translation + Direction, Vector3(0, 1, 0)); + glm::mat4 tr = lookAt(Translation, Translation + glm::normalize(Direction), Vector3(0, 1, 0)); return tr; } @@ -98,6 +112,8 @@ namespace Nuake BEGIN_SERIALIZE(); SERIALIZE_VAL(m_Type); SERIALIZE_VAL(AspectRatio); + SERIALIZE_VEC3(Translation) + SERIALIZE_VEC3(Direction) SERIALIZE_VAL(Fov); SERIALIZE_VAL(Exposure); SERIALIZE_VAL(Speed); @@ -109,6 +125,12 @@ namespace Nuake BEGIN_DESERIALIZE(); j = j["CameraInstance"]; this->m_Type = (CAMERA_TYPE)j["m_Type"]; + if(j.contains("Translation")) + DESERIALIZE_VEC3(j["Translation"], Translation); + + if (j.contains("Direction")) + DESERIALIZE_VEC3(j["Direction"], Direction); + this->AspectRatio = j["AspectRatio"]; this->Fov = j["Fov"]; this->Exposure = j["Exposure"]; diff --git a/Nuake/src/Rendering/Camera.h b/Nuake/src/Rendering/Camera.h index c52c9361..2ed7c504 100644 --- a/Nuake/src/Rendering/Camera.h +++ b/Nuake/src/Rendering/Camera.h @@ -44,6 +44,7 @@ namespace Nuake void OnWindowResize(float x, float y); void SetDirection(Vector3 direction); + void SetDirection(const Quat& direction); Vector3 GetTranslation(); Vector3 GetDirection(); diff --git a/Nuake/src/Scene/Components/TransformComponent.h b/Nuake/src/Scene/Components/TransformComponent.h index 2cdea3fd..dbc8062f 100644 --- a/Nuake/src/Scene/Components/TransformComponent.h +++ b/Nuake/src/Scene/Components/TransformComponent.h @@ -46,11 +46,13 @@ namespace Nuake json Serialize() { - Rotation = glm::normalize(Rotation); BEGIN_SERIALIZE(); SERIALIZE_VAL_LBL("Type", "TransformComponent"); SERIALIZE_VEC3(Translation); + SERIALIZE_VEC3(GlobalTranslation); SERIALIZE_VEC4(Rotation); + SERIALIZE_VEC4(GlobalRotation); + SERIALIZE_VEC3(GlobalScale); SERIALIZE_VEC3(Scale); END_SERIALIZE(); } @@ -59,6 +61,16 @@ namespace Nuake { BEGIN_DESERIALIZE(); this->Translation = Vector3(j["Translation"]["x"], j["Translation"]["y"], j["Translation"]["z"]); + + if (j.contains("GlobalTranslation")) + { + float x = j["GlobalTranslation"]["x"]; + float y = j["GlobalTranslation"]["y"]; + float z = j["GlobalTranslation"]["z"]; + + this->GlobalTranslation = Vector3(x, y, z); + } + if (j.contains("Rotation")) { float w = j["Rotation"]["w"]; @@ -68,6 +80,25 @@ namespace Nuake this->Rotation = Quat(w, x, y, z); } + + if (j.contains("GlobalRotation")) + { + float w = j["GlobalRotation"]["w"]; + float x = j["GlobalRotation"]["x"]; + float y = j["GlobalRotation"]["y"]; + float z = j["GlobalRotation"]["z"]; + + this->GlobalRotation = Quat(w, x, y, z); + } + + if (j.contains("GlobalScale")) + { + float x = j["GlobalScale"]["x"]; + float y = j["GlobalScale"]["y"]; + float z = j["GlobalScale"]["z"]; + + this->GlobalScale = Vector3(x, y, z); + } this->Scale = Vector3(j["Scale"]["x"], j["Scale"]["y"], j["Scale"]["z"]); diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index c9e776ae..479a2327 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -109,10 +109,13 @@ namespace Nuake Matrix4 cameraTransform = camera.CameraInstance->GetTransformRotation(); camera.CameraInstance->Translation = transform.GlobalTranslation; - const auto& globalRotation = transform.GetGlobalRotation(); - auto& forward = QuatToDirection(globalRotation); + const auto& globalTransform = transform.GetGlobalTransform(); + const auto& forwardTransform = Vector3(globalTransform[0][2], globalTransform[1][2], globalTransform[2][2]); + //const auto& globalRotation = transform.GetGlobalRotation(); + //auto& forward = QuatToDirection(globalRotation); //forward *= -1.0; - camera.CameraInstance->SetDirection(forward); + //f/orward.z *= -1.0f; + camera.CameraInstance->SetDirection(forwardTransform); } } } From 8a8db47f6c1be032cffb4f623cc197945894467f Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Wed, 12 Jul 2023 16:10:20 -0400 Subject: [PATCH 06/13] Added lookat --- Editor/resources/Scripts/Scene.wren | 4 ++ Nuake/src/Core/Maths.cpp | 48 ++++++++++++++++++++++- Nuake/src/Core/Maths.h | 2 + Nuake/src/Scripting/Modules/SceneModule.h | 16 ++++++++ 4 files changed, 69 insertions(+), 1 deletion(-) diff --git a/Editor/resources/Scripts/Scene.wren b/Editor/resources/Scripts/Scene.wren index 4b870cbd..b6bfd84a 100644 --- a/Editor/resources/Scripts/Scene.wren +++ b/Editor/resources/Scripts/Scene.wren @@ -44,6 +44,7 @@ class Scene { foreign static GetTranslation_(e) foreign static SetTranslation_(e, x, y, z) foreign static SetRotation_(e, x, y, z) + foreign static SetLookAt_(e, x, y, z) foreign static GetRotation_(e) //foreign static SetScale_(e, x, y, z) @@ -111,6 +112,9 @@ class TransformComponent { Scene.SetRotation_(_entityId, t.x, t.y, t.z) } + SetLookAt(t) { + Scene.SetLookAt_(_entityId, t.x, t.y, t.z) + } } class Light { diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index f77709c5..971339eb 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -2,9 +2,55 @@ using namespace Nuake; +Quat Nuake::LookAt(Vector3 sourcePoint, Vector3 destPoint) +{ + Vector3 forwardVector = glm::normalize(destPoint - sourcePoint); + + float dot = glm::dot(Vector3(0, 0, 1), forwardVector); + if (glm::abs(dot - (-1.0f)) < 0.000001f) + { + return Quat(0, 1, 0, 3.1415926535897932f); + } + if (glm::abs(dot - (1.0f)) < 0.000001f) + { + return Quat(); // identity + } + + float rotAngle = acos(dot); + Vector3 rotAxis = glm::cross(Vector3(0, 0, 1), forwardVector); + rotAxis = glm::normalize(rotAxis); + return CreateFromAxisAngle(rotAxis, rotAngle); +} + +// just in case you need that function also +Quat Nuake::CreateFromAxisAngle(Vector3 axis, float angle) +{ + float halfAngle = angle * .5f; + float s = sin(halfAngle); + Quat q; + q.x = axis.x * s; + q.y = axis.y * s; + q.z = axis.z * s; + q.w = cos(halfAngle); + return q; +} + Quat Nuake::QuatFromEuler(float x, float y, float z) { - return Quat(Vector3(Rad(z), Rad(y), Rad(x))); + Quat q; + + float cr = cos(x * 0.5); + float sr = sin(x * 0.5); + float cp = cos(y * 0.5); + float sp = sin(y * 0.5); + float cy = cos(z * 0.5); + float sy = sin(z * 0.5); + + q.w = cr * cp * cy + sr * sp * sy; + q.x = sr * cp * cy - cr * sp * sy; + q.y = cr * sp * cy + sr * cp * sy; + q.z = cr * cp * sy - sr * sp * cy; + return q; } Vector3 Nuake::QuatToDirection(const Quat& quat) diff --git a/Nuake/src/Core/Maths.h b/Nuake/src/Core/Maths.h index c16fba0e..13a91871 100644 --- a/Nuake/src/Core/Maths.h +++ b/Nuake/src/Core/Maths.h @@ -20,6 +20,8 @@ namespace Nuake using Matrix3 = glm::mat3; #define Rad(degrees) glm::radians(degrees) + Quat LookAt(Vector3 sourcePoint, Vector3 destPoint); + Quat CreateFromAxisAngle(Vector3 axis, float angle); Quat QuatFromEuler(float x, float y, float z); Vector3 QuatToDirection(const Quat& quat); } diff --git a/Nuake/src/Scripting/Modules/SceneModule.h b/Nuake/src/Scripting/Modules/SceneModule.h index 2e0087d7..fbaa0ac5 100644 --- a/Nuake/src/Scripting/Modules/SceneModule.h +++ b/Nuake/src/Scripting/Modules/SceneModule.h @@ -40,6 +40,8 @@ namespace Nuake { RegisterMethod("SetTranslation_(_,_,_,_)", (void*)SetTranslation); RegisterMethod("GetRotation_(_)", (void*)GetRotation); RegisterMethod("SetRotation_(_,_,_,_)", (void*)SetRotation); + RegisterMethod("SetLookAt_(_,_,_,_)", (void*)SetLookAt); + RegisterMethod("SetLightIntensity_(_,_)", (void*)SetLightIntensity); RegisterMethod("GetLightIntensity_(_)", (void*)GetLightIntensity); @@ -263,6 +265,20 @@ namespace Nuake { transform.SetLocalRotation(QuatFromEuler(x, y, z)); } + static void SetLookAt(WrenVM* vm) + { + double handle = wrenGetSlotDouble(vm, 1); + Entity ent = Entity((entt::entity)handle, Engine::GetCurrentScene().get()); + auto& transform = ent.GetComponent(); + // set the slots + float x = (float)wrenGetSlotDouble(vm, 2); + float y = (float)wrenGetSlotDouble(vm, 3); + float z = (float)wrenGetSlotDouble(vm, 4); + Vector3 targetPosition = Vector3(x, y, z); + Quat rotation = LookAt(transform.GetGlobalPosition(), transform.GetGlobalPosition() + targetPosition); + transform.SetLocalRotation(rotation); + } + static void SetTranslation(WrenVM* vm) { double handle = wrenGetSlotDouble(vm, 1); From 33569901ba67321d394b03eebd885b8057ed8757 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Wed, 12 Jul 2023 22:50:28 -0400 Subject: [PATCH 07/13] Work --- Nuake/src/Core/Maths.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index 971339eb..27f21147 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -37,6 +37,8 @@ Quat Nuake::CreateFromAxisAngle(Vector3 axis, float angle) Quat Nuake::QuatFromEuler(float x, float y, float z) { + return Quat(Vector3(Rad(z), Rad(y), Rad(x))); + Quat q; float cr = cos(x * 0.5); @@ -56,5 +58,5 @@ Quat Nuake::QuatFromEuler(float x, float y, float z) Vector3 Nuake::QuatToDirection(const Quat& quat) { //return quat * Vector3(0, 0, -1); - return glm::rotate(glm::inverse(quat), glm::vec3(0.0, 0.0, 1.0)); + return glm::rotate(glm::inverse(quat), glm::vec3(-1.0, 0.0, 0.0)); } \ No newline at end of file From 44597fbe43857394d317d8db24a71850abb66e73 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Thu, 13 Jul 2023 15:57:54 -0400 Subject: [PATCH 08/13] Work but still broken --- Editor/src/Windows/EditorInterface.cpp | 26 +++++++++++--- Nuake/src/Core/Maths.cpp | 13 +++++-- Nuake/src/Rendering/Camera.cpp | 14 ++++++-- Nuake/src/Rendering/Camera.h | 2 ++ Nuake/src/Scene/EditorCamera.cpp | 3 +- Nuake/src/Scene/Systems/TransformSystem.cpp | 40 +++++++++++---------- 6 files changed, 67 insertions(+), 31 deletions(-) diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index a474ce7b..15b71032 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -212,23 +212,39 @@ namespace Nuake { Vector3 scale = Vector3(); Quat rotation = Quat(); Vector3 pos = Vector3(); - ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(localTransform), glm::value_ptr(pos), glm::value_ptr(rotation), glm::value_ptr(scale)); - + Vector3 skew = Vector3(); + Vector4 pesp = Vector4(); + glm::decompose(localTransform, scale, rotation, pos, skew, pesp); + tc.Translation = pos; tc.Rotation = rotation; tc.Scale = scale; tc.LocalTransform = localTransform; + tc.Dirty = true; + + const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), pos); + const Matrix4& rotationMatrix = glm::mat4_cast(rotation); + const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), scale); + const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; + + //tc.SetLocalPosition(pos); + //tc.SetLocalRotation(-rotationQuaternion); + //tc.SetLocalScale(scale); + //tc.SetLocalTransform(localTransform); // Decompose global trasnform Vector3 gscale = Vector3(); Quat grotation = Quat(); Vector3 gpos = Vector3(); - ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(transform), glm::value_ptr(gpos), glm::value_ptr(grotation), glm::value_ptr(gscale)); - + Vector3 gskew = Vector3(); + Vector4 gpesp = Vector4(); + glm::decompose(transform, gscale, grotation, gpos, gskew, gpesp); + + //glm::quat rotationQuaternionG = glm::quat_cast(transform); tc.SetGlobalPosition(gpos); tc.SetGlobalRotation(grotation); tc.SetGlobalScale(gscale); - tc.SetGlobalTransform(transform); + tc.SetGlobalTransform(localTransform); } } diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index 27f21147..fc6761a8 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -37,7 +37,14 @@ Quat Nuake::CreateFromAxisAngle(Vector3 axis, float angle) Quat Nuake::QuatFromEuler(float x, float y, float z) { - return Quat(Vector3(Rad(z), Rad(y), Rad(x))); + glm::quat yawQuat = glm::angleAxis(Rad(y), glm::vec3(0.0f, 1.0f, 0.0f)); + glm::quat rollQuat = glm::angleAxis(Rad(z), glm::vec3(0.0f, 0.0f, 1.0f)); + glm::quat pitchQuat = glm::angleAxis(Rad(x), glm::vec3(1.0f, 0.0f, 0.0f)); + glm::quat orientation = yawQuat * pitchQuat * rollQuat; + + return glm::normalize(orientation); + + return Quat(Vector3(Rad(x), Rad(y), Rad(z))); Quat q; @@ -57,6 +64,6 @@ Quat Nuake::QuatFromEuler(float x, float y, float z) Vector3 Nuake::QuatToDirection(const Quat& quat) { - //return quat * Vector3(0, 0, -1); - return glm::rotate(glm::inverse(quat), glm::vec3(-1.0, 0.0, 0.0)); + return glm::normalize(quat * Vector3(0, 0, -1)); + //return glm::normalize(glm::rotate(glm::inverse(quat), glm::vec3(-1.0, 0.0, 0.0))); } \ No newline at end of file diff --git a/Nuake/src/Rendering/Camera.cpp b/Nuake/src/Rendering/Camera.cpp index 0910ad3e..5cc11146 100644 --- a/Nuake/src/Rendering/Camera.cpp +++ b/Nuake/src/Rendering/Camera.cpp @@ -52,6 +52,8 @@ namespace Nuake //cam->cameraRight = glm::normalize(glm::cross(cam->up, cam->cameraFront)); Direction = glm::normalize(direction); Right = glm::normalize(glm::cross(Vector3(0, 1, 0), Direction)); + m_View = lookAt(Translation, Translation + glm::normalize(Direction), Vector3(0, 1, 0)); + //Up = glm::normalize(glm::cross(Direction, Right)); } @@ -84,8 +86,14 @@ namespace Nuake return m_Perspective; } + void Camera::SetTransform(const Matrix4& transform) + { + m_View = transform; + } + Matrix4 Camera::GetTransform() { + return m_View; glm::mat4 tr = lookAt(Translation, Translation + glm::normalize(Direction), Vector3(0, 1, 0)); return tr; } @@ -94,7 +102,7 @@ namespace Nuake { return lookAt(glm::vec3(), Direction, Up); } - + bool Camera::BoxFrustumCheck(const AABB& aabb) { m_Frustum = Frustum(GetPerspective() * GetTransform()); @@ -128,8 +136,8 @@ namespace Nuake if(j.contains("Translation")) DESERIALIZE_VEC3(j["Translation"], Translation); - if (j.contains("Direction")) - DESERIALIZE_VEC3(j["Direction"], Direction); + //if (j.contains("Direction")) + // DESERIALIZE_VEC3(j["Direction"], Direction); this->AspectRatio = j["AspectRatio"]; this->Fov = j["Fov"]; diff --git a/Nuake/src/Rendering/Camera.h b/Nuake/src/Rendering/Camera.h index 2ed7c504..e72a9a93 100644 --- a/Nuake/src/Rendering/Camera.h +++ b/Nuake/src/Rendering/Camera.h @@ -26,6 +26,7 @@ namespace Nuake Vector3 Up = Vector3(0, 1, 0); Vector3 Right = Vector3(1, 0, 0); Matrix4 m_Perspective; + Matrix4 m_View; public: float AspectRatio = 16.0f / 9.0f; @@ -51,6 +52,7 @@ namespace Nuake Matrix4 GetPerspective(); Matrix4 GetTransform(); Matrix4 GetTransformRotation(); + void SetTransform(const Matrix4& transform); inline Vector3 GetRight() const { return Right; } inline Vector3 GetUp() const { return glm::cross(Direction, Right); } bool BoxFrustumCheck(const AABB& aabb); diff --git a/Nuake/src/Scene/EditorCamera.cpp b/Nuake/src/Scene/EditorCamera.cpp index 6df9d0a8..9d80a962 100644 --- a/Nuake/src/Scene/EditorCamera.cpp +++ b/Nuake/src/Scene/EditorCamera.cpp @@ -148,7 +148,8 @@ namespace Nuake Direction.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch)); Direction.y = sin(glm::radians(Pitch)); Direction.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch)); - Direction = glm::normalize(Direction); + + SetDirection(glm::normalize(Direction)); Right = glm::normalize(glm::cross(Up, Direction)); } else if (Input::IsMouseButtonDown(2)) diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index f87b92df..334207cf 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -43,15 +43,20 @@ namespace Nuake TransformComponent& transform = localTransformView.get(tv); if (transform.Dirty) { - Matrix4 localTransform = Matrix4(1.0f); auto& localTranslate = transform.GetLocalPosition(); auto& localRot = transform.GetLocalRotation(); auto& localScale = transform.GetLocalScale(); - localRot.w *= -1.0; - localTransform = glm::translate(localTransform, localTranslate); - localTransform = localTransform * glm::toMat4(localRot); - localTransform = glm::scale(localTransform, localScale); - transform.SetLocalTransform(localTransform); + + const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), localTranslate); + localRot.w *= -1.0f; + const Matrix4& rotationMatrix = glm::mat4_cast(localRot); + const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), localScale); + const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; + + //if(localRot.y != 0) + // assert(newLocalTransform == transform.GetLocalTransform()); + + transform.SetLocalTransform(newLocalTransform); transform.Dirty = false; } } @@ -63,7 +68,7 @@ namespace Nuake auto [parent, transform] = transformView.get(e); if (!parent.HasParent) - { + { // If no parents, then globalTransform is local transform. transform.SetGlobalTransform(transform.GetLocalTransform()); transform.SetGlobalPosition(transform.GetLocalPosition()); @@ -84,14 +89,13 @@ namespace Nuake { TransformComponent& transformComponent = parentComponent.Parent.GetComponent(); - globalPosition = transformComponent.GetLocalPosition() + (transformComponent.GetLocalRotation() * globalPosition); + globalPosition = transformComponent.GetLocalPosition() + (globalPosition); + + globalScale *= transformComponent.GetLocalScale(); + globalOrientation = transformComponent.GetLocalRotation() * globalOrientation; globalTransform = transformComponent.GetLocalTransform() * globalTransform; - globalOrientation = transformComponent.GetLocalRotation() * globalOrientation; - globalScale *= transformComponent.GetLocalScale(); - NameComponent& nameComponent = parentComponent.Parent.GetComponent(); - parentComponent = parentComponent.Parent.GetComponent(); } @@ -106,15 +110,13 @@ namespace Nuake { auto [transform, camera] = camView.get(e); Matrix4 cameraTransform = camera.CameraInstance->GetTransformRotation(); + camera.CameraInstance->Translation = transform.GlobalTranslation; - const auto& globalTransform = transform.GetGlobalTransform(); - const auto& forwardTransform = Vector3(globalTransform[0][2], globalTransform[1][2], globalTransform[2][2]); - //const auto& globalRotation = transform.GetGlobalRotation(); - //auto& forward = QuatToDirection(globalRotation); - //forward *= -1.0; - //f/orward.z *= -1.0f; - camera.CameraInstance->SetDirection(forwardTransform); + auto globalRotation = transform.GetGlobalRotation(); + auto& trnaslationMatrix = glm::translate(Matrix4(1.0f), transform.GetGlobalPosition()); + const Matrix4& rotationMatrix = glm::mat4_cast(globalRotation); + camera.CameraInstance->SetTransform(glm::inverse(trnaslationMatrix * rotationMatrix)); } } } From 13fb6be4307faba3eb58d43a803034e43cdf023d Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Thu, 13 Jul 2023 17:26:14 -0400 Subject: [PATCH 09/13] Calculate Forward and Right vector fixed gizmo stutter --- Editor/resources/Models/Camera.gltf | 72 ++++++--------------- Editor/src/Windows/EditorInterface.cpp | 14 ++-- Nuake/src/Rendering/Camera.cpp | 1 + Nuake/src/Rendering/Camera.h | 3 +- Nuake/src/Scene/Systems/TransformSystem.cpp | 11 +++- 5 files changed, 38 insertions(+), 63 deletions(-) diff --git a/Editor/resources/Models/Camera.gltf b/Editor/resources/Models/Camera.gltf index 472b79b8..b8fbf7ed 100644 --- a/Editor/resources/Models/Camera.gltf +++ b/Editor/resources/Models/Camera.gltf @@ -8,8 +8,7 @@ { "name" : "Scene", "nodes" : [ - 0, - 1 + 0 ] } ], @@ -19,33 +18,14 @@ "name" : "Cube", "rotation" : [ 0, + -0.7071067690849304, 0, - 0.027799464762210846, - 0.9996135234832764 + 0.7071068286895752 ], "scale" : [ 0.21287661790847778, 0.14901362359523773, 0.14901362359523773 - ], - "translation" : [ - 0.007667064666748047, - 0, - 0 - ] - }, - { - "name" : "Camera", - "rotation" : [ - 0.483536034822464, - 0.33687159419059753, - -0.20870360732078552, - 0.7804827094078064 - ], - "translation" : [ - 7.358891487121582, - 4.958309173583984, - 6.925790786743164 ] } ], @@ -73,10 +53,9 @@ "attributes" : { "POSITION" : 0, "NORMAL" : 1, - "TANGENT" : 2, - "TEXCOORD_0" : 3 + "TEXCOORD_0" : 2 }, - "indices" : 4, + "indices" : 3, "material" : 0 } ] @@ -86,10 +65,10 @@ { "bufferView" : 0, "componentType" : 5126, - "count" : 170, + "count" : 204, "max" : [ 0.2293514609336853, - 0.20000004768371582, + 0.25309160351753235, 0.19999998807907104 ], "min" : [ @@ -102,59 +81,48 @@ { "bufferView" : 1, "componentType" : 5126, - "count" : 170, + "count" : 204, "type" : "VEC3" }, { "bufferView" : 2, "componentType" : 5126, - "count" : 170, - "type" : "VEC4" - }, - { - "bufferView" : 3, - "componentType" : 5126, - "count" : 170, + "count" : 204, "type" : "VEC2" }, { - "bufferView" : 4, + "bufferView" : 3, "componentType" : 5123, - "count" : 204, + "count" : 270, "type" : "SCALAR" } ], "bufferViews" : [ { "buffer" : 0, - "byteLength" : 2040, + "byteLength" : 2448, "byteOffset" : 0 }, { "buffer" : 0, - "byteLength" : 2040, - "byteOffset" : 2040 + "byteLength" : 2448, + "byteOffset" : 2448 }, { "buffer" : 0, - "byteLength" : 2720, - "byteOffset" : 4080 + "byteLength" : 1632, + "byteOffset" : 4896 }, { "buffer" : 0, - "byteLength" : 1360, - "byteOffset" : 6800 - }, - { - "buffer" : 0, - "byteLength" : 408, - "byteOffset" : 8160 + "byteLength" : 540, + "byteOffset" : 6528 } ], "buffers" : [ { - "byteLength" : 8568, - "uri" : "data:application/octet-stream;base64,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" + "byteLength" : 7068, + "uri" : "data:application/octet-stream;base64,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" } ] } diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index 15b71032..b659c5e1 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -204,8 +204,9 @@ namespace Nuake { ParentComponent& parent = Selection.Entity.GetComponent(); if (parent.HasParent) { - Matrix4 inverseParent = glm::inverse(parent.Parent.GetComponent().GetGlobalTransform()); - localTransform = inverseParent * localTransform; + const auto& parentTransformComponent = parent.Parent.GetComponent(); + const Matrix4& parentTransform = parentTransformComponent.GetGlobalTransform(); + localTransform = glm::inverse(parentTransform) * localTransform; } // Decompose local transform @@ -217,20 +218,17 @@ namespace Nuake { glm::decompose(localTransform, scale, rotation, pos, skew, pesp); tc.Translation = pos; + + rotation.w *= -1.0f; tc.Rotation = rotation; tc.Scale = scale; tc.LocalTransform = localTransform; - tc.Dirty = true; + //tc.Dirty = true; const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), pos); const Matrix4& rotationMatrix = glm::mat4_cast(rotation); const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), scale); const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; - - //tc.SetLocalPosition(pos); - //tc.SetLocalRotation(-rotationQuaternion); - //tc.SetLocalScale(scale); - //tc.SetLocalTransform(localTransform); // Decompose global trasnform Vector3 gscale = Vector3(); diff --git a/Nuake/src/Rendering/Camera.cpp b/Nuake/src/Rendering/Camera.cpp index 5cc11146..11342a89 100644 --- a/Nuake/src/Rendering/Camera.cpp +++ b/Nuake/src/Rendering/Camera.cpp @@ -89,6 +89,7 @@ namespace Nuake void Camera::SetTransform(const Matrix4& transform) { m_View = transform; + } Matrix4 Camera::GetTransform() diff --git a/Nuake/src/Rendering/Camera.h b/Nuake/src/Rendering/Camera.h index e72a9a93..a2e20590 100644 --- a/Nuake/src/Rendering/Camera.h +++ b/Nuake/src/Rendering/Camera.h @@ -24,7 +24,6 @@ namespace Nuake Vector3 Rotation = { 0.0f, 0.0f, 0.0f }; Vector3 Scale = { 1.0f, 1.0f, 1.0f }; Vector3 Up = Vector3(0, 1, 0); - Vector3 Right = Vector3(1, 0, 0); Matrix4 m_Perspective; Matrix4 m_View; @@ -32,6 +31,8 @@ namespace Nuake float AspectRatio = 16.0f / 9.0f; Vector3 Direction = Vector3(0, 0, 1); + Vector3 Right = Vector3(1, 0, 0); + Vector3 Translation = { 0.0f, 0.0f, 0.0f }; float Fov = 88.0f; float Exposure = 1.0f; diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index 334207cf..ea80f716 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -48,7 +48,7 @@ namespace Nuake auto& localScale = transform.GetLocalScale(); const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), localTranslate); - localRot.w *= -1.0f; + //localRot.w *= -1.0f; const Matrix4& rotationMatrix = glm::mat4_cast(localRot); const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), localScale); const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; @@ -116,7 +116,14 @@ namespace Nuake auto globalRotation = transform.GetGlobalRotation(); auto& trnaslationMatrix = glm::translate(Matrix4(1.0f), transform.GetGlobalPosition()); const Matrix4& rotationMatrix = glm::mat4_cast(globalRotation); - camera.CameraInstance->SetTransform(glm::inverse(trnaslationMatrix * rotationMatrix)); + Vector4 forward = Vector4(0, 0, -1, 1); + const auto globalForward = rotationMatrix * forward; + + Vector4 right = Vector4(1, 0, 0, 1); + const auto globalRight = rotationMatrix * right; + camera.CameraInstance->Direction = globalForward; + camera.CameraInstance->Right = globalRight; +; camera.CameraInstance->SetTransform(glm::inverse(trnaslationMatrix * rotationMatrix)); } } } From 9f60963102f991a8a099f9418b6b986bfbf8056d Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Thu, 13 Jul 2023 23:31:07 -0400 Subject: [PATCH 10/13] Progress towards mental freedom --- Editor/resources/Models/Camera.gltf | 46 +++++++-------- Editor/src/Windows/EditorInterface.cpp | 62 +++++++++++++-------- Nuake/src/Core/Maths.cpp | 12 ++++ Nuake/src/Core/Maths.h | 1 + Nuake/src/Scene/Systems/TransformSystem.cpp | 11 ++-- 5 files changed, 82 insertions(+), 50 deletions(-) diff --git a/Editor/resources/Models/Camera.gltf b/Editor/resources/Models/Camera.gltf index b8fbf7ed..b3228a9a 100644 --- a/Editor/resources/Models/Camera.gltf +++ b/Editor/resources/Models/Camera.gltf @@ -22,17 +22,17 @@ 0, 0.7071068286895752 ], - "scale" : [ - 0.21287661790847778, - 0.14901362359523773, - 0.14901362359523773 + "translation" : [ + 0, + 0, + 0.06328082829713821 ] } ], "materials" : [ { "doubleSided" : true, - "name" : "Material.001", + "name" : "Material.002", "pbrMetallicRoughness" : { "baseColorFactor" : [ 0.800000011920929, @@ -47,7 +47,7 @@ ], "meshes" : [ { - "name" : "Cube.001", + "name" : "Cube.002", "primitives" : [ { "attributes" : { @@ -65,29 +65,29 @@ { "bufferView" : 0, "componentType" : 5126, - "count" : 204, + "count" : 261, "max" : [ - 0.2293514609336853, - 0.25309160351753235, - 0.19999998807907104 + 0.13640516996383667, + 0.2530915439128876, + 0.43141499161720276 ], "min" : [ - -0.3706485629081726, - -0.19999998807907104, - -0.19999998807907104 + -0.14359483122825623, + -0.19999995827674866, + -0.4257279336452484 ], "type" : "VEC3" }, { "bufferView" : 1, "componentType" : 5126, - "count" : 204, + "count" : 261, "type" : "VEC3" }, { "bufferView" : 2, "componentType" : 5126, - "count" : 204, + "count" : 261, "type" : "VEC2" }, { @@ -100,29 +100,29 @@ "bufferViews" : [ { "buffer" : 0, - "byteLength" : 2448, + "byteLength" : 3132, "byteOffset" : 0 }, { "buffer" : 0, - "byteLength" : 2448, - "byteOffset" : 2448 + "byteLength" : 3132, + "byteOffset" : 3132 }, { "buffer" : 0, - "byteLength" : 1632, - "byteOffset" : 4896 + "byteLength" : 2088, + "byteOffset" : 6264 }, { "buffer" : 0, "byteLength" : 540, - "byteOffset" : 6528 + "byteOffset" : 8352 } ], "buffers" : [ { - "byteLength" : 7068, - "uri" : "data:application/octet-stream;base64,gL4uvlzOvj1czr69gL4uvlzOvj1czr69gL4uvlzOvj1czr69gL4uvlzOvj1czr69gL4uvlzOvj1czr69gL4uvljOvr1czr69gL4uvljOvr1czr69gL4uvljOvr1czr69gL4uvljOvr1czr69gL4uvljOvr1czr69gL4uvljOvr1czr69gL4uvlzOvj1czr49gL4uvlzOvj1czr49gL4uvlzOvj1czr49gL4uvlzOvj1czr49gL4uvlzOvj1czr49gL4uvljOvr1czr49gL4uvljOvr1czr49gL4uvljOvr1czr49gL4uvljOvr1czr49gL4uvljOvr1czr49psW9vnSJNL50iTS+psW9vnSJNL50iTS+psW9vnSJNL50iTS+psW9vnSJNL50iTS+Jh65vkB4Or5AeDq+Jh65vkB4Or5AeDq+Jh65vkB4Or5AeDq+Jh65vkB4Or5AeDq+Jh65vkB4Or5AeDq+Jh65vkB4Or5AeDq+Jh65vkB4Or5AeDo+Jh65vkB4Or5AeDo+Jh65vkB4Or5AeDo+Jh65vkB4Or5AeDo+Jh65vkB4Or5AeDo+Jh65vkB4Or5AeDo+psW9vnSJNL50iTQ+psW9vnSJNL50iTQ+psW9vnSJNL50iTQ+psW9vnSJNL50iTQ+Jh65vkR4Oj5AeDo+Jh65vkR4Oj5AeDo+Jh65vkR4Oj5AeDo+Jh65vkR4Oj5AeDo+Jh65vkR4Oj5AeDo+psW9vnSJND50iTQ+psW9vnSJND50iTQ+psW9vnSJND50iTQ+psW9vnSJND50iTQ+psW9vnSJND50iTS+psW9vnSJND50iTS+psW9vnSJND50iTS+Jh65vkR4Oj5AeDq+Jh65vkR4Oj5AeDq+Jh65vkR4Oj5AeDq+Jh65vkR4Oj5AeDq+Jh65vkR4Oj5AeDq+Jh65vkR4Oj5AeDq+ALZhPrCnQz7MzEy+ALZhPrCnQz7MzEy+ALZhPrCnQz7MzEy+ALZhPrCnQz7MzEy+ALZhPtDMTD6wp0O+ALZhPtDMTD6wp0O+ALZhPtDMTD6wp0O+ALZhPtDMTD6wp0O+ALZhPtDMTD6wp0O+HNtqPrCnQz6wp0O+HNtqPrCnQz6wp0O+HNtqPrCnQz6wp0O+HNtqPrCnQz6wp0O+ALZhPszMTL6wp0O+ALZhPszMTL6wp0O+ALZhPszMTL6wp0O+ALZhPszMTL6wp0O+ALZhPqynQ77MzEy+ALZhPqynQ77MzEy+ALZhPqynQ77MzEy+ALZhPqynQ77MzEy+HNtqPqynQ76wp0O+HNtqPqynQ76wp0O+HNtqPqynQ76wp0O+HNtqPqynQ76wp0O+HNtqPqynQ76wp0O+HNtqPqynQ76wp0O+HNtqPrCnQz6wp0M+HNtqPrCnQz6wp0M+HNtqPrCnQz6wp0M+HNtqPrCnQz6wp0M+HNtqPrCnQz6wp0M+HNtqPrCnQz6wp0M+ALZhPtDMTD6wp0M+ALZhPtDMTD6wp0M+ALZhPtDMTD6wp0M+ALZhPtDMTD6wp0M+ALZhPrCnQz7MzEw+ALZhPrCnQz7MzEw+ALZhPrCnQz7MzEw+ALZhPrCnQz7MzEw+HNtqPqynQ76wp0M+HNtqPqynQ76wp0M+HNtqPqynQ76wp0M+HNtqPqynQ76wp0M+ALZhPqynQ77MzEw+ALZhPqynQ77MzEw+ALZhPqynQ77MzEw+ALZhPqynQ77MzEw+ALZhPszMTL6wp0M+ALZhPszMTL6wp0M+ALZhPszMTL6wp0M+ALZhPszMTL6wp0M+ALZhPszMTL6wp0M+gL4uvqynQ76wp0O+gL4uvqynQ76wp0O+gL4uvqynQ76wp0O+gL4uvqynQ76wp0O+gL4uvqynQ76wp0O+ZJklvqynQ77MzEy+ZJklvqynQ77MzEy+ZJklvqynQ77MzEy+ZJklvqynQ77MzEy+ZJklvszMTL6wp0O+ZJklvszMTL6wp0O+ZJklvszMTL6wp0O+ZJklvszMTL6wp0O+ZJklvszMTL6wp0O+ZJklvszMTL6wp0M+ZJklvszMTL6wp0M+ZJklvszMTL6wp0M+ZJklvszMTL6wp0M+ZJklvqynQ77MzEw+ZJklvqynQ77MzEw+ZJklvqynQ77MzEw+ZJklvqynQ77MzEw+gL4uvqynQ76wp0M+gL4uvqynQ76wp0M+gL4uvqynQ76wp0M+gL4uvqynQ76wp0M+gL4uvqynQ76wp0M+gL4uvqynQ76wp0M+ZJklvrCnQz7MzEw+ZJklvrCnQz7MzEw+ZJklvrCnQz7MzEw+ZJklvrCnQz7MzEw+ZJklvtDMTD6wp0M+ZJklvtDMTD6wp0M+ZJklvtDMTD6wp0M+ZJklvtDMTD6wp0M+ZJklvtDMTD6wp0M+gL4uvrCnQz6wp0M+gL4uvrCnQz6wp0M+gL4uvrCnQz6wp0M+gL4uvrCnQz6wp0M+gL4uvrCnQz6wp0M+gL4uvrCnQz6wp0O+gL4uvrCnQz6wp0O+gL4uvrCnQz6wp0O+gL4uvrCnQz6wp0O+gL4uvrCnQz6wp0O+gL4uvrCnQz6wp0O+gL4uvrCnQz6wp0O+ZJklvtDMTD6wp0O+ZJklvtDMTD6wp0O+ZJklvtDMTD6wp0O+ZJklvtDMTD6wp0O+ZJklvrCnQz7MzEy+ZJklvrCnQz7MzEy+ZJklvrCnQz7MzEy+ZJklvrCnQz7MzEy+ALZhPtDMTD4AAACAZJklvtDMTD4AAACAALZhPtDMTD6wp8M9ZJklvtDMTD6wp8M9ALZhPtDMTD6wp8O9ZJklvtDMTD6wp8O9ALZhPtDMTD6wp0O9ALZhPtDMTD6wp0O9ALZhPtDMTD6wp0O9ZJklvtDMTD6wp0O9ZJklvtDMTD6wp0O9ZJklvtDMTD6wp0O9ZJklvtDMTD6wp0M9ZJklvtDMTD6wp0M9ZJklvtDMTD6wp0M9ALZhPtDMTD6wp0M9ALZhPtDMTD6wp0M9ALZhPtDMTD6wp0M9ALZhPjmVgT6wp0O9ALZhPjmVgT6wp0O9ALZhPjmVgT6wp0O9ALZhPjmVgT4AAACAALZhPjmVgT4AAACAZJklvjmVgT6wp0M9ZJklvjmVgT6wp0M9ZJklvjmVgT6wp0M9ZJklvjmVgT4AAACAZJklvjmVgT4AAACAZJklvjmVgT6wp0O9ZJklvjmVgT6wp0O9ZJklvjmVgT6wp0O9ALZhPjmVgT6wp0M9ALZhPjmVgT6wp0M9ALZhPjmVgT6wp0M9AACAvwAAAACMRFu0AACAvwAAAAAAAACAQjPYPgAAAACLDmi/RjPYPgAAAACJDmi/SDPYPosOaD8AAACAAACAvwAAAACMRFu0AACAvwAAAABp1dU0AACAvwAAAAAAAACAQjPYPgAAAACLDmi/RDPYPosOaL8AAACARTPYPosOaL8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAQjPYPgAAAACLDmg/SDPYPosOaD8AAACASTPYPooOaD8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAQjPYPgAAAACLDmg/RjPYPgAAAACJDmg/RTPYPosOaL8AAACAAACAvwAAAAAAAACAU5cJvwAAAACV4Ve/TJcJvwAAAACa4Ve/bZcJv4XhV78AAACAU5cJvwAAAACV4Ve/bZcJv4XhV78AAACAKJcJv7DhV78AAACAQjPYPgAAAACLDmi/RjPYPgAAAACJDmi/RDPYPosOaL8AAACAiZcJvwAAAAB04Vc/OJcJvwAAAACm4Vc/KJcJv7DhV78AAACARjPYPgAAAACJDmg/RDPYPosOaL8AAACARTPYPosOaL8AAACAAACAvwAAAAAAAACAiZcJvwAAAAB04Vc/bZcJv4XhV78AAACAKJcJv7DhV78AAACAm5cJv2jhVz8AAACAOJcJvwAAAACm4Vc/QjPYPgAAAACLDmg/RjPYPgAAAACJDmg/STPYPooOaD8AAACAAACAvwAAAAAAAACAnJcJv2fhVz8AAACAiZcJvwAAAAB04Vc/OJcJvwAAAACm4Vc/AACAvwAAAAAAAACAgpcJv3fhVz8AAACATJcJvwAAAACa4Ve/gpcJv3fhVz8AAACAU5cJvwAAAACV4Ve/TJcJvwAAAACa4Ve/RjPYPgAAAACJDmi/SDPYPosOaD8AAACASTPYPooOaD8AAACAAAAAAAAAAAAAAIC/AAAAAM0ENT8ZBTW/Tc0TPxTNEz9NzRO/8AQ1PwAAAAD3BDW/AAAAAM0ENT8ZBTW/AAAAAAAAgD8AAACATc0TPxTNEz9NzRO/EAU1P9cENT8AAACAKQU1P70ENT8AAACATc0TPxTNEz9NzRO/8AQ1PwAAAAD3BDW/EAU1P9cENT8AAACAAACAPwAAAAAAAACAAAAAAAAAgL8AAACAAAAAAM0ENb8ZBTW/Tc0TPxTNE79NzRO/KQU1P70ENb8AAACAAAAAAM0ENb8ZBTW/AAAAAAAAAAAAAIC/Tc0TPxTNE79NzRO/8AQ1PwAAAAD3BDW/Tc0TPxTNE79NzRO/8AQ1PwAAAAD3BDW/EAU1P9cENb8AAACAKQU1P70ENb8AAACA//9/PwAAAAAAAACAAACAPwAAAAAAAACATc0TPxTNEz9NzRM/8AQ1PwAAAAD3BDU/EAU1P9cENT8AAACAKQU1P70ENT8AAACA//9/PwAAAAAAAACAAACAPwAAAAAAAACAAAAAAM0ENT8ZBTU/AAAAAAAAgD8AAACATc0TPxTNEz9NzRM/KQU1P70ENT8AAACAAAAAAAAAAAAAAIA/AAAAAM0ENT8ZBTU/Tc0TPxTNEz9NzRM/8AQ1PwAAAAD3BDU/Tc0TPxTNE79NzRM/8AQ1PwAAAAD3BDU/EAU1P9cENb8AAACA//9/PwAAAAAAAACAAAAAAM0ENb8ZBTU/AAAAAAAAAAAAAIA/Tc0TPxTNE79NzRM/8AQ1PwAAAAD3BDU/AAAAAAAAgL8AAACAAAAAAM0ENb8ZBTU/Tc0TPxTNE79NzRM/EAU1P9cENb8AAACAKQU1P70ENb8AAACAAACAvwAAAABp1dU0AACAvwAAAAAAAACAEAU1v9cENb8AAACA8AQ1vwAAAAD3BDW/Tc0TvxTNE79NzRO/8AQ1vwAAAAD3BDW/Tc0TvxTNE79NzRO/AAAAAM0ENb8ZBTW/AAAAAAAAAAAAAIC/KQU1v70ENb8AAACAEAU1v9cENb8AAACATc0TvxTNE79NzRO/AAAAAAAAgL8AAACAAAAAAM0ENb8ZBTW/KQU1v70ENb8AAACATc0TvxTNE79NzRM/AAAAAAAAgL8AAACAAAAAAM0ENb8ZBTU/8AQ1vwAAAAD3BDU/Tc0TvxTNE79NzRM/AAAAAM0ENb8ZBTU/AAAAAAAAAAAAAIA/AACAvwAAAAAAAACAAACAvwAAAAAAAACAKQU1v70ENb8AAACAEAU1v9cENb8AAACA8AQ1vwAAAAD3BDU/Tc0TvxTNE79NzRM/8AQ1vwAAAAD3BDU/Tc0TvxTNEz9NzRM/AAAAAAAAAAAAAIA/AAAAAM0ENT8ZBTU/KQU1v70ENT8AAACAEAU1v9cENT8AAACATc0TvxTNEz9NzRM/AAAAAM0ENT8ZBTU/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAACAvwAAAAAAAACAEAU1v9cENT8AAACA8AQ1vwAAAAD3BDU/Tc0TvxTNEz9NzRM/AACAvwAAAACMRFu0AACAvwAAAABp1dU0AACAvwAAAAAAAACAKQU1v70ENT8AAACAEAU1v9cENT8AAACA8AQ1vwAAAAD3BDW/Tc0TvxTNEz9NzRO/KQU1v70ENT8AAACATc0TvxTNEz9NzRO/AAAAAM0ENT8ZBTW/AAAAAAAAgD8AAACA8AQ1vwAAAAD3BDW/Tc0TvxTNEz9NzRO/AAAAAAAAAAAAAIC/AAAAAM0ENT8ZBTW/AACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAgD8AAACAAAAAAAAAAAD//3+/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAD//3+/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAAAAAgD8AAACAAAAAAAAAAAD//38/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAAAD//3+/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAAAAAAAAAgD8AAACAAACAPwAAAAAAAACAAACAvwAAAAAAAACAAAAAAAAAAAD//38/AAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAgD8AAACAAACAvwAAAAAAAACAAAAAAAAAAAD//3+/AAAAAAAAgD8AAACAAAAAAAAAAAD//38/AAAAAAAAgD8AAACAAACAPwAAAAAAAACAH+gOP+EXUT8f6A4/4RdRPx/oDj/hF1E/H+gOP+EXUT8f6A4/4RdRP8Ev4j7hF1E/wS/iPuEXUT/BL+I+4RdRP8Ev4j7hF1E/wS/iPuEXUT/BL+I+4RdRPx/oDj8f6G4/H+gOPx/obj8f6A4/H+huPx/oDj8f6G4/H+gOPx/obj/BL+I+H+huP8Ev4j4f6G4/wS/iPh/obj/BL+I+H+huP8Ev4j4f6G4/hMrjPkPlUT+EyuM+Q+VRP4TK4z5D5VE/hMrjPkPlUT/BL+I+4RdRP8Ev4j7hF1E/wS/iPuEXUT/BL+I+4RdRP8Ev4j7hF1E/wS/iPuEXUT/CL+I+H+huP8Iv4j4f6G4/wS/iPh/obj/CL+I+H+huP8Ev4j4f6G4/wS/iPh/obj+EyuM+vRpuP4TK4z69Gm4/hMrjPr0abj+EyuM+vRpuPx/oDj8f6G4/H+gOPx/obj8f6A4/H+huPx/oDj8f6G4/H+gOPx/obj+8Gg4/vRpuP7waDj+9Gm4/vBoOP70abj+8Gg4/vRpuP7waDj9D5VE/vBoOP0PlUT+8Gg4/Q+VRPx/oDj/hF1E/IOgOP+EXUT8g6A4/4RdRPyDoDj/hF1E/H+gOP+EXUT8f6A4/4RdRPzSSHj/MbQE/NJIeP8xtAT80kh4/zG0BPzSSHj/MbQE/AAAgP8xtAT/MbSE/ZiT9PgAAID/MbQE/zG0hP2Yk/T7MbSE/ZiT9PjSSHj8AAAA/M5IeP2gk/T4zkh4/aCT9PjOSHj9oJP0+ZiS9Pmgk/T5mJL0+aCT9PmYkvT5oJP0+ZiS9Pmgk/T5mJL0+AAAAP5nbwj7NbQE/ZiS9PgAAAD+Z28I+zW0BPwAAwD5oJP0+mdvCPmYk/T6Z28I+ZiT9Ppnbwj5mJP0+mdvCPmYk/T6Z28I+ZiT9PgEAID+a24I+NJIeP5jbgj40kh4/mNuCPjSSHj+Y24I+NJIeP5jbgj40kh4/mNuCPgEAID/QSHo+zG0hP5rbgj4AACA/mtuCPsxtIT+a24I+M5IeP8xIej4zkh4/zEh6Ps1tIT8AAIA+M5IeP8xIej6Z28I+AACAPpnbwj6a24I+mdvCPprbgj6Z28I+mtuCPmYkvT4AAIA+mdvCPsxIej4AAMA+0Eh6Ppnbwj7MSHo+ZyS9Ppjbgj5nJL0+mNuCPgAAwD7QSHo+ZyS9Ppjbgj5nJL0+mNuCPpnbwj7NbUE/mtvCPs1tQT8AAAA+aCT9Ppnbwj7NbUE/mdvCPgAAQD+Z28I+NJI+PwAAwD40kj4/MrcFPgAAAD+Z28I+NJI+PzK3BT5mJP0+MrcFPmYk/T4AAMA+NJI+PzK3BT5mJP0+MrcFPmYk/T4ytwU+mtuCPjK3BT6a24I+MrcFPprbgj4ytwU+mtuCPpnbwj6A5rY7MrcFPgAAgD4ytwU+AACAPpnbwj6A5rY7mtvCPjOSfj+Z28I+M5J+PwAAAD6a24I+AAAAPprbgj6Y28I+AAAAAAAAAD6a24I+NJIePwDmtjs0kh4/AOa2OzSSHj8A5rY7NJIePwDmtjs0kl4/mNuCPjSSXj+Y24I+AAAgPwDmtjsAACA/AOa2OzSSXj+Y24I+M5IePzOSfj8zkh4/M5J+PwAAYD+a24I+NJIePwAAAAA0kh4/AAAAADOSHj/MbUE/M5IeP8xtQT8zkh4/zW1BPwAAYD9oJP0+AABgP2gk/T4zkh4/zG1BPwAAYD9mJP0+M5JeP2gk/T4AAGA/aCT9PgEAID8zkj4/M5JeP2gk/T4zkh4/NJI+PzOSXj8AAAA/M5IePzSSPj8zkh4/NJI+PwAAAAAAAIA/AAAAAAAAgD/MbSE/zG2hPjSSXj/MbaE+zG0hPzSS3j40kl4/NJLePsxtIT8aSc8+zG0hPxpJzz4AAAAAAACAPwAAAAAAAIA/NJJePxpJzz40kl4/GknPPgAAAAAAAIA/NJJeP+a2sD40kl4/5rawPsxtIT/mtrA+zG0hP+a2sD4AAAAAAACAP8xtIT8aSc8+zG0hPxpJzz4AAAAAAACAP8xtIT8AAMA+AAAAAAAAgD8AAAAAAACAPzSSXj/mtrA+NJJeP+a2sD4AAAAAAACAPzSSXj8AAMA+AAAAAAAAgD80kl4/GknPPjSSXj8aSc8+zG0hP+a2sD7MbSE/5rawPgAAAAAAAIA/fQBIAGwAfQBsAIEAEQAHAHIAEQByAIgAEgANACsAEwAsACIAaQBgAI8AaQCPAIYAsAC0AMcAsADHALwAugC4AK0AugCtAKwAVQBHAFsAVABaAGcABQAAAJsABgCcAHEAAQAMAJcAAQCXAJ0ACwAQAIcACwCHAJYAAgAIABwAAwAdADgAJQAuADIAJQAyABUADgAEADkADwA6AC0AGwAhACgAGgAnABgAIAAqADEAHwAwACYANgAZABYANwAXADQAKQA1ADMAKQAzAC8ACgAUACQACQAjAB4APQBBAEQASgBOAFAAVgBeAGIAZABqAG4AdQB3AHwAgACEAIwAjgCTAJoAoQCjAKcAegB/AIkAewCKAHMASQB+AHgASQB4AEwARQBRAE8ARQBPAD4AgwCNAJkAgwCZAIsAYwBrAGUAYwBlAFcApgB2AHQApgB0AKAAXACUAJAAXACQAGEAQwBfAFkAQgBYAEYAggBtAGgAggBoAIUAkQCiAJ4AkgCfAJgApAA/ADwApAA8AKkAcABLAFMAbwBSAGYAeQCoADsAeQA7AE0ArACtAJUArACVAF0AQAClAK8AQACvAK4ArgCvALUArgC1ALEAvwC9AMgAxQDDAMoAvwDIAMUAxQDKAL8AuwCqAMAAuwDAAMsAtwC5AMkAtwDJAMIAqwC2AMEAqwDBAMQAqgCyAL4AqgC+AMAAswCrAMQAswDEAMYA" + "byteLength" : 8892, + "uri" : "data:application/octet-stream;base64,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" } ] } diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index b659c5e1..534d1a39 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -197,6 +197,10 @@ namespace Nuake { if (ImGuizmo::IsUsing()) { + // TODO: CALCAULATE DELTA BETWEEN THE GLOBAL TRANSFORMS, CALCULATE ROTAION, SCALe DELTAS + // AND add Them to each component. + // + // const Matrix4& transformDelta = // Since imguizmo returns a transform in global space and we want the local transform, // we need to multiply by the inverse of the parent's global transform in order to revert // the changes from the parent transform. @@ -217,32 +221,47 @@ namespace Nuake { Vector4 pesp = Vector4(); glm::decompose(localTransform, scale, rotation, pos, skew, pesp); - tc.Translation = pos; - rotation.w *= -1.0f; - tc.Rotation = rotation; - tc.Scale = scale; - tc.LocalTransform = localTransform; - //tc.Dirty = true; + float newScale[3]; + float newRot[3]; + float rotates[3]; + float newPos[3]; + ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(localTransform), newPos, newRot, newScale); + rotates[0] = -newRot[0]; + rotates[1] = -newRot[1]; + rotates[2] = newRot[2]; - const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), pos); - const Matrix4& rotationMatrix = glm::mat4_cast(rotation); + auto rott = QuatFromEuler(rotates[0], rotates[1], rotates[2]); + + + + const Matrix4& rotationMatrix = glm::mat4_cast(glm::conjugate(rott)); const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), scale); + const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), pos); const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; + + //assert(newLocalTransform == localTransform); + tc.Translation = pos; + tc.Rotation = glm::normalize(glm::conjugate(rotation)); + tc.Scale = scale; + tc.LocalTransform = newLocalTransform; + tc.Dirty = true; + + // Decompose global trasnform - Vector3 gscale = Vector3(); - Quat grotation = Quat(); - Vector3 gpos = Vector3(); - Vector3 gskew = Vector3(); - Vector4 gpesp = Vector4(); - glm::decompose(transform, gscale, grotation, gpos, gskew, gpesp); - - //glm::quat rotationQuaternionG = glm::quat_cast(transform); - tc.SetGlobalPosition(gpos); - tc.SetGlobalRotation(grotation); - tc.SetGlobalScale(gscale); - tc.SetGlobalTransform(localTransform); + //Vector3 gscale = Vector3(); + //Quat grotation = Quat(); + //Vector3 gpos = Vector3(); + //Vector3 gskew = Vector3(); + //Vector4 gpesp = Vector4(); + //glm::decompose(transform, gscale, grotation, gpos, gskew, gpesp); + // + ////glm::quat rotationQuaternionG = glm::quat_cast(transform); + //tc.SetGlobalPosition(gpos); + //tc.SetGlobalRotation(glm::conjugate(grotation)); + //tc.SetGlobalScale(gscale); + //tc.SetGlobalTransform(localTransform); } } @@ -375,9 +394,8 @@ namespace Nuake { if (ImGui::Selectable("Focus camera")) { Ref editorCam = Engine::GetCurrentScene()->m_EditorCamera; - editorCam->Translation = entity.GetComponent().GetGlobalPosition(); Vector3 camDirection = entity.GetComponent().CameraInstance->GetDirection(); - editorCam->SetDirection(camDirection); + editorCam->SetTransform(glm::inverse(entity.GetComponent().GetGlobalTransform())); } ImGui::Separator(); } diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index fc6761a8..9009df68 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -66,4 +66,16 @@ Vector3 Nuake::QuatToDirection(const Quat& quat) { return glm::normalize(quat * Vector3(0, 0, -1)); //return glm::normalize(glm::rotate(glm::inverse(quat), glm::vec3(-1.0, 0.0, 0.0))); +} + +void Nuake::Decompose(const Matrix4& m, Vector3& pos, Quat& rot, Vector3& scale) +{ + pos = m[3]; + for (int i = 0; i < 3; i++) + scale[i] = glm::length(Vector3(m[i])); + const glm::mat3 rotMtx( + glm::vec3(m[0]) / scale[0], + glm::vec3(m[1]) / scale[1], + glm::vec3(m[2]) / scale[2]); + rot = glm::quat_cast(rotMtx); } \ No newline at end of file diff --git a/Nuake/src/Core/Maths.h b/Nuake/src/Core/Maths.h index 13a91871..ba3b1c18 100644 --- a/Nuake/src/Core/Maths.h +++ b/Nuake/src/Core/Maths.h @@ -24,4 +24,5 @@ namespace Nuake Quat CreateFromAxisAngle(Vector3 axis, float angle); Quat QuatFromEuler(float x, float y, float z); Vector3 QuatToDirection(const Quat& quat); + void Decompose(const Matrix4& m, Vector3& pos, Quat& rot, Vector3& scale); } diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index ea80f716..cd7cfaa4 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -44,15 +44,16 @@ namespace Nuake if (transform.Dirty) { auto& localTranslate = transform.GetLocalPosition(); - auto& localRot = transform.GetLocalRotation(); + auto& localRot = glm::normalize(transform.GetLocalRotation()); auto& localScale = transform.GetLocalScale(); - const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), localTranslate); - //localRot.w *= -1.0f; + const Matrix4& rotationMatrix = glm::mat4_cast(localRot); const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), localScale); const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; + + //localRot *= -1.0f; //if(localRot.y != 0) // assert(newLocalTransform == transform.GetLocalTransform()); @@ -114,7 +115,7 @@ namespace Nuake camera.CameraInstance->Translation = transform.GlobalTranslation; auto globalRotation = transform.GetGlobalRotation(); - auto& trnaslationMatrix = glm::translate(Matrix4(1.0f), transform.GetGlobalPosition()); + auto& translationMatrix = glm::translate(Matrix4(1.0f), transform.GetGlobalPosition()); const Matrix4& rotationMatrix = glm::mat4_cast(globalRotation); Vector4 forward = Vector4(0, 0, -1, 1); const auto globalForward = rotationMatrix * forward; @@ -123,7 +124,7 @@ namespace Nuake const auto globalRight = rotationMatrix * right; camera.CameraInstance->Direction = globalForward; camera.CameraInstance->Right = globalRight; -; camera.CameraInstance->SetTransform(glm::inverse(trnaslationMatrix * rotationMatrix)); +; camera.CameraInstance->SetTransform(glm::inverse(translationMatrix * rotationMatrix)); } } } From b2f14472f883e2b12c03a0a82af5590e9c3361bb Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Fri, 14 Jul 2023 11:25:33 -0400 Subject: [PATCH 11/13] Now everything works, except rotating while having scale --- Editor/src/Windows/EditorInterface.cpp | 40 ++++++++++----------- Nuake/src/Core/Maths.cpp | 10 +++--- Nuake/src/Scene/Systems/TransformSystem.cpp | 10 ++---- 3 files changed, 27 insertions(+), 33 deletions(-) diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index 534d1a39..38133729 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -204,7 +204,7 @@ namespace Nuake { // Since imguizmo returns a transform in global space and we want the local transform, // we need to multiply by the inverse of the parent's global transform in order to revert // the changes from the parent transform. - Matrix4 localTransform = transform; + Matrix4 localTransform = Matrix4(transform); ParentComponent& parent = Selection.Entity.GetComponent(); if (parent.HasParent) { @@ -221,43 +221,41 @@ namespace Nuake { Vector4 pesp = Vector4(); glm::decompose(localTransform, scale, rotation, pos, skew, pesp); - float newScale[3]; float newRot[3]; float rotates[3]; float newPos[3]; ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(localTransform), newPos, newRot, newScale); - rotates[0] = -newRot[0]; - rotates[1] = -newRot[1]; + rotates[0] = newRot[0]; + rotates[1] = newRot[1]; rotates[2] = newRot[2]; + + auto newnewScale = Vector3(newScale[0], newScale[1], newScale[2]); + glm::mat3 rotationMatrix2 = glm::mat3(localTransform); + glm::quat rotationQuaternion = glm::normalize(glm::quat(rotationMatrix2)); auto rott = QuatFromEuler(rotates[0], rotates[1], rotates[2]); - - - - const Matrix4& rotationMatrix = glm::mat4_cast(glm::conjugate(rott)); - const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), scale); + const Matrix4& rotationMatrix = glm::mat4_cast(rott); + const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), newnewScale); const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), pos); const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; //assert(newLocalTransform == localTransform); tc.Translation = pos; - tc.Rotation = glm::normalize(glm::conjugate(rotation)); - tc.Scale = scale; + tc.Rotation = rotationQuaternion; + tc.Scale = newnewScale; tc.LocalTransform = newLocalTransform; tc.Dirty = true; - - // Decompose global trasnform - //Vector3 gscale = Vector3(); - //Quat grotation = Quat(); - //Vector3 gpos = Vector3(); - //Vector3 gskew = Vector3(); - //Vector4 gpesp = Vector4(); - //glm::decompose(transform, gscale, grotation, gpos, gskew, gpesp); - // - ////glm::quat rotationQuaternionG = glm::quat_cast(transform); + Vector3 gscale = Vector3(); + Quat grotation = Quat(); + Vector3 gpos = Vector3(); + Vector3 gskew = Vector3(); + Vector4 gpesp = Vector4(); + glm::decompose(transform, gscale, grotation, gpos, gskew, gpesp); + + //glm::quat rotationQuaternionG = glm::quat_cast(transform); //tc.SetGlobalPosition(gpos); //tc.SetGlobalRotation(glm::conjugate(grotation)); //tc.SetGlobalScale(gscale); diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index 9009df68..e1edc573 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -37,12 +37,12 @@ Quat Nuake::CreateFromAxisAngle(Vector3 axis, float angle) Quat Nuake::QuatFromEuler(float x, float y, float z) { - glm::quat yawQuat = glm::angleAxis(Rad(y), glm::vec3(0.0f, 1.0f, 0.0f)); - glm::quat rollQuat = glm::angleAxis(Rad(z), glm::vec3(0.0f, 0.0f, 1.0f)); - glm::quat pitchQuat = glm::angleAxis(Rad(x), glm::vec3(1.0f, 0.0f, 0.0f)); - glm::quat orientation = yawQuat * pitchQuat * rollQuat; + glm::quat pitchQuat = glm::angleAxis(Rad(x), glm::vec3(1.0f, 0.0f, 0.0f)); + glm::quat yawQuat = glm::angleAxis(Rad(y), glm::vec3(0.0f, 1.0f, 0.0f)); + glm::quat rollQuat = glm::angleAxis(Rad(z), glm::vec3(0.0f, 0.0f, -1.0f)); + glm::quat orientation = yawQuat * pitchQuat * rollQuat; - return glm::normalize(orientation); + return glm::normalize(orientation); return Quat(Vector3(Rad(x), Rad(y), Rad(z))); diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index cd7cfaa4..3e5b69b9 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -47,14 +47,11 @@ namespace Nuake auto& localRot = glm::normalize(transform.GetLocalRotation()); auto& localScale = transform.GetLocalScale(); const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), localTranslate); - const Matrix4& rotationMatrix = glm::mat4_cast(localRot); const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), localScale); const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; - - - //localRot *= -1.0f; - //if(localRot.y != 0) + // localRot *= -1.0f; + // if(localRot.y != 0) // assert(newLocalTransform == transform.GetLocalTransform()); transform.SetLocalTransform(newLocalTransform); @@ -67,7 +64,6 @@ namespace Nuake for (auto e : transformView) { auto [parent, transform] = transformView.get(e); - if (!parent.HasParent) { // If no parents, then globalTransform is local transform. @@ -99,7 +95,7 @@ namespace Nuake NameComponent& nameComponent = parentComponent.Parent.GetComponent(); parentComponent = parentComponent.Parent.GetComponent(); } - + transform.SetGlobalPosition(globalPosition); transform.SetGlobalRotation(globalOrientation); transform.SetGlobalScale(globalScale); From 94ba63cc28cf0ded946733a1cd1f5fe33b764728 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Fri, 14 Jul 2023 11:51:06 -0400 Subject: [PATCH 12/13] Clean up --- Editor/src/Windows/EditorInterface.cpp | 69 +++++++-------------- Nuake/src/Scene/Systems/TransformSystem.cpp | 9 +-- 2 files changed, 27 insertions(+), 51 deletions(-) diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index 38133729..6c24d27a 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -197,10 +197,6 @@ namespace Nuake { if (ImGuizmo::IsUsing()) { - // TODO: CALCAULATE DELTA BETWEEN THE GLOBAL TRANSFORMS, CALCULATE ROTAION, SCALe DELTAS - // AND add Them to each component. - // - // const Matrix4& transformDelta = // Since imguizmo returns a transform in global space and we want the local transform, // we need to multiply by the inverse of the parent's global transform in order to revert // the changes from the parent transform. @@ -214,52 +210,35 @@ namespace Nuake { } // Decompose local transform - Vector3 scale = Vector3(); - Quat rotation = Quat(); - Vector3 pos = Vector3(); - Vector3 skew = Vector3(); - Vector4 pesp = Vector4(); - glm::decompose(localTransform, scale, rotation, pos, skew, pesp); + float decomposedPosition[3]; + float decomposedEuler[3]; + float decomposedScale[3]; + ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(localTransform), decomposedPosition, decomposedEuler, decomposedScale); - float newScale[3]; - float newRot[3]; - float rotates[3]; - float newPos[3]; - ImGuizmo::DecomposeMatrixToComponents(glm::value_ptr(localTransform), newPos, newRot, newScale); - rotates[0] = newRot[0]; - rotates[1] = newRot[1]; - rotates[2] = newRot[2]; - - auto newnewScale = Vector3(newScale[0], newScale[1], newScale[2]); - glm::mat3 rotationMatrix2 = glm::mat3(localTransform); - glm::quat rotationQuaternion = glm::normalize(glm::quat(rotationMatrix2)); + const auto& localPosition = Vector3(decomposedPosition[0], decomposedPosition[1], decomposedPosition[2]); + const auto& localScale = Vector3(decomposedScale[0], decomposedScale[1], decomposedScale[2]); - auto rott = QuatFromEuler(rotates[0], rotates[1], rotates[2]); - const Matrix4& rotationMatrix = glm::mat4_cast(rott); - const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), newnewScale); - const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), pos); - const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; + localTransform[0] /= localScale.x; + localTransform[1] /= localScale.y; + localTransform[2] /= localScale.z; + const auto& rotationMatrix = Matrix3(localTransform); + const Quat& localRotation = glm::normalize(Quat(rotationMatrix)); - //assert(newLocalTransform == localTransform); - tc.Translation = pos; - tc.Rotation = rotationQuaternion; - tc.Scale = newnewScale; + const Matrix4& rotationMatrix4 = glm::mat4_cast(localRotation); + const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), localScale); + const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), localPosition); + const Matrix4& newLocalTransform = translationMatrix * rotationMatrix4 * scaleMatrix; + + tc.Translation = localPosition; + + if (CurrentOperation != ImGuizmo::SCALE) + { + tc.Rotation = localRotation; + } + + tc.Scale = localScale; tc.LocalTransform = newLocalTransform; tc.Dirty = true; - - // Decompose global trasnform - Vector3 gscale = Vector3(); - Quat grotation = Quat(); - Vector3 gpos = Vector3(); - Vector3 gskew = Vector3(); - Vector4 gpesp = Vector4(); - glm::decompose(transform, gscale, grotation, gpos, gskew, gpesp); - - //glm::quat rotationQuaternionG = glm::quat_cast(transform); - //tc.SetGlobalPosition(gpos); - //tc.SetGlobalRotation(glm::conjugate(grotation)); - //tc.SetGlobalScale(gscale); - //tc.SetGlobalTransform(localTransform); } } diff --git a/Nuake/src/Scene/Systems/TransformSystem.cpp b/Nuake/src/Scene/Systems/TransformSystem.cpp index 3e5b69b9..793f8c75 100644 --- a/Nuake/src/Scene/Systems/TransformSystem.cpp +++ b/Nuake/src/Scene/Systems/TransformSystem.cpp @@ -43,16 +43,13 @@ namespace Nuake TransformComponent& transform = localTransformView.get(tv); if (transform.Dirty) { - auto& localTranslate = transform.GetLocalPosition(); - auto& localRot = glm::normalize(transform.GetLocalRotation()); - auto& localScale = transform.GetLocalScale(); + const Vector3& localTranslate = transform.GetLocalPosition(); + const Quat& localRot = glm::normalize(transform.GetLocalRotation()); + const Vector3& localScale = transform.GetLocalScale(); const Matrix4& translationMatrix = glm::translate(Matrix4(1.0f), localTranslate); const Matrix4& rotationMatrix = glm::mat4_cast(localRot); const Matrix4& scaleMatrix = glm::scale(Matrix4(1.0f), localScale); const Matrix4& newLocalTransform = translationMatrix * rotationMatrix * scaleMatrix; - // localRot *= -1.0f; - // if(localRot.y != 0) - // assert(newLocalTransform == transform.GetLocalTransform()); transform.SetLocalTransform(newLocalTransform); transform.Dirty = false; From 6384c39efd788b3ff284efa561f2ec5aaff01321 Mon Sep 17 00:00:00 2001 From: Antoine Pilote Date: Fri, 14 Jul 2023 12:32:26 -0400 Subject: [PATCH 13/13] PR Fixes --- Editor/src/Misc/GizmoDrawer.cpp | 2 +- Editor/src/Windows/EditorInterface.cpp | 1 + Nuake/src/Core/Maths.cpp | 1 - Nuake/src/Rendering/Camera.cpp | 22 ++-------------------- 4 files changed, 4 insertions(+), 22 deletions(-) diff --git a/Editor/src/Misc/GizmoDrawer.cpp b/Editor/src/Misc/GizmoDrawer.cpp index 2618377b..3a9524ee 100644 --- a/Editor/src/Misc/GizmoDrawer.cpp +++ b/Editor/src/Misc/GizmoDrawer.cpp @@ -259,7 +259,7 @@ void GizmoDrawer::DrawGizmos(Ref scene) flatShader->SetUniformVec4("u_Color", Vector4(0.0f, 1.0f, 0.4f, 1.0f)); const auto scaledTransform = glm::scale(transformComponent.GetGlobalTransform(), Vector3(0.25f, 0.25f, 0.25f)); - //renderList.AddToRenderList(_gizmos["player"]->GetMeshes()[0], scaledTransform); + renderList.AddToRenderList(_gizmos["player"]->GetMeshes()[0], scaledTransform); renderList.Flush(flatShader, true); } diff --git a/Editor/src/Windows/EditorInterface.cpp b/Editor/src/Windows/EditorInterface.cpp index 6c24d27a..5af71753 100644 --- a/Editor/src/Windows/EditorInterface.cpp +++ b/Editor/src/Windows/EditorInterface.cpp @@ -372,6 +372,7 @@ namespace Nuake { { Ref editorCam = Engine::GetCurrentScene()->m_EditorCamera; Vector3 camDirection = entity.GetComponent().CameraInstance->GetDirection(); + camDirection.z *= -1.0f; editorCam->SetTransform(glm::inverse(entity.GetComponent().GetGlobalTransform())); } ImGui::Separator(); diff --git a/Nuake/src/Core/Maths.cpp b/Nuake/src/Core/Maths.cpp index e1edc573..884f4339 100644 --- a/Nuake/src/Core/Maths.cpp +++ b/Nuake/src/Core/Maths.cpp @@ -65,7 +65,6 @@ Quat Nuake::QuatFromEuler(float x, float y, float z) Vector3 Nuake::QuatToDirection(const Quat& quat) { return glm::normalize(quat * Vector3(0, 0, -1)); - //return glm::normalize(glm::rotate(glm::inverse(quat), glm::vec3(-1.0, 0.0, 0.0))); } void Nuake::Decompose(const Matrix4& m, Vector3& pos, Quat& rot, Vector3& scale) diff --git a/Nuake/src/Rendering/Camera.cpp b/Nuake/src/Rendering/Camera.cpp index 11342a89..f44b340c 100644 --- a/Nuake/src/Rendering/Camera.cpp +++ b/Nuake/src/Rendering/Camera.cpp @@ -45,30 +45,15 @@ namespace Nuake void Camera::SetDirection(Vector3 direction) { - //cam->cameraDirection.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch)); - //cam->cameraDirection.y = sin(glm::radians(Pitch)); - //cam->cameraDirection.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch)); - //cam->cameraFront = glm::normalize(cam->cameraDirection); - //cam->cameraRight = glm::normalize(glm::cross(cam->up, cam->cameraFront)); Direction = glm::normalize(direction); Right = glm::normalize(glm::cross(Vector3(0, 1, 0), Direction)); m_View = lookAt(Translation, Translation + glm::normalize(Direction), Vector3(0, 1, 0)); - - //Up = glm::normalize(glm::cross(Direction, Right)); } void Camera::SetDirection(const Quat& direction) { - //cam->cameraDirection.x = cos(glm::radians(Yaw)) * cos(glm::radians(Pitch)); - //cam->cameraDirection.y = sin(glm::radians(Pitch)); - //cam->cameraDirection.z = sin(glm::radians(Yaw)) * cos(glm::radians(Pitch)); - //cam->cameraFront = glm::normalize(cam->cameraDirection); - //cam->cameraRight = glm::normalize(glm::cross(cam->up, cam->cameraFront)); - - //glm::quatLookAt(); - //Direction = glm::normalize(direction); - //Right = glm::normalize(glm::cross(Vector3(0, 1, 0), Direction)); - //Up = glm::normalize(glm::cross(Direction, Right)); + // TODO: Calculate forward and Right from quaternion. + assert("Not implemented!"); } Vector3 Camera::GetTranslation() { @@ -89,14 +74,11 @@ namespace Nuake void Camera::SetTransform(const Matrix4& transform) { m_View = transform; - } Matrix4 Camera::GetTransform() { return m_View; - glm::mat4 tr = lookAt(Translation, Translation + glm::normalize(Direction), Vector3(0, 1, 0)); - return tr; } Matrix4 Camera::GetTransformRotation()