CMakeLists.txt

@@ -409,38 +409,6 @@ set_target_properties(libzip_external_lib PROPERTIES
     INTERFACE_LINK_LIBRARIES zlib_external_lib
 )
 
-# ===========================================
-# 5) Eigen (5.0.0.zip → eigen-5.0.0) - HEADER-ONLY
-# ===========================================
-set(EIGEN_ARCHIVE     "${THIRDPARTY_DIR}/eigen-5.0.0.zip")
-set(EIGEN_SRC_DIR     "${THIRDPARTY_DIR}/eigen-5.0.0")
-
-if(NOT EXISTS "${EIGEN_ARCHIVE}")
-    log("Downloading Eigen 5.0.0.zip ...")
-    file(DOWNLOAD
-        "https://gitlab.com/libeigen/eigen/-/archive/5.0.0/eigen-5.0.0.zip"
-        "${EIGEN_ARCHIVE}"
-        SHOW_PROGRESS
-    )
-endif()
-
-if(NOT EXISTS "${EIGEN_SRC_DIR}/CMakeLists.txt")
-    log("Extracting Eigen 5.0.0.zip ...")
-    execute_process(
-        COMMAND ${CMAKE_COMMAND} -E tar xvf "${EIGEN_ARCHIVE}"
-        WORKING_DIRECTORY "${THIRDPARTY_DIR}"
-        RESULT_VARIABLE _eigen_extract_res
-    )
-    if(NOT _eigen_extract_res EQUAL 0)
-        message(FATAL_ERROR "Failed to extract Eigen archive")
-    endif()
-endif()
-
-if(NOT TARGET eigen_external_lib)
-    add_library(eigen_external_lib INTERFACE)
-    target_include_directories(eigen_external_lib INTERFACE "${EIGEN_SRC_DIR}")
-endif()
-
 # ===========================================
 # Основной проект space-game001
 # ===========================================
@@ -462,6 +430,8 @@ add_executable(space-game001
     src/AudioPlayerAsync.h
     src/BoneAnimatedModel.cpp
     src/BoneAnimatedModel.h
+    src/utils/ZLMath.cpp
+    src/utils/ZLMath.h
     src/render/OpenGlExtensions.cpp
     src/render/OpenGlExtensions.h
     src/utils/Utils.cpp
@@ -514,7 +484,6 @@ target_link_libraries(space-game001 PRIVATE
     libpng_external_lib
     zlib_external_lib
     libzip_external_lib
-    eigen_external_lib
 )
 
 # Линкуем OpenGL (Windows)

src/BoneAnimatedModel.cpp

@@ -119,9 +119,9 @@ namespace ZL
 				b = match.suffix().first;
 			}
 
-			bones[i].boneMatrixWorld.data()[0] = floatValues[0];
+			bones[i].boneMatrixWorld.m[0] = floatValues[0];
-			bones[i].boneMatrixWorld.data()[0 + 1 * 3] = floatValues[1];
+			bones[i].boneMatrixWorld.m[0 + 1 * 3] = floatValues[1];
-			bones[i].boneMatrixWorld.data()[0 + 2 * 3] = floatValues[2];
+			bones[i].boneMatrixWorld.m[0 + 2 * 3] = floatValues[2];
 
 
 			std::getline(f, tempLine);
@@ -134,9 +134,9 @@ namespace ZL
 				b = match.suffix().first;
 			}
 
-			bones[i].boneMatrixWorld.data()[1] = floatValues[0];
+			bones[i].boneMatrixWorld.m[1] = floatValues[0];
-			bones[i].boneMatrixWorld.data()[1 + 1 * 3] = floatValues[1];
+			bones[i].boneMatrixWorld.m[1 + 1 * 3] = floatValues[1];
-			bones[i].boneMatrixWorld.data()[1 + 2 * 3] = floatValues[2];
+			bones[i].boneMatrixWorld.m[1 + 2 * 3] = floatValues[2];
 
 
 			std::getline(f, tempLine);
@@ -149,9 +149,9 @@ namespace ZL
 				b = match.suffix().first;
 			}
 
-			bones[i].boneMatrixWorld.data()[2] = floatValues[0];
+			bones[i].boneMatrixWorld.m[2] = floatValues[0];
-			bones[i].boneMatrixWorld.data()[2 + 1 * 3] = floatValues[1];
+			bones[i].boneMatrixWorld.m[2 + 1 * 3] = floatValues[1];
-			bones[i].boneMatrixWorld.data()[2 + 2 * 3] = floatValues[2];
+			bones[i].boneMatrixWorld.m[2 + 2 * 3] = floatValues[2];
 
 			//----------- matrix end
 			std::getline(f, tempLine); //parent
@@ -489,10 +489,10 @@ namespace ZL
 					b = match.suffix().first;
 				}
 
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0] = floatValues[0];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0] = floatValues[0];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0 + 1 * 4] = floatValues[1];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0 + 1 * 4] = floatValues[1];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0 + 2 * 4] = floatValues[2];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0 + 2 * 4] = floatValues[2];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[0 + 3 * 4] = floatValues[3];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[0 + 3 * 4] = floatValues[3];
 
 
 				std::getline(f, tempLine);
@@ -504,10 +504,10 @@ namespace ZL
 					b = match.suffix().first;
 				}
 
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1] = floatValues[0];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1] = floatValues[0];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1 + 1 * 4] = floatValues[1];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1 + 1 * 4] = floatValues[1];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1 + 2 * 4] = floatValues[2];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1 + 2 * 4] = floatValues[2];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[1 + 3 * 4] = floatValues[3];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[1 + 3 * 4] = floatValues[3];
 
 				std::getline(f, tempLine);
 				b = tempLine.cbegin();
@@ -518,10 +518,10 @@ namespace ZL
 					b = match.suffix().first;
 				}
 
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2] = floatValues[0];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2] = floatValues[0];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2 + 1 * 4] = floatValues[1];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2 + 1 * 4] = floatValues[1];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2 + 2 * 4] = floatValues[2];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2 + 2 * 4] = floatValues[2];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[2 + 3 * 4] = floatValues[3];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[2 + 3 * 4] = floatValues[3];
 
 
 				std::getline(f, tempLine);
@@ -533,10 +533,10 @@ namespace ZL
 					b = match.suffix().first;
 				}
 
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3] = floatValues[0];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3] = floatValues[0];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3 + 1 * 4] = floatValues[1];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3 + 1 * 4] = floatValues[1];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3 + 2 * 4] = floatValues[2];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3 + 2 * 4] = floatValues[2];
-				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.data()[3 + 3 * 4] = floatValues[3];
+				animations[0].keyFrames[i].bones[boneNumber].boneMatrixWorld.m[3 + 3 * 4] = floatValues[3];
 
 				//std::getline(f, tempLine);// ignore last matrix line
 
@@ -602,79 +602,88 @@ namespace ZL
 		
 		for (int i = 0; i < currentBones.size(); i++)
 		{
-			currentBones[i].boneStartWorld(0) = oneFrameBones[i].boneStartWorld(0) + t * (nextFrameBones[i].boneStartWorld(0) - oneFrameBones[i].boneStartWorld(0));
+			currentBones[i].boneStartWorld.v[0] = oneFrameBones[i].boneStartWorld.v[0] + t * (nextFrameBones[i].boneStartWorld.v[0] - oneFrameBones[i].boneStartWorld.v[0]);
-			currentBones[i].boneStartWorld(1) = oneFrameBones[i].boneStartWorld(1) + t * (nextFrameBones[i].boneStartWorld(1) - oneFrameBones[i].boneStartWorld(1));
+			currentBones[i].boneStartWorld.v[1] = oneFrameBones[i].boneStartWorld.v[1] + t * (nextFrameBones[i].boneStartWorld.v[1] - oneFrameBones[i].boneStartWorld.v[1]);
-			currentBones[i].boneStartWorld(2) = oneFrameBones[i].boneStartWorld(2) + t * (nextFrameBones[i].boneStartWorld(2) - oneFrameBones[i].boneStartWorld(2));
+			currentBones[i].boneStartWorld.v[2] = oneFrameBones[i].boneStartWorld.v[2] + t * (nextFrameBones[i].boneStartWorld.v[2] - oneFrameBones[i].boneStartWorld.v[2]);
 			
 			Matrix3f oneFrameBonesMatrix;
 
-			oneFrameBonesMatrix = oneFrameBones[i].boneMatrixWorld.block<3, 3>(0, 0);
+			oneFrameBonesMatrix.m[0] = oneFrameBones[i].boneMatrixWorld.m[0];
-			/*
+			oneFrameBonesMatrix.m[1] = oneFrameBones[i].boneMatrixWorld.m[1];
-			oneFrameBonesMatrix.data()[0] = oneFrameBones[i].boneMatrixWorld.m[0];
+			oneFrameBonesMatrix.m[2] = oneFrameBones[i].boneMatrixWorld.m[2];
-			oneFrameBonesMatrix.data()[1] = oneFrameBones[i].boneMatrixWorld.m[1];
-			oneFrameBonesMatrix.data()[2] = oneFrameBones[i].boneMatrixWorld.m[2];
 
-			oneFrameBonesMatrix.data()[3] = oneFrameBones[i].boneMatrixWorld.m[0 + 1*4];
+			oneFrameBonesMatrix.m[3] = oneFrameBones[i].boneMatrixWorld.m[0 + 1*4];
-			oneFrameBonesMatrix.data()[4] = oneFrameBones[i].boneMatrixWorld.m[1 + 1*4];
+			oneFrameBonesMatrix.m[4] = oneFrameBones[i].boneMatrixWorld.m[1 + 1*4];
-			oneFrameBonesMatrix.data()[5] = oneFrameBones[i].boneMatrixWorld.m[2 + 1*4];
+			oneFrameBonesMatrix.m[5] = oneFrameBones[i].boneMatrixWorld.m[2 + 1*4];
 
-			oneFrameBonesMatrix.data()[6] = oneFrameBones[i].boneMatrixWorld.m[0 + 2*4];
+			oneFrameBonesMatrix.m[6] = oneFrameBones[i].boneMatrixWorld.m[0 + 2*4];
-			oneFrameBonesMatrix.data()[7] = oneFrameBones[i].boneMatrixWorld.m[1 + 2*4];
+			oneFrameBonesMatrix.m[7] = oneFrameBones[i].boneMatrixWorld.m[1 + 2*4];
-			oneFrameBonesMatrix.data()[8] = oneFrameBones[i].boneMatrixWorld.m[2 + 2*4];
+			oneFrameBonesMatrix.m[8] = oneFrameBones[i].boneMatrixWorld.m[2 + 2*4];
-			*/
+			
 			Matrix3f nextFrameBonesMatrix;
 
-			nextFrameBonesMatrix = nextFrameBones[i].boneMatrixWorld.block<3, 3>(0, 0);
+			nextFrameBonesMatrix.m[0] = nextFrameBones[i].boneMatrixWorld.m[0];
-			/*
+			nextFrameBonesMatrix.m[1] = nextFrameBones[i].boneMatrixWorld.m[1];
-			nextFrameBonesMatrix.data()[0] = nextFrameBones[i].boneMatrixWorld.m[0];
+			nextFrameBonesMatrix.m[2] = nextFrameBones[i].boneMatrixWorld.m[2];
-			nextFrameBonesMatrix.data()[1] = nextFrameBones[i].boneMatrixWorld.m[1];
-			nextFrameBonesMatrix.data()[2] = nextFrameBones[i].boneMatrixWorld.m[2];
 
-			nextFrameBonesMatrix.data()[3] = nextFrameBones[i].boneMatrixWorld.m[0 + 1 * 4];
+			nextFrameBonesMatrix.m[3] = nextFrameBones[i].boneMatrixWorld.m[0 + 1 * 4];
-			nextFrameBonesMatrix.data()[4] = nextFrameBones[i].boneMatrixWorld.m[1 + 1 * 4];
+			nextFrameBonesMatrix.m[4] = nextFrameBones[i].boneMatrixWorld.m[1 + 1 * 4];
-			nextFrameBonesMatrix.data()[5] = nextFrameBones[i].boneMatrixWorld.m[2 + 1 * 4];
+			nextFrameBonesMatrix.m[5] = nextFrameBones[i].boneMatrixWorld.m[2 + 1 * 4];
 
-			nextFrameBonesMatrix.data()[6] = nextFrameBones[i].boneMatrixWorld.m[0 + 2 * 4];
+			nextFrameBonesMatrix.m[6] = nextFrameBones[i].boneMatrixWorld.m[0 + 2 * 4];
-			nextFrameBonesMatrix.data()[7] = nextFrameBones[i].boneMatrixWorld.m[1 + 2 * 4];
+			nextFrameBonesMatrix.m[7] = nextFrameBones[i].boneMatrixWorld.m[1 + 2 * 4];
-			nextFrameBonesMatrix.data()[8] = nextFrameBones[i].boneMatrixWorld.m[2 + 2 * 4];
+			nextFrameBonesMatrix.m[8] = nextFrameBones[i].boneMatrixWorld.m[2 + 2 * 4];
-			*/
-			Eigen::Quaternionf q1 = Eigen::Quaternionf(oneFrameBonesMatrix).normalized();
-			Eigen::Quaternionf q2 = Eigen::Quaternionf(nextFrameBonesMatrix).normalized();
-			Eigen::Quaternionf q1_norm = q1.normalized();
-			Eigen::Quaternionf q2_norm = q2.normalized();
 
-			Eigen::Quaternionf result = q1_norm.slerp(t, q2_norm);
+			Vector4f q1 = MatrixToQuat(oneFrameBonesMatrix);
+			Vector4f q2 = MatrixToQuat(nextFrameBonesMatrix);
+			Vector4f q1_norm = q1.normalized();
+			Vector4f q2_norm = q2.normalized();
 
-			Matrix3f boneMatrixWorld3 = result.toRotationMatrix();
+			Vector4f result = slerp(q1_norm, q2_norm, t);
 
-			currentBones[i].boneMatrixWorld = Eigen::Matrix4f::Identity();
+			Matrix3f boneMatrixWorld3 = QuatToMatrix(result);
 
-			// Копируем 3x3 матрицу в верхний левый угол
+			currentBones[i].boneMatrixWorld = MakeMatrix4x4(boneMatrixWorld3, currentBones[i].boneStartWorld);
-			currentBones[i].boneMatrixWorld.block<3, 3>(0, 0) = boneMatrixWorld3;
+			
-
-			// Копируем позицию в последний столбец (первые 3 элемента)
-			currentBones[i].boneMatrixWorld.block<3, 1>(0, 3) = currentBones[i].boneStartWorld;
-
-	
 			Matrix4f currentBoneMatrixWorld4 = currentBones[i].boneMatrixWorld;
 			Matrix4f startBoneMatrixWorld4 = animations[0].keyFrames[0].bones[i].boneMatrixWorld;
 
-			Matrix4f inverstedStartBoneMatrixWorld4 = startBoneMatrixWorld4.inverse();
+			Matrix4f inverstedStartBoneMatrixWorld4 = InverseMatrix(startBoneMatrixWorld4);
 
-			skinningMatrixForEachBone[i] = currentBoneMatrixWorld4 * inverstedStartBoneMatrixWorld4;
+			skinningMatrixForEachBone[i] = MultMatrixMatrix(currentBoneMatrixWorld4, inverstedStartBoneMatrixWorld4);
 			
 		}
 		
+		
+		/*
+		for (int i = 0; i < currentBones.size(); i++)
+		{
+			currentBones[i].boneStartWorld = oneFrameBones[i].boneStartWorld;
+			currentBones[i].boneMatrixWorld = oneFrameBones[i].boneMatrixWorld;
+			//Matrix4f currentBoneMatrixWorld4 = MakeMatrix4x4(currentBones[i].boneMatrixWorld, currentBones[i].boneStartWorld);
+			//Matrix4f startBoneMatrixWorld4 = MakeMatrix4x4(animations[0].keyFrames[0].bones[i].boneMatrixWorld, animations[0].keyFrames[0].bones[i].boneStartWorld);
+			Matrix4f currentBoneMatrixWorld4 = currentBones[i].boneMatrixWorld;
+			Matrix4f startBoneMatrixWorld4 = animations[0].keyFrames[0].bones[i].boneMatrixWorld;
+			Matrix4f inverstedStartBoneMatrixWorld4 = InverseMatrix(startBoneMatrixWorld4);
+			skinningMatrixForEachBone[i] = MultMatrixMatrix(currentBoneMatrixWorld4, inverstedStartBoneMatrixWorld4);
+
+			if (i == 10)
+			{
+				std::cout << i << std::endl;
+			}
+		}*/
+		
 		for (int i = 0; i < mesh.PositionData.size(); i++)
 		{
 			Vector4f originalPos = { 
-				startMesh.PositionData[i](0), 
+				startMesh.PositionData[i].v[0], 
-				startMesh.PositionData[i](1), 
+				startMesh.PositionData[i].v[1], 
-				startMesh.PositionData[i](2), 1.0};
+				startMesh.PositionData[i].v[2], 1.0};
 
 			Vector4f finalPos = Vector4f{0.f, 0.f, 0.f, 0.f};
 
 			bool vMoved = false;
+			//Vector3f finalPos = Vector3f{ 0.f, 0.f, 0.f };
 
 			for (int j = 0; j < MAX_BONE_COUNT; j++)
 			{
@@ -682,11 +691,11 @@ namespace ZL
 				{
 					vMoved = true;
 					//finalPos = finalPos + MultVectorMatrix(originalPos, skinningMatrixForEachBone[verticesBoneWeight[i][j].boneIndex]) * verticesBoneWeight[i][j].weight;
-					finalPos = finalPos + (skinningMatrixForEachBone[verticesBoneWeight[i][j].boneIndex] * originalPos) * verticesBoneWeight[i][j].weight;
+					finalPos = finalPos + MultMatrixVector(skinningMatrixForEachBone[verticesBoneWeight[i][j].boneIndex], originalPos) * verticesBoneWeight[i][j].weight;
 				}
 			}
 
-			if (abs(finalPos(0) - originalPos(0)) > 1 || abs(finalPos(1) - originalPos(1)) > 1 || abs(finalPos(2) - originalPos(2)) > 1)
+			if (abs(finalPos.v[0] - originalPos.v[0]) > 1 || abs(finalPos.v[1] - originalPos.v[1]) > 1 || abs(finalPos.v[2] - originalPos.v[2]) > 1)
 			{
 
 			}
@@ -696,9 +705,9 @@ namespace ZL
 				finalPos = originalPos;
 			}
 
-			mesh.PositionData[i](0) = finalPos(0);
+			mesh.PositionData[i].v[0] = finalPos.v[0];
-			mesh.PositionData[i](1) = finalPos(1);
+			mesh.PositionData[i].v[1] = finalPos.v[1];
-			mesh.PositionData[i](2) = finalPos(2);
+			mesh.PositionData[i].v[2] = finalPos.v[2];
 		}
 
 

src/BoneAnimatedModel.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "utils/ZLMath.h"
 #include "render/Renderer.h"
 #include <unordered_map>
 

src/Environment.cpp

@@ -23,15 +23,15 @@ bool Environment::showMouse = false;
 
 bool Environment::exitGameLoop = false;
 
-Eigen::Matrix3f Environment::shipMatrix = Eigen::Matrix3f::Identity();
+Matrix3f Environment::shipMatrix = Matrix3f::Identity();
-Eigen::Matrix3f Environment::inverseShipMatrix = Eigen::Matrix3f::Identity();
+Matrix3f Environment::inverseShipMatrix = Matrix3f::Identity();
 
 
 bool Environment::tapDownHold = false;
-Eigen::Vector2f Environment::tapDownStartPos = { 0, 0 };
+Vector2f Environment::tapDownStartPos = { 0, 0 };
-Eigen::Vector2f Environment::tapDownCurrentPos = { 0, 0 };
+Vector2f Environment::tapDownCurrentPos = { 0, 0 };
 
-Eigen::Vector3f Environment::shipPosition = {0,0,45000.f};
+Vector3f Environment::shipPosition = {0,0,45000.f};
 
 float Environment::shipVelocity = 0.f;
 

src/Environment.h

@@ -1,9 +1,9 @@
 #pragma once
+#include "utils/ZLMath.h"
 #ifdef __linux__
 #include <SDL2/SDL.h>
 #endif
 #include "render/OpenGlExtensions.h"
-#include <Eigen/Dense>
 
 namespace ZL {
 
@@ -21,8 +21,8 @@ public:
 
     static bool settings_inverseVertical;
 
-    static Eigen::Matrix3f shipMatrix;
+    static Matrix3f shipMatrix;
-    static Eigen::Matrix3f inverseShipMatrix;
+    static Matrix3f inverseShipMatrix;
 
     static SDL_Window* window;
 
@@ -31,10 +31,10 @@ public:
 
 
     static bool tapDownHold;
-    static Eigen::Vector2f tapDownStartPos;
+    static Vector2f tapDownStartPos;
-    static Eigen::Vector2f tapDownCurrentPos;
+    static Vector2f tapDownCurrentPos;
 
-    static Eigen::Vector3f shipPosition;
+    static Vector3f shipPosition;
     static float shipVelocity;
 
     static const float CONST_Z_NEAR;

src/Game.cpp

@@ -19,12 +19,12 @@ namespace ZL
 
 	
 
-	Eigen::Quaternionf generateRandomQuaternion(std::mt19937& gen)
+	Vector4f generateRandomQuaternion(std::mt19937& gen)
 	{
 
 		std::normal_distribution<> distrib(0.0, 1.0);
 
-		Eigen::Quaternionf randomQuat = {
+		Vector4f randomQuat = {
 			(float)distrib(gen),
 			(float)distrib(gen),
 			(float)distrib(gen),
@@ -81,9 +81,9 @@ namespace ZL
 
 				if (accepted)
 				{
-					Eigen::Quaternionf randomQuat = generateRandomQuaternion(gen);
+					Vector4f randomQuat = generateRandomQuaternion(gen);
 
-					Matrix3f randomMatrix = randomQuat.toRotationMatrix();
+					Matrix3f randomMatrix = QuatToMatrix(randomQuat);
 
 					boxCoordsArr.emplace_back(BoxCoords{ newPos, randomMatrix });
 					generatedCount++;
@@ -92,6 +92,7 @@ namespace ZL
 			}
 
 			if (!accepted) {
+				std::cerr << "Ïðåäóïðåæäåíèå: Íå óäàëîñü ñãåíåðèðîâàòü " << N << " îáúåêòîâ. Ñãåíåðèðîâàíî: " << generatedCount << std::endl;
 				break;
 			}
 		}
@@ -205,7 +206,7 @@ namespace ZL
 		//Load texture
 		spaceshipTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/DefaultMaterial_BaseColor_shine.png", CONST_ZIP_FILE));
 		spaceshipBase = LoadFromTextFile02("./resources/spaceship006.txt", CONST_ZIP_FILE);
-		spaceshipBase.RotateByMatrix(Eigen::Quaternionf(Eigen::AngleAxisf(M_PI / 2.0, Eigen::Vector3f::UnitY())).toRotationMatrix());// QuatFromRotateAroundY(M_PI / 2.0).toRotationMatrix());
+		spaceshipBase.RotateByMatrix(QuatToMatrix(QuatFromRotateAroundY(M_PI / 2.0)));
 		//spaceshipBase.Move(Vector3f{ -0.52998, -13, 0 });
 		//spaceshipBase.Move(Vector3f{ -0.52998, -10, 10 });
 
@@ -555,26 +556,32 @@ namespace ZL
 
 			if (Environment::tapDownHold) {
 
-				float diffx = Environment::tapDownCurrentPos(0) - Environment::tapDownStartPos(0);
+				float diffx = Environment::tapDownCurrentPos.v[0] - Environment::tapDownStartPos.v[0];
-				float diffy = Environment::tapDownCurrentPos(1) - Environment::tapDownStartPos(1);
+				float diffy = Environment::tapDownCurrentPos.v[1] - Environment::tapDownStartPos.v[1];
 
 				if (abs(diffy) > 5.0 || abs(diffx) > 5.0) //threshold
 				{
 
 					float rotationPower = sqrtf(diffx * diffx + diffy * diffy);
-					float deltaAlpha = rotationPower * delta * static_cast<float>(M_PI) / 500000.f;
 
-					Eigen::Vector3f rotationDirection(diffy, diffx, 0.0f);
+					//std::cout << rotationPower << std::endl;
-					rotationDirection.normalize(); // Eigen-way нормализация
 
-					// Создаем кватернион через AngleAxis
+					float deltaAlpha = rotationPower * delta * M_PI / 500000.f;
-					// Конструктор принимает (угол_в_радианах, ось_вращения)
-					Eigen::Quaternionf rotateQuat(Eigen::AngleAxisf(deltaAlpha, rotationDirection));
 
-					Matrix3f rotateMat = rotateQuat.toRotationMatrix();
+					Vector3f rotationDirection = { diffy, diffx, 0 };
 
-					Environment::shipMatrix = Environment::shipMatrix * rotateMat;
+					rotationDirection = rotationDirection.normalized();
-					Environment::inverseShipMatrix = Environment::shipMatrix.inverse();
+
+					Vector4f rotateQuat = {
+						rotationDirection.v[0] * sin(deltaAlpha * 0.5f),
+						rotationDirection.v[1] * sin(deltaAlpha * 0.5f),
+						rotationDirection.v[2] * sin(deltaAlpha * 0.5f),
+						cos(deltaAlpha * 0.5f) };
+
+					Matrix3f rotateMat = QuatToMatrix(rotateQuat);
+
+					Environment::shipMatrix = MultMatrixMatrix(Environment::shipMatrix, rotateMat);
+					Environment::inverseShipMatrix = InverseMatrix(Environment::shipMatrix);
 
 				}
 			}
@@ -582,7 +589,7 @@ namespace ZL
 			if (fabs(Environment::shipVelocity) > 0.01f)
 			{
 				Vector3f velocityDirection = { 0,0, -Environment::shipVelocity * delta / 1000.f };
-				Vector3f velocityDirectionAdjusted = Environment::shipMatrix * velocityDirection;
+				Vector3f velocityDirectionAdjusted = MultMatrixVector(Environment::shipMatrix, velocityDirection);
 				Environment::shipPosition = Environment::shipPosition + velocityDirectionAdjusted;
 			}
 
@@ -597,7 +604,7 @@ namespace ZL
 				if (p && p->isActive()) {
 					Vector3f worldPos = p->getPosition();
 					Vector3f rel = worldPos - Environment::shipPosition;
-					Vector3f camPos = Environment::inverseShipMatrix * rel;
+					Vector3f camPos = MultMatrixVector(Environment::inverseShipMatrix, rel);
 					projCameraPoints.push_back(camPos);
 				}
 			}
@@ -636,10 +643,10 @@ namespace ZL
 		const float size = 0.5f;
 
 		Vector3f localForward = { 0,0,-1 };
-		Vector3f worldForward = (Environment::shipMatrix * localForward).normalized();
+		Vector3f worldForward = MultMatrixVector(Environment::shipMatrix, localForward).normalized();
 
 		for (const auto& lo : localOffsets) {
-			Vector3f worldPos = Environment::shipPosition + Environment::shipMatrix * lo;
+			Vector3f worldPos = Environment::shipPosition + MultMatrixVector(Environment::shipMatrix, lo);
 			Vector3f worldVel = worldForward * projectileSpeed;
 
 			for (auto& p : projectiles) {
@@ -670,6 +677,8 @@ namespace ZL
 				Environment::exitGameLoop = true;
 			}
 			else if (event.type == SDL_MOUSEBUTTONDOWN) {
+				// 1. Îáðàáîòêà íàæàòèÿ êíîïêè ìûøè
+
 				int mx = event.button.x;
 				int my = event.button.y;
 				int uiX = mx;
@@ -700,16 +709,16 @@ namespace ZL
 
 				if (!uiManager.isUiInteraction()) {
 					Environment::tapDownHold = true;
-
+					// Êîîðäèíàòû íà÷àëüíîãî íàæàòèÿ
-					Environment::tapDownStartPos(0) = mx;
+					Environment::tapDownStartPos.v[0] = mx;
-					Environment::tapDownStartPos(1) = my;
+					Environment::tapDownStartPos.v[1] = my;
-
+					// Íà÷àëüíàÿ ïîçèöèÿ òàêæå ñòàíîâèòñÿ òåêóùåé
-					Environment::tapDownCurrentPos(0) = mx;
+					Environment::tapDownCurrentPos.v[0] = mx;
-					Environment::tapDownCurrentPos(1) = my;
+					Environment::tapDownCurrentPos.v[1] = my;
 				}
 			}
 			else if (event.type == SDL_MOUSEBUTTONUP) {
-
+				// 2. Îáðàáîòêà îòïóñêàíèÿ êíîïêè ìûøè
 				int mx = event.button.x;
 				int my = event.button.y;
 				int uiX = mx;
@@ -722,7 +731,7 @@ namespace ZL
 				}
 			}
 			else if (event.type == SDL_MOUSEMOTION) {
-
+				// 3. Îáðàáîòêà ïåðåìåùåíèÿ ìûøè
 				int mx = event.motion.x;
 				int my = event.motion.y;
 				int uiX = mx;
@@ -731,8 +740,8 @@ namespace ZL
 				uiManager.onMouseMove(uiX, uiY);
 
 				if (Environment::tapDownHold && !uiManager.isUiInteraction()) {
-					Environment::tapDownCurrentPos(0) = mx;
+					Environment::tapDownCurrentPos.v[0] = mx;
-					Environment::tapDownCurrentPos(1) = my;
+					Environment::tapDownCurrentPos.v[1] = my;
 				}
 			}
 			else if (event.type == SDL_MOUSEWHEEL) {

src/Projectile.cpp

@@ -46,13 +46,13 @@ namespace ZL {
 		mesh.data.PositionData.clear();
 		mesh.data.TexCoordData.clear();
 
-		mesh.data.PositionData.push_back({ pos(0) - half, pos(1) - half, pos(2) });
+		mesh.data.PositionData.push_back({ pos.v[0] - half, pos.v[1] - half, pos.v[2] });
-		mesh.data.PositionData.push_back({ pos(0) - half, pos(1) + half, pos(2) });
+		mesh.data.PositionData.push_back({ pos.v[0] - half, pos.v[1] + half, pos.v[2] });
-		mesh.data.PositionData.push_back({ pos(0) + half, pos(1) + half, pos(2) });
+		mesh.data.PositionData.push_back({ pos.v[0] + half, pos.v[1] + half, pos.v[2] });
 
-		mesh.data.PositionData.push_back({ pos(0) - half, pos(1) - half, pos(2) });
+		mesh.data.PositionData.push_back({ pos.v[0] - half, pos.v[1] - half, pos.v[2] });
-		mesh.data.PositionData.push_back({ pos(0) + half, pos(1) + half, pos(2) });
+		mesh.data.PositionData.push_back({ pos.v[0] + half, pos.v[1] + half, pos.v[2] });
-		mesh.data.PositionData.push_back({ pos(0) + half, pos(1) - half, pos(2) });
+		mesh.data.PositionData.push_back({ pos.v[0] + half, pos.v[1] - half, pos.v[2] });
 
 		mesh.data.TexCoordData.push_back({ 0.0f, 0.0f });
 		mesh.data.TexCoordData.push_back({ 0.0f, 1.0f });

src/Projectile.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "utils/ZLMath.h"
 #include "render/Renderer.h"
 #include "render/TextureManager.h"
 #include <memory>

src/SparkEmitter.cpp

@@ -69,7 +69,7 @@ namespace ZL {
 
 		for (const auto& particle : particles) {
 			if (particle.active) {
-				sortedParticles.push_back({ &particle, particle.position(2) });
+				sortedParticles.push_back({ &particle, particle.position.v[2] });
 			}
 		}
 
@@ -83,22 +83,22 @@ namespace ZL {
 			Vector3f pos = particle.position;
 			float size = particleSize * particle.scale;
 
-			drawPositions.push_back({ pos(0) - size, pos(1) - size, pos(2) });
+			drawPositions.push_back({ pos.v[0] - size, pos.v[1] - size, pos.v[2] });
 			drawTexCoords.push_back({ 0.0f, 0.0f });
 
-			drawPositions.push_back({ pos(0) - size, pos(1) + size, pos(2) });
+			drawPositions.push_back({ pos.v[0] - size, pos.v[1] + size, pos.v[2] });
 			drawTexCoords.push_back({ 0.0f, 1.0f });
 
-			drawPositions.push_back({ pos(0) + size, pos(1) + size, pos(2) });
+			drawPositions.push_back({ pos.v[0] + size, pos.v[1] + size, pos.v[2] });
 			drawTexCoords.push_back({ 1.0f, 1.0f });
 
-			drawPositions.push_back({ pos(0) - size, pos(1) - size, pos(2) });
+			drawPositions.push_back({ pos.v[0] - size, pos.v[1] - size, pos.v[2] });
 			drawTexCoords.push_back({ 0.0f, 0.0f });
 
-			drawPositions.push_back({ pos(0) + size, pos(1) + size, pos(2) });
+			drawPositions.push_back({ pos.v[0] + size, pos.v[1] + size, pos.v[2] });
 			drawTexCoords.push_back({ 1.0f, 1.0f });
 
-			drawPositions.push_back({ pos(0) + size, pos(1) - size, pos(2) });
+			drawPositions.push_back({ pos.v[0] + size, pos.v[1] - size, pos.v[2] });
 			drawTexCoords.push_back({ 1.0f, 0.0f });
 		}
 
@@ -182,9 +182,9 @@ namespace ZL {
 				Vector3f oldPosition = particle.position;
 				float oldScale = particle.scale;
 
-				particle.position(0) += particle.velocity(0) * deltaTimeMs / 1000.0f;
+				particle.position.v[0] += particle.velocity.v[0] * deltaTimeMs / 1000.0f;
-				particle.position(1) += particle.velocity(1) * deltaTimeMs / 1000.0f;
+				particle.position.v[1] += particle.velocity.v[1] * deltaTimeMs / 1000.0f;
-				particle.position(2) += particle.velocity(2) * deltaTimeMs / 1000.0f;
+				particle.position.v[2] += particle.velocity.v[2] * deltaTimeMs / 1000.0f;
 
 				particle.lifeTime += deltaTimeMs;
 
@@ -196,9 +196,9 @@ namespace ZL {
 					float lifeRatio = particle.lifeTime / particle.maxLifeTime;
 					particle.scale = 1.0f - lifeRatio * 0.8f;
 
-					if (oldPosition(0) != particle.position(0) ||
+					if (oldPosition.v[0] != particle.position.v[0] ||
-						oldPosition(1) != particle.position(1) ||
+						oldPosition.v[1] != particle.position.v[1] ||
-						oldPosition(2) != particle.position(2) ||
+						oldPosition.v[2] != particle.position.v[2] ||
 						oldScale != particle.scale) {
 						anyChanged = true;
 					}
@@ -404,8 +404,8 @@ namespace ZL {
 					for (int k = 0; k < count; ++k) {
 						Vector3f randomPoint{ dx(gen), dy(gen), dz(gen) };
 						points.push_back(randomPoint);
-						std::cout << "Random point " << k + 1 << ": [" << randomPoint(0)
+						std::cout << "Random point " << k + 1 << ": [" << randomPoint.v[0]
-							<< ", " << randomPoint(1) << ", " << randomPoint(2) << "]" << std::endl;
+							<< ", " << randomPoint.v[1] << ", " << randomPoint.v[2] << "]" << std::endl;
 					}
 				}
 			}

src/SparkEmitter.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "utils/ZLMath.h"
 #include "render/Renderer.h"
 #include "render/TextureManager.h"
 #include <vector>

src/TextModel.cpp

@@ -211,9 +211,15 @@ namespace ZL
 		for (int i = 0; i < result.PositionData.size(); i++)
 		{
 			Vector3f tempVec = result.PositionData[i];
-			result.PositionData[i](0) = tempVec(1);
+			result.PositionData[i].v[0] = tempVec.v[1];
-			result.PositionData[i](1) = tempVec(2);
+			result.PositionData[i].v[1] = tempVec.v[2];
-			result.PositionData[i](2) = tempVec(0);
+			result.PositionData[i].v[2] = tempVec.v[0];
+
+			/*
+			tempVec = result.NormalData[i];
+			result.NormalData[i].v[0] = tempVec.v[1];
+			result.NormalData[i].v[1] = tempVec.v[2];
+			result.NormalData[i].v[2] = tempVec.v[0];*/
 
 		}
 
@@ -363,14 +369,14 @@ namespace ZL
 		for (size_t i = 0; i < result.PositionData.size(); i++)
 		{
 			Vector3f originalPos = result.PositionData[i];
-			result.PositionData[i](0) = originalPos(1); // New X = Old Y
+			result.PositionData[i].v[0] = originalPos.v[1]; // New X = Old Y
-			result.PositionData[i](1) = originalPos(2); // New Y = Old Z
+			result.PositionData[i].v[1] = originalPos.v[2]; // New Y = Old Z
-			result.PositionData[i](2) = originalPos(0); // New Z = Old X
+			result.PositionData[i].v[2] = originalPos.v[0]; // New Z = Old X
 
 			Vector3f originalNorm = result.NormalData[i];
-			result.NormalData[i](0) = originalNorm(1);
+			result.NormalData[i].v[0] = originalNorm.v[1];
-			result.NormalData[i](1) = originalNorm(2);
+			result.NormalData[i].v[1] = originalNorm.v[2];
-			result.NormalData[i](2) = originalNorm(0);
+			result.NormalData[i].v[2] = originalNorm.v[0];
 		}
 
 		std::cout << "Model loaded: " << numberVertices << " verts, " << numberTriangles << " tris." << std::endl;

src/TextModel.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "utils/ZLMath.h"
 #include "render/Renderer.h"
 #include <unordered_map>
 

src/planet/PlanetData.cpp

@@ -169,7 +169,7 @@ namespace ZL {
     std::vector<int> PlanetData::getTrianglesUnderCameraNew2(const Vector3f& viewerPosition) {
         const LodLevel& finalLod = planetMeshLods[currentLod];
         Vector3f shipLocal = viewerPosition - PLANET_CENTER_OFFSET;
-        float currentDist = shipLocal.norm();
+        float currentDist = shipLocal.length();
         Vector3f targetDir = shipLocal.normalized();
 
         // Æåëàåìûé ðàäèóñ ïîêðûòèÿ íà ïîâåðõíîñòè ïëàíåòû (â ìåòðàõ/åäèíèöàõ äâèæêà)
@@ -318,9 +318,9 @@ namespace ZL {
                 // Èñïîëüçóåì îäèí øóì äëÿ âûáîðà ìåæäó ðîçîâûì è æåëòûì
                 Vector3f dir = t.data[i].normalized();
                 float blendFactor = colorPerlin.noise(
-                    dir(0) * colorFrequency,
+                    dir.v[0] * colorFrequency,
-                    dir(1) * colorFrequency,
+                    dir.v[1] * colorFrequency,
-                    dir(2) * colorFrequency
+                    dir.v[2] * colorFrequency
                 );
 
                 // Ïðèâîäèì øóì èç äèàïàçîíà [-1, 1] â [0, 1]
@@ -328,8 +328,9 @@ namespace ZL {
 
                 // Ëèíåéíàÿ èíòåðïîëÿöèÿ ìåæäó äâóìÿ öâåòàìè
                 Vector3f finalColor;
-
+                finalColor.v[0] = colorPinkish.v[0] + blendFactor * (colorYellowish.v[0] - colorPinkish.v[0]);
-                finalColor = colorPinkish + blendFactor * (colorYellowish - colorPinkish);
+                finalColor.v[1] = colorPinkish.v[1] + blendFactor * (colorYellowish.v[1] - colorPinkish.v[1]);
+                finalColor.v[2] = colorPinkish.v[2] + blendFactor * (colorYellowish.v[2] - colorPinkish.v[2]);
 
                 lod.vertexData.ColorData.push_back(finalColor);
             }
@@ -367,9 +368,9 @@ namespace ZL {
 
             // Ãåíåðèðóåì ID äëÿ áàçîâûõ âåðøèí (ìîæíî èñïîëüçîâàòü èõ êîîðäèíàòû)
             for (int i = 0; i < 3; ++i) {
-                tri.ids[i] = std::to_string(tri.data[i](0)) + "_" +
+                tri.ids[i] = std::to_string(tri.data[i].v[0]) + "_" +
-                    std::to_string(tri.data[i](1)) + "_" +
+                    std::to_string(tri.data[i].v[1]) + "_" +
-                    std::to_string(tri.data[i](2));
+                    std::to_string(tri.data[i].v[2]);
             }
             geometry.push_back(tri);
         }

src/planet/PlanetData.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "utils/ZLMath.h"
 #include "utils/Perlin.h"
 #include "render/Renderer.h"
 #include <vector>
@@ -14,15 +15,6 @@ namespace ZL {
     using VertexID = std::string;
     using V2TMap = std::map<VertexID, std::vector<int>>;
 
-    struct Vector3fComparator {
-        bool operator()(const Eigen::Vector3f& a, const Eigen::Vector3f& b) const {
-            // Ëåêñèêîãðàôè÷åñêîå ñðàâíåíèå (x, çàòåì y, çàòåì z)
-            if (a.x() != b.x()) return a.x() < b.x();
-            if (a.y() != b.y()) return a.y() < b.y();
-            return a.z() < b.z();
-        }
-    };
-
     VertexID generateEdgeID(const VertexID& id1, const VertexID& id2);
 
 	constexpr static int MAX_LOD_LEVELS = 6;
@@ -90,7 +82,7 @@ namespace ZL {
 
         int currentLod; // Ëîãè÷åñêèé òåêóùèé óðîâåíü äåòàëèçàöèè
 
-        std::map<Vector3f, VertexID, Vector3fComparator> initialVertexMap;
+        std::map<Vector3f, VertexID> initialVertexMap;
 
         // Âíóòðåííèå ìåòîäû ãåíåðàöèè
         std::vector<Triangle> subdivideTriangles(const std::vector<Triangle>& inputTriangles, float noiseCoeff);

src/planet/PlanetObject.cpp

@@ -31,13 +31,19 @@ namespace ZL {
 		Matrix3f rot;
 
 		// Столбец 0: Ось X
-		rot.col(0) = x_axis;
+		rot.m[0] = x_axis.v[0];
-		
+		rot.m[3] = x_axis.v[1];
+		rot.m[6] = x_axis.v[2];
+
 		// Столбец 1: Ось Y
-		rot.col(1) = y_axis;
+		rot.m[1] = y_axis.v[0];
+		rot.m[4] = y_axis.v[1];
+		rot.m[7] = y_axis.v[2];
 
 		// Столбец 2: Ось Z
-		rot.col(2) = z_axis;
+		rot.m[2] = z_axis.v[0];
+		rot.m[5] = z_axis.v[1];
+		rot.m[8] = z_axis.v[2];
 
 		return rot;
 	}
@@ -124,15 +130,15 @@ namespace ZL {
 		// 2. Трансформируем вершины в локальное пространство экрана, чтобы найти габариты
 		// Используем MultMatrixVector(Matrix, Vector). 
 		// Если ваша функция считает V * M, то передайте Inverse(mr).
-		Vector3f rA = mr * tr.data[0];
+		Vector3f rA = MultMatrixVector(mr, tr.data[0]);
-		Vector3f rB = mr * tr.data[1];
+		Vector3f rB = MultMatrixVector(mr, tr.data[1]);
-		Vector3f rC = mr * tr.data[2];
+		Vector3f rC = MultMatrixVector(mr, tr.data[2]);
 
 		// 3. Вычисляем реальные границы треугольника после поворота
-		float minX = min(rA(0), min(rB(0), rC(0)));
+		float minX = min(rA.v[0], min(rB.v[0], rC.v[0]));
-		float maxX = max(rA(0), max(rB(0), rC(0)));
+		float maxX = max(rA.v[0], max(rB.v[0], rC.v[0]));
-		float minY = min(rA(1), min(rB(1), rC(1)));
+		float minY = min(rA.v[1], min(rB.v[1], rC.v[1]));
-		float maxY = max(rA(1), max(rB(1), rC(1)));
+		float maxY = max(rA.v[1], max(rB.v[1], rC.v[1]));
 
 
 		// Находим центр и размеры
@@ -159,10 +165,10 @@ namespace ZL {
 		
 		
 		// Извлекаем нормаль треугольника (это 3-й столбец нашей матрицы вращения)
-		Vector3f planeNormal = mr.col(2);
+		Vector3f planeNormal = { mr.m[2], mr.m[5], mr.m[8] };
 
-		renderer.RenderUniform3fv("uPlanePoint", tr.data[0].data());
+		renderer.RenderUniform3fv("uPlanePoint", &tr.data[0].v[0]);
-		renderer.RenderUniform3fv("uPlaneNormal", planeNormal.data());
+		renderer.RenderUniform3fv("uPlaneNormal", &planeNormal.v[0]);
 		renderer.RenderUniform1f("uMaxHeight", StoneParams::BASE_SCALE * 1.1f); // Соответствует BASE_SCALE + perturbation
 		
 		
@@ -261,7 +267,7 @@ namespace ZL {
 		Matrix3f mr = GetRotationForTriangle(tr); // Та же матрица, что и при запекании
 
 		// Позиция камеры (корабля) в мире
-		renderer.RenderUniform3fv("uViewPos", Environment::shipPosition.data());
+		renderer.RenderUniform3fv("uViewPos", &Environment::shipPosition.v[0]);
 
 		//renderer.RenderUniform1f("uHeightScale", 0.08f);
 		renderer.RenderUniform1f("uHeightScale", 0.0f);
@@ -329,7 +335,7 @@ namespace ZL {
 
 		renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
 		renderer.RenderUniform1f("uCurrentZFar", currentZFar);
-		renderer.RenderUniform3fv("uViewPos", Environment::shipPosition.data());
+		renderer.RenderUniform3fv("uViewPos", &Environment::shipPosition.v[0]);
 
 		glEnable(GL_CULL_FACE);
 		glCullFace(GL_BACK);
@@ -393,9 +399,9 @@ namespace ZL {
 		Vector3f color = { 0.0, 0.5, 1.0 };
 
 
-		renderer.RenderUniform3fv("uColor", color.data());
+		renderer.RenderUniform3fv("uColor", &color.v[0]);
 
-		renderer.RenderUniformMatrix4fv("ModelViewMatrix", false, viewMatrix.data());
+		renderer.RenderUniformMatrix4fv("ModelViewMatrix", false, &viewMatrix.m[0]);
 
 		renderer.RenderUniform1f("uDistanceToPlanetSurface", dist);
 

src/planet/PlanetObject.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "utils/ZLMath.h"
 #include "render/Renderer.h"
 #include "render/TextureManager.h"
 #include <vector>

src/planet/StoneObject.cpp

@@ -104,16 +104,16 @@ namespace ZL {
 
 		// Применяем масштабирование
 		for (Vector3f& v : initialVertices) {
-			v(0) *= scaleFactors(0);
+			v.v[0] *= scaleFactors.v[0];
-			v(1) *= scaleFactors(1);
+			v.v[1] *= scaleFactors.v[1];
-			v(2) *= scaleFactors(2);
+			v.v[2] *= scaleFactors.v[2];
 		}
 
 		/*
 		// Случайный поворот (например, вокруг трех осей)
-		Vector4f qx = Eigen::Quaternionf(Eigen::AngleAxisf(getRandomFloat(engine, 0.0f, 360.0f), Eigen::Vector3f::UnitX()));//QuatFromRotateAroundX(getRandomFloat(engine, 0.0f, 360.0f));
+		Vector4f qx = QuatFromRotateAroundX(getRandomFloat(engine, 0.0f, 360.0f));
-		Vector4f qy = Eigen::Quaternionf(Eigen::AngleAxisf(getRandomFloat(engine, 0.0f, 360.0f), Eigen::Vector3f::UnitY()));//QuatFromRotateAroundY(getRandomFloat(engine, 0.0f, 360.0f));
+		Vector4f qy = QuatFromRotateAroundY(getRandomFloat(engine, 0.0f, 360.0f));
-		Vector4f qz = Eigen::Quaternionf(Eigen::AngleAxisf(getRandomFloat(engine, 0.0f, 360.0f), Eigen::Vector3f::UnitZ()));//QuatFromRotateAroundZ(getRandomFloat(engine, 0.0f, 360.0f));
+		Vector4f qz = QuatFromRotateAroundZ(getRandomFloat(engine, 0.0f, 360.0f));
 		Vector4f qFinal = slerp(qx, qy, 0.5f); // Простой пример комбинирования
 		qFinal = slerp(qFinal, qz, 0.5f).normalized();
 		Matrix3f rotationMatrix = QuatToMatrix(qFinal);
@@ -126,7 +126,7 @@ namespace ZL {
 		VertexDataStruct result;
 		// Карта для накопления нормалей по уникальным позициям вершин
 		// (Требует определенного оператора < для Vector3f в ZLMath.h, который у вас есть)
-		std::map<Vector3f, Vector3f, Vector3fComparator> smoothNormalsMap;
+		std::map<Vector3f, Vector3f> smoothNormalsMap;
 
 		// Предварительное заполнение карты нормалями
 		for (const auto& face : faces) {
@@ -178,18 +178,18 @@ namespace ZL {
 			Vector3f vAxisRaw = vRaw - (uAxis * uProjLen);
 
 			// Длина оси V
-			float vLen = vAxisRaw.norm();
+			float vLen = vAxisRaw.length();
 
 			// Нормализованная ось V
 			Vector3f vAxis = vAxisRaw.normalized();
 
 			// Координаты (u, v) для p1, p2, p3 относительно p1
 			Vector2f uv1 = { 0.0f, 0.0f };
-			Vector2f uv2 = { (p2 - p1).norm(), 0.0f }; // p2-p1 вдоль оси U
+			Vector2f uv2 = { (p2 - p1).length(), 0.0f }; // p2-p1 вдоль оси U
 			Vector2f uv3 = { uProjLen, vLen };          // p3-p1: u-компонента = uProjLen, v-компонента = vLen
 
 			// Находим максимальный размер, чтобы масштабировать в [0, 1]
-			float maxUV = max(uv2(0), max(uv3(0), uv3(1)));
+			float maxUV = max(uv2.v[0], max(uv3.v[0], uv3.v[1]));
 
 			if (maxUV > 0.000001f) {
 				// Масштабируем:
@@ -320,18 +320,18 @@ namespace ZL {
 
 
 			for (const auto& inst : allInstances[index]) {
-				Matrix3f rotMat = inst.rotation.toRotationMatrix();
+				Matrix3f rotMat = QuatToMatrix(inst.rotation);
 
 				for (size_t j = 0; j < baseStone.PositionData.size(); ++j) {
 					Vector3f p = baseStone.PositionData[j];
 					Vector3f n = baseStone.NormalData[j];
 
-					p(0) *= inst.scale(0) * scaleModifier;
+					p.v[0] *= inst.scale.v[0] * scaleModifier;
-					p(1) *= inst.scale(1) * scaleModifier;
+					p.v[1] *= inst.scale.v[1] * scaleModifier;
-					p(2) *= inst.scale(2) * scaleModifier;
+					p.v[2] *= inst.scale.v[2] * scaleModifier;
 
-					result.data.PositionData.push_back(rotMat * p + inst.position);
+					result.data.PositionData.push_back(MultMatrixVector(rotMat, p) + inst.position);
-					result.data.NormalData.push_back(rotMat * n);
+					result.data.NormalData.push_back(MultMatrixVector(rotMat, n));
 					result.data.TexCoordData.push_back(baseStone.TexCoordData[j]);
 
 				}

src/planet/StoneObject.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "utils/ZLMath.h"
 #include "render/Renderer.h"
 #include "PlanetData.h"
 
@@ -19,7 +20,7 @@ namespace ZL {
         uint64_t seed;
         Vector3f position;
         Vector3f scale;
-        Eigen::Quaternionf rotation;
+        Vector4f rotation;
     };
 
     struct StoneGroup {

src/render/Renderer.cpp

@@ -3,105 +3,6 @@
 
 namespace ZL {
 
-	Matrix4f MakeOrthoMatrix(float width, float height, float zNear, float zFar)
-	{
-		float depthRange = zFar - zNear;
-
-		if (depthRange <= 0)
-		{
-			throw std::runtime_error("zFar must be greater than zNear");
-		}
-
-		Matrix4f r;
-
-		r.data()[0] = 2.f / width;
-		r.data()[1] = 0;
-		r.data()[2] = 0;
-		r.data()[3] = 0;
-
-		r.data()[4] = 0;
-		r.data()[5] = 2.f / height;
-		r.data()[6] = 0;
-		r.data()[7] = 0;
-
-		r.data()[8] = 0;
-		r.data()[9] = 0;
-		r.data()[10] = -1 / depthRange;
-		r.data()[11] = 0;
-
-		r.data()[12] = -1;
-		r.data()[13] = -1;
-		r.data()[14] = zNear / depthRange;
-		r.data()[15] = 1;
-
-		return r;
-	}
-
-	Matrix4f MakeOrthoMatrix(float xmin, float xmax, float ymin, float ymax, float zNear, float zFar)
-	{
-		float width = xmax - xmin;
-		float height = ymax - ymin;
-		float depthRange = zFar - zNear;
-
-		if (width <= 0 || height <= 0 || depthRange <= 0)
-		{
-			throw std::runtime_error("Invalid dimensions for orthogonal matrix");
-		}
-
-		Matrix4f r;
-
-		// Ìàñøòàáèðîâàíèå
-		r.data()[0] = 2.f / width;
-		r.data()[5] = 2.f / height;
-		r.data()[10] = -1.f / depthRange;
-
-		// Îáíóëåíèå íåèñïîëüçóåìûõ êîìïîíåíòîâ
-		r.data()[1] = r.data()[2] = r.data()[3] = 0;
-		r.data()[4] = r.data()[6] = r.data()[7] = 0;
-		r.data()[8] = r.data()[9] = r.data()[11] = 0;
-
-		// Òðàíñëÿöèÿ (ñìåùåíèå)
-		r.data()[12] = -(xmax + xmin) / width;
-		r.data()[13] = -(ymax + ymin) / height;
-		r.data()[14] = zNear / depthRange;
-		r.data()[15] = 1.f;
-
-		return r;
-	}
-
-	Matrix4f MakePerspectiveMatrix(float fovY, float aspectRatio, float zNear, float zFar)
-	{
-		float tanHalfFovy = tan(fovY / 2.f);
-		Matrix4f r;
-
-		if (zNear >= zFar || aspectRatio == 0)
-		{
-			throw std::runtime_error("Invalid perspective parameters");
-		}
-
-		r.data()[0] = 1.f / (aspectRatio * tanHalfFovy);
-		r.data()[1] = 0;
-		r.data()[2] = 0;
-		r.data()[3] = 0;
-
-		r.data()[4] = 0;
-		r.data()[5] = 1.f / (tanHalfFovy);
-		r.data()[6] = 0;
-		r.data()[7] = 0;
-
-		r.data()[8] = 0;
-		r.data()[9] = 0;
-		r.data()[10] = -(zFar + zNear) / (zFar - zNear);
-		r.data()[11] = -1;
-
-		r.data()[12] = 0;
-		r.data()[13] = 0;
-		r.data()[14] = -(2.f * zFar * zNear) / (zFar - zNear);
-		r.data()[15] = 0;
-
-		return r;
-	}
-
 	VBOHolder::VBOHolder()
 	{
 		glGenBuffers(1, &Buffer);
@@ -149,10 +50,10 @@ namespace ZL {
 
 		Vector2f posTo = center + halfWidthHeight;
 		
-		Vector3f pos1 = { posFrom(0), posFrom(1), zLevel };
+		Vector3f pos1 = { posFrom.v[0], posFrom.v[1], zLevel };
-		Vector3f pos2 = { posFrom(0), posTo(1), zLevel }; 
+		Vector3f pos2 = { posFrom.v[0], posTo.v[1], zLevel }; 
-		Vector3f pos3 = { posTo(0), posTo(1), zLevel };
+		Vector3f pos3 = { posTo.v[0], posTo.v[1], zLevel };
-		Vector3f pos4 = { posTo(0), posFrom(1), zLevel };
+		Vector3f pos4 = { posTo.v[0], posFrom.v[1], zLevel };
 
 
 		Vector2f texCoordPos1 = { 0.0f, 0.0f };
@@ -185,16 +86,16 @@ namespace ZL {
 
 		Vector2f posTo = center + halfWidthHeight;
 
-		float sectionWidth = halfWidthHeight(0) * 2.f;
+		float sectionWidth = halfWidthHeight.v[0] * 2.f;
 
 		VertexDataStruct result;
 
 		for (size_t i = 0; i < sectionCount; i++)
 		{
-			Vector3f pos1 = { posFrom(0)+sectionWidth*i, posFrom(1), zLevel };
+			Vector3f pos1 = { posFrom.v[0]+sectionWidth*i, posFrom.v[1], zLevel };
-			Vector3f pos2 = { posFrom(0) + sectionWidth * i, posTo(1), zLevel };
+			Vector3f pos2 = { posFrom.v[0] + sectionWidth * i, posTo.v[1], zLevel };
-			Vector3f pos3 = { posTo(0) + sectionWidth * i, posTo(1), zLevel };
+			Vector3f pos3 = { posTo.v[0] + sectionWidth * i, posTo.v[1], zLevel };
-			Vector3f pos4 = { posTo(0) + sectionWidth * i, posFrom(1), zLevel };
+			Vector3f pos4 = { posTo.v[0] + sectionWidth * i, posFrom.v[1], zLevel };
 
 			result.PositionData.push_back(pos1);
 			result.PositionData.push_back(pos2);
@@ -461,9 +362,9 @@ namespace ZL {
 	{
 		for (int i = 0; i < PositionData.size(); i++)
 		{
-			auto value = PositionData[i](1);
+			auto value = PositionData[i].v[1];
-			PositionData[i](1) = PositionData[i](2);
+			PositionData[i].v[1] = PositionData[i].v[2];
-			PositionData[i](2) = value;
+			PositionData[i].v[2] = value;
 		}
 	}
 	
@@ -473,22 +374,22 @@ namespace ZL {
 
 		for (int i = 0; i < PositionData.size(); i++)
 		{
-			PositionData[i] = PositionData[i].transpose() * m;
+			PositionData[i] = MultVectorMatrix(PositionData[i], m);
 		}
 
 		for (int i = 0; i < NormalData.size(); i++)
 		{
-			NormalData[i] = NormalData[i].transpose() * m;
+			NormalData[i] = MultVectorMatrix(NormalData[i], m);
 		}
 
 		for (int i = 0; i < TangentData.size(); i++)
 		{
-			TangentData[i] = TangentData[i].transpose() * m;
+			TangentData[i] = MultVectorMatrix(TangentData[i], m);
 		}
 
 		for (int i = 0; i < BinormalData.size(); i++)
 		{
-			BinormalData[i] = BinormalData[i].transpose() * m;
+			BinormalData[i] = MultVectorMatrix(BinormalData[i], m);
 		}
 	}
 
@@ -592,11 +493,11 @@ namespace ZL {
 
 		static const std::string ProjectionModelViewMatrixName = "ProjectionModelViewMatrix";
 	
-		RenderUniformMatrix4fv(ProjectionModelViewMatrixName, false, ProjectionModelViewMatrix.data());
+		RenderUniformMatrix4fv(ProjectionModelViewMatrixName, false, &ProjectionModelViewMatrix.m[0]);
 
 		static const std::string ModelViewMatrixName = "ModelViewMatrix";
 
-		RenderUniformMatrix4fv(ModelViewMatrixName, false, modelViewMatrix.data());
+		RenderUniformMatrix4fv(ModelViewMatrixName, false, &modelViewMatrix.m[0]);
 
 	}
 
@@ -632,9 +533,9 @@ namespace ZL {
 	{
 
 		Matrix4f m = Matrix4f::Identity();
-		m.data()[12] = p(0);
+		m.m[12] = p.v[0];
-		m.data()[13] = p(1);
+		m.m[13] = p.v[1];
-		m.data()[14] = p(2);
+		m.m[14] = p.v[2];
 
 		m = ModelviewMatrixStack.top() * m;
 
@@ -652,9 +553,9 @@ namespace ZL {
 	void Renderer::ScaleMatrix(float scale)
 	{
 		Matrix4f m = Matrix4f::Identity();
-		m.data()[0] = scale;
+		m.m[0] = scale;
-		m.data()[5] = scale;
+		m.m[5] = scale;
-		m.data()[10] = scale;
+		m.m[10] = scale;
 
 		m = ModelviewMatrixStack.top() * m;
 
@@ -672,9 +573,9 @@ namespace ZL {
 	void Renderer::ScaleMatrix(const Vector3f& scale)
 	{
 		Matrix4f m = Matrix4f::Identity();
-		m.data()[0] = scale(0);
+		m.m[0] = scale.v[0];
-		m.data()[5] = scale(1);
+		m.m[5] = scale.v[1];
-		m.data()[10] = scale(2);
+		m.m[10] = scale.v[2];
 
 		m = ModelviewMatrixStack.top() * m;
 
@@ -689,26 +590,23 @@ namespace ZL {
 		SetMatrix();
 	}
 
-	void Renderer::RotateMatrix(const Eigen::Quaternionf& q)
+	void Renderer::RotateMatrix(const Vector4f& q)
 	{
-	
+		
-		Matrix3f m3 = q.toRotationMatrix();
+		Matrix3f m3 = QuatToMatrix(q);
 		Matrix4f m = Matrix4f::Identity();
+		m.m[0] = m3.m[0];
+		m.m[1] = m3.m[1];
+		m.m[2] = m3.m[2];
 
-		m.block<3, 3>(0, 0) = m3;
+		m.m[4] = m3.m[3];
-		/*
+		m.m[5] = m3.m[4];
-		m.m[0] = m3.data()[0];
+		m.m[6] = m3.m[5];
-		m.m[1] = m3.data()[1];
-		m.m[2] = m3.data()[2];
 
-		m.m[4] = m3.data()[3];
+		m.m[8] = m3.m[6];
-		m.m[5] = m3.data()[4];
+		m.m[9] = m3.m[7];
-		m.m[6] = m3.data()[5];
+		m.m[10] = m3.m[8];
 
-		m.m[8] = m3.data()[6];
-		m.m[9] = m3.data()[7];
-		m.m[10] = m3.data()[8];
-		*/
 		m = ModelviewMatrixStack.top() * m;
 
 		if (ModelviewMatrixStack.size() == 0)
@@ -726,18 +624,17 @@ namespace ZL {
 	void Renderer::RotateMatrix(const Matrix3f& m3)
 	{
 		Matrix4f m = Matrix4f::Identity();
-		/*m.m[0] = m3.data()[0];
+		m.m[0] = m3.m[0];
-		m.m[1] = m3.data()[1];
+		m.m[1] = m3.m[1];
-		m.m[2] = m3.data()[2];
+		m.m[2] = m3.m[2];
 
-		m.m[4] = m3.data()[3];
+		m.m[4] = m3.m[3];
-		m.m[5] = m3.data()[4];
+		m.m[5] = m3.m[4];
-		m.m[6] = m3.data()[5];
+		m.m[6] = m3.m[5];
 
-		m.m[8] = m3.data()[6];
+		m.m[8] = m3.m[6];
-		m.m[9] = m3.data()[7];
+		m.m[9] = m3.m[7];
-		m.m[10] = m3.data()[8];*/
+		m.m[10] = m3.m[8];
-		m.block<3, 3>(0, 0) = m3;
 
 		m = ModelviewMatrixStack.top() * m;
 
@@ -921,11 +818,11 @@ namespace ZL {
 		int screenWidth, int screenHeight,
 		int& screenX, int& screenY) {
 
-		Vector4f inx = { objectPos(0), objectPos(1), objectPos(2), 1.0f };
+		Vector4f inx = { objectPos.v[0], objectPos.v[1], objectPos.v[2], 1.0f };
-		Vector4f clipCoords = projectionModelView * inx;
+		Vector4f clipCoords = MultMatrixVector(projectionModelView, inx);
 
-		float ndcX = clipCoords(0) / clipCoords(3);
+		float ndcX = clipCoords.v[0] / clipCoords.v[3];
-		float ndcY = clipCoords(1) / clipCoords(3);
+		float ndcY = clipCoords.v[1] / clipCoords.v[3];
 
 		screenX = (int)((ndcX + 1.0f) * 0.5f * screenWidth);
 		screenY = (int)((1.0f + ndcY) * 0.5f * screenHeight);

src/render/Renderer.h

@@ -1,26 +1,13 @@
 #pragma once
 
 #include "OpenGlExtensions.h"
+#include "utils/ZLMath.h"
 #include <exception>
 #include <stdexcept>
 #include "ShaderManager.h"
-#include <Eigen/Dense>
 
 namespace ZL {
 
-	using Eigen::Vector2f;
-	using Eigen::Vector3f;
-	using Eigen::Vector4f;
-
-	using Eigen::Matrix3f;
-	using Eigen::Matrix4f;
-
-	Matrix4f MakeOrthoMatrix(float width, float height, float zNear, float zFar);
-	Matrix4f MakeOrthoMatrix(float xmin, float xmax, float ymin, float ymax, float zNear, float zFar);
-
-	Matrix4f MakePerspectiveMatrix(float fovY, float aspectRatio, float zNear, float zFar);
-
-
 	constexpr size_t CONST_MATRIX_STACK_SIZE = 64;
 
 	class VBOHolder {
@@ -115,7 +102,7 @@ namespace ZL {
 		void TranslateMatrix(const Vector3f& p);
 		void ScaleMatrix(float scale);
 		void ScaleMatrix(const Vector3f& scale);
-		void RotateMatrix(const Eigen::Quaternionf& q);
+		void RotateMatrix(const Vector4f& q);
 		void RotateMatrix(const Matrix3f& m3);
 		void PushSpecialMatrix(const Matrix4f& m);
 		void PopMatrix();

src/utils/Perlin.cpp

@@ -57,12 +57,12 @@ namespace ZL {
                 lerp(u, grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1))));
     }
 
-    float PerlinNoise::getSurfaceHeight(Eigen::Vector3f pos, float noiseCoeff) {
+    float PerlinNoise::getSurfaceHeight(Vector3f pos, float noiseCoeff) {
         // Частота шума (чем больше, тем больше "холмов")
         float frequency = 7.0f;
 
         // Получаем значение шума (обычно от -1 до 1)
-        float noiseValue = noise(pos(0) * frequency, pos(1) * frequency, pos(2) * frequency);
+        float noiseValue = noise(pos.v[0] * frequency, pos.v[1] * frequency, pos.v[2] * frequency);
 
         // Масштабируем: хотим отклонение от 1.0 до 1.1 (примерно)
         float height = 1.0f + (noiseValue * noiseCoeff);

src/utils/Perlin.h

@@ -2,7 +2,7 @@
 
 #include <vector>
 #include <cstdint>
-#include <Eigen/Dense>
+#include "utils/ZLMath.h" 
 
 namespace ZL {
 
@@ -18,7 +18,7 @@ namespace ZL {
 
         float noise(float x, float y, float z);
 
-        float getSurfaceHeight(Eigen::Vector3f pos, float noiseCoeff);
+        float getSurfaceHeight(Vector3f pos, float noiseCoeff);
     };
 
 } // namespace ZL

src/utils/ZLMath.cpp

@@ -0,0 +1,799 @@
+#include "utils/ZLMath.h"
+
+#include <exception>
+#include <cmath>
+
+namespace ZL {
+
+	Vector2f operator+(const Vector2f& x, const Vector2f& y)
+	{
+		Vector2f result;
+
+		result.v[0] = x.v[0] + y.v[0];
+		result.v[1] = x.v[1] + y.v[1];
+
+		return result;
+	}
+
+	Vector2f operator-(const Vector2f& x, const Vector2f& y)
+	{
+		Vector2f result;
+
+		result.v[0] = x.v[0] - y.v[0];
+		result.v[1] = x.v[1] - y.v[1];
+
+		return result;
+	}
+
+	Vector3f operator+(const Vector3f& x, const Vector3f& y)
+	{
+		Vector3f result;
+
+		result.v[0] = x.v[0] + y.v[0];
+		result.v[1] = x.v[1] + y.v[1];
+		result.v[2] = x.v[2] + y.v[2];
+		return result;
+	}
+
+	Vector3f operator-(const Vector3f& x, const Vector3f& y)
+	{
+		Vector3f result;
+
+		result.v[0] = x.v[0] - y.v[0];
+		result.v[1] = x.v[1] - y.v[1];
+		result.v[2] = x.v[2] - y.v[2];
+		return result;
+	}
+
+	Vector3f operator-(const Vector3f& x)
+	{
+		Vector3f result;
+
+		result.v[0] = -x.v[0];
+		result.v[1] = -x.v[1];
+		result.v[2] = -x.v[2];
+		return result;
+	}
+
+	Vector4f operator+(const Vector4f& x, const Vector4f& y)
+	{
+		Vector4f result;
+
+		result.v[0] = x.v[0] + y.v[0];
+		result.v[1] = x.v[1] + y.v[1];
+		result.v[2] = x.v[2] + y.v[2];
+		result.v[3] = x.v[3] + y.v[3];
+		return result;
+	}
+
+	Vector4f operator-(const Vector4f& x, const Vector4f& y)
+	{
+		Vector4f result;
+
+		result.v[0] = x.v[0] - y.v[0];
+		result.v[1] = x.v[1] - y.v[1];
+		result.v[2] = x.v[2] - y.v[2];
+		result.v[3] = x.v[3] - y.v[3];
+		return result;
+	}
+
+
+
+	Matrix3f Matrix3f::Identity()
+	{
+		Matrix3f r;
+
+		r.m[0] = 1.f;
+		r.m[1] = 0.f;
+		r.m[2] = 0.f;
+
+		r.m[3] = 0.f;
+		r.m[4] = 1.f;
+		r.m[5] = 0.f;
+
+		r.m[6] = 0.f;
+		r.m[7] = 0.f;
+		r.m[8] = 1.f;
+		
+		return r;
+
+	}
+
+	Matrix4f Matrix4f::Identity()
+	{
+		Matrix4f r;
+
+		r.m[0] = 1.f;
+		r.m[1] = 0.f;
+		r.m[2] = 0.f;
+		r.m[3] = 0.f;
+
+		r.m[4] = 0.f;
+		r.m[5] = 1.f;
+		r.m[6] = 0.f;
+		r.m[7] = 0.f;
+
+		r.m[8] = 0.f;
+		r.m[9] = 0.f;
+		r.m[10] = 1.f;
+		r.m[11] = 0.f;
+
+		r.m[12] = 0.f;
+		r.m[13] = 0.f;
+		r.m[14] = 0.f;
+		r.m[15] = 1.f;
+
+		return r;
+
+	}
+
+	Matrix4f operator*(const Matrix4f& m1, const Matrix4f& m2)
+	{
+		Matrix4f r;
+
+		r.m[0] = m1.m[0] * m2.m[0] + m1.m[4] * m2.m[1] + m1.m[8] * m2.m[2] + m1.m[12] * m2.m[3];
+		r.m[1] = m1.m[1] * m2.m[0] + m1.m[5] * m2.m[1] + m1.m[9] * m2.m[2] + m1.m[13] * m2.m[3];
+		r.m[2] = m1.m[2] * m2.m[0] + m1.m[6] * m2.m[1] + m1.m[10] * m2.m[2] + m1.m[14] * m2.m[3];
+		r.m[3] = m1.m[3] * m2.m[0] + m1.m[7] * m2.m[1] + m1.m[11] * m2.m[2] + m1.m[15] * m2.m[3];
+
+		r.m[4] = m1.m[0] * m2.m[4] + m1.m[4] * m2.m[5] + m1.m[8] * m2.m[6] + m1.m[12] * m2.m[7];
+		r.m[5] = m1.m[1] * m2.m[4] + m1.m[5] * m2.m[5] + m1.m[9] * m2.m[6] + m1.m[13] * m2.m[7];
+		r.m[6] = m1.m[2] * m2.m[4] + m1.m[6] * m2.m[5] + m1.m[10] * m2.m[6] + m1.m[14] * m2.m[7];
+		r.m[7] = m1.m[3] * m2.m[4] + m1.m[7] * m2.m[5] + m1.m[11] * m2.m[6] + m1.m[15] * m2.m[7];
+
+
+		r.m[8] = m1.m[0] * m2.m[8] + m1.m[4] * m2.m[9] + m1.m[8] * m2.m[10] + m1.m[12] * m2.m[11];
+		r.m[9] = m1.m[1] * m2.m[8] + m1.m[5] * m2.m[9] + m1.m[9] * m2.m[10] + m1.m[13] * m2.m[11];
+		r.m[10] = m1.m[2] * m2.m[8] + m1.m[6] * m2.m[9] + m1.m[10] * m2.m[10] + m1.m[14] * m2.m[11];
+		r.m[11] = m1.m[3] * m2.m[8] + m1.m[7] * m2.m[9] + m1.m[11] * m2.m[10] + m1.m[15] * m2.m[11];
+
+		r.m[12] = m1.m[0] * m2.m[12] + m1.m[4] * m2.m[13] + m1.m[8] * m2.m[14] + m1.m[12] * m2.m[15];
+		r.m[13] = m1.m[1] * m2.m[12] + m1.m[5] * m2.m[13] + m1.m[9] * m2.m[14] + m1.m[13] * m2.m[15];
+		r.m[14] = m1.m[2] * m2.m[12] + m1.m[6] * m2.m[13] + m1.m[10] * m2.m[14] + m1.m[14] * m2.m[15];
+		r.m[15] = m1.m[3] * m2.m[12] + m1.m[7] * m2.m[13] + m1.m[11] * m2.m[14] + m1.m[15] * m2.m[15];
+
+		return r;
+	}
+
+	Matrix4f MakeOrthoMatrix(float width, float height, float zNear, float zFar)
+	{
+		float depthRange = zFar - zNear;
+
+		if (depthRange <= 0)
+		{
+			throw std::runtime_error("zFar must be greater than zNear");
+		}
+
+		Matrix4f r;
+
+		r.m[0] = 2.f / width;
+		r.m[1] = 0;
+		r.m[2] = 0;
+		r.m[3] = 0;
+
+		r.m[4] = 0;
+		r.m[5] = 2.f / height;
+		r.m[6] = 0;
+		r.m[7] = 0;
+
+		r.m[8] = 0;
+		r.m[9] = 0;
+		r.m[10] = -1 / depthRange;
+		r.m[11] = 0;
+
+		r.m[12] = -1;
+		r.m[13] = -1;
+		r.m[14] = zNear / depthRange;
+		r.m[15] = 1;
+
+		return r;
+	}
+
+	Matrix4f MakeOrthoMatrix(float xmin, float xmax, float ymin, float ymax, float zNear, float zFar)
+	{
+		float width = xmax - xmin;
+		float height = ymax - ymin;
+		float depthRange = zFar - zNear;
+
+		if (width <= 0 || height <= 0 || depthRange <= 0)
+		{
+			throw std::runtime_error("Invalid dimensions for orthogonal matrix");
+		}
+
+		Matrix4f r;
+
+		// Масштабирование
+		r.m[0] = 2.f / width;
+		r.m[5] = 2.f / height;
+		r.m[10] = -1.f / depthRange;
+
+		// Обнуление неиспользуемых компонентов
+		r.m[1] = r.m[2] = r.m[3] = 0;
+		r.m[4] = r.m[6] = r.m[7] = 0;
+		r.m[8] = r.m[9] = r.m[11] = 0;
+
+		// Трансляция (смещение)
+		r.m[12] = -(xmax + xmin) / width;
+		r.m[13] = -(ymax + ymin) / height;
+		r.m[14] = zNear / depthRange;
+		r.m[15] = 1.f;
+
+		return r;
+	}
+
+	Matrix4f MakePerspectiveMatrix(float fovY, float aspectRatio, float zNear, float zFar)
+	{
+		float tanHalfFovy = tan(fovY / 2.f);
+		Matrix4f r;
+
+		if (zNear >= zFar || aspectRatio == 0)
+		{
+			throw std::runtime_error("Invalid perspective parameters");
+		}
+
+		r.m[0] = 1.f / (aspectRatio * tanHalfFovy);
+		r.m[1] = 0;
+		r.m[2] = 0;
+		r.m[3] = 0;
+
+		r.m[4] = 0;
+		r.m[5] = 1.f / (tanHalfFovy);
+		r.m[6] = 0;
+		r.m[7] = 0;
+
+		r.m[8] = 0;
+		r.m[9] = 0;
+		r.m[10] = -(zFar + zNear) / (zFar - zNear);
+		r.m[11] = -1;
+
+		r.m[12] = 0;
+		r.m[13] = 0;
+		r.m[14] = -(2.f * zFar * zNear) / (zFar - zNear);
+		r.m[15] = 0;
+
+		return r;
+	}
+
+	Matrix3f QuatToMatrix(const Vector4f& q)
+	{
+		Matrix3f m;
+
+		float wx, wy, wz, xx, yy, yz, xy, xz, zz, s, x2, y2, z2;
+
+		s = 2.0f / (q.v[0] * q.v[0] + q.v[1] * q.v[1] + q.v[2] * q.v[2] + q.v[3] * q.v[3]);
+
+
+		x2 = q.v[0] * s;
+		y2 = q.v[1] * s;
+		z2 = q.v[2] * s;
+
+		wx = q.v[3] * x2; wy = q.v[3] * y2; wz = q.v[3] * z2;
+		xx = q.v[0] * x2; xy = q.v[1] * x2; xz = q.v[2] * x2;
+		yy = q.v[1] * y2; yz = q.v[2] * y2;
+		zz = q.v[2] * z2;
+
+		m.m[0] = 1.0f - (yy + zz);
+		m.m[1] = xy + wz;
+		m.m[2] = xz - wy;
+
+		m.m[3] = xy - wz;
+		m.m[4] = 1.0f - (xx + zz);
+		m.m[5] = yz + wx;
+
+		m.m[6] = xz + wy;
+		m.m[7] = yz - wx;
+		m.m[8] = 1.0f - (xx + yy);
+
+		return m;
+
+	}
+
+	Vector4f MatrixToQuat(const Matrix3f& m)
+	{
+		Vector4f r;
+		float trace = m.m[0] + m.m[4] + m.m[8]; 
+
+		if (trace > 0)
+		{
+			float s = 0.5f / sqrtf(trace + 1.0f);
+			r.v[3] = 0.25f / s;
+			r.v[0] = (m.m[5] - m.m[7]) * s;
+			r.v[1] = (m.m[6] - m.m[2]) * s;
+			r.v[2] = (m.m[1] - m.m[3]) * s;
+		}
+		else if (m.m[0] > m.m[4] && m.m[0] > m.m[8])
+		{
+			float s = 2.0f * sqrtf(1.0f + m.m[0] - m.m[4] - m.m[8]);
+			r.v[3] = (m.m[5] - m.m[7]) / s;
+			r.v[0] = 0.25f * s;
+			r.v[1] = (m.m[1] + m.m[3]) / s;
+			r.v[2] = (m.m[6] + m.m[2]) / s;
+		}
+		else if (m.m[4] > m.m[8])
+		{
+			float s = 2.0f * sqrtf(1.0f + m.m[4] - m.m[0] - m.m[8]);
+			r.v[3] = (m.m[6] - m.m[2]) / s;
+			r.v[0] = (m.m[1] + m.m[3]) / s;
+			r.v[1] = 0.25f * s;
+			r.v[2] = (m.m[5] + m.m[7]) / s;
+		}
+		else
+		{
+			float s = 2.0f * sqrtf(1.0f + m.m[8] - m.m[0] - m.m[4]);
+			r.v[3] = (m.m[1] - m.m[3]) / s;
+			r.v[0] = (m.m[6] + m.m[2]) / s;
+			r.v[1] = (m.m[5] + m.m[7]) / s;
+			r.v[2] = 0.25f * s;
+		}
+
+		return r.normalized();
+	}
+
+	Vector4f QuatFromRotateAroundX(float angle)
+	{
+		Vector4f result;
+
+		result.v[0] = sinf(angle * 0.5f);
+		result.v[1] = 0.f;
+		result.v[2] = 0.f;
+		result.v[3] = cosf(angle * 0.5f);
+
+		return result;
+	}
+
+	Vector4f QuatFromRotateAroundY(float angle)
+	{
+		Vector4f result;
+
+		result.v[0] = 0.f;
+		result.v[1] = sinf(angle * 0.5f);
+		result.v[2] = 0.f;
+		result.v[3] = cosf(angle * 0.5f);
+
+		return result;
+	}
+
+	Vector4f QuatFromRotateAroundZ(float angle)
+	{
+		Vector4f result;
+
+		result.v[0] = 0.f;
+		result.v[1] = 0.f;
+		result.v[2] = sinf(angle * 0.5f);
+		result.v[3] = cosf(angle * 0.5f);
+
+		return result;
+	}
+
+	Matrix3f TransposeMatrix(const Matrix3f& m)
+	{
+		Matrix3f r;
+		r.m[0] = m.m[0];
+		r.m[1] = m.m[3];
+		r.m[2] = m.m[6];
+		r.m[3] = m.m[1];
+		r.m[4] = m.m[4];
+		r.m[5] = m.m[7];
+		r.m[6] = m.m[2];
+		r.m[7] = m.m[5];
+		r.m[8] = m.m[8];
+		return r;
+	}
+
+	Matrix3f InverseMatrix(const Matrix3f& m)
+	{
+		float d;
+		Matrix3f r;
+
+		d = m.m[0] * (m.m[4] * m.m[8] - m.m[5] * m.m[7]);
+		d -= m.m[1] * (m.m[3] * m.m[8] - m.m[6] * m.m[5]);
+		d += m.m[2] * (m.m[3] * m.m[7] - m.m[6] * m.m[4]);
+
+		if (fabs(d) < 0.01f)
+		{
+			throw std::runtime_error("Error: matrix cannot be inversed!");
+
+		}
+		else
+		{
+
+			r.m[0] = (m.m[4] * m.m[8] - m.m[5] * m.m[7]) / d;
+			r.m[1] = -(m.m[1] * m.m[8] - m.m[2] * m.m[7]) / d;
+			r.m[2] = (m.m[1] * m.m[5] - m.m[2] * m.m[4]) / d;
+
+			r.m[3] = -(m.m[3] * m.m[8] - m.m[5] * m.m[6]) / d;
+			r.m[4] = (m.m[0] * m.m[8] - m.m[2] * m.m[6]) / d;
+			r.m[5] = -(m.m[0] * m.m[5] - m.m[2] * m.m[3]) / d;
+
+			r.m[6] = (m.m[3] * m.m[7] - m.m[6] * m.m[4]) / d;
+			r.m[7] = -(m.m[0] * m.m[7] - m.m[6] * m.m[1]) / d;
+			r.m[8] = (m.m[0] * m.m[4] - m.m[1] * m.m[3]) / d;
+
+		};
+		return r;
+	}
+
+
+	Matrix4f InverseMatrix(const Matrix4f& mat)
+	{
+		Matrix4f inv;
+		float det;
+
+		inv.m[0] = mat.m[5] * mat.m[10] * mat.m[15] -
+			mat.m[5] * mat.m[11] * mat.m[14] -
+			mat.m[9] * mat.m[6] * mat.m[15] +
+			mat.m[9] * mat.m[7] * mat.m[14] +
+			mat.m[13] * mat.m[6] * mat.m[11] -
+			mat.m[13] * mat.m[7] * mat.m[10];
+
+		inv.m[4] = -mat.m[4] * mat.m[10] * mat.m[15] +
+			mat.m[4] * mat.m[11] * mat.m[14] +
+			mat.m[8] * mat.m[6] * mat.m[15] -
+			mat.m[8] * mat.m[7] * mat.m[14] -
+			mat.m[12] * mat.m[6] * mat.m[11] +
+			mat.m[12] * mat.m[7] * mat.m[10];
+
+		inv.m[8] = mat.m[4] * mat.m[9] * mat.m[15] -
+			mat.m[4] * mat.m[11] * mat.m[13] -
+			mat.m[8] * mat.m[5] * mat.m[15] +
+			mat.m[8] * mat.m[7] * mat.m[13] +
+			mat.m[12] * mat.m[5] * mat.m[11] -
+			mat.m[12] * mat.m[7] * mat.m[9];
+
+		inv.m[12] = -mat.m[4] * mat.m[9] * mat.m[14] +
+			mat.m[4] * mat.m[10] * mat.m[13] +
+			mat.m[8] * mat.m[5] * mat.m[14] -
+			mat.m[8] * mat.m[6] * mat.m[13] -
+			mat.m[12] * mat.m[5] * mat.m[10] +
+			mat.m[12] * mat.m[6] * mat.m[9];
+
+		inv.m[1] = -mat.m[1] * mat.m[10] * mat.m[15] +
+			mat.m[1] * mat.m[11] * mat.m[14] +
+			mat.m[9] * mat.m[2] * mat.m[15] -
+			mat.m[9] * mat.m[3] * mat.m[14] -
+			mat.m[13] * mat.m[2] * mat.m[11] +
+			mat.m[13] * mat.m[3] * mat.m[10];
+
+		inv.m[5] = mat.m[0] * mat.m[10] * mat.m[15] -
+			mat.m[0] * mat.m[11] * mat.m[14] -
+			mat.m[8] * mat.m[2] * mat.m[15] +
+			mat.m[8] * mat.m[3] * mat.m[14] +
+			mat.m[12] * mat.m[2] * mat.m[11] -
+			mat.m[12] * mat.m[3] * mat.m[10];
+
+		inv.m[9] = -mat.m[0] * mat.m[9] * mat.m[15] +
+			mat.m[0] * mat.m[11] * mat.m[13] +
+			mat.m[8] * mat.m[1] * mat.m[15] -
+			mat.m[8] * mat.m[3] * mat.m[13] -
+			mat.m[12] * mat.m[1] * mat.m[11] +
+			mat.m[12] * mat.m[3] * mat.m[9];
+
+		inv.m[13] = mat.m[0] * mat.m[9] * mat.m[14] -
+			mat.m[0] * mat.m[10] * mat.m[13] -
+			mat.m[8] * mat.m[1] * mat.m[14] +
+			mat.m[8] * mat.m[2] * mat.m[13] +
+			mat.m[12] * mat.m[1] * mat.m[10] -
+			mat.m[12] * mat.m[2] * mat.m[9];
+
+		inv.m[2] = mat.m[1] * mat.m[6] * mat.m[15] -
+			mat.m[1] * mat.m[7] * mat.m[14] -
+			mat.m[5] * mat.m[2] * mat.m[15] +
+			mat.m[5] * mat.m[3] * mat.m[14] +
+			mat.m[13] * mat.m[2] * mat.m[7] -
+			mat.m[13] * mat.m[3] * mat.m[6];
+
+		inv.m[6] = -mat.m[0] * mat.m[6] * mat.m[15] +
+			mat.m[0] * mat.m[7] * mat.m[14] +
+			mat.m[4] * mat.m[2] * mat.m[15] -
+			mat.m[4] * mat.m[3] * mat.m[14] -
+			mat.m[12] * mat.m[2] * mat.m[7] +
+			mat.m[12] * mat.m[3] * mat.m[6];
+
+		inv.m[10] = mat.m[0] * mat.m[5] * mat.m[15] -
+			mat.m[0] * mat.m[7] * mat.m[13] -
+			mat.m[4] * mat.m[1] * mat.m[15] +
+			mat.m[4] * mat.m[3] * mat.m[13] +
+			mat.m[12] * mat.m[1] * mat.m[7] -
+			mat.m[12] * mat.m[3] * mat.m[5];
+
+		inv.m[14] = -mat.m[0] * mat.m[5] * mat.m[14] +
+			mat.m[0] * mat.m[6] * mat.m[13] +
+			mat.m[4] * mat.m[1] * mat.m[14] -
+			mat.m[4] * mat.m[2] * mat.m[13] -
+			mat.m[12] * mat.m[1] * mat.m[6] +
+			mat.m[12] * mat.m[2] * mat.m[5];
+
+		inv.m[3] = -mat.m[1] * mat.m[6] * mat.m[11] +
+			mat.m[1] * mat.m[7] * mat.m[10] +
+			mat.m[5] * mat.m[2] * mat.m[11] -
+			mat.m[5] * mat.m[3] * mat.m[10] -
+			mat.m[9] * mat.m[2] * mat.m[7] +
+			mat.m[9] * mat.m[3] * mat.m[6];
+
+		inv.m[7] = mat.m[0] * mat.m[6] * mat.m[11] -
+			mat.m[0] * mat.m[7] * mat.m[10] -
+			mat.m[4] * mat.m[2] * mat.m[11] +
+			mat.m[4] * mat.m[3] * mat.m[10] +
+			mat.m[8] * mat.m[2] * mat.m[7] -
+			mat.m[8] * mat.m[3] * mat.m[6];
+
+		inv.m[11] = -mat.m[0] * mat.m[5] * mat.m[11] +
+			mat.m[0] * mat.m[7] * mat.m[9] +
+			mat.m[4] * mat.m[1] * mat.m[11] -
+			mat.m[4] * mat.m[3] * mat.m[9] -
+			mat.m[8] * mat.m[1] * mat.m[7] +
+			mat.m[8] * mat.m[3] * mat.m[5];
+
+		inv.m[15] = mat.m[0] * mat.m[5] * mat.m[10] -
+			mat.m[0] * mat.m[6] * mat.m[9] -
+			mat.m[4] * mat.m[1] * mat.m[10] +
+			mat.m[4] * mat.m[2] * mat.m[9] +
+			mat.m[8] * mat.m[1] * mat.m[6] -
+			mat.m[8] * mat.m[2] * mat.m[5];
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+		det = mat.m[0] * inv.m[0] + mat.m[1] * inv.m[4] + mat.m[2] * inv.m[8] + mat.m[3] * inv.m[12];
+
+		if (std::fabs(det) < 0.01f)
+		{
+			throw std::runtime_error("Error: matrix cannot be inversed!");
+		}
+
+		// <20><><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+		det = 1.0f / det;
+		for (int i = 0; i < 16; i++)
+		{
+			inv.m[i] *= det;
+		}
+
+		return inv;
+	}
+
+	Matrix3f CreateZRotationMatrix(float angle)
+	{
+		Matrix3f result = Matrix3f::Identity();
+
+		result.m[0] = cosf(angle);
+		result.m[1] = -sinf(angle);
+		result.m[3] = sinf(angle);
+		result.m[4] = cosf(angle);
+
+		return result;
+	}
+
+	Matrix4f MultMatrixMatrix(const Matrix4f& m1, const Matrix4f& m2)
+	{
+		Matrix4f rx;
+
+		rx.m[0] = m1.m[0] * m2.m[0] + m1.m[4] * m2.m[1] + m1.m[8] * m2.m[2] + m1.m[12] * m2.m[3];
+		rx.m[1] = m1.m[1] * m2.m[0] + m1.m[5] * m2.m[1] + m1.m[9] * m2.m[2] + m1.m[13] * m2.m[3];
+		rx.m[2] = m1.m[2] * m2.m[0] + m1.m[6] * m2.m[1] + m1.m[10] * m2.m[2] + m1.m[14] * m2.m[3];
+		rx.m[3] = m1.m[3] * m2.m[0] + m1.m[7] * m2.m[1] + m1.m[11] * m2.m[2] + m1.m[15] * m2.m[3];
+
+		rx.m[4] = m1.m[0] * m2.m[4] + m1.m[4] * m2.m[5] + m1.m[8] * m2.m[6] + m1.m[12] * m2.m[7];
+		rx.m[5] = m1.m[1] * m2.m[4] + m1.m[5] * m2.m[5] + m1.m[9] * m2.m[6] + m1.m[13] * m2.m[7];
+		rx.m[6] = m1.m[2] * m2.m[4] + m1.m[6] * m2.m[5] + m1.m[10] * m2.m[6] + m1.m[14] * m2.m[7];
+		rx.m[7] = m1.m[3] * m2.m[4] + m1.m[7] * m2.m[5] + m1.m[11] * m2.m[6] + m1.m[15] * m2.m[7];
+
+
+		rx.m[8] = m1.m[0] * m2.m[8] + m1.m[4] * m2.m[9] + m1.m[8] * m2.m[10] + m1.m[12] * m2.m[11];
+		rx.m[9] = m1.m[1] * m2.m[8] + m1.m[5] * m2.m[9] + m1.m[9] * m2.m[10] + m1.m[13] * m2.m[11];
+		rx.m[10] = m1.m[2] * m2.m[8] + m1.m[6] * m2.m[9] + m1.m[10] * m2.m[10] + m1.m[14] * m2.m[11];
+		rx.m[11] = m1.m[3] * m2.m[8] + m1.m[7] * m2.m[9] + m1.m[11] * m2.m[10] + m1.m[15] * m2.m[11];
+
+		rx.m[12] = m1.m[0] * m2.m[12] + m1.m[4] * m2.m[13] + m1.m[8] * m2.m[14] + m1.m[12] * m2.m[15];
+		rx.m[13] = m1.m[1] * m2.m[12] + m1.m[5] * m2.m[13] + m1.m[9] * m2.m[14] + m1.m[13] * m2.m[15];
+		rx.m[14] = m1.m[2] * m2.m[12] + m1.m[6] * m2.m[13] + m1.m[10] * m2.m[14] + m1.m[14] * m2.m[15];
+		rx.m[15] = m1.m[3] * m2.m[12] + m1.m[7] * m2.m[13] + m1.m[11] * m2.m[14] + m1.m[15] * m2.m[15];
+
+		return rx;
+	}
+
+	Matrix3f MultMatrixMatrix(const Matrix3f& m1, const Matrix3f& m2)
+	{
+		Matrix3f r;
+
+		r.m[0] = m1.m[0] * m2.m[0] + m1.m[3] * m2.m[1] + m1.m[6] * m2.m[2];
+		r.m[1] = m1.m[1] * m2.m[0] + m1.m[4] * m2.m[1] + m1.m[7] * m2.m[2];
+		r.m[2] = m1.m[2] * m2.m[0] + m1.m[5] * m2.m[1] + m1.m[8] * m2.m[2];
+
+		r.m[3] = m1.m[0] * m2.m[3] + m1.m[3] * m2.m[4] + m1.m[6] * m2.m[5];
+		r.m[4] = m1.m[1] * m2.m[3] + m1.m[4] * m2.m[4] + m1.m[7] * m2.m[5];
+		r.m[5] = m1.m[2] * m2.m[3] + m1.m[5] * m2.m[4] + m1.m[8] * m2.m[5];
+
+		r.m[6] = m1.m[0] * m2.m[6] + m1.m[3] * m2.m[7] + m1.m[6] * m2.m[8] ;
+		r.m[7] = m1.m[1] * m2.m[6] + m1.m[4] * m2.m[7] + m1.m[7] * m2.m[8];
+		r.m[8] = m1.m[2] * m2.m[6] + m1.m[5] * m2.m[7] + m1.m[8] * m2.m[8];
+
+		return r;
+	}
+
+	Matrix3f MakeTranslationMatrix(const Vector3f& p)
+	{
+		Matrix3f r = Matrix3f::Identity();
+
+		r.m[12] = p.v[0];
+		r.m[13] = p.v[1];
+		r.m[14] = p.v[2];
+
+		return r;
+	}
+
+	Matrix3f MakeScaleMatrix(float scale)
+	{
+		Matrix3f r = Matrix3f::Identity();
+
+		r.m[0] = scale;
+		r.m[5] = scale;
+		r.m[10] = scale;
+
+		return r;
+	}
+
+	Matrix3f MakeRotationMatrix(const Vector3f& p)
+	{
+		Matrix3f r = Matrix3f::Identity();
+
+		r.m[12] = p.v[0];
+		r.m[13] = p.v[1];
+		r.m[14] = p.v[2];
+
+		return r;
+	}
+
+	Vector2f operator*(Vector2f v, float scale)
+	{
+		Vector2f r = v;
+
+		r.v[0] = v.v[0] * scale;
+		r.v[1] = v.v[1] * scale;
+
+		return r;
+	}
+
+	Vector3f operator*(Vector3f v, float scale)
+	{
+		Vector3f r = v;
+
+		r.v[0] = v.v[0] * scale;
+		r.v[1] = v.v[1] * scale;
+		r.v[2] = v.v[2] * scale;
+
+		return r;
+	}
+
+	Vector4f operator*(Vector4f v, float scale)
+	{
+		Vector4f r = v;
+
+		r.v[0] = v.v[0] * scale;
+		r.v[1] = v.v[1] * scale;
+		r.v[2] = v.v[2] * scale;
+		r.v[3] = v.v[3] * scale;
+
+		return r;
+	}
+
+	Vector3f MultVectorMatrix(Vector3f v, Matrix3f mt)
+	{
+		Vector3f r;
+
+		r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[1] + v.v[2] * mt.m[2];
+		r.v[1] = v.v[0] * mt.m[3] + v.v[1] * mt.m[4] + v.v[2] * mt.m[5];
+		r.v[2] = v.v[0] * mt.m[6] + v.v[1] * mt.m[7] + v.v[2] * mt.m[8];
+
+		return r;
+	}
+
+	Vector4f MultVectorMatrix(Vector4f v, Matrix4f mt)
+	{
+		Vector4f r;
+
+		r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[1] + v.v[2] * mt.m[2] + v.v[3] * mt.m[3];
+		r.v[1] = v.v[0] * mt.m[4] + v.v[1] * mt.m[5] + v.v[2] * mt.m[6] + v.v[3] * mt.m[7];
+		r.v[2] = v.v[0] * mt.m[8] + v.v[1] * mt.m[9] + v.v[2] * mt.m[10] + v.v[3] * mt.m[11];
+		r.v[3] = v.v[0] * mt.m[12] + v.v[1] * mt.m[13] + v.v[2] * mt.m[14] + v.v[3] * mt.m[15];
+
+		return r;
+	}
+
+	Vector4f MultMatrixVector(Matrix4f mt, Vector4f v)
+	{
+		Vector4f r;
+
+		r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[4] + v.v[2] * mt.m[8] + v.v[3] * mt.m[12];
+		r.v[1] = v.v[0] * mt.m[1] + v.v[1] * mt.m[5] + v.v[2] * mt.m[9] + v.v[3] * mt.m[13];
+		r.v[2] = v.v[0] * mt.m[2] + v.v[1] * mt.m[6] + v.v[2] * mt.m[10] + v.v[3] * mt.m[14];
+		r.v[3] = v.v[0] * mt.m[3] + v.v[1] * mt.m[7] + v.v[2] * mt.m[11] + v.v[3] * mt.m[15];
+
+		return r;
+	}
+
+	Vector3f MultMatrixVector(Matrix3f mt, Vector3f v)
+	{
+		Vector3f r;
+
+		r.v[0] = v.v[0] * mt.m[0] + v.v[1] * mt.m[3] + v.v[2] * mt.m[6];
+		r.v[1] = v.v[0] * mt.m[1] + v.v[1] * mt.m[4] + v.v[2] * mt.m[7];
+		r.v[2] = v.v[0] * mt.m[2] + v.v[1] * mt.m[5] + v.v[2] * mt.m[8];
+
+		return r;
+	}
+
+	Vector4f slerp(const Vector4f& q1, const Vector4f& q2, float t)
+	{
+		const float epsilon = 1e-6f;
+
+		// Нормализация входных кватернионов
+		Vector4f q1_norm = q1.normalized();
+		Vector4f q2_norm = q2.normalized();
+
+		float cosTheta = q1_norm.dot(q2_norm);
+
+		// Если q1 и q2 близки к противоположным направлениям, корректируем q2
+		Vector4f q2_adjusted = q2_norm;
+		if (cosTheta < 0.0f) {
+			q2_adjusted.v[0] = -q2_adjusted.v[0];
+			q2_adjusted.v[1] = -q2_adjusted.v[1];
+			q2_adjusted.v[2] = -q2_adjusted.v[2];
+			q2_adjusted.v[3] = -q2_adjusted.v[3];
+			cosTheta = -cosTheta;
+		}
+
+		// Если кватернионы близки, используем линейную интерполяцию
+		if (cosTheta > 1.0f - epsilon) {
+			Vector4f result;
+
+			result.v[0] = q1_norm.v[0] + t * (q2_adjusted.v[0] - q1_norm.v[0]);
+			result.v[1] = q1_norm.v[1] + t * (q2_adjusted.v[1] - q1_norm.v[1]);
+			result.v[2] = q1_norm.v[2] + t * (q2_adjusted.v[2] - q1_norm.v[2]);
+			result.v[3] = q1_norm.v[3] + t * (q2_adjusted.v[3] - q1_norm.v[3]);
+
+			return result.normalized();
+		}
+
+		// Иначе используем сферическую интерполяцию
+		float theta = std::acos(cosTheta);
+		float sinTheta = std::sin(theta);
+
+		float coeff1 = std::sin((1.0f - t) * theta) / sinTheta;
+		float coeff2 = std::sin(t * theta) / sinTheta;
+
+		Vector4f result;
+
+		result.v[0] = coeff1 * q1_norm.v[0] + coeff2 * q2_adjusted.v[0];
+		result.v[1] = coeff1 * q1_norm.v[1] + coeff2 * q2_adjusted.v[1];
+		result.v[2] = coeff1 * q1_norm.v[2] + coeff2 * q2_adjusted.v[2];
+		result.v[3] = coeff1 * q1_norm.v[3] + coeff2 * q2_adjusted.v[3];
+
+		return result.normalized();
+	}
+
+	Matrix4f MakeMatrix4x4(const Matrix3f& m, const Vector3f pos)
+	{
+		Matrix4f r;
+
+		r.m[0] = m.m[0];
+		r.m[1] = m.m[1];
+		r.m[2] = m.m[2];
+		r.m[3] = 0;
+
+		r.m[4] = m.m[3];
+		r.m[5] = m.m[4];
+		r.m[6] = m.m[5];
+		r.m[7] = 0;
+
+		r.m[8] = m.m[6];
+		r.m[9] = m.m[7];
+		r.m[10] = m.m[8];
+		r.m[11] = 0;
+
+		r.m[12] = pos.v[0];
+		r.m[13] = pos.v[1];
+		r.m[14] = pos.v[2];
+		r.m[15] = 1.0;
+		return r;
+	}
+
+
+};

src/utils/ZLMath.h

@@ -0,0 +1,189 @@
+#pragma once
+
+#include <array>
+#include <exception>
+#include <stdexcept>
+#include <cmath>
+
+namespace ZL {
+
+	struct Vector4f
+	{
+		Vector4f()
+		{
+
+		}
+
+		Vector4f(float x, float y, float z, float t)
+			: v{ x,y,z,t }
+		{
+		}
+
+		std::array<float, 4> v = { 0.f, 0.f, 0.f, 0.f };
+
+		Vector4f normalized() const {
+			double norm = std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2] + v[3] * v[3]);
+			if (norm <= 0.000001f) {
+				return { 0,0, 0, 0};
+			}
+			Vector4f r;
+
+			r.v[0] = v[0] / norm;
+			r.v[1] = v[1] / norm;
+			r.v[2] = v[2] / norm;
+			r.v[3] = v[3] / norm;
+
+			return r;
+		}
+
+		double dot(const Vector4f& other) const {
+			return v[0] * other.v[0] + v[1] * other.v[1] + v[2] * other.v[2] + v[3] * other.v[3];
+		}
+	};
+
+	struct Vector3f
+	{
+		std::array<float, 3> v = { 0.f, 0.f, 0.f };
+
+		Vector3f()
+		{
+		}
+
+		Vector3f(float x, float y, float z)
+			: v{x,y,z}
+		{
+		}
+
+		Vector3f normalized() const {
+			double norm = std::sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
+			if (norm <= 0.000001f) {
+				return { 0,0,0 };
+			}
+			Vector3f r;
+
+			r.v[0] = v[0] / norm;
+			r.v[1] = v[1] / norm;
+			r.v[2] = v[2] / norm;
+
+			return r;
+		}
+
+		float squaredNorm() const {
+			return v[0] * v[0] + v[1] * v[1] + v[2] * v[2];
+		}
+
+		float length() const
+		{
+			return sqrt(squaredNorm());
+		}
+
+		float dot(const Vector3f& other) const {
+			return v[0] * other.v[0] + v[1] * other.v[1] + v[2] * other.v[2];
+		}
+
+		Vector3f cross(const Vector3f& other) const {
+			return Vector3f(
+				v[1] * other.v[2] - v[2] * other.v[1],
+				v[2] * other.v[0] - v[0] * other.v[2],
+				v[0] * other.v[1] - v[1] * other.v[0]
+			);
+		}
+
+		bool operator<(const Vector3f& other) const {
+			if (v[0] != other.v[0]) return v[0] < other.v[0];
+			if (v[1] != other.v[1]) return v[1] < other.v[1];
+			return v[2] < other.v[2];
+		}
+	};
+
+
+
+	struct Vector2f
+	{
+		std::array<float, 2> v = {0.f, 0.f};
+
+		Vector2f()
+		{
+		}
+
+		Vector2f(float x, float y)
+			: v{ x,y }
+		{
+		}
+	};
+
+	Vector2f operator+(const Vector2f& x, const Vector2f& y);
+
+	Vector2f operator-(const Vector2f& x, const Vector2f& y);
+	
+	Vector3f operator+(const Vector3f& x, const Vector3f& y);
+
+	Vector3f operator-(const Vector3f& x, const Vector3f& y);
+	Vector4f operator+(const Vector4f& x, const Vector4f& y);
+
+	Vector4f operator-(const Vector4f& x, const Vector4f& y);
+
+	Vector3f operator-(const Vector3f& x);
+
+
+	struct Matrix3f
+	{
+		std::array<float, 9> m = {	0.f, 0.f, 0.f, 
+									0.f, 0.f, 0.f,
+									0.f, 0.f, 0.f, };
+
+		static Matrix3f Identity();
+	};
+
+	struct Matrix4f
+	{
+		std::array<float, 16> m = { 0.f, 0.f, 0.f, 0.f,
+									0.f, 0.f, 0.f, 0.f,
+									0.f, 0.f, 0.f, 0.f,
+									0.f, 0.f, 0.f, 0.f };
+
+		static Matrix4f Identity();
+
+		float& operator()(int row, int col) {
+			//return m[row * 4 + col]; //OpenGL specific
+			return m[col * 4 + row];
+		}
+
+		const float& operator()(int row, int col) const {
+			//return m[row * 4 + col];
+			return m[col * 4 + row];
+		}
+	};
+
+	Matrix4f operator*(const Matrix4f& m1, const Matrix4f& m2);
+
+	Matrix4f MakeOrthoMatrix(float width, float height, float zNear, float zFar);
+	Matrix4f MakeOrthoMatrix(float xmin, float xmax, float ymin, float ymax, float zNear, float zFar);
+
+	Matrix4f MakePerspectiveMatrix(float fovY, float aspectRatio, float zNear, float zFar);
+
+	Matrix3f QuatToMatrix(const Vector4f& q);
+
+	Vector4f MatrixToQuat(const Matrix3f& m);
+
+	Vector4f QuatFromRotateAroundX(float angle);
+	Vector4f QuatFromRotateAroundY(float angle);
+	Vector4f QuatFromRotateAroundZ(float angle);
+
+	Vector2f operator*(Vector2f v, float scale);
+	Vector3f operator*(Vector3f v, float scale);
+	Vector4f operator*(Vector4f v, float scale);
+
+	Vector3f MultVectorMatrix(Vector3f v, Matrix3f mt);
+	Vector4f MultVectorMatrix(Vector4f v, Matrix4f mt);
+	Vector4f MultMatrixVector(Matrix4f mt, Vector4f v);
+	Vector3f MultMatrixVector(Matrix3f mt, Vector3f v);
+
+	Vector4f slerp(const Vector4f& q1, const Vector4f& q2, float t);
+	Matrix3f InverseMatrix(const Matrix3f& m);
+	Matrix4f InverseMatrix(const Matrix4f& m);
+	Matrix3f MultMatrixMatrix(const Matrix3f& m1, const Matrix3f& m2);
+	Matrix4f MultMatrixMatrix(const Matrix4f& m1, const Matrix4f& m2);
+	Matrix4f MakeMatrix4x4(const Matrix3f& m, const Vector3f pos);
+
+};