correct bugs, save changes with tests, allow gizmos to controller cameras & adjust to changes - take reference frame with ::manipulate parameter; I need to inspect a few issues with reference events

Author: AnastaZIuk

61_UI/main.cpp

@@ -1211,7 +1211,7 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 projection.endInputProcessing();
 
 if (vCount)
-camera->manipulate({ virtualEvents.data(), vCount }, ICamera::Local);
+camera->manipulate({ virtualEvents.data(), vCount });
 }
 
 m_ui.manager->update(params);
@@ -1350,7 +1350,6 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 
 const bool isCameraGimbalTarget = modelIx; // I assume scene demo model is 0th ix, left are planar cameras
 ICamera* const targetGimbalManipulationCamera = isCameraGimbalTarget ? m_planarProjections[modelIx - 1u]->getCamera() : nullptr;
-bool discard = isCameraGimbalTarget && mCurrentGizmoOperation != ImGuizmo::TRANSLATE; // discard WiP stuff
 
 // if we try to manipulate a camera which appears to be the same camera we see scene from then obvsly it doesn't make sense to manipulate its gizmo so we skip it
 // EDIT: it actually makes some sense if you assume render planar view is rendered with ortho projection, but we would need to add imguizmo controller virtual map
@@ -1373,98 +1372,94 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 
 imguizmoModel.outTRS = imguizmoModel.inTRS;
 {
-const bool success = ImGuizmo::Manipulate(&imguizmoPlanar.view[0][0], &imguizmoPlanar.projection[0][0], mCurrentGizmoOperation, mCurrentGizmoMode, &imguizmoModel.outTRS[0][0], &imguizmoModel.outDeltaTRS[0][0], useSnap ? &snap[0] : nullptr);
+const bool success = ImGuizmo::Manipulate(&imguizmoPlanar.view[0][0], &imguizmoPlanar.projection[0][0], ImGuizmo::OPERATION::UNIVERSAL, mCurrentGizmoMode, &imguizmoModel.outTRS[0][0], &imguizmoModel.outDeltaTRS[0][0], useSnap ? &snap[0] : nullptr);
 
 if (success)
 {
-++manipulationCounter;
-discard |= manipulationCounter > 1;
-
-/*
-
-NOTE to self & TODO: I must be killing ImGuizmo last invocation cache or something with my delta events (or at least I dont 
-see now where I'm *maybe* using its API incorrectly, the problem is I get translation parts in delta matrix when doing 
-rotations hence it glitches my cameras -> on the other hand I can see it kinda correctly outputs the delta matrix when
-gc model is bound
-
-auto postprocessDeltaManipulation = [](const float32_t4x4& inDeltaMatrix, float32_t4x4& outDeltaMatrix, ImGuizmo::OPERATION operation) -> void
+if (targetGimbalManipulationCamera)
 {
-struct
-{
-float32_t3 dTranslation, dRotation, dScale;
-} world;
+boundCameraToManipulate = smart_refctd_ptr<ICamera>(targetGimbalManipulationCamera);
+boundPlanarCameraIxToManipulate = modelIx - 1u;
 
-ImGuizmo::DecomposeMatrixToComponents(&inDeltaMatrix[0][0], &world.dTranslation[0], &world.dRotation[0], &world.dScale[0]);
+auto& gimbal = (ICamera::CGimbal&)targetGimbalManipulationCamera->getGimbal();
 
-if (operation == ImGuizmo::TRANSLATE)
-{
-world.dRotation = float32_t3(0, 0, 0);
-}
-else if (operation == ImGuizmo::ROTATE)
+struct
 {
-world.dTranslation = float32_t3(0, 0, 0);
-}
-
-ImGuizmo::RecomposeMatrixFromComponents(&world.dTranslation[0], &world.dRotation[0], &world.dScale[0], &outDeltaMatrix[0][0]);
-};
-
-postprocessDeltaManipulation(imguizmoModel.outDeltaTRS, imguizmoModel.outDeltaTRS, mCurrentGizmoOperation); 
-*/
+float32_t3 t, r, s;
+} out, delta;
 
-if (!discard)
-{
-if (targetGimbalManipulationCamera)
+ImGuizmo::DecomposeMatrixToComponents(&imguizmoModel.outTRS[0][0], &out.t[0], &out.r[0], &out.s[0]);
+ImGuizmo::DecomposeMatrixToComponents(&imguizmoModel.outDeltaTRS[0][0], &delta.t[0], &delta.r[0], &delta.s[0]);
 {
-boundCameraToManipulate = smart_refctd_ptr<ICamera>(targetGimbalManipulationCamera);
-boundPlanarCameraIxToManipulate = modelIx - 1u;
-
-/*
-testing imguizmo controller for target camera, we use delta world imguizmo TRS matrix to generate virtual events
-*/
-
+std::vector<CVirtualGimbalEvent> virtualEvents;
+
+auto requestMagnitudeUpdateWithScalar = [&](float signPivot, float dScalar, float dMagnitude, auto positive, auto negative)
 {
-static std::vector<CVirtualGimbalEvent> virtualEvents(0x45);
-uint32_t vCount = {};
-
-targetGimbalManipulationCamera->beginInputProcessing(m_nextPresentationTimestamp);
+if (dScalar != signPivot)
 {
-targetGimbalManipulationCamera->process(nullptr, vCount);
-
-if (virtualEvents.size() < vCount)
-virtualEvents.resize(vCount);
+auto& ev = virtualEvents.emplace_back();
+auto code = (dScalar > signPivot) ? positive : negative;
 
-IGimbalController::SUpdateParameters params;
-params.imguizmoEvents = { { imguizmoModel.outDeltaTRS } };
-targetGimbalManipulationCamera->process(virtualEvents.data(), vCount, params);
+ev.type = code;
+ev.magnitude += dMagnitude;
 }
-targetGimbalManipulationCamera->endInputProcessing();
+};
+
+// Delta translation impulse
+requestMagnitudeUpdateWithScalar(0.f, delta.t[0], std::abs(delta.t[0]), CVirtualGimbalEvent::VirtualEventType::MoveRight, CVirtualGimbalEvent::VirtualEventType::MoveLeft);
+requestMagnitudeUpdateWithScalar(0.f, delta.t[1], std::abs(delta.t[1]), CVirtualGimbalEvent::VirtualEventType::MoveUp, CVirtualGimbalEvent::VirtualEventType::MoveDown);
+requestMagnitudeUpdateWithScalar(0.f, delta.t[2], std::abs(delta.t[2]), CVirtualGimbalEvent::VirtualEventType::MoveForward, CVirtualGimbalEvent::VirtualEventType::MoveBackward);
+
+// Delta rotation impulse
+requestMagnitudeUpdateWithScalar(0.f, delta.r[0], std::abs(delta.r[0]), CVirtualGimbalEvent::VirtualEventType::TiltUp, CVirtualGimbalEvent::VirtualEventType::TiltDown);
+requestMagnitudeUpdateWithScalar(0.f, delta.r[1], std::abs(delta.r[1]), CVirtualGimbalEvent::VirtualEventType::PanRight, CVirtualGimbalEvent::VirtualEventType::PanLeft);
+requestMagnitudeUpdateWithScalar(0.f, delta.r[2], std::abs(delta.r[2]), CVirtualGimbalEvent::VirtualEventType::RollRight, CVirtualGimbalEvent::VirtualEventType::RollLeft);
+
+// Delta scale impulse
+requestMagnitudeUpdateWithScalar(1.f, delta.s[0], std::abs(delta.s[0]), CVirtualGimbalEvent::VirtualEventType::ScaleXInc, CVirtualGimbalEvent::VirtualEventType::ScaleXDec);
+requestMagnitudeUpdateWithScalar(1.f, delta.s[1], std::abs(delta.s[1]), CVirtualGimbalEvent::VirtualEventType::ScaleYInc, CVirtualGimbalEvent::VirtualEventType::ScaleYDec);
+requestMagnitudeUpdateWithScalar(1.f, delta.s[2], std::abs(delta.s[2]), CVirtualGimbalEvent::VirtualEventType::ScaleZInc, CVirtualGimbalEvent::VirtualEventType::ScaleZDec);
+
+constexpr auto TESSTTSS = CVirtualGimbalEvent::All;
+const auto impulse = gimbal.accumulate<TESSTTSS>(virtualEvents);
+
+assert(impulse.dVirtualTranslate == float64_t3(delta.t));
+assert(impulse.dVirtualRotation == float64_t3(delta.r));
+assert(impulse.dVirtualScale == float64_t3(delta.s));
 
-if (vCount)
-{
-const float pMoveSpeed = targetGimbalManipulationCamera->getMoveSpeedScale();
-const float pRotationSpeed = targetGimbalManipulationCamera->getRotationSpeedScale();
+const auto vCount = virtualEvents.size();
 
-// I start to think controller should be able to set sensitivity to scale magnitudes of generated events
-// in order for camera to not keep any magnitude scalars like move or rotation speed scales
+if (vCount)
+{
+const float pMoveSpeed = targetGimbalManipulationCamera->getMoveSpeedScale();
+const float pRotationSpeed = targetGimbalManipulationCamera->getRotationSpeedScale();
 
-targetGimbalManipulationCamera->setMoveSpeedScale(1);
-targetGimbalManipulationCamera->setRotationSpeedScale(1);
+// I start to think controller should be able to set sensitivity to scale magnitudes of generated events
+// in order for camera to not keep any magnitude scalars like move or rotation speed scales
 
-// NOTE: generated events from ImGuizmo controller are always in world space!
-targetGimbalManipulationCamera->manipulate({ virtualEvents.data(), vCount }, ICamera::World);
+targetGimbalManipulationCamera->setMoveSpeedScale(1);
+targetGimbalManipulationCamera->setRotationSpeedScale(1);
 
-targetGimbalManipulationCamera->setMoveSpeedScale(pMoveSpeed);
-targetGimbalManipulationCamera->setRotationSpeedScale(pRotationSpeed);
-}
+/*
+new = old * delta
+delta^(-1) * new = old
+*/
+
+const auto referenceFrame = getCastedMatrix<float64_t>(mul(inverse(imguizmoModel.outDeltaTRS), imguizmoModel.outTRS));
+targetGimbalManipulationCamera->manipulate({ virtualEvents.data(), vCount }, &referenceFrame);
+
+targetGimbalManipulationCamera->setMoveSpeedScale(pMoveSpeed);
+targetGimbalManipulationCamera->setRotationSpeedScale(pRotationSpeed);
 }
+
 }
-else
-{
-// again, for scene demo model full affine transformation without limits is assumed 
-m_model = float32_t3x4(hlsl::transpose(imguizmoModel.outTRS));
-boundCameraToManipulate = nullptr;
-boundPlanarCameraIxToManipulate = std::nullopt;
-}
+}
+else
+{
+// again, for scene demo model full affine transformation without limits is assumed 
+m_model = float32_t3x4(hlsl::transpose(imguizmoModel.outTRS));
+boundCameraToManipulate = nullptr;
+boundPlanarCameraIxToManipulate = std::nullopt;
 }
 }
 
@@ -2102,8 +2097,7 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 boundCameraToManipulate->setMoveSpeedScale(1);
 boundCameraToManipulate->setRotationSpeedScale(1);
 
-// NOTE: generated events from ImGuizmo controller are always in world space!
-boundCameraToManipulate->manipulate({ virtualEvents.data(), vCount }, ICamera::World);
+boundCameraToManipulate->manipulate({ virtualEvents.data(), vCount });
 
 boundCameraToManipulate->setMoveSpeedScale(pmSpeed);
 boundCameraToManipulate->setRotationSpeedScale(prSpeed);

common/include/camera/CFPSCamera.hpp

@@ -1,4 +1,4 @@
-// Copyright (C) 2018-2020 - DevSH Graphics Programming Sp. z O.O.
+// Copyright (C) 2018-2020 - DevSH Graphics Programming Sp. z O.O.
 // This file is part of the "Nabla Engine".
 // For conditions of distribution and use, see copyright notice in nabla.h
 
@@ -17,7 +17,24 @@ class CFPSCamera final : public ICamera
  using base_t = ICamera;
 
  CFPSCamera(const float64_t3& position, const glm::quat& orientation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f))
- : base_t(), m_gimbal({ .position = position, .orientation = orientation }) {}
+ : base_t(), m_gimbal({ .position = position, .orientation = orientation }) 
+ {
+ m_gimbal.begin();
+ {
+ const auto& gForward = m_gimbal.getZAxis();
+ const float gPitch = atan2(glm::length(glm::vec2(gForward.x, gForward.z)), gForward.y) - glm::half_pi<float>(), gYaw = atan2(gForward.x, gForward.z);
+
+
+
+
+ auto test = glm::quat(glm::vec3(gPitch, gYaw, 0.0f));
+
+ glm::vec3 euler = glm::eulerAngles(test);
+
+ m_gimbal.setOrientation(test);
+ }
+ m_gimbal.end();
+ }
 ~CFPSCamera() = default;
 
  const base_t::keyboard_to_virtual_events_t getKeyboardMappingPreset() const override { return m_keyboard_to_virtual_events_preset; }
@@ -29,51 +46,55 @@ class CFPSCamera final : public ICamera
  return m_gimbal;
  }
 
- virtual bool manipulate(std::span<const CVirtualGimbalEvent> virtualEvents, base_t::ManipulationMode mode) override
+ virtual bool manipulate(std::span<const CVirtualGimbalEvent> virtualEvents, const float64_t4x4 const* referenceFrame = nullptr) override
  {
- constexpr double MaxVerticalAngle = glm::radians(88.0f), MinVerticalAngle = -MaxVerticalAngle;
-
  if (!virtualEvents.size())
  return false;
 
- const auto& gForward = m_gimbal.getZAxis();
- const float gPitch = atan2(glm::length(glm::vec2(gForward.x, gForward.z)), gForward.y) - glm::half_pi<float>(), gYaw = atan2(gForward.x, gForward.z);
-
- glm::quat newOrientation; float64_t3 newPosition;
+ //! true if virtual events are with respect to the moving gimbal frame, otherwise it is assumed deltas are generated for fixed reference frame
+ const bool isMovingReference = not referenceFrame;
 
- // TODO: I make assumption what world base is now (at least temporary), I need to think of this but maybe each ITransformObject should know what its world is
- // in ideal scenario we would define this crazy enum with all possible standard bases
- const auto impulse = mode == base_t::Local ? m_gimbal.accumulate<AllowedLocalVirtualEvents>(virtualEvents)
- : m_gimbal.accumulate<AllowedWorldVirtualEvents>(virtualEvents, { 1, 0, 0 }, { 0, 1, 0 }, { 0, 0, 1 });
+ CReferenceTransform reference;
+ if (not m_gimbal.extractReferenceTransform(&reference, referenceFrame))
+ return false;
 
- const auto newPitch = std::clamp(gPitch + impulse.dVirtualRotation.x * m_rotationSpeedScale, MinVerticalAngle, MaxVerticalAngle), newYaw = gYaw + impulse.dVirtualRotation.y * m_rotationSpeedScale;
- newOrientation = glm::quat(glm::vec3(newPitch, newYaw, 0.0f)); newPosition = m_gimbal.getPosition() + impulse.dVirtualTranslate * m_moveSpeedScale;
+ auto impulse = m_gimbal.accumulate<AllowedVirtualEvents>(virtualEvents);
 
  bool manipulated = true;
 
  m_gimbal.begin();
  {
- m_gimbal.setOrientation(newOrientation);
- m_gimbal.setPosition(newPosition);
+ if (isMovingReference)
+ {
+ const auto& gForward = m_gimbal.getZAxis();
+ const float gPitch = atan2(glm::length(glm::vec2(gForward.x, gForward.z)), gForward.y) - glm::half_pi<float>(), gYaw = atan2(gForward.x, gForward.z);
+ const float newPitch = std::clamp<float>(gPitch + impulse.dVirtualRotation.x * m_rotationSpeedScale, MinVerticalAngle, MaxVerticalAngle), newYaw = gYaw + impulse.dVirtualRotation.y * m_rotationSpeedScale;
+ 
+ m_gimbal.setOrientation(glm::quat(glm::vec3(newPitch, newYaw, 0.0f)));
+ m_gimbal.setPosition(m_gimbal.getPosition() + mul(impulse.dVirtualTranslate * m_moveSpeedScale, m_gimbal.getOrthonornalMatrix()));
+ }
+ else
+ {
+ // TODO: I need to think of this, the problem is that since reference frame may not be aligned with world nicely it means events must be transformed
+ // what FPS camera really does is:
+ // tilt around FIXED world (0,1,0) vector
+ // pitch around REFERENCE right vector
+ m_gimbal.transform(reference, impulse); 
+ }
  }
  m_gimbal.end();
 
  manipulated &= bool(m_gimbal.getManipulationCounter());
 
- if(manipulated)
+ if (manipulated)
  m_gimbal.updateView();
 
  return manipulated;
  }
 
- virtual const uint32_t getAllowedVirtualEvents(base_t::ManipulationMode mode) override
+ virtual const uint32_t getAllowedVirtualEvents() override
  {
- switch (mode)
- {
- case base_t::Local: return AllowedLocalVirtualEvents;
- case base_t::World: return AllowedWorldVirtualEvents;
- default: return CVirtualGimbalEvent::None;
- }
+ return AllowedVirtualEvents;
  }
 
  virtual const std::string_view getIdentifier() override
@@ -82,10 +103,11 @@ class CFPSCamera final : public ICamera
  }
 
 private:
+
  typename base_t::CGimbal m_gimbal;
 
- static inline constexpr auto AllowedLocalVirtualEvents = CVirtualGimbalEvent::Translate | CVirtualGimbalEvent::TiltUp | CVirtualGimbalEvent::TiltDown | CVirtualGimbalEvent::PanRight | CVirtualGimbalEvent::PanLeft;
- static inline constexpr auto AllowedWorldVirtualEvents = AllowedLocalVirtualEvents;
+ static inline constexpr auto AllowedVirtualEvents = CVirtualGimbalEvent::Translate | CVirtualGimbalEvent::Rotate;
+ static inline constexpr float MaxVerticalAngle = glm::radians(88.0f), MinVerticalAngle = -MaxVerticalAngle;
 
  static inline const auto m_keyboard_to_virtual_events_preset = []()
  {