Cameraz

.gitignore

@@ -13,3 +13,5 @@ compiled.spv
 */.vscode/*
 */__main__.py
 tmp
+/tmp/rtSamples.bin
+/runtime/

09_GeometryCreator/include/common.hpp

@@ -3,6 +3,10 @@
 
 
 #include "nbl/examples/examples.hpp"
+#include "nbl/ext/Cameras/CCameraMathUtilities.hpp"
+#include "nbl/ext/Cameras/CCameraMouseKeyboardController.hpp"
+#include "nbl/ext/Cameras/CCameraMouseKeyboardPresets.hpp"
+#include "nbl/ext/Cameras/CFPSCamera.hpp"
 
 using namespace nbl;
 using namespace core;
@@ -15,4 +19,4 @@ using namespace scene;
 using namespace nbl::examples;
 
 
-#endif // __NBL_THIS_EXAMPLE_COMMON_H_INCLUDED__
+#endif // __NBL_THIS_EXAMPLE_COMMON_H_INCLUDED__

09_GeometryCreator/main.cpp

@@ -72,10 +72,24 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 
 			// camera
 			{
-				core::vectorSIMDf cameraPosition(-5.81655884, 2.58630896, -4.23974705);
-				core::vectorSIMDf cameraTarget(-0.349590302, -0.213266611, 0.317821503);
-				float32_t4x4 projectionMatrix = hlsl::math::thin_lens::lhPerspectiveFovMatrix<float>(core::radians(60.0f), float(m_initialResolution.x) / m_initialResolution.y, 10000.0f, 0.1f);
-				camera = Camera(cameraPosition, cameraTarget, projectionMatrix, 1.069f, 0.4f);
+				const auto cameraPosition = hlsl::float64_t3(-5.81655884, 2.58630896, -4.23974705);
+				const auto cameraTarget = hlsl::float64_t3(-0.349590302, -0.213266611, 0.317821503);
+				cameraProjection = hlsl::math::thin_lens::lhPerspectiveFovMatrix<float>(core::radians(60.0f), float(m_initialResolution.x) / m_initialResolution.y, 10000.0f, 0.1f);
+
+				hlsl::math::quaternion<hlsl::float64_t> cameraOrientation;
+				if (!ext::cameras::CCameraMathUtilities::tryCreateQuaternionFromLookAt(cameraPosition, cameraTarget, hlsl::float64_t3(0.0, 1.0, 0.0), cameraOrientation))
+					return logFail("Could not initialize camera orientation!");
+				camera = core::make_smart_refctd_ptr<ext::cameras::CFPSCamera>(cameraPosition, cameraOrientation);
+
+				// WASD moves, the mouse looks while the left button is held
+				{
+					using namespace ext::cameras;
+					auto& binding = cameraController.binding;
+					binding = CCameraMouseKeyboardPresets::makeDefaultBinding(ICamera::CameraKind::FPS);
+					binding.scaleSensitivity(ECameraControlAxis::Translate, 1.069);
+					binding.scaleSensitivity(ECameraControlAxis::Rotate, 0.4);
+					binding.setMouseMovementGate(ECameraControlAxis::Rotate, ui::EMB_LEFT_BUTTON);
+				}
 			}
 
 			onAppInitializedFinish();
@@ -94,10 +108,16 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 			cb->begin(IGPUCommandBuffer::USAGE::ONE_TIME_SUBMIT_BIT);
 			cb->beginDebugMarker("GeometryCreatorApp Frame");
 			{
-				camera.beginInputProcessing(nextPresentationTimestamp);
-				mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void { camera.mouseProcess(events); mouseProcess(events); }, m_logger.get());
-				keyboard.consumeEvents([&](const IKeyboardEventChannel::range_t& events) -> void { camera.keyboardProcess(events); }, m_logger.get());
-				camera.endInputProcessing(nextPresentationTimestamp);
+				std::vector<ui::SMouseEvent> mouseEvents;
+				std::vector<ui::SKeyboardEvent> keyboardEvents;
+
+				mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void { mouseEvents.insert(mouseEvents.end(), events.begin(), events.end()); }, m_logger.get());
+				keyboard.consumeEvents([&](const IKeyboardEventChannel::range_t& events) -> void { keyboardEvents.insert(keyboardEvents.end(), events.begin(), events.end()); }, m_logger.get());
+
+				mouseProcess({ mouseEvents.data(), mouseEvents.size() });
+
+				const auto controls = cameraController.collect(nextPresentationTimestamp, keyboardEvents, mouseEvents);
+				camera->manipulate(controls);
 			}
 
 
@@ -138,8 +158,8 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 				cb->beginRenderPass(info, IGPUCommandBuffer::SUBPASS_CONTENTS::INLINE);
 			}
 
-			float32_t3x4 viewMatrix = camera.getViewMatrix();
-			float32_t4x4 viewProjMatrix = camera.getConcatenatedMatrix();
+			const auto viewMatrix = hlsl::float32_t3x4(camera->getGimbal().getViewMatrixLH());
+			const auto viewProjMatrix = hlsl::math::linalg::promoted_mul(cameraProjection, viewMatrix);
 			const auto viewParams = CSimpleDebugRenderer::SViewParams(viewMatrix,viewProjMatrix);
 
 			// tear down scene every frame
@@ -245,16 +265,16 @@ class GeometryCreatorApp final : public MonoWindowApplication, public BuiltinRes
 		InputSystem::ChannelReader<IKeyboardEventChannel> keyboard;
 
 		//
-		Camera camera = Camera(core::vectorSIMDf(0, 0, 0), core::vectorSIMDf(0, 0, 0), hlsl::float32_t4x4());
+		core::smart_refctd_ptr<ext::cameras::CFPSCamera> camera;
+		ext::cameras::CCameraMouseKeyboardController cameraController;
+		hlsl::float32_t4x4 cameraProjection = hlsl::float32_t4x4(1.0f);
 
 		uint16_t gcIndex = {};
 
-		void mouseProcess(const nbl::ui::IMouseEventChannel::range_t& events)
+		void mouseProcess(std::span<const nbl::ui::SMouseEvent> events)
 		{
-			for (auto eventIt = events.begin(); eventIt != events.end(); eventIt++)
+			for (const auto& ev : events)
 			{
-				auto ev = *eventIt;
-
 				if (ev.type==nbl::ui::SMouseEvent::EET_SCROLL && m_renderer)
 				{
 					gcIndex += int16_t(core::sign(ev.scrollEvent.verticalScroll));

0_ImportanceSamplingEnvMaps/main.cpp

@@ -6,7 +6,10 @@
 #include <nabla.h>
 #include "nbl/ext/FullScreenTriangle/FullScreenTriangle.h"
 #include "nbl/ext/ScreenShot/ScreenShot.h"
-#include "CCamera.hpp"
+#include "nbl/ext/Cameras/CCameraMathUtilities.hpp"
+#include "nbl/ext/Cameras/CCameraMouseKeyboardController.hpp"
+#include "nbl/ext/Cameras/CCameraMouseKeyboardPresets.hpp"
+#include "nbl/ext/Cameras/CFPSCamera.hpp"
 #include "../common/CommonAPI.h"
 
 using namespace nbl;
@@ -122,7 +125,9 @@ class ImportanceSamplingEnvMaps : public ApplicationBase
 
 	CommonAPI::InputSystem::ChannelReader<IMouseEventChannel> mouse;
 	CommonAPI::InputSystem::ChannelReader<IKeyboardEventChannel> keyboard;
-	Camera camera = Camera(vectorSIMDf(0, 0, 0), vectorSIMDf(0, 0, 0), matrix4SIMD());
+	core::smart_refctd_ptr<ext::cameras::CFPSCamera> camera;
+	ext::cameras::CCameraMouseKeyboardController cameraController;
+	hlsl::float32_t4x4 cameraProjection = hlsl::float32_t4x4(1.0f);
 
 	core::smart_refctd_ptr<IGPUGraphicsPipeline> gpuEnvmapPipeline;
 	core::smart_refctd_ptr<IGPUMeshBuffer> gpuEnvmapMeshBuffer;
@@ -297,10 +302,22 @@ class ImportanceSamplingEnvMaps : public ApplicationBase
 		logger = std::move(initOutput.logger);
 		inputSystem = std::move(initOutput.inputSystem);
 
-		core::vectorSIMDf cameraPosition(-0.0889001, 0.678913, -4.01774);
-		core::vectorSIMDf cameraTarget(1.80119, 0.515374, -0.410544);
-		matrix4SIMD projectionMatrix = matrix4SIMD::buildProjectionMatrixPerspectiveFovLH(core::radians(60.0f), float(WIN_W) / WIN_H, 0.03125f, 200.0f);
-		camera = Camera(cameraPosition, cameraTarget, projectionMatrix, 10.f, 1.f);
+		const auto cameraPosition = hlsl::float64_t3(-0.0889001, 0.678913, -4.01774);
+		const auto cameraTarget = hlsl::float64_t3(1.80119, 0.515374, -0.410544);
+		cameraProjection = matrix4SIMD::buildProjectionMatrixPerspectiveFovLH(core::radians(60.0f), float(WIN_W) / WIN_H, 0.03125f, 200.0f);
+		hlsl::math::quaternion<hlsl::float64_t> cameraOrientation;
+		if (!ext::cameras::CCameraMathUtilities::tryCreateQuaternionFromLookAt(cameraPosition, cameraTarget, hlsl::float64_t3(0.0, 1.0, 0.0), cameraOrientation))
+			return logFail("Could not initialize camera orientation!");
+		camera = core::make_smart_refctd_ptr<ext::cameras::CFPSCamera>(cameraPosition, cameraOrientation);
+
+		// WASD moves, the mouse looks while the left button is held
+		{
+			using namespace ext::cameras;
+			auto& binding = cameraController.binding;
+			binding = CCameraMouseKeyboardPresets::makeDefaultBinding(ICamera::CameraKind::FPS);
+			binding.scaleSensitivity(ECameraControlAxis::Translate, 10.0);
+			binding.setMouseMovementGate(ECameraControlAxis::Rotate, ui::EMB_LEFT_BUTTON);
+		}
 
 		descriptorPool = createDescriptorPool(1u);
 
@@ -775,10 +792,10 @@ class ImportanceSamplingEnvMaps : public ApplicationBase
 
 	void onAppTerminated_impl() override
 	{
-		const core::vectorSIMDf& last_cam_pos = camera.getPosition();
-		const core::vectorSIMDf& last_cam_target = camera.getTarget();
-		std::cout << "Last camera position: (" << last_cam_pos.X << ", " << last_cam_pos.Y << ", " << last_cam_pos.Z << ")" << std::endl;
-		std::cout << "Last camera target: (" << last_cam_target.X << ", " << last_cam_target.Y << ", " << last_cam_target.Z << ")" << std::endl;
+		const auto& lastCamPos = camera->getGimbal().getPosition();
+		const auto lastCamTarget = camera->getGimbal().getPosition() + camera->getGimbal().getForward();
+		std::cout << "Last camera position: (" << lastCamPos.x << ", " << lastCamPos.y << ", " << lastCamPos.z << ")" << std::endl;
+		std::cout << "Last camera target: (" << lastCamTarget.x << ", " << lastCamTarget.y << ", " << lastCamTarget.z << ")" << std::endl;
 	}
 
 	void workLoopBody() override
@@ -802,14 +819,22 @@ class ImportanceSamplingEnvMaps : public ApplicationBase
 			inputSystem->getDefaultMouse(&mouse);
 			inputSystem->getDefaultKeyboard(&keyboard);
 
-			camera.beginInputProcessing(nextPresentationTimestamp);
-			mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void { camera.mouseProcess(events); }, logger.get());
-			keyboard.consumeEvents([&](const IKeyboardEventChannel::range_t& events) -> void { camera.keyboardProcess(events); }, logger.get());
-			camera.endInputProcessing(nextPresentationTimestamp);
+			std::vector<SMouseEvent> mouseEvents;
+			std::vector<SKeyboardEvent> keyboardEvents;
+			mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void
+			{
+				mouseEvents.insert(mouseEvents.end(), events.begin(), events.end());
+			}, logger.get());
+			keyboard.consumeEvents([&](const IKeyboardEventChannel::range_t& events) -> void
+			{
+				keyboardEvents.insert(keyboardEvents.end(), events.begin(), events.end());
+			}, logger.get());
+			const auto controls = cameraController.collect(nextPresentationTimestamp, keyboardEvents, mouseEvents);
+			camera->manipulate(controls);
 		}
 
-		const auto& viewMatrix = camera.getViewMatrix();
-		const auto& viewProjectionMatrix = camera.getConcatenatedMatrix();
+		const auto viewMatrix = hlsl::float32_t3x4(camera->getGimbal().getViewMatrixLH());
+		const auto viewProjectionMatrix = hlsl::math::linalg::promoted_mul(cameraProjection, viewMatrix);
 
 		asset::SViewport viewport;
 		viewport.minDepth = 1.f;
@@ -883,4 +908,4 @@ class ImportanceSamplingEnvMaps : public ApplicationBase
 		return windowCb->isWindowOpen();
 	}
 };
-NBL_COMMON_API_MAIN(ImportanceSamplingEnvMaps)
+NBL_COMMON_API_MAIN(ImportanceSamplingEnvMaps)

100_PhotonCaustics/include/common.hpp

@@ -2,6 +2,10 @@
 #define _NBL_THIS_EXAMPLE_COMMON_H_INCLUDED_
 
 #include "nbl/examples/examples.hpp"
+#include "nbl/ext/Cameras/CCameraMathUtilities.hpp"
+#include "nbl/ext/Cameras/CCameraMouseKeyboardController.hpp"
+#include "nbl/ext/Cameras/CCameraMouseKeyboardPresets.hpp"
+#include "nbl/ext/Cameras/CFPSCamera.hpp"
 
 using namespace nbl;
 using namespace nbl::core;

100_PhotonCaustics/main.cpp

@@ -44,8 +44,9 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 	constexpr static inline float EmitterHalfExtent = 0.5f;
 	constexpr static inline float SphereRadius = 0.75f;
 	constexpr static inline float SceneHalfExtent = 2.f;
-	static inline const core::vectorSIMDf InitialCamPos = core::vectorSIMDf(0, 3, 8);
-	static inline const core::vectorSIMDf InitialCamTarget = core::vectorSIMDf(0, 1, 0);
+	static inline const hlsl::float64_t3 InitialCamPos = hlsl::float64_t3(0, 3, 8);
+	static inline const hlsl::float64_t3 InitialCamTarget = hlsl::float64_t3(0, 1, 0);
+	static inline const hlsl::float64_t3 CamUp = hlsl::float64_t3(0, 1, 0);
 
 public:
 	inline PhotonCausticsApp(const path& _localInputCWD, const path& _localOutputCWD, const path& _sharedInputCWD, const path& _sharedOutputCWD)
@@ -373,15 +374,18 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 		// Camera Init position and matrices
 		//-------------------------------------
 		{
-			hlsl::float32_t4x4 proj = hlsl::math::thin_lens::rhPerspectiveFovMatrix(
+			m_cameraProjection = hlsl::math::thin_lens::rhPerspectiveFovMatrix(
 				core::radians(m_cameraSetting.fov),
 				float(WIN_W) / float(WIN_H),
 				m_cameraSetting.zNear, m_cameraSetting.zFar);
 			// Initial position of the camera
-			m_camera = Camera(InitialCamPos, InitialCamTarget, proj);
+			m_camera = core::make_smart_refctd_ptr<ext::cameras::CFPSCamera>(InitialCamPos);
+			if (!resetCameraPose())
+				return logFail("Could not initialize camera orientation!");
+			// WASD moves, the mouse looks while the left button is held
+			updateCameraBinding();
 			// cache this to reset it
-			m_InitialMVP = m_camera.getConcatenatedMatrix();
-			m_camera.mapKeysToWASD();
+			m_InitialMVP = getViewProjectionMatrix();
 		}
 
 		// show the window (and start presentation time recording?)
@@ -459,7 +463,7 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 		cmdbuf->begin(IGPUCommandBuffer::USAGE::ONE_TIME_SUBMIT_BIT);
 		cmdbuf->beginDebugMarker("PhotonCaustics Frame");
 
-		const auto& viewProjectionMatrix = m_camera.getConcatenatedMatrix();
+		const auto viewProjectionMatrix = getViewProjectionMatrix();
 		// reset accumulation when we move the camera
 		if (m_cachedMVP != viewProjectionMatrix)
 		{
@@ -575,8 +579,8 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 
 			SPushConstants pc = {};
 			pc.invMVP = invMVP;
-			const auto camPos = m_camera.getPosition().getAsVector3df();
-			pc.camPos = float32_t3(camPos.X, camPos.Y, camPos.Z);
+			const auto camPos = m_camera->getGimbal().getPosition();
+			pc.camPos = float32_t3(float(camPos.x), float(camPos.y), float(camPos.z));
 			pc.accumulatedFrames = m_accumulatedFrames;
 			pc.geomInfoBuffer = m_geomInfoBuffer->getDeviceAddress();
 			pc.lightBuffer = m_lightBuffer->getDeviceAddress();
@@ -669,12 +673,35 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 		}
 	}
 
-	inline void update()
+	// the view matrix is the camera's, the projection is ours, so the concatenation is built here every time it's needed
+	inline hlsl::float32_t4x4 getViewProjectionMatrix() const
 	{
-		m_camera.setMoveSpeed(m_cameraSetting.moveSpeed);
-		m_camera.setRotateSpeed(m_cameraSetting.rotateSpeed);
+		const auto viewMatrix = hlsl::float32_t3x4(m_camera->getGimbal().getViewMatrixRH());
+		return hlsl::math::linalg::promoted_mul(m_cameraProjection, viewMatrix);
+	}
 
-		static std::chrono::microseconds previousEventTimestamp{};
+	// the UI owns the speeds, so the binding is rebuilt from the default and scaled instead of being compounded
+	inline void updateCameraBinding()
+	{
+		using namespace ext::cameras;
+		auto& binding = m_cameraController.binding;
+		binding = CCameraMouseKeyboardPresets::makeDefaultBinding(ICamera::CameraKind::FPS);
+		binding.scaleSensitivity(ECameraControlAxis::Translate, m_cameraSetting.moveSpeed);
+		binding.scaleSensitivity(ECameraControlAxis::Rotate, m_cameraSetting.rotateSpeed);
+		binding.setMouseMovementGate(ECameraControlAxis::Rotate, ui::EMB_LEFT_BUTTON);
+	}
+
+	inline bool resetCameraPose()
+	{
+		hlsl::math::quaternion<hlsl::float64_t> orientation;
+		if (!ext::cameras::CCameraMathUtilities::tryCreateQuaternionFromLookAt(InitialCamPos, InitialCamTarget, CamUp, orientation))
+			return false;
+		return m_camera->setPose(ext::cameras::SCameraRigPose{ .position = InitialCamPos, .orientation = orientation });
+	}
+
+	inline void update()
+	{
+		updateCameraBinding();
 
 		m_inputSystem->getDefaultMouse(&m_mouse);
 		m_inputSystem->getDefaultKeyboard(&m_keyboard);
@@ -692,32 +719,29 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 		struct {
 			std::vector<SMouseEvent> mouse{};
 			std::vector<SKeyboardEvent> keyboard{};
+			std::vector<SMouseEvent> cameraMouse{};
+			std::vector<SKeyboardEvent> cameraKeyboard{};
 		} capturedEvents;
 
-		m_camera.beginInputProcessing(nextPresentationTimestamp);
 		{
 			const auto& io = ImGui::GetIO();
 
 			m_mouse.consumeEvents([&](const IMouseEventChannel::range_t& events) -> void
 				{
-					// Note: When the cursor is over ImGui, the camera must not also see the event
-					if (!io.WantCaptureMouse)
-						m_camera.mouseProcess(events);
 					for (const auto& e : events) {
-						if (e.timeStamp < previousEventTimestamp) continue;
-						previousEventTimestamp = e.timeStamp;
 						capturedEvents.mouse.emplace_back(e);
+						// Note: When the cursor is over ImGui, the camera must not also see the event
+						if (!io.WantCaptureMouse)
+							capturedEvents.cameraMouse.emplace_back(e);
 					}
 				}, m_logger.get());
 
 			m_keyboard.consumeEvents([&](const IKeyboardEventChannel::range_t& events) -> void
 				{
-					if (!io.WantCaptureKeyboard)
-						m_camera.keyboardProcess(events);
 					for (const auto& e : events) {
-						if (e.timeStamp < previousEventTimestamp) continue;
-						previousEventTimestamp = e.timeStamp;
 						capturedEvents.keyboard.emplace_back(e);
+						if (!io.WantCaptureKeyboard)
+							capturedEvents.cameraKeyboard.emplace_back(e);
 
 						//if (e.keyCode == EKC_ESCAPE)
 						//{
@@ -726,7 +750,10 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 					}
 				}, m_logger.get());
 		}
-		m_camera.endInputProcessing(nextPresentationTimestamp);
+		{
+			const auto controls = m_cameraController.collect(nextPresentationTimestamp, capturedEvents.cameraKeyboard, capturedEvents.cameraMouse);
+			m_camera->manipulate(controls);
+		}
 
 		const core::SRange<const nbl::ui::SMouseEvent> mouseEvents(capturedEvents.mouse.data(), capturedEvents.mouse.data() + capturedEvents.mouse.size());
 		const core::SRange<const nbl::ui::SKeyboardEvent> keyboardEvents(capturedEvents.keyboard.data(), capturedEvents.keyboard.data() + capturedEvents.keyboard.size());
@@ -763,7 +790,7 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 				hlsl::float32_t3x4 transform;
 				if (degrees != 0.f)
 				{
-					const auto rotation = hlsl::math::quaternion<hlsl::float32_t>::create(axis, core::radians(degrees));
+					const auto rotation = hlsl::math::quaternion<hlsl::float32_t>::createFromAxisAngle(axis, core::radians(degrees));
 					transform = hlsl::math::linalg::promote_affine<3, 4, 3, 3>(hlsl::_static_cast<hlsl::float32_t3x3>(rotation));
 				}
 				else
@@ -1525,8 +1552,7 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 				ImGui::SliderFloat("Rotate speed", &m_cameraSetting.rotateSpeed, 0.1f, 10.f);
 				if (ImGui::Button("Reset Camera"))
 				{
-					m_camera.setPosition(InitialCamPos);
-					m_camera.setTarget(InitialCamTarget);
+					resetCameraPose();
 					m_cachedMVP = m_InitialMVP;
 					m_accumulatedFrames = 0;
 				}
@@ -1628,7 +1654,9 @@ class PhotonCausticsApp final : public SimpleWindowedApplication, public Builtin
 	} m_ui;
 
 	struct CameraSettings { float moveSpeed = 1.f, rotateSpeed = 1.f, fov = 60.f, zNear = 0.01f, zFar = 500.f; } m_cameraSetting;
-	Camera m_camera;
+	core::smart_refctd_ptr<ext::cameras::CFPSCamera> m_camera;
+	ext::cameras::CCameraMouseKeyboardController m_cameraController;
+	hlsl::float32_t4x4 m_cameraProjection = hlsl::float32_t4x4(1.f);
 	hlsl::float32_t4x4 m_cachedMVP;
 	hlsl::float32_t4x4 m_InitialMVP;
 	uint32_t m_accumulatedFrames = 0;