headtracking from joystick input

CMakeLists.txt

@@ -128,6 +128,8 @@ set(SOURCES
 "pythonscreenviewer.cpp"
 "dictionary.cpp"
 "particles.cpp"
+"headtrack.cpp"
+"headtrack.h"
 
 "network/network.cpp"
 "network/message.cpp"

Globals.cpp

@@ -953,6 +953,15 @@ global_settings::ConfigParse(cParser &Parser) {
 			Parser.getTokens(1);
 			Parser >> crash_damage;
 		}
+        else if (token == "headtrack") {
+            Parser.getTokens(14);
+            Parser >> headtrack_conf.joy;
+            Parser >> headtrack_conf.magic_window;
+            Parser >> headtrack_conf.move_axes[0] >> headtrack_conf.move_axes[1] >> headtrack_conf.move_axes[2];
+            Parser >> headtrack_conf.move_mul[0] >> headtrack_conf.move_mul[1] >> headtrack_conf.move_mul[2];
+            Parser >> headtrack_conf.rot_axes[0] >> headtrack_conf.rot_axes[1] >> headtrack_conf.rot_axes[2];
+            Parser >> headtrack_conf.rot_mul[0] >> headtrack_conf.rot_mul[1] >> headtrack_conf.rot_mul[2];
+        }
     } while ((token != "") && (token != "endconfig")); //(!Parser->EndOfFile)
     // na koniec trochę zależności
     if (!bLoadTraction) // wczytywanie drutów i słupów

Globals.h

@@ -251,6 +251,22 @@ struct global_settings {
 	};
 	std::vector<pythonviewport_config> python_viewports;
 
+    struct headtrack_config {
+        std::string joy;
+
+        bool magic_window = false;
+
+        glm::ivec3 move_axes;
+        glm::vec3 move_mul;
+
+        glm::ivec3 rot_axes;
+        glm::vec3 rot_mul;
+    };
+    headtrack_config headtrack_conf;
+
+    glm::vec3 viewport_move;
+    glm::vec3 viewport_rotate;
+
 	std::vector<std::pair<std::string, std::string>> network_servers;
 	std::optional<std::pair<std::string, std::string>> network_client;
 	float desync = 0.0f;

application.cpp

@@ -169,6 +169,9 @@ eu07_application::run() {
         Timer::subsystem.mainloop_total.start();
         glfwPollEvents();
 
+        if (m_headtrack)
+            m_headtrack->update();
+
 		begin_ui_frame();
 
 		// -------------------------------------------------------------------
@@ -772,6 +775,9 @@ eu07_application::init_gfx() {
 		if (!GfxRenderer.AddViewport(conf))
 			return -1;
 
+    if (!Global.headtrack_conf.joy.empty())
+        m_headtrack.emplace();
+
     return 0;
 }
 

application.h

@@ -12,6 +12,7 @@ http://mozilla.org/MPL/2.0/.
 #include "applicationmode.h"
 #include "PyInt.h"
 #include "network/manager.h"
+#include "headtrack.h"
 
 class eu07_application {
 	const int MAX_NETWORK_PER_FRAME = 1000;
@@ -117,6 +118,7 @@ private:
     std::vector<GLFWwindow *> m_windows;
 
 	std::optional<network::manager> m_network;
+    std::optional<headtrack> m_headtrack;
 };
 
 extern eu07_application Application;

headtrack.cpp

@@ -0,0 +1,63 @@
+#include "stdafx.h"
+#include "headtrack.h"
+#include "Globals.h"
+
+headtrack::headtrack()
+{
+
+}
+
+void headtrack::find_joy() {
+    for (size_t i = GLFW_JOYSTICK_1; i <= GLFW_JOYSTICK_LAST; i++) {
+        if (!glfwJoystickPresent(i))
+            continue;
+
+        std::string name(glfwGetJoystickName(i));
+        if (name == Global.headtrack_conf.joy) {
+            joy_id = i;
+            return;
+        }
+    }
+
+    joy_id = -1;
+}
+
+float headtrack::get_axis(const float *data, int count, int axis, float mul) {
+    if (axis < 0)
+        return 0.0f;
+    if (axis >= count)
+        return 0.0f;
+
+    return data[axis] * mul;
+}
+
+void headtrack::update()
+{
+    if (joy_id == -1 || !glfwJoystickPresent(joy_id)) {
+        Global.viewport_move = glm::vec3();
+        Global.viewport_rotate = glm::vec3();
+        find_joy();
+        return;
+    }
+
+    int count;
+    const float* axes = glfwGetJoystickAxes(joy_id, &count);
+
+    auto const &move_axes = Global.headtrack_conf.move_axes;
+    auto const &rot_axes = Global.headtrack_conf.rot_axes;
+    auto const &move_mul = Global.headtrack_conf.move_mul;
+    auto const &rot_mul = Global.headtrack_conf.rot_mul;
+
+    glm::vec3 move;
+    move.x = get_axis(axes, count, move_axes.x, move_mul.x);
+    move.y = get_axis(axes, count, move_axes.y, move_mul.y);
+    move.z = get_axis(axes, count, move_axes.z, move_mul.z);
+
+    glm::vec3 rotate;
+    rotate.x = get_axis(axes, count, rot_axes.x, rot_mul.x);
+    rotate.y = get_axis(axes, count, rot_axes.y, rot_mul.y);
+    rotate.z = get_axis(axes, count, rot_axes.z, rot_mul.z);
+
+    Global.viewport_move = move;
+    Global.viewport_rotate = rotate;
+}

headtrack.h

@@ -0,0 +1,14 @@
+#pragma once
+
+class headtrack
+{
+    int joy_id = -1;
+
+    void find_joy();
+    float get_axis(const float *data, int count, int axis, float mul);
+
+public:
+    headtrack();
+
+    void update();
+};

renderer.cpp

@@ -1222,16 +1222,25 @@ void opengl_renderer::setup_pass(viewport_config &Viewport, renderpass_config &C
         Viewport.projection.pe = glm::vec3(0.0f, 0.0f, 0.0f);
 	}
 
-	Config.viewport_camera.position() = Global.pCamera.Pos;
+    if (Global.headtrack_conf.magic_window)
+        Viewport.projection.pe = Global.viewport_move;
+
+    Config.viewport_camera.position() = Global.pCamera.Pos;
 
 	switch (Mode)
 	{
 	case rendermode::color:
 	{
+        if (!Global.headtrack_conf.magic_window) {
+            Global.pCamera.Pos += Global.viewport_move;
+            Global.pCamera.LookAt += Global.viewport_move;
+            Global.pCamera.Angle += Global.viewport_rotate;
+        }
+
 		// modelview
 		if ((false == DebugCameraFlag) || (true == Ignoredebug))
 		{
-			camera.position() = Global.pCamera.Pos;
+            camera.position() = Global.pCamera.Pos;
 			Global.pCamera.SetMatrix(viewmatrix);
 		}
 		else