make the imgui window not be focused by default and put math_graphics into a namespace

src/main.cpp

@@ -2,6 +2,7 @@
 #include <stdint.h>
 #include <SDL3/SDL.h>
 #include <imgui.h>
+#include <imgui_internal.h>
 #include <imgui_impl_sdl3.h>
 #include <imgui_impl_sdlgpu3.h>
 
@@ -14,6 +15,8 @@
 #include "../assets/shader/basic_vertex_shader.h"
 #include "../assets/shader/basic_pixel_shader.h"
 
+using namespace M;
+
 SDL_GPUDevice *device;
 SDL_Window    *window;
 
@@ -750,6 +753,7 @@ int main(int argc, char **argv) {
     ImGui_ImplSDLGPU3_Init(&imgui_init_info);
 
     bool show_demo_window = true;
+    bool first_frame      = true;
 
     // MSG Message;
     while (Running) {
@@ -760,6 +764,11 @@ int main(int argc, char **argv) {
         if (show_demo_window)
             ImGui::ShowDemoWindow(&show_demo_window);
 
+        if (first_frame) {
+            ImGui::SetWindowFocus(NULL);
+            first_frame = false;
+        }
+
         SDL_GPUCommandBuffer *command_buffer = SDL_AcquireGPUCommandBuffer(device);
         if (!command_buffer) {
             log_error("Failed to acquire gpu command buffer (%s). Exiting.", SDL_GetError());

src/math_graphics.h

@@ -11,82 +11,83 @@
 #undef min
 #undef max
 
-//clamp
+namespace M {
-constexpr inline float clamp(float min, float a, float max) {
+	//clamp
+	constexpr inline float clamp(float min, float a, float max) {
 		float result = a;
 		if (a < min)
 			result = min;
 		if (a > max)
 			result = max;
 		return result;
-}
+	}
 
-//clamp für 0-1 Bereich (Grafik)
+	//clamp für 0-1 Bereich (Grafik)
-constexpr inline float clamp01(float a) {
+	constexpr inline float clamp01(float a) {
 		return clamp(0, a, 1);
-}
+	}
 
-//clamp für Integer
+	//clamp für Integer
-constexpr inline int64_t clamp(int64_t min, int64_t a, int64_t max) {
+	constexpr inline int64_t clamp(int64_t min, int64_t a, int64_t max) {
 		int64_t result = a;
 		if (a < min)
 			result = min;
 		if (a > max)
 			result = max;
 		return result;
-}
+	}
 
-//wurzelberechnung
+	//wurzelberechnung
-inline float square_root(float a) {
+	inline float square_root(float a) {
 		return _mm_cvtss_f32(_mm_sqrt_ss(_mm_set_ss(a)));
-}
+	}
 
-inline float reciprocal_square_root(float a) {
+	inline float reciprocal_square_root(float a) {
 		return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(a)));
-}
+	}
 
-constexpr inline float min(float a, float b) {
+	constexpr inline float min(float a, float b) {
 		return a < b ? a : b;
-}
+	}
 
-constexpr inline float max(float a, float b) {
+	constexpr inline float max(float a, float b) {
 		return a > b ? a : b;
-}
+	}
 
-constexpr inline double min(double a, double b) {
+	constexpr inline double min(double a, double b) {
 		return a < b ? a : b;
-}
+	}
 
-constexpr inline double max(double a, double b) {
+	constexpr inline double max(double a, double b) {
 		return a > b ? a : b;
-}
+	}
 
-constexpr inline int64_t min(int64_t a, int64_t b) {
+	constexpr inline int64_t min(int64_t a, int64_t b) {
 		return a < b ? a : b;
-}
+	}
 
-template<typename T>
+	template<typename T>
-constexpr inline T min(T a, T b) {
+	constexpr inline T min(T a, T b) {
 		return a < b ? a : b;
-}
+	}
 
-constexpr float lerp(float a, float b, float t) {
+	constexpr float lerp(float a, float b, float t) {
 		return (1.0f - t) * a + t * b;
-}
+	}
 
-inline float ilerp(float a, float b, float v) {
+	inline float ilerp(float a, float b, float v) {
 		return (v - a) / (b - a);
-}
+	}
 
-inline float remap(float in_a, float in_b, float out_a, float out_b, float v) {
+	inline float remap(float in_a, float in_b, float out_a, float out_b, float v) {
 		float t = ilerp(in_a, in_b, v);
 		return lerp(out_a, out_b, t);
-}
+	}
 
 
-//-----------------------------------------------
+	//-----------------------------------------------
-//Vektorberechnung 2-dim
+	//Vektorberechnung 2-dim
-union V2 {
+	union V2 {
 		struct {
 			float x;
 			float y;
@@ -110,191 +111,191 @@ union V2 {
 			assert(index < 2);
 			return  E[index];
 		}
-};
+	};
 
-//Negation von 2-dim Vektor
+	//Negation von 2-dim Vektor
-inline V2 operator -(V2 a) {
+	inline V2 operator -(V2 a) {
 		return {
 			-a.x,
 			-a.y
 		};
-}
+	}
 
-//Addition 2er 2-dim Vektoren
+	//Addition 2er 2-dim Vektoren
-inline V2 operator +(V2 a, V2 b) {
+	inline V2 operator +(V2 a, V2 b) {
 		return {
 			a.x + b.x,
 			a.y + b.y
 		};
-}
+	}
 
-//Vektor Addition
+	//Vektor Addition
-inline V2 operator +=(V2& a, V2 b) {
+	inline V2 operator +=(V2& a, V2 b) {
 		return a = a + b;
-}
+	}
 
-//Subtraktion 2er 2-dim Vektoren
+	//Subtraktion 2er 2-dim Vektoren
-inline V2 operator -(V2 a, V2 b) {
+	inline V2 operator -(V2 a, V2 b) {
 		return {
 			a.x - b.x,
 			a.y - b.y
 		};
-}
+	}
 
-//Vektor Subtraktion
+	//Vektor Subtraktion
-inline V2 operator -=(V2& a, V2 b) {
+	inline V2 operator -=(V2& a, V2 b) {
 		return a = a - b;
-}
+	}
 
-//Skalarmultiplikation -> erst Skalar, dann Vektor
+	//Skalarmultiplikation -> erst Skalar, dann Vektor
-inline V2 operator *(float a, V2 b) {
+	inline V2 operator *(float a, V2 b) {
 		return {
 			a * b.x,
 			a * b.y
 		};
-}
+	}
 
-//Skalarmultiplikation -> erst Vektor, dann Skalar
+	//Skalarmultiplikation -> erst Vektor, dann Skalar
-inline V2 operator *(V2 a, float b) {
+	inline V2 operator *(V2 a, float b) {
 		return {
 			a.x * b,
 			a.y * b
 		};
-}
+	}
 
-//Skalarmultiplikation -> mit V2 Pointer
+	//Skalarmultiplikation -> mit V2 Pointer
-inline V2 &operator *= (V2 &a, float b) {
+	inline V2 &operator *= (V2 &a, float b) {
 		a = a * b;
 		return a;
-}
+	}
 
-//Division mit einem Skalar Oo -> Skalar geteilt durch Vektor
+	//Division mit einem Skalar Oo -> Skalar geteilt durch Vektor
-inline V2 operator /(float a, V2 b) {
+	inline V2 operator /(float a, V2 b) {
 		return {
 			a / b.x,
 			a / b.y
 		};
-}
+	}
 
-//Division mit einem Skalar Oo -> Vektor geteilt durch Skalar
+	//Division mit einem Skalar Oo -> Vektor geteilt durch Skalar
-inline V2 operator /(V2 a, float b) {
+	inline V2 operator /(V2 a, float b) {
 		return {
 			a.x / b,
 			a.y / b
 		};
-}
+	}
 
-//Division mit einem Skalar -> 2 Vektoren
+	//Division mit einem Skalar -> 2 Vektoren
-inline V2 operator /(V2 a, V2 b) {
+	inline V2 operator /(V2 a, V2 b) {
 		return {
 			a.x / b.x,
 			a.y / b.y
 		};
-}
+	}
 
-//Division mit einem Skalar -> mit V2 Pointer
+	//Division mit einem Skalar -> mit V2 Pointer
-inline V2 &operator /= (V2 &a, float b) {
+	inline V2 &operator /= (V2 &a, float b) {
 		a = a / b;
 		return a;
-}
+	}
 
-//Skalarprodukt
+	//Skalarprodukt
-inline float dot(V2 a, V2 b) {
+	inline float dot(V2 a, V2 b) {
 		return a.x * b.x + a.y * b.y;
-}
+	}
 
-//Hadamard-Produkt
+	//Hadamard-Produkt
-inline V2 hadamard(V2 a, V2 b) {
+	inline V2 hadamard(V2 a, V2 b) {
 		return {
 			a.x * b.x,
 			a.y * b.y
 		};
-}
+	}
 
-//Betrag des Vektors quadrieren
+	//Betrag des Vektors quadrieren
-inline float length_squared(V2 a) {
+	inline float length_squared(V2 a) {
 		return dot(a, a);
-}
+	}
 
-//Betrag eines Vektors
+	//Betrag eines Vektors
-inline float length(V2 a) {
+	inline float length(V2 a) {
 		return square_root(length_squared(a));
-}
+	}
 
-//Reziproke der Länge
+	//Reziproke der Länge
-inline float reciprocal_length(V2 a) {
+	inline float reciprocal_length(V2 a) {
 		return reciprocal_square_root(length_squared(a));
-}
+	}
 
-//Einheitsvektor
+	//Einheitsvektor
-inline V2 normalize(V2 a) {
+	inline V2 normalize(V2 a) {
 		return a * reciprocal_length(a);
-}
+	}
 
-//Vektor der 90
+	//Vektor der 90
-inline V2 perp(V2 a) {
+	inline V2 perp(V2 a) {
 		return {
 			-a.y,
 			a.x
 		};
-}
+	}
 
-//clamp für 2-dim Vektor
+	//clamp für 2-dim Vektor
-inline V2 clamp01(V2 a) {
+	inline V2 clamp01(V2 a) {
 		return {
 			clamp01(a.x),
 			clamp01(a.y)
 		};
-}
+	}
 
-//Vektor mit den kleinsten Werten 2er Vektoren
+	//Vektor mit den kleinsten Werten 2er Vektoren
-inline V2 min(V2 a, V2 b) {
+	inline V2 min(V2 a, V2 b) {
 		return {
 			min(a.x, b.x),
 			min(a.y, b.y),
 		};
-}
+	}
 
-//Vektor mit den groessten Werten 2er Vektoren
+	//Vektor mit den groessten Werten 2er Vektoren
-inline V2 max(V2 a, V2 b) {
+	inline V2 max(V2 a, V2 b) {
 		return {
 			max(a.x, b.x),
 			max(a.y, b.y),
 		};
-}
+	}
 
-//kleinster Vektor Wert
+	//kleinster Vektor Wert
-inline float min(V2 a) {
+	inline float min(V2 a) {
 		return min(a.x, a.y);
-}
+	}
 
-//groesster Vektor Wert
+	//groesster Vektor Wert
-inline float max(V2 a) {
+	inline float max(V2 a) {
 		return max(a.x, a.y);
-}
+	}
 
-//Lerp mit 2 Vektoren
+	//Lerp mit 2 Vektoren
-inline V2 lerp(V2 a, V2 b, V2 t) {
+	inline V2 lerp(V2 a, V2 b, V2 t) {
 		return V2{
 			lerp(a.x, b.x, t.x),
 			lerp(a.y, b.y, t.y),
 		};
-}
+	}
 
-//
+	//
-inline V2 ilerp(V2 a, V2 b, V2 v) {
+	inline V2 ilerp(V2 a, V2 b, V2 v) {
 		return (v - a) / (b - a);
-}
+	}
 
-//
+	//
-inline V2 remap(V2 in_a, V2 in_b, V2 out_a, V2 out_b, V2 v) {
+	inline V2 remap(V2 in_a, V2 in_b, V2 out_a, V2 out_b, V2 v) {
 		V2 t = ilerp(in_a, in_b, v);
 		return lerp(out_a, out_b, t);
-}
+	}
 
-//-----------------------------------------------
+	//-----------------------------------------------
-//Vektorberechnung 3-dim
+	//Vektorberechnung 3-dim
-union V3 {
+	union V3 {
 		struct {
 			float x;
 			float y;
@@ -335,117 +336,117 @@ union V3 {
 			assert(index < 3);
 			return  E[index];
 		}
-};
+	};
 
-//Negation von 2-dim Vektor
+	//Negation von 2-dim Vektor
-inline V3 operator -(V3 a) {
+	inline V3 operator -(V3 a) {
 		return {
 			-a.x,
 			-a.y,
 			-a.z
 		};
-}
+	}
 
-//Addition 2er 2-dim Vektoren
+	//Addition 2er 2-dim Vektoren
-inline V3 operator +(V3 a, V3 b) {
+	inline V3 operator +(V3 a, V3 b) {
 		return {
 			a.x + b.x,
 			a.y + b.y,
 			a.z + b.z
 		};
-}
+	}
 
-//Subtraktion 2er 2-dim Vektoren
+	//Subtraktion 2er 2-dim Vektoren
-inline V3 operator -(V3 a, V3 b) {
+	inline V3 operator -(V3 a, V3 b) {
 		return {
 			a.x - b.x,
 			a.y - b.y,
 			a.z - b.z
 		};
-}
+	}
 
-//Skalarmultiplikation -> erst Skalar, dann Vektor
+	//Skalarmultiplikation -> erst Skalar, dann Vektor
-inline V3 operator *(float a, V3 b) {
+	inline V3 operator *(float a, V3 b) {
 		return {
 			a * b.x,
 			a * b.y,
 			a * b.z
 		};
 
-}
+	}
 
-//Skalarmultiplikation -> erst Vektor, dann Skalar
+	//Skalarmultiplikation -> erst Vektor, dann Skalar
-inline V3 operator *(V3 a, float b) {
+	inline V3 operator *(V3 a, float b) {
 		return {
 			a.x * b,
 			a.y * b,
 			a.z * b
 		};
 
-}
+	}
 
-//Division mit nem Skalar Oo -> Skalar geteilt durch Vektor
+	//Division mit nem Skalar Oo -> Skalar geteilt durch Vektor
-inline V3 operator /(float a, V3 b) {
+	inline V3 operator /(float a, V3 b) {
 		return {
 			a / b.x,
 			a / b.y,
 			a / b.z
 		};
-}
+	}
 
-//Division mit nem Skalar Oo -> Vektor geteilt durch Skalar
+	//Division mit nem Skalar Oo -> Vektor geteilt durch Skalar
-inline V3 operator /(V3 a, float b) {
+	inline V3 operator /(V3 a, float b) {
 		return {
 			a.x / b,
 			a.y / b,
 			a.z / b
 		};
-}
+	}
 
-//Skalarprodukt
+	//Skalarprodukt
-inline float dot(V3 a, V3 b) {
+	inline float dot(V3 a, V3 b) {
 		return a.x * b.x + a.y * b.y + a.z * b.z;
-}
+	}
 
-//Hadamard-Produkt
+	//Hadamard-Produkt
-inline V3 hadamard(V3 a, V3 b) {
+	inline V3 hadamard(V3 a, V3 b) {
 		return {
 			a.x * b.x,
 			a.y * b.y,
 			a.z * b.z
 		};
-}
+	}
 
-//Kreuzprodukt
+	//Kreuzprodukt
-inline V3 cross(V3 a, V3 b) {
+	inline V3 cross(V3 a, V3 b) {
 		return {
 			a.y * b.z - a.z * b.y,
 			a.z * b.x - a.x * b.z,
 			a.x * b.y - a.y * b.x
 		};
-}
+	}
 
-//Betrag des Vektors quadrieren
+	//Betrag des Vektors quadrieren
-inline float length_squared(V3 a) {
+	inline float length_squared(V3 a) {
 		return dot(a, a);
-}
+	}
 
-//Betrag eines Vektors
+	//Betrag eines Vektors
-inline float length(V3 a) {
+	inline float length(V3 a) {
 		return square_root(length_squared(a));
-}
+	}
 
-//Reziproke der Länge
+	//Reziproke der Länge
-inline float reciprocal_length(V3 a) {
+	inline float reciprocal_length(V3 a) {
 		return reciprocal_square_root(length_squared(a));
-}
+	}
 
-//Einheitsvektor
+	//Einheitsvektor
-inline V3 normalize(V3 a) {
+	inline V3 normalize(V3 a) {
 		return a * reciprocal_length(a);
-}
+	}
 
-union V4 {
+	union V4 {
 		struct {
 			float x;
 			float y;
@@ -501,18 +502,18 @@ union V4 {
 			assert(index < 4);
 			return  E[index];
 		}
-};
+	};
 
 
-//-----------------------------------------------
+	//-----------------------------------------------
-//2x2 Matrix
+	//2x2 Matrix
 
-//M2x2 m;
+	//M2x2 m;
-//m.E[0][1]
+	//m.E[0][1]
-//m.V[1]
+	//m.V[1]
 
-//m[1][0]
+	//m[1][0]
-union M2x2 {
+	union M2x2 {
 		struct {
 			float x1; float x2;
 			float y1; float y2;
@@ -530,84 +531,84 @@ union M2x2 {
 			assert(index < 2);
 			return V[index];
 		}
-};
+	};
 
-//Matrix negieren
+	//Matrix negieren
-inline M2x2 operator -(M2x2 a){
+	inline M2x2 operator -(M2x2 a){
 		return {
 			-a[0][0], -a[0][1],
 			-a[1][0], -a[1][1]
 		};
-}
+	}
 
-//Matrix Addition
+	//Matrix Addition
-inline M2x2 operator +(M2x2 a, M2x2 b) {
+	inline M2x2 operator +(M2x2 a, M2x2 b) {
 		return {
 			a[0][0] + b[0][0], a[0][1] + b[0][1],
 			a[1][0] + b[1][0], a[1][1] + b[1][1]
 		};
-}
+	}
 
-//Matrix Subtraktion
+	//Matrix Subtraktion
-inline M2x2 operator -(M2x2 a, M2x2 b) {
+	inline M2x2 operator -(M2x2 a, M2x2 b) {
 		return {
 			a[0][0] - b[0][0], a[0][1] - b[0][1],
 			a[1][0] - b[1][0], a[1][1] - b[1][1]
 		};
-}
+	}
 
-//Matrix Skalarmultiplikation 
+	//Matrix Skalarmultiplikation 
-inline M2x2 operator *(M2x2 a, float b) {
+	inline M2x2 operator *(M2x2 a, float b) {
 		return {
 			a[0][0] * b, a[0][1] * b,
 			a[1][0] * b, a[1][1] * b
 		};
-}
+	}
 
-//Matrix Skalarmultiplikation 
+	//Matrix Skalarmultiplikation 
-inline M2x2 operator *(float a, M2x2 b) {
+	inline M2x2 operator *(float a, M2x2 b) {
 		return {
 			a * b[0][0], a * b[0][1],
 			a * b[1][0], a * b[1][1]
 		};
-}
+	}
 
-//Matrix Multiplikation
+	//Matrix Multiplikation
-inline M2x2 operator *(M2x2 a, M2x2 b) {
+	inline M2x2 operator *(M2x2 a, M2x2 b) {
 		return {
 			a[0][0] * b[0][0] + a[0][1] * b[1][0], a[0][0] * b[0][1] + a[0][1] * b[1][1], 
 			a[1][0] * b[0][0] + a[1][1] * b[1][0], a[1][0] * b[0][1] + a[1][1] * b[1][1]
 		};
-}
+	}
 
-//Matrix * Vektor
+	//Matrix * Vektor
-inline V2 operator *(M2x2 a, V2 b) {
+	inline V2 operator *(M2x2 a, V2 b) {
 		return {
 			a[0][0] * b[0] + a[0][1] * b[1],
 			a[1][0] * b[0] + a[1][1] * b[1],
 		};
-}
+	}
 
-//Matrix Transponieren
+	//Matrix Transponieren
-inline M2x2 transpose(M2x2 a) {
+	inline M2x2 transpose(M2x2 a) {
 		return {
 			a[0][0], a[1][0],
 			a[0][1], a[1][1]
 		};
-}
+	}
 
-//Einheitsmatrix (oder Identitätsmatrix)
+	//Einheitsmatrix (oder Identitätsmatrix)
-constexpr inline M2x2 identityM2x2() {
+	constexpr inline M2x2 identityM2x2() {
 		return {
 			1.0f, 0.0f,
 			0.0f, 1.0f
 		};
-}
+	}
 
 
-//-----------------------------------------------
+	//-----------------------------------------------
-//3x3 Matrix
+	//3x3 Matrix
-union M3x3 {
+	union M3x3 {
 		struct {
 			float x1; float x2; float x3;
 			float y1; float y2; float y3;
@@ -628,145 +629,146 @@ union M3x3 {
 			return V[index];
 		}
 		
-};
+	};
 
-//Matrix negieren
+	//Matrix negieren
-inline M3x3 operator -(M3x3 a) {
+	inline M3x3 operator -(M3x3 a) {
 		return {
 			-a[0][0], -a[0][1], -a[0][1],
 			-a[1][0], -a[1][1], -a[1][2],
 			-a[2][0], -a[2][1], -a[2][2]
 		};
-}
+	}
 
-//Matrix Addition
+	//Matrix Addition
-inline M3x3 operator +(M3x3 a, M3x3 b) {
+	inline M3x3 operator +(M3x3 a, M3x3 b) {
 		return {
 			a[0][0] + b[0][0], a[0][1] + b[0][1], a[0][2] + b[0][2],
 			a[1][0] + b[1][0], a[1][1] + b[1][1], a[1][2] + b[1][2],
 			a[2][0] + b[2][0], a[2][1] + b[2][1], a[2][2] + b[2][2]
 		};
-}
+	}
 
-//Matrix Subtraktion
+	//Matrix Subtraktion
-inline M3x3 operator -(M3x3 a, M3x3 b) {
+	inline M3x3 operator -(M3x3 a, M3x3 b) {
 		return {
 			a[0][0] - b[0][0], a[0][1] - b[0][1], a[0][2] - b[0][2],
 			a[1][0] - b[1][0], a[1][1] - b[1][1], a[1][2] - b[1][2],
 			a[2][0] - b[2][0], a[2][1] - b[2][1], a[2][2] - b[2][2]
 		};
-}
+	}
 
-//Matrix Skalarmultiplikation 
+	//Matrix Skalarmultiplikation 
-inline M3x3 operator *(M3x3 a, float b) {
+	inline M3x3 operator *(M3x3 a, float b) {
 		return {
 			a[0][0] * b, a[0][1] * b, a[0][2] * b,
 			a[1][0] * b, a[1][1] * b, a[1][2] * b,
 			a[2][0] * b, a[2][1] * b, a[2][2] * b
 		};
-}
+	}
 
-//Matrix Skalarmultiplikation 
+	//Matrix Skalarmultiplikation 
-inline M3x3 operator *(float a, M3x3 b) {
+	inline M3x3 operator *(float a, M3x3 b) {
 		return {
 			a * b[0][0], a * b[0][1], a * b[0][2],
 			a * b[1][0], a * b[1][1], a * b[1][2],
 			a * b[2][0], a * b[2][1], a * b[2][2]
 		};
-}
+	}
 
-//Matrix Multiplikation
+	//Matrix Multiplikation
-inline M3x3 operator *(M3x3 a, M3x3 b) {
+	inline M3x3 operator *(M3x3 a, M3x3 b) {
 		return {
 			a[0][0] * b[0][0] + a[0][1] * b[1][0] + a[0][2] * b[2][0], a[0][0] * b[0][1] + a[0][1] * b[1][1] + a[0][2] * b[2][1], a[0][0] * b[0][2] + a[0][1] * b[1][2] + a[0][2] * b[2][2],
 			a[1][0] * b[0][0] + a[1][1] * b[1][0] + a[1][2] * b[2][0], a[1][0] * b[0][1] + a[1][1] * b[1][1] + a[1][2] * b[2][1], a[1][0] * b[0][2] + a[1][1] * b[1][2] + a[0][2] * b[2][2],
 			a[2][0] * b[0][0] + a[2][1] * b[1][0] + a[2][2] * b[2][0], a[2][0] * b[0][1] + a[2][1] * b[1][1] + a[2][2] * b[2][1], a[2][0] * b[0][2] + a[2][1] * b[1][2] + a[0][2] * b[2][2]
 		};
-}
+	}
 
-//Matrix * V2
+	//Matrix * V2
-inline V2 operator *(M3x3 a, V2 b) {
+	inline V2 operator *(M3x3 a, V2 b) {
 		return {
 			b.x * a[0][0] + b.y * a[0][1] + 1.0f * a[0][2],
 			b.x * a[1][0] + b.y * a[1][1] + 1.0f * a[1][2],
 		};
-}
+	}
 
-//Matrix * V3
+	//Matrix * V3
-inline V3 operator *(M3x3 a, V3 b) {
+	inline V3 operator *(M3x3 a, V3 b) {
 		return {
 			b.x * a[0][0] + b.y * a[0][1] + b.z * a[0][2],
 			b.x * a[1][0] + b.y * a[1][1] + b.z * a[1][2],
 			b.x * a[2][0] + b.y * a[2][1] + b.z * a[2][2]
 		};
-}
+	}
 
 
-//Matrix transponieren
+	//Matrix transponieren
-inline M3x3 transpose(M3x3 a) {
+	inline M3x3 transpose(M3x3 a) {
 		return {
 			a[0][0], a[1][0], a[2][0],
 			a[0][1], a[1][1], a[2][1],
 			a[0][2], a[1][2], a[2][2]
 		};
-}
+	}
 
-//Einheitsmatrix (oder Identitätsmatrix)
+	//Einheitsmatrix (oder Identitätsmatrix)
-inline M3x3 identityM3x3() {
+	inline M3x3 identityM3x3() {
 		return {
 			1.0f, 0.0f, 0.0f,
 			0.0f, 1.0f, 0.0f,
 			0.0f, 0.0f, 1.0f
 		};
-}
+	}
 
 
 
-//-----------------------------------------------
+	//-----------------------------------------------
-//m128i
+	//m128i
-struct m128i {
+	struct m128i {
 		__m128i val;
-};
+	};
 
-inline __m128i operator &(m128i a, m128i b) {
+	inline __m128i operator &(m128i a, m128i b) {
 		return _mm_and_si128(a.val, b.val);
-}
+	}
 
-inline __m128i operator |(m128i a, m128i b) {
+	inline __m128i operator |(m128i a, m128i b) {
 		return _mm_or_si128(a.val, b.val);
-}
+	}
 
-inline __m128i operator >>(m128i a, int b) {
+	inline __m128i operator >>(m128i a, int b) {
 		return _mm_srli_epi32(a.val, b);
-}
+	}
 
-inline __m128i operator <<(m128i a, int b) {
+	inline __m128i operator <<(m128i a, int b) {
 		return _mm_slli_epi32(a.val, b);
-}
+	}
 
 
-//-----------------------------------------------
+	//-----------------------------------------------
-//m128
+	//m128
-struct m128 {
+	struct m128 {
 		__m128 val;
-};
+	};
 
-inline __m128 operator +(m128 a, m128 b) {
+	inline __m128 operator +(m128 a, m128 b) {
 		return _mm_mul_ps(a.val, b.val);
-}
+	}
 
-inline __m128 operator *(m128 a, m128 b) {
+	inline __m128 operator *(m128 a, m128 b) {
 		return _mm_mul_ps(a.val, b.val);
-}
+	}
 
-inline __m128 operator *(float a, m128 b) {
+	inline __m128 operator *(float a, m128 b) {
 		return _mm_mul_ps(_mm_set1_ps(a), b.val);
-}
+	}
 
-inline __m128 square_root(__m128 a) {
+	inline __m128 square_root(__m128 a) {
 		return _mm_sqrt_ps(a);
-}
+	}
 
-inline __m128 operator /(m128 a, m128 b) {
+	inline __m128 operator /(m128 a, m128 b) {
 		return _mm_div_ps(a.val, b.val);
+	}
 }