Cameraz

61_UI/main.cpp

@@ -4,6 +4,16 @@
 
 #include "common.hpp"
 
+#include "camera/CCubeProjection.hpp"
+#include "camera/ICameraControl.hpp"
+#include "glm/glm/ext/matrix_clip_space.hpp" // TODO: TESTING
+
+// FPS Camera, TESTS
+using projection_matrix_t = float32_t4x4;
+using camera_t = Camera<projection_matrix_t>;
+using gimbal_t = camera_t::CGimbal;
+using projection_t = camera_t::base_t::projection_t;
+
 /*
 	Renders scene texture to an offline
 	framebuffer which color attachment
@@ -166,28 +176,26 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 			pass.ui.manager->registerListener([this]() -> void
 				{
 					ImGuiIO& io = ImGui::GetIO();
-
-					camera.setProjectionMatrix([&]() 
 					{
-						static matrix4SIMD projection;
+						auto* projection = camera->getProjection();
 
 						if (isPerspective)
-							if(isLH)
-								projection = matrix4SIMD::buildProjectionMatrixPerspectiveFovLH(core::radians(fov), io.DisplaySize.x / io.DisplaySize.y, zNear, zFar);
+						{
+							if (isLH)
+								projection->setMatrix(buildProjectionMatrixPerspectiveFovLH(glm::radians(fov), io.DisplaySize.x / io.DisplaySize.y, zNear, zFar));
 							else
-								projection = matrix4SIMD::buildProjectionMatrixPerspectiveFovRH(core::radians(fov), io.DisplaySize.x / io.DisplaySize.y, zNear, zFar);
+								projection->setMatrix(buildProjectionMatrixPerspectiveFovRH(glm::radians(fov), io.DisplaySize.x / io.DisplaySize.y, zNear, zFar));
+						}
 						else
 						{
 							float viewHeight = viewWidth * io.DisplaySize.y / io.DisplaySize.x;
 
-							if(isLH)
-								projection = matrix4SIMD::buildProjectionMatrixOrthoLH(viewWidth, viewHeight, zNear, zFar);
+							if (isLH)
+								projection->setMatrix(buildProjectionMatrixOrthoLH(viewWidth, viewHeight, zNear, zFar));
 							else
-								projection = matrix4SIMD::buildProjectionMatrixOrthoRH(viewWidth, viewHeight, zNear, zFar);
+								projection->setMatrix(buildProjectionMatrixOrthoRH(viewWidth, viewHeight, zNear, zFar));
 						}
-
-						return projection;
-					}());
+					}
 
 					ImGuizmo::SetOrthographic(false);
 					ImGuizmo::BeginFrame();
@@ -246,15 +254,11 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 
 					if (viewDirty || firstFrame)
 					{
-						core::vectorSIMDf cameraPosition(cosf(camYAngle)* cosf(camXAngle)* transformParams.camDistance, sinf(camXAngle)* transformParams.camDistance, sinf(camYAngle)* cosf(camXAngle)* transformParams.camDistance);
-						core::vectorSIMDf cameraTarget(0.f, 0.f, 0.f);
-						const static core::vectorSIMDf up(0.f, 1.f, 0.f);
-
-						camera.setPosition(cameraPosition);
-						camera.setTarget(cameraTarget);
-						camera.setBackupUpVector(up);
+						float32_t3 cameraPosition(cosf(camYAngle)* cosf(camXAngle)* transformParams.camDistance, sinf(camXAngle)* transformParams.camDistance, sinf(camYAngle)* cosf(camXAngle)* transformParams.camDistance);
+						float32_t3 cameraTarget(0.f, 0.f, 0.f);
 
-						camera.recomputeViewMatrix();
+						gimbal->setPosition(cameraPosition);
+						camera->setTarget(cameraTarget);
 
 						firstFrame = false;
 					}
@@ -322,35 +326,34 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 
 					static struct
 					{
-						core::matrix4SIMD view, projection, model;
+						float32_t4x4 view, projection, model;
 					} imguizmoM16InOut;
 
-					ImGuizmo::SetID(0u);
+					const auto& projectionMatrix = camera->getProjection()->getMatrix();
 
-					imguizmoM16InOut.view = core::transpose(matrix4SIMD(camera.getViewMatrix()));
-					imguizmoM16InOut.projection = core::transpose(camera.getProjectionMatrix());
-					imguizmoM16InOut.model = core::transpose(core::matrix4SIMD(pass.scene->object.model));
+					ImGuizmo::SetID(0u);
+					imguizmoM16InOut.view = transpose(getMatrix3x4As4x4(camera->getViewMatrix()));
+					imguizmoM16InOut.projection = transpose(projectionMatrix);
+					imguizmoM16InOut.model = transpose(getMatrix3x4As4x4(pass.scene->object.model));
 					{
 						if (flipGizmoY) // note we allow to flip gizmo just to match our coordinates
 							imguizmoM16InOut.projection[1][1] *= -1.f; // https://johannesugb.github.io/gpu-programming/why-do-opengl-proj-matrices-fail-in-vulkan/	
 
 						transformParams.editTransformDecomposition = true;
-						EditTransform(imguizmoM16InOut.view.pointer(), imguizmoM16InOut.projection.pointer(), imguizmoM16InOut.model.pointer(), transformParams);
+						EditTransform(&imguizmoM16InOut.view[0][0], &imguizmoM16InOut.projection[0][0], &imguizmoM16InOut.model[0][0], transformParams);
 					}
 
 					// to Nabla + update camera & model matrices
-					const auto& view = camera.getViewMatrix();
-					const auto& projection = camera.getProjectionMatrix();
-
+					const auto& view = camera->getViewMatrix();
+
 					// TODO: make it more nicely
-					const_cast<core::matrix3x4SIMD&>(view) = core::transpose(imguizmoM16InOut.view).extractSub3x4(); // a hack, correct way would be to use inverse matrix and get position + target because now it will bring you back to last position & target when switching from gizmo move to manual move (but from manual to gizmo is ok)
-					camera.setProjectionMatrix(projection); // update concatanated matrix
+					const_cast<float32_t3x4&>(view) = float32_t3x4(transpose(imguizmoM16InOut.view)); // a hack, correct way would be to use inverse matrix and get position + target because now it will bring you back to last position & target when switching from gizmo move to manual move (but from manual to gizmo is ok)
 					{
-						static nbl::core::matrix3x4SIMD modelView, normal;
-						static nbl::core::matrix4SIMD modelViewProjection;
+						static float32_t3x4 modelView, normal;
+						static float32_t4x4 modelViewProjection;
 
 						auto& hook = pass.scene->object;
-						hook.model = core::transpose(imguizmoM16InOut.model).extractSub3x4();
+						hook.model = float32_t3x4(transpose(imguizmoM16InOut.model));
 						{
 							const auto& references = pass.scene->getResources().objects;
 							const auto type = static_cast<ObjectType>(gcIndex);
@@ -362,13 +365,17 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 
 						auto& ubo = hook.viewParameters;
 
-						modelView = nbl::core::concatenateBFollowedByA(view, hook.model);
-						modelView.getSub3x3InverseTranspose(normal);
-						modelViewProjection = nbl::core::concatenateBFollowedByA(camera.getConcatenatedMatrix(), hook.model);
+						modelView = concatenateBFollowedByA<float>(view, hook.model);
+
+						// TODO
+						//modelView.getSub3x3InverseTranspose(normal);
 
-						memcpy(ubo.MVP, modelViewProjection.pointer(), sizeof(ubo.MVP));
-						memcpy(ubo.MV, modelView.pointer(), sizeof(ubo.MV));
-						memcpy(ubo.NormalMat, normal.pointer(), sizeof(ubo.NormalMat));
+						auto concatMatrix = mul(projectionMatrix, getMatrix3x4As4x4(view));
+						modelViewProjection = mul(concatMatrix, getMatrix3x4As4x4(hook.model));
+
+						memcpy(ubo.MVP, &modelViewProjection[0][0], sizeof(ubo.MVP));
+						memcpy(ubo.MV, &modelView[0][0], sizeof(ubo.MV));
+						memcpy(ubo.NormalMat, &normal[0][0], sizeof(ubo.NormalMat));
 
 						// object meta display
 						{
@@ -403,9 +410,18 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 								ImGui::Separator();
 						};
 
-						addMatrixTable("Model Matrix", "ModelMatrixTable", 3, 4, pass.scene->object.model.pointer());
-						addMatrixTable("Camera View Matrix", "ViewMatrixTable", 3, 4, view.pointer());
-						addMatrixTable("Camera View Projection Matrix", "ViewProjectionMatrixTable", 4, 4, projection.pointer(), false);
+						auto& orientation = gimbal->getOrthonornalMatrix();
+
+						addMatrixTable("Model Matrix", "ModelMatrixTable", 3, 4, &pass.scene->object.model[0][0]);
+
+						addMatrixTable("Right", "OrientationRightVec", 1, 3, &gimbal->getXAxis()[0]);
+						addMatrixTable("Up", "OrientationUpVec", 1, 3, &gimbal->getYAxis()[0]);
+						addMatrixTable("Forward", "OrientationForwardVec", 1, 3, &gimbal->getZAxis()[0]);
+						addMatrixTable("Position", "PositionForwardVec", 1, 3, &gimbal->getPosition()[0]);
+
+						//addMatrixTable("Camera Gimbal Orientation Matrix", "OrientationMatrixTable", 3, 3, &orientation[0][0]);
+						addMatrixTable("Camera Gimbal View Matrix", "ViewMatrixTable", 3, 4, &view[0][0]);
+						addMatrixTable("Camera Gimbal Projection Matrix", "ProjectionMatrixTable", 4, 4, &projectionMatrix[0][0], false);
 
 						ImGui::End();
 					}
@@ -487,7 +503,19 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 			m_surface->recreateSwapchain();
 			m_winMgr->show(m_window.get());
 			oracle.reportBeginFrameRecord();
-			camera.mapKeysToArrows();
+
+			/*
+				TESTS, TODO: remove all once finished work & integrate with the example properly
+			*/
+
+			const float32_t3 position(cosf(camYAngle)* cosf(camXAngle)* transformParams.camDistance, sinf(camXAngle)* transformParams.camDistance, sinf(camYAngle)* cosf(camXAngle)* transformParams.camDistance),
+			target(0.f, 0.f, 0.f);
+
+			auto projection = make_smart_refctd_ptr<projection_t>();
+			projection->setMatrix(buildProjectionMatrixPerspectiveFovLH(glm::radians(fov), float(m_window->getWidth()) / float(m_window->getHeight()), zNear, zFar));
+
+			gimbal = make_smart_refctd_ptr<gimbal_t>(position);
+			camera = make_smart_refctd_ptr<camera_t>(core::smart_refctd_ptr(gimbal), core::smart_refctd_ptr(projection), target);
 
 			return true;
 		}
@@ -666,8 +694,8 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 
 		inline void update()
 		{
-			camera.setMoveSpeed(moveSpeed);
-			camera.setRotateSpeed(rotateSpeed);
+			camera->setMoveSpeed(moveSpeed);
+			camera->setRotateSpeed(rotateSpeed);
 
 			static std::chrono::microseconds previousEventTimestamp{};
 
@@ -692,54 +720,58 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 				std::vector<SMouseEvent> mouse{};
 				std::vector<SKeyboardEvent> keyboard{};
 			} capturedEvents;
+
+			if (move)
+				camera->begin(nextPresentationTimestamp);
 
-			if (move) camera.beginInputProcessing(nextPresentationTimestamp);
+			mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void
 			{
-				mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void
+				for (const auto& e : events) // here capture
 				{
-					if (move)
-						camera.mouseProcess(events); // don't capture the events, only let camera handle them with its impl
-
-					for (const auto& e : events) // here capture
-					{
-						if (e.timeStamp < previousEventTimestamp)
-							continue;
+					if (e.timeStamp < previousEventTimestamp)
+						continue;
 
-						previousEventTimestamp = e.timeStamp;
-						capturedEvents.mouse.emplace_back(e);
+					previousEventTimestamp = e.timeStamp;
+					capturedEvents.mouse.emplace_back(e);
 
-						if (e.type == nbl::ui::SMouseEvent::EET_SCROLL)
-							gcIndex = std::clamp<uint16_t>(int16_t(gcIndex) + int16_t(core::sign(e.scrollEvent.verticalScroll)), int64_t(0), int64_t(OT_COUNT - (uint8_t)1u));
-					}
-				}, m_logger.get());
+					if (e.type == nbl::ui::SMouseEvent::EET_SCROLL)
+						gcIndex = std::clamp<uint16_t>(int16_t(gcIndex) + int16_t(core::sign(e.scrollEvent.verticalScroll)), int64_t(0), int64_t(OT_COUNT - (uint8_t)1u));
+				}
+			}, m_logger.get());
 
 			keyboard.consumeEvents([&](const IKeyboardEventChannel::range_t& events) -> void
+			{
+				for (const auto& e : events) // here capture
 				{
-					if (move)
-						camera.keyboardProcess(events); // don't capture the events, only let camera handle them with its impl
-
-					for (const auto& e : events) // here capture
-					{
-						if (e.timeStamp < previousEventTimestamp)
-							continue;
+					if (e.timeStamp < previousEventTimestamp)
+						continue;
 
-						previousEventTimestamp = e.timeStamp;
-						capturedEvents.keyboard.emplace_back(e);
-					}
-				}, m_logger.get());
-			}
-			if (move) camera.endInputProcessing(nextPresentationTimestamp);
+					previousEventTimestamp = e.timeStamp;
+					capturedEvents.keyboard.emplace_back(e);
+				}
+			}, m_logger.get());
 
 			const auto cursorPosition = m_window->getCursorControl()->getPosition();
 
-			nbl::ext::imgui::UI::SUpdateParameters params = 
+			nbl::ext::imgui::UI::SUpdateParameters params =
 			{
 				.mousePosition = nbl::hlsl::float32_t2(cursorPosition.x, cursorPosition.y) - nbl::hlsl::float32_t2(m_window->getX(), m_window->getY()),
 				.displaySize = { m_window->getWidth(), m_window->getHeight() },
 				.mouseEvents = { capturedEvents.mouse.data(), capturedEvents.mouse.size() },
 				.keyboardEvents = { capturedEvents.keyboard.data(), capturedEvents.keyboard.size() }
 			};
 
+			if (move)
+			{
+				const auto virtualMouseEvents = camera->processMouse(params.mouseEvents);
+				const auto virtualKeyboardEvents = camera->processKeyboard(params.keyboardEvents);
+
+				camera->manipulate({ virtualMouseEvents.data(), virtualMouseEvents.size()});
+				camera->manipulate({ virtualKeyboardEvents.data(), virtualKeyboardEvents.size()});
+
+				camera->end(nextPresentationTimestamp);
+			}
+
 			pass.ui.manager->update(params);
 		}
 
@@ -781,7 +813,8 @@ class UISampleApp final : public examples::SimpleWindowedApplication
 			C_UI ui;
 		} pass;
 
-		Camera camera = Camera(core::vectorSIMDf(0, 0, 0), core::vectorSIMDf(0, 0, 0), core::matrix4SIMD());
+		core::smart_refctd_ptr<gimbal_t> gimbal;
+		core::smart_refctd_ptr<ICamera<projection_matrix_t>> camera;
 		video::CDumbPresentationOracle oracle;
 
 		uint16_t gcIndex = {}; // note: this is dirty however since I assume only single object in scene I can leave it now, when this example is upgraded to support multiple objects this needs to be changed