CMakeLists.txt

@@ -436,8 +436,6 @@ add_executable(space-game001
     OpenGlExtensions.h
     Utils.cpp
     Utils.h
-    SparkEmitter.cpp
-    SparkEmitter.h
 )
 
 # Установка проекта по умолчанию для Visual Studio

Game.cpp

@@ -1,4 +1,4 @@
-#include "Game.h"
+#include "Game.h"
 #include "AnimatedModel.h"
 #include "BoneAnimatedModel.h"
 #include "Utils.h"
@@ -12,458 +12,445 @@
 namespace ZL
 {
 #ifdef EMSCRIPTEN
-	const char* CONST_ZIP_FILE = "space-game001.zip";
+    const char* CONST_ZIP_FILE = "space-game001.zip";
 #else
-	const char* CONST_ZIP_FILE = "";
+    const char* CONST_ZIP_FILE = "";
 #endif
 
-	Vector4f generateRandomQuaternion(std::mt19937& gen)
+    Vector4f generateRandomQuaternion(std::mt19937& gen)
-	{
+    {
-		// Ðàñïðåäåëåíèå äëÿ ãåíåðàöèè ñëó÷àéíûõ êîîðäèíàò êâàòåðíèîíà
+        // Ðàñïðåäåëåíèå äëÿ ãåíåðàöèè ñëó÷àéíûõ êîîðäèíàò êâàòåðíèîíà
-		std::normal_distribution<> distrib(0.0, 1.0);
+        std::normal_distribution<> distrib(0.0, 1.0);
 
-		// Ãåíåðèðóåì ÷åòûðå ñëó÷àéíûõ ÷èñëà èç íîðìàëüíîãî ðàñïðåäåëåíèÿ N(0, 1).
+        // Ãåíåðèðóåì ÷åòûðå ñëó÷àéíûõ ÷èñëà èç íîðìàëüíîãî ðàñïðåäåëåíèÿ N(0, 1).
-		// Íîðìàëèçàöèÿ ýòîãî âåêòîðà äàåò ðàâíîìåðíîå ðàñïðåäåëåíèå ïî 4D-ñôåðå (ò.å. êâàòåðíèîí åäèíè÷íîé äëèíû).
+        // Íîðìàëèçàöèÿ ýòîãî âåêòîðà äàåò ðàâíîìåðíîå ðàñïðåäåëåíèå ïî 4D-ñôåðå (ò.å. êâàòåðíèîí åäèíè÷íîé äëèíû).
-		Vector4f randomQuat = {
+        Vector4f randomQuat = {
-			(float)distrib(gen),
+            (float)distrib(gen),
-			(float)distrib(gen),
+            (float)distrib(gen),
-			(float)distrib(gen),
+            (float)distrib(gen),
-			(float)distrib(gen)
+            (float)distrib(gen)
-		};
+        };
 
-		return randomQuat.normalized();
+        return randomQuat.normalized();
-	}
+    }
 
 
-	// --- Îñíîâíàÿ ôóíêöèÿ ãåíåðàöèè ---
+    // --- Îñíîâíàÿ ôóíêöèÿ ãåíåðàöèè ---
-	std::vector<BoxCoords> generateRandomBoxCoords(int N)
+    std::vector<BoxCoords> generateRandomBoxCoords(int N)
-	{
+    {
-		// Êîíñòàíòû
+        // Êîíñòàíòû
-		const float MIN_DISTANCE = 3.0f;
+        const float MIN_DISTANCE = 3.0f;
-		const float MIN_DISTANCE_SQUARED = MIN_DISTANCE * MIN_DISTANCE; // Ðàáîòàåì ñ êâàäðàòîì ðàññòîÿíèÿ
+        const float MIN_DISTANCE_SQUARED = MIN_DISTANCE * MIN_DISTANCE; // Ðàáîòàåì ñ êâàäðàòîì ðàññòîÿíèÿ
-		const float MIN_COORD = -100.0f;
+        const float MIN_COORD = -100.0f;
-		const float MAX_COORD = 100.0f;
+        const float MAX_COORD = 100.0f;
-		const int MAX_ATTEMPTS = 1000; // Îãðàíè÷åíèå íà êîëè÷åñòâî ïîïûòîê, ÷òîáû èçáåæàòü áåñêîíå÷íîãî öèêëà
+        const int MAX_ATTEMPTS = 1000; // Îãðàíè÷åíèå íà êîëè÷åñòâî ïîïûòîê, ÷òîáû èçáåæàòü áåñêîíå÷íîãî öèêëà
 
-		std::vector<BoxCoords> boxCoordsArr;
+        std::vector<BoxCoords> boxCoordsArr;
-		boxCoordsArr.reserve(N); // Ðåçåðâèðóåì ïàìÿòü
+        boxCoordsArr.reserve(N); // Ðåçåðâèðóåì ïàìÿòü
 
-		// 1. Èíèöèàëèçàöèÿ ãåíåðàòîðà ïñåâäîñëó÷àéíûõ ÷èñåë
+        // 1. Èíèöèàëèçàöèÿ ãåíåðàòîðà ïñåâäîñëó÷àéíûõ ÷èñåë
-		// Èñïîëüçóåì Mersenne Twister (mt19937) êàê âûñîêîêà÷åñòâåííûé ãåíåðàòîð
+        // Èñïîëüçóåì Mersenne Twister (mt19937) êàê âûñîêîêà÷åñòâåííûé ãåíåðàòîð
-		std::random_device rd;
+        std::random_device rd;
-		std::mt19937 gen(rd());
+        std::mt19937 gen(rd());
 
-		// 2. Îïðåäåëåíèå ðàâíîìåðíîãî ðàñïðåäåëåíèÿ äëÿ êîîðäèíàò [MIN_COORD, MAX_COORD]
+        // 2. Îïðåäåëåíèå ðàâíîìåðíîãî ðàñïðåäåëåíèÿ äëÿ êîîðäèíàò [MIN_COORD, MAX_COORD]
-		std::uniform_real_distribution<> distrib(MIN_COORD, MAX_COORD);
+        std::uniform_real_distribution<> distrib(MIN_COORD, MAX_COORD);
 
-		int generatedCount = 0;
+        int generatedCount = 0;
 
-		while (generatedCount < N)
+        while (generatedCount < N)
-		{
+        {
-			bool accepted = false;
+            bool accepted = false;
-			int attempts = 0;
+            int attempts = 0;
 
-			// Ïîïûòêà íàéòè ïîäõîäÿùèå êîîðäèíàòû
+            // Ïîïûòêà íàéòè ïîäõîäÿùèå êîîðäèíàòû
-			while (!accepted && attempts < MAX_ATTEMPTS)
+            while (!accepted && attempts < MAX_ATTEMPTS)
-			{
+            {
-				// Ãåíåðèðóåì íîâûå ñëó÷àéíûå êîîðäèíàòû
+                // Ãåíåðèðóåì íîâûå ñëó÷àéíûå êîîðäèíàòû
-				Vector3f newPos(
+                Vector3f newPos(
-					(float)distrib(gen),
+                    (float)distrib(gen),
-					(float)distrib(gen),
+                    (float)distrib(gen),
-					(float)distrib(gen)
+                    (float)distrib(gen)
-				);
+                );
 
-				// Ïðîâåðêà ðàññòîÿíèÿ äî âñåõ óæå ñóùåñòâóþùèõ îáúåêòîâ
+                // Ïðîâåðêà ðàññòîÿíèÿ äî âñåõ óæå ñóùåñòâóþùèõ îáúåêòîâ
-				accepted = true; // Ïðåäïîëàãàåì, ÷òî ïîäõîäèò, ïîêà íå äîêàçàíî îáðàòíîå
+                accepted = true; // Ïðåäïîëàãàåì, ÷òî ïîäõîäèò, ïîêà íå äîêàçàíî îáðàòíîå
-				for (const auto& existingBox : boxCoordsArr)
+                for (const auto& existingBox : boxCoordsArr)
-				{
+                {
-					// Ðàñ÷åò âåêòîðà ðàçíîñòè
+                    // Ðàñ÷åò âåêòîðà ðàçíîñòè
-					Vector3f diff = newPos - existingBox.pos;
+                    Vector3f diff = newPos - existingBox.pos;
 
-					// Ðàñ÷åò êâàäðàòà ðàññòîÿíèÿ
+                    // Ðàñ÷åò êâàäðàòà ðàññòîÿíèÿ
-					float distanceSquared = diff.squaredNorm();
+                    float distanceSquared = diff.squaredNorm();
 
-					// Åñëè êâàäðàò ðàññòîÿíèÿ ìåíüøå êâàäðàòà ìèíèìàëüíîãî ðàññòîÿíèÿ
+                    // Åñëè êâàäðàò ðàññòîÿíèÿ ìåíüøå êâàäðàòà ìèíèìàëüíîãî ðàññòîÿíèÿ
-					if (distanceSquared < MIN_DISTANCE_SQUARED)
+                    if (distanceSquared < MIN_DISTANCE_SQUARED)
-					{
+                    {
-						accepted = false; // Îòêëîíÿåì, ñëèøêîì áëèçêî
+                        accepted = false; // Îòêëîíÿåì, ñëèøêîì áëèçêî
-						break;           // Íåò ñìûñëà ïðîâåðÿòü äàëüøå, åñëè îäíî íàðóøåíèå íàéäåíî
+                        break;           // Íåò ñìûñëà ïðîâåðÿòü äàëüøå, åñëè îäíî íàðóøåíèå íàéäåíî
-					}
+                    }
-				}
+                }
 
-				if (accepted)
+                if (accepted)
-				{
+                {
-					// 2. Ãåíåðèðóåì ñëó÷àéíûé êâàòåðíèîí
+                    // 2. Ãåíåðèðóåì ñëó÷àéíûé êâàòåðíèîí
-					Vector4f randomQuat = generateRandomQuaternion(gen);
+                    Vector4f randomQuat = generateRandomQuaternion(gen);
 
-					// 3. Ïðåîáðàçóåì åãî â ìàòðèöó âðàùåíèÿ
+                    // 3. Ïðåîáðàçóåì åãî â ìàòðèöó âðàùåíèÿ
-					Matrix3f randomMatrix = QuatToMatrix(randomQuat);
+                    Matrix3f randomMatrix = QuatToMatrix(randomQuat);
 
-					// 4. Äîáàâëÿåì îáúåêò ñ íîâîé ñëó÷àéíîé ìàòðèöåé
+                    // 4. Äîáàâëÿåì îáúåêò ñ íîâîé ñëó÷àéíîé ìàòðèöåé
-					boxCoordsArr.emplace_back(BoxCoords{ newPos, randomMatrix });
+                    boxCoordsArr.emplace_back(BoxCoords{ newPos, randomMatrix });
-					generatedCount++;
+                    generatedCount++;
-				}
+                }
-				attempts++;
+                attempts++;
-			}
+            }
 
-			// Åñëè ïðåâûøåíî ìàêñèìàëüíîå êîëè÷åñòâî ïîïûòîê, âûõîäèì èç öèêëà, 
+            // Åñëè ïðåâûøåíî ìàêñèìàëüíîå êîëè÷åñòâî ïîïûòîê, âûõîäèì èç öèêëà, 
-			// ÷òîáû èçáåæàòü çàâèñàíèÿ, åñëè N ñëèøêîì âåëèêî èëè äèàïàçîí ñëèøêîì ìàë.
+            // ÷òîáû èçáåæàòü çàâèñàíèÿ, åñëè N ñëèøêîì âåëèêî èëè äèàïàçîí ñëèøêîì ìàë.
-			if (!accepted) {
+            if (!accepted) {
-				std::cerr << "Ïðåäóïðåæäåíèå: Íå óäàëîñü ñãåíåðèðîâàòü " << N << " îáúåêòîâ. Ñãåíåðèðîâàíî: " << generatedCount << std::endl;
+                std::cerr << "Ïðåäóïðåæäåíèå: Íå óäàëîñü ñãåíåðèðîâàòü " << N << " îáúåêòîâ. Ñãåíåðèðîâàíî: " << generatedCount << std::endl;
-				break;
+                break;
-			}
+            }
-		}
+        }
 
-		return boxCoordsArr;
+        return boxCoordsArr;
-	}
+    }
 
-	Game::Game()
+Game::Game() 
-		: window(nullptr)
+    : window(nullptr)
-		, glContext(nullptr)
+    , glContext(nullptr)
-		, newTickCount(0)
+    , newTickCount(0)
-		, lastTickCount(0)
+    , lastTickCount(0)
-	{
+{
-		std::vector<Vector3f> emissionPoints = {
+}
-			Vector3f{-2.1f, 0.9f, 5.0f},
-			Vector3f{2.1f, 0.9f, 5.0f}
-		};
-		sparkEmitter = SparkEmitter(emissionPoints, 100.0f);
-	}
 
-	Game::~Game() {
+Game::~Game() {
-		if (glContext) {
+    if (glContext) {
-			SDL_GL_DeleteContext(glContext);
+        SDL_GL_DeleteContext(glContext);
-		}
+    }
-		if (window) {
+    if (window) {
-			SDL_DestroyWindow(window);
+        SDL_DestroyWindow(window);
-		}
+    }
-		SDL_Quit();
+    SDL_Quit();
-	}
+}
 
-	void Game::setup() {
+void Game::setup() {   
-		glContext = SDL_GL_CreateContext(ZL::Environment::window);
+    glContext = SDL_GL_CreateContext(ZL::Environment::window);
 
-		ZL::BindOpenGlFunctions();
+    ZL::BindOpenGlFunctions();
-		ZL::CheckGlError();
+    ZL::CheckGlError();
 
-		// Initialize renderer
+    // Initialize renderer
 
 #ifdef EMSCRIPTEN
-		renderer.shaderManager.AddShaderFromFiles("default", "./shaders/default.vertex", "./shaders/default_web.fragment", CONST_ZIP_FILE);
+    renderer.shaderManager.AddShaderFromFiles("default", "./shaders/default.vertex", "./shaders/default_web.fragment", CONST_ZIP_FILE);
-		renderer.shaderManager.AddShaderFromFiles("defaultColor", "./shaders/defaultColor.vertex", "./shaders/defaultColor_web.fragment", CONST_ZIP_FILE);
+    renderer.shaderManager.AddShaderFromFiles("defaultColor", "./shaders/defaultColor.vertex", "./shaders/defaultColor_web.fragment", CONST_ZIP_FILE);
-		renderer.shaderManager.AddShaderFromFiles("env", "./shaders/env.vertex", "./shaders/env_web.fragment", CONST_ZIP_FILE);
+    renderer.shaderManager.AddShaderFromFiles("env", "./shaders/env.vertex", "./shaders/env_web.fragment", CONST_ZIP_FILE);
 
 #else
-		renderer.shaderManager.AddShaderFromFiles("default", "./shaders/default.vertex", "./shaders/default_desktop.fragment", CONST_ZIP_FILE);
+    renderer.shaderManager.AddShaderFromFiles("default", "./shaders/default.vertex", "./shaders/default_desktop.fragment", CONST_ZIP_FILE);
-		renderer.shaderManager.AddShaderFromFiles("defaultColor", "./shaders/defaultColor.vertex", "./shaders/defaultColor_desktop.fragment", CONST_ZIP_FILE);
+    renderer.shaderManager.AddShaderFromFiles("defaultColor", "./shaders/defaultColor.vertex", "./shaders/defaultColor_desktop.fragment", CONST_ZIP_FILE);
-		renderer.shaderManager.AddShaderFromFiles("env", "./shaders/env.vertex", "./shaders/env_desktop.fragment", CONST_ZIP_FILE);
+    renderer.shaderManager.AddShaderFromFiles("env", "./shaders/env.vertex", "./shaders/env_desktop.fragment", CONST_ZIP_FILE);
 
 #endif
-
+    
-		cubemapTexture = std::make_shared<Texture>(
+    cubemapTexture = std::make_shared<Texture>(
-			std::array<TextureDataStruct, 6>{
+        std::array<TextureDataStruct, 6>{
-			CreateTextureDataFromBmp24("./resources/sky/space_rt.bmp", CONST_ZIP_FILE),
+            CreateTextureDataFromBmp24("./resources/sky/space_rt.bmp", CONST_ZIP_FILE),
-				CreateTextureDataFromBmp24("./resources/sky/space_lf.bmp", CONST_ZIP_FILE),
+            CreateTextureDataFromBmp24("./resources/sky/space_lf.bmp", CONST_ZIP_FILE),
-				CreateTextureDataFromBmp24("./resources/sky/space_up.bmp", CONST_ZIP_FILE),
+            CreateTextureDataFromBmp24("./resources/sky/space_up.bmp", CONST_ZIP_FILE),
-				CreateTextureDataFromBmp24("./resources/sky/space_dn.bmp", CONST_ZIP_FILE),
+            CreateTextureDataFromBmp24("./resources/sky/space_dn.bmp", CONST_ZIP_FILE),
-				CreateTextureDataFromBmp24("./resources/sky/space_bk.bmp", CONST_ZIP_FILE),
+            CreateTextureDataFromBmp24("./resources/sky/space_bk.bmp", CONST_ZIP_FILE),
-				CreateTextureDataFromBmp24("./resources/sky/space_ft.bmp", CONST_ZIP_FILE)
+            CreateTextureDataFromBmp24("./resources/sky/space_ft.bmp", CONST_ZIP_FILE)
-		});
+    });
-
+
-
+    
-		cubemap.data = ZL::CreateCubemap(500);
+    cubemap.data = ZL::CreateCubemap(500);
-		cubemap.RefreshVBO();
+    cubemap.RefreshVBO();
-
+
-		//Load texture
+    //Load texture
-		spaceshipTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/DefaultMaterial_BaseColor.png", CONST_ZIP_FILE));
+    spaceshipTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/DefaultMaterial_BaseColor.png", CONST_ZIP_FILE));
-		spaceshipBase = LoadFromTextFile02("./resources/spaceship005.txt", CONST_ZIP_FILE);
+    spaceshipBase = LoadFromTextFile02("./resources/spaceship005.txt", CONST_ZIP_FILE);
-		spaceshipBase.RotateByMatrix(QuatToMatrix(QuatFromRotateAroundY(M_PI / 2.0)));
+    spaceshipBase.RotateByMatrix(QuatToMatrix(QuatFromRotateAroundY(M_PI / 2.0)));
-		//spaceshipBase.Move(Vector3f{ -0.52998, -13, 0 });
+    //spaceshipBase.Move(Vector3f{ -0.52998, -13, 0 });
-		spaceshipBase.Move(Vector3f{ -0.52998, -10, 10 });
+    spaceshipBase.Move(Vector3f{ -0.52998, -10, 10 });
-
+
-		spaceship.AssignFrom(spaceshipBase);
+    spaceship.AssignFrom(spaceshipBase);
-		spaceship.RefreshVBO();
+    spaceship.RefreshVBO();
-
+
-		//Boxes
+    //Boxes
-		boxTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/box/box.png", CONST_ZIP_FILE));
+    boxTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/box/box.png", CONST_ZIP_FILE));
-		boxBase = LoadFromTextFile02("./resources/box/box.txt", CONST_ZIP_FILE);
+    boxBase = LoadFromTextFile02("./resources/box/box.txt", CONST_ZIP_FILE);
-
+
-		boxCoordsArr = generateRandomBoxCoords(50);
+    boxCoordsArr = generateRandomBoxCoords(50);
-
+
-		boxRenderArr.resize(boxCoordsArr.size());
+    boxRenderArr.resize(boxCoordsArr.size());
-
+
-		for (int i = 0; i < boxCoordsArr.size(); i++)
+    for (int i = 0; i < boxCoordsArr.size(); i++)
-		{
+    {
-			boxRenderArr[i].AssignFrom(boxBase);
+        boxRenderArr[i].AssignFrom(boxBase);
-			boxRenderArr[i].RefreshVBO();
+        boxRenderArr[i].RefreshVBO();
-		}
+    }
-
+
-		sparkTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/spark.png", CONST_ZIP_FILE));
+    renderer.InitOpenGL();
-
+    
-		sparkEmitter.setTexture(sparkTexture);
+}
-
+
-		renderer.InitOpenGL();
+void Game::drawCubemap()
-
+{
-	}
+    static const std::string defaultShaderName = "default";
-
+    static const std::string envShaderName = "env";
-	void Game::drawCubemap()
+    static const std::string vPositionName = "vPosition";
-	{
+    static const std::string vTexCoordName = "vTexCoord";
-		static const std::string defaultShaderName = "default";
+    static const std::string textureUniformName = "Texture";
-		static const std::string envShaderName = "env";
+
-		static const std::string vPositionName = "vPosition";
+    renderer.shaderManager.PushShader(envShaderName);
-		static const std::string vTexCoordName = "vTexCoord";
+    renderer.RenderUniform1i(textureUniformName, 0);
-		static const std::string textureUniformName = "Texture";
+    renderer.EnableVertexAttribArray(vPositionName);
-
+    renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
-		renderer.shaderManager.PushShader(envShaderName);
+        static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
-		renderer.RenderUniform1i(textureUniformName, 0);
+        1, 1000);
-		renderer.EnableVertexAttribArray(vPositionName);
+    renderer.PushMatrix();
-		renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
+    renderer.LoadIdentity();
-			static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
+    renderer.RotateMatrix(Environment::inverseShipMatrix);
-			1, 1000);
+
-		renderer.PushMatrix();
+    CheckGlError();
-		renderer.LoadIdentity();
+
-		renderer.RotateMatrix(Environment::inverseShipMatrix);
+    glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture->getTexID());
-
+    renderer.DrawVertexRenderStruct(cubemap);
-		CheckGlError();
+
-
+    CheckGlError();
-		glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture->getTexID());
+
-		renderer.DrawVertexRenderStruct(cubemap);
+
-
+    renderer.PopMatrix();
-		CheckGlError();
+    renderer.PopProjectionMatrix();
-
+    renderer.DisableVertexAttribArray(vPositionName);
-
+
-		renderer.PopMatrix();
+    renderer.shaderManager.PopShader();
-		renderer.PopProjectionMatrix();
+    CheckGlError();
-		renderer.DisableVertexAttribArray(vPositionName);
+}
-
+void Game::drawShip()
-		renderer.shaderManager.PopShader();
+{
-		CheckGlError();
+    static const std::string defaultShaderName = "default";
-	}
+    static const std::string envShaderName = "env";
-
+    static const std::string vPositionName = "vPosition";
-	void Game::drawShip()
+    static const std::string vTexCoordName = "vTexCoord";
-	{
+    static const std::string textureUniformName = "Texture";
-		static const std::string defaultShaderName = "default";
+
-		static const std::string envShaderName = "env";
+    renderer.shaderManager.PushShader(defaultShaderName);
-		static const std::string vPositionName = "vPosition";
+    renderer.RenderUniform1i(textureUniformName, 0);
-		static const std::string vTexCoordName = "vTexCoord";
+    renderer.EnableVertexAttribArray(vPositionName);
-		static const std::string textureUniformName = "Texture";
+    renderer.EnableVertexAttribArray(vTexCoordName);
-
+
-		renderer.shaderManager.PushShader(defaultShaderName);
+    renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
-		renderer.RenderUniform1i(textureUniformName, 0);
+        static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
-		renderer.EnableVertexAttribArray(vPositionName);
+        1, 1000);
-		renderer.EnableVertexAttribArray(vTexCoordName);
+    renderer.PushMatrix();
-
+
-		renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
+    renderer.LoadIdentity();
-			static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
+    renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
-			1, 1000);
+
-		renderer.PushMatrix();
+
-
+    glBindTexture(GL_TEXTURE_2D, spaceshipTexture->getTexID());
-		renderer.LoadIdentity();
+    renderer.DrawVertexRenderStruct(spaceship);
-		renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
+
-
+    renderer.PopMatrix();
-
+    renderer.PopProjectionMatrix();
-		glBindTexture(GL_TEXTURE_2D, spaceshipTexture->getTexID());
+    renderer.DisableVertexAttribArray(vPositionName);
-		renderer.DrawVertexRenderStruct(spaceship);
+    renderer.DisableVertexAttribArray(vTexCoordName);
-
+
-		sparkEmitter.draw(renderer, Environment::zoom, Environment::width, Environment::height);
+    renderer.shaderManager.PopShader();
-
+    CheckGlError();
-		renderer.PopMatrix();
+}
-		renderer.PopProjectionMatrix();
+
-		renderer.DisableVertexAttribArray(vPositionName);
+void Game::drawBoxes()
-		renderer.DisableVertexAttribArray(vTexCoordName);
+{
-
+    static const std::string defaultShaderName = "default";
-		renderer.shaderManager.PopShader();
+    static const std::string envShaderName = "env";
-		CheckGlError();
+    static const std::string vPositionName = "vPosition";
-	}
+    static const std::string vTexCoordName = "vTexCoord";
-
+    static const std::string textureUniformName = "Texture";
-	void Game::drawBoxes()
+
-	{
+    renderer.shaderManager.PushShader(defaultShaderName);
-		static const std::string defaultShaderName = "default";
+    renderer.RenderUniform1i(textureUniformName, 0);
-		static const std::string envShaderName = "env";
+    renderer.EnableVertexAttribArray(vPositionName);
-		static const std::string vPositionName = "vPosition";
+    renderer.EnableVertexAttribArray(vTexCoordName);
-		static const std::string vTexCoordName = "vTexCoord";
+
-		static const std::string textureUniformName = "Texture";
+    renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
-
+        static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
-		renderer.shaderManager.PushShader(defaultShaderName);
+        1, 1000);
-		renderer.RenderUniform1i(textureUniformName, 0);
+
-		renderer.EnableVertexAttribArray(vPositionName);
+    for (int i = 0; i < boxCoordsArr.size(); i++)
-		renderer.EnableVertexAttribArray(vTexCoordName);
+    {
-
+        renderer.PushMatrix();
-		renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
+
-			static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
+        renderer.LoadIdentity();
-			1, 1000);
+        renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
-
+        renderer.RotateMatrix(Environment::inverseShipMatrix);
-		for (int i = 0; i < boxCoordsArr.size(); i++)
+        renderer.TranslateMatrix(-Environment::shipPosition);
-		{
+        renderer.TranslateMatrix(boxCoordsArr[i].pos);
-			renderer.PushMatrix();
+        renderer.RotateMatrix(boxCoordsArr[i].m);
-
+        
-			renderer.LoadIdentity();
+        glBindTexture(GL_TEXTURE_2D, boxTexture->getTexID());
-			renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
+        renderer.DrawVertexRenderStruct(boxRenderArr[i]);
-			renderer.RotateMatrix(Environment::inverseShipMatrix);
+
-			renderer.TranslateMatrix(-Environment::shipPosition);
+        renderer.PopMatrix();
-			renderer.TranslateMatrix(boxCoordsArr[i].pos);
+    }
-			renderer.RotateMatrix(boxCoordsArr[i].m);
+    renderer.PopProjectionMatrix();
-
+    renderer.DisableVertexAttribArray(vPositionName);
-			glBindTexture(GL_TEXTURE_2D, boxTexture->getTexID());
+    renderer.DisableVertexAttribArray(vTexCoordName);
-			renderer.DrawVertexRenderStruct(boxRenderArr[i]);
+
-
+    renderer.shaderManager.PopShader();
-			renderer.PopMatrix();
+    CheckGlError();
-		}
+}
-		renderer.PopProjectionMatrix();
+
-		renderer.DisableVertexAttribArray(vPositionName);
+void Game::drawScene() {
-		renderer.DisableVertexAttribArray(vTexCoordName);
+    static const std::string defaultShaderName = "default";
-
+    static const std::string envShaderName = "env";
-		renderer.shaderManager.PopShader();
+    static const std::string vPositionName = "vPosition";
-		CheckGlError();
+    static const std::string vTexCoordName = "vTexCoord";
-	}
+    static const std::string textureUniformName = "Texture";
-
+
-	void Game::drawScene() {
+    glClearColor(0.0f, 0.5f, 1.0f, 1.0f);
-		static const std::string defaultShaderName = "default";
+    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
-		static const std::string envShaderName = "env";
+    
-		static const std::string vPositionName = "vPosition";
+    glViewport(0, 0, Environment::width, Environment::height);
-		static const std::string vTexCoordName = "vTexCoord";
+
-		static const std::string textureUniformName = "Texture";
+    CheckGlError();
-
+
-		glClearColor(0.0f, 0.5f, 1.0f, 1.0f);
+    drawCubemap();
-		glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
+    drawShip();
-
+    drawBoxes();
-		glViewport(0, 0, Environment::width, Environment::height);
+    
-
+    CheckGlError();
-		CheckGlError();
+}
-
+
-		drawCubemap();
+void Game::processTickCount() {
-		drawShip();
+
-		drawBoxes();
+    if (lastTickCount == 0) {
-
+        lastTickCount = SDL_GetTicks64();
-		CheckGlError();
+        return;
-	}
+    }
-
+    
-	void Game::processTickCount() {
+    newTickCount = SDL_GetTicks64();
-
+    if (newTickCount - lastTickCount > CONST_TIMER_INTERVAL) {
-		if (lastTickCount == 0) {
+        size_t delta = (newTickCount - lastTickCount > CONST_MAX_TIME_INTERVAL) ? 
-			lastTickCount = SDL_GetTicks64();
+            CONST_MAX_TIME_INTERVAL : newTickCount - lastTickCount;
-			return;
+        
-		}
+        //gameObjects.updateScene(delta);
-
+
-		newTickCount = SDL_GetTicks64();
+        if (Environment::tapDownHold) {
-		if (newTickCount - lastTickCount > CONST_TIMER_INTERVAL) {
+
-			size_t delta = (newTickCount - lastTickCount > CONST_MAX_TIME_INTERVAL) ?
+            float diffx = Environment::tapDownCurrentPos.v[0] - Environment::tapDownStartPos.v[0];
-				CONST_MAX_TIME_INTERVAL : newTickCount - lastTickCount;
+            float diffy = Environment::tapDownCurrentPos.v[1] - Environment::tapDownStartPos.v[1];
-
+
-			//gameObjects.updateScene(delta);
+           
-			sparkEmitter.update(static_cast<float>(delta));
+            if (abs(diffy) > 5.0 || abs(diffx) > 5.0) //threshold
-
+            {
-			if (Environment::tapDownHold) {
+
-
+                float rotationPower = sqrtf(diffx * diffx + diffy * diffy);
-				float diffx = Environment::tapDownCurrentPos.v[0] - Environment::tapDownStartPos.v[0];
+
-				float diffy = Environment::tapDownCurrentPos.v[1] - Environment::tapDownStartPos.v[1];
+                //std::cout << rotationPower << std::endl;
-
+
-
+                float deltaAlpha = rotationPower * delta * M_PI / 500000.f;
-				if (abs(diffy) > 5.0 || abs(diffx) > 5.0) //threshold
+
-				{
+                Vector3f rotationDirection = { diffy, diffx, 0 };
-
+
-					float rotationPower = sqrtf(diffx * diffx + diffy * diffy);
+                rotationDirection = rotationDirection.normalized();
-
+
-					//std::cout << rotationPower << std::endl;
+                Vector4f rotateQuat = {
-
+                    rotationDirection.v[0] * sin(deltaAlpha * 0.5f),
-					float deltaAlpha = rotationPower * delta * M_PI / 500000.f;
+                    rotationDirection.v[1] * sin(deltaAlpha * 0.5f),
-
+                    rotationDirection.v[2] * sin(deltaAlpha * 0.5f),
-					Vector3f rotationDirection = { diffy, diffx, 0 };
+                    cos(deltaAlpha * 0.5f) };
-
+
-					rotationDirection = rotationDirection.normalized();
+                Matrix3f rotateMat = QuatToMatrix(rotateQuat);
-
+
-					Vector4f rotateQuat = {
+                Environment::shipMatrix = MultMatrixMatrix(Environment::shipMatrix, rotateMat);
-						rotationDirection.v[0] * sin(deltaAlpha * 0.5f),
+                Environment::inverseShipMatrix = InverseMatrix(Environment::shipMatrix);
-						rotationDirection.v[1] * sin(deltaAlpha * 0.5f),
+
-						rotationDirection.v[2] * sin(deltaAlpha * 0.5f),
+            }
-						cos(deltaAlpha * 0.5f) };
+        }
-
+
-					Matrix3f rotateMat = QuatToMatrix(rotateQuat);
+        if (fabs(Environment::shipVelocity) > 0.01f)
-
+        {
-					Environment::shipMatrix = MultMatrixMatrix(Environment::shipMatrix, rotateMat);
+            Vector3f velocityDirection = { 0,0, -Environment::shipVelocity*delta / 1000.f };
-					Environment::inverseShipMatrix = InverseMatrix(Environment::shipMatrix);
+            Vector3f velocityDirectionAdjusted = MultMatrixVector(Environment::shipMatrix, velocityDirection);
-
+
-				}
+            Environment::shipPosition = Environment::shipPosition + velocityDirectionAdjusted;
-			}
+        }
-
+
-			if (fabs(Environment::shipVelocity) > 0.01f)
+        lastTickCount = newTickCount;
-			{
+    }
-				Vector3f velocityDirection = { 0,0, -Environment::shipVelocity * delta / 1000.f };
+}
-				Vector3f velocityDirectionAdjusted = MultMatrixVector(Environment::shipMatrix, velocityDirection);
+
-
+void Game::render() {
-				Environment::shipPosition = Environment::shipPosition + velocityDirectionAdjusted;
+    SDL_GL_MakeCurrent(ZL::Environment::window, glContext);
-			}
+    ZL::CheckGlError();
-
+
-			lastTickCount = newTickCount;
+    glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
-		}
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-	}
+    
-
+    drawScene();
-	void Game::render() {
+    processTickCount();
-		SDL_GL_MakeCurrent(ZL::Environment::window, glContext);
+
-		ZL::CheckGlError();
+    SDL_GL_SwapWindow(ZL::Environment::window);
-
+}
-		glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
+void Game::update() {
-		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    SDL_Event event;
-
+    while (SDL_PollEvent(&event)) {
-		drawScene();
+        if (event.type == SDL_QUIT) {
-		processTickCount();
+            Environment::exitGameLoop = true;
-
+
-		SDL_GL_SwapWindow(ZL::Environment::window);
+        }
-	}
+        else if (event.type == SDL_MOUSEBUTTONDOWN) {
-	void Game::update() {
+            // 1. Îáðàáîòêà íàæàòèÿ êíîïêè ìûøè
-		SDL_Event event;
+            Environment::tapDownHold = true;
-		while (SDL_PollEvent(&event)) {
+            // Êîîðäèíàòû íà÷àëüíîãî íàæàòèÿ
-			if (event.type == SDL_QUIT) {
+            Environment::tapDownStartPos.v[0] = event.button.x;
-				Environment::exitGameLoop = true;
+            Environment::tapDownStartPos.v[1] = event.button.y;
-
+            // Íà÷àëüíàÿ ïîçèöèÿ òàêæå ñòàíîâèòñÿ òåêóùåé
-			}
+            Environment::tapDownCurrentPos.v[0] = event.button.x;
-			else if (event.type == SDL_MOUSEBUTTONDOWN) {
+            Environment::tapDownCurrentPos.v[1] = event.button.y;
-				// 1. Îáðàáîòêà íàæàòèÿ êíîïêè ìûøè
+        }
-				Environment::tapDownHold = true;
+        else if (event.type == SDL_MOUSEBUTTONUP) {
-				// Êîîðäèíàòû íà÷àëüíîãî íàæàòèÿ
+            // 2. Îáðàáîòêà îòïóñêàíèÿ êíîïêè ìûøè
-				Environment::tapDownStartPos.v[0] = event.button.x;
+            Environment::tapDownHold = false;
-				Environment::tapDownStartPos.v[1] = event.button.y;
+        }
-				// Íà÷àëüíàÿ ïîçèöèÿ òàêæå ñòàíîâèòñÿ òåêóùåé
+        else if (event.type == SDL_MOUSEMOTION) {
-				Environment::tapDownCurrentPos.v[0] = event.button.x;
+            // 3. Îáðàáîòêà ïåðåìåùåíèÿ ìûøè
-				Environment::tapDownCurrentPos.v[1] = event.button.y;
+            if (Environment::tapDownHold) {
-			}
+                // Îáíîâëåíèå òåêóùåé ïîçèöèè, åñëè êíîïêà óäåðæèâàåòñÿ
-			else if (event.type == SDL_MOUSEBUTTONUP) {
+                Environment::tapDownCurrentPos.v[0] = event.motion.x;
-				// 2. Îáðàáîòêà îòïóñêàíèÿ êíîïêè ìûøè
+                Environment::tapDownCurrentPos.v[1] = event.motion.y;
-				Environment::tapDownHold = false;
+            }
-			}
+        }
-			else if (event.type == SDL_MOUSEMOTION) {
+        else if (event.type == SDL_MOUSEWHEEL) {
-				// 3. Îáðàáîòêà ïåðåìåùåíèÿ ìûøè
+            static const float zoomstep = 2.0f;
-				if (Environment::tapDownHold) {
+            if (event.wheel.y > 0) {
-					// Îáíîâëåíèå òåêóùåé ïîçèöèè, åñëè êíîïêà óäåðæèâàåòñÿ
+                Environment::zoom -= zoomstep;
-					Environment::tapDownCurrentPos.v[0] = event.motion.x;
+            }
-					Environment::tapDownCurrentPos.v[1] = event.motion.y;
+            else if (event.wheel.y < 0) {
-				}
+                Environment::zoom += zoomstep;
-			}
+            }
-			else if (event.type == SDL_MOUSEWHEEL) {
+            if (Environment::zoom < zoomstep) {
-				static const float zoomstep = 2.0f;
+                Environment::zoom = zoomstep;
-				if (event.wheel.y > 0) {
+            }
-					Environment::zoom -= zoomstep;
+        }
-				}
+        else if (event.type == SDL_KEYUP)
-				else if (event.wheel.y < 0) {
+        {
-					Environment::zoom += zoomstep;
+            if (event.key.keysym.sym == SDLK_i)
-				}
+            {
-				if (Environment::zoom < zoomstep) {
+                Environment::shipVelocity += 1.f;
-					Environment::zoom = zoomstep;
+            }
-				}
+            if (event.key.keysym.sym == SDLK_k)
-			}
+            {
-			else if (event.type == SDL_KEYUP)
+                Environment::shipVelocity -= 1.f;
-			{
+            }
-				if (event.key.keysym.sym == SDLK_i)
+        }
-				{
+    }
-					Environment::shipVelocity += 1.f;
+    render();
-				}
+}
-				if (event.key.keysym.sym == SDLK_k)
-				{
-					Environment::shipVelocity -= 1.f;
-				}
-			}
-		}
-		render();
-	}
 
 }  // namespace ZL

Game.h

@@ -1,64 +1,61 @@
-#pragma once
+#pragma once
 
 #include "OpenGlExtensions.h"
 #include "Renderer.h"
 #include "Environment.h"
 #include "TextureManager.h"
-#include "SparkEmitter.h"
 
 namespace ZL {
 
 
-	struct BoxCoords
+    struct BoxCoords
-	{
+    {
-		Vector3f pos;
+        Vector3f pos;
-		Matrix3f m;
+        Matrix3f m;
-	};
+    };
 
 
-	class Game {
+class Game {
-	public:
+public:
-		Game();
+    Game();
-		~Game();
+    ~Game();
+    
+    void setup();
+    void update();
+    void render();
+    
+    bool shouldExit() const { return Environment::exitGameLoop; }
 
-		void setup();
+private:    
-		void update();
+    void processTickCount();
-		void render();
+    void drawScene();
+    void drawCubemap();
+    void drawShip();
+    void drawBoxes();
 
-		bool shouldExit() const { return Environment::exitGameLoop; }
+    SDL_Window* window;
+    SDL_GLContext glContext;
+    Renderer renderer;
+    
+    size_t newTickCount;
+    size_t lastTickCount;
+    
+    static const size_t CONST_TIMER_INTERVAL = 10;
+    static const size_t CONST_MAX_TIME_INTERVAL = 1000;
 
-	private:
+    std::shared_ptr<Texture> spaceshipTexture;
-		void processTickCount();
+    std::shared_ptr<Texture> cubemapTexture;
-		void drawScene();
+    VertexDataStruct spaceshipBase;
-		void drawCubemap();
+    VertexRenderStruct spaceship;
-		void drawShip();
-		void drawBoxes();
 
-		SDL_Window* window;
+    VertexRenderStruct cubemap;
-		SDL_GLContext glContext;
-		Renderer renderer;
 
-		size_t newTickCount;
+    std::shared_ptr<Texture> boxTexture;
-		size_t lastTickCount;
+    VertexDataStruct boxBase;
 
-		static const size_t CONST_TIMER_INTERVAL = 10;
+    std::vector<BoxCoords> boxCoordsArr;
-		static const size_t CONST_MAX_TIME_INTERVAL = 1000;
+    std::vector<VertexRenderStruct> boxRenderArr;
 
-		std::shared_ptr<Texture> sparkTexture;
+};
-		std::shared_ptr<Texture> spaceshipTexture;
-		std::shared_ptr<Texture> cubemapTexture;
-		VertexDataStruct spaceshipBase;
-		VertexRenderStruct spaceship;
-
-		VertexRenderStruct cubemap;
-
-		std::shared_ptr<Texture> boxTexture;
-		VertexDataStruct boxBase;
-
-		std::vector<BoxCoords> boxCoordsArr;
-		std::vector<VertexRenderStruct> boxRenderArr;
-
-		SparkEmitter sparkEmitter;
-	};
 
 } // namespace ZL

SparkEmitter.cpp

@@ -1,297 +0,0 @@
-#include "SparkEmitter.h"
-#include <random>
-#include <cmath>
-#include "OpenGlExtensions.h"
-
-namespace ZL {
-
-	SparkEmitter::SparkEmitter()
-		: emissionRate(100.0f), isActive(true), drawDataDirty(true), maxParticles(200) {
-		particles.resize(maxParticles);
-		drawPositions.reserve(maxParticles * 6);
-		drawTexCoords.reserve(maxParticles * 6);
-		lastEmissionTime = std::chrono::steady_clock::now();
-
-		sparkQuad.data = VertexDataStruct();
-	}
-
-	SparkEmitter::SparkEmitter(const std::vector<Vector3f>& positions, float rate)
-		: emissionPoints(positions), emissionRate(rate), isActive(true),
-		drawDataDirty(true), maxParticles(positions.size() * 100) {
-		particles.resize(maxParticles);
-		drawPositions.reserve(maxParticles * 6);
-		drawTexCoords.reserve(maxParticles * 6);
-		lastEmissionTime = std::chrono::steady_clock::now();
-
-		sparkQuad.data = VertexDataStruct();
-	}
-
-	SparkEmitter::SparkEmitter(const std::vector<Vector3f>& positions,
-		std::shared_ptr<Texture> tex,
-		float rate)
-		: emissionPoints(positions), texture(tex), emissionRate(rate),
-		isActive(true), drawDataDirty(true), maxParticles(positions.size() * 100) {
-		particles.resize(maxParticles);
-		drawPositions.reserve(maxParticles * 6);
-		drawTexCoords.reserve(maxParticles * 6);
-		lastEmissionTime = std::chrono::steady_clock::now();
-
-		sparkQuad.data = VertexDataStruct();
-	}
-
-	void SparkEmitter::setTexture(std::shared_ptr<Texture> tex) {
-		texture = tex;
-	}
-
-	void SparkEmitter::prepareDrawData() {
-		if (!drawDataDirty) return;
-
-		drawPositions.clear();
-		drawTexCoords.clear();
-
-		if (getActiveParticleCount() == 0) {
-			drawDataDirty = false;
-			return;
-		}
-
-		std::vector<std::pair<const SparkParticle*, float>> sortedParticles;
-		sortedParticles.reserve(getActiveParticleCount());
-
-		for (const auto& particle : particles) {
-			if (particle.active) {
-				sortedParticles.push_back({ &particle, particle.position.v[2] });
-			}
-		}
-
-		std::sort(sortedParticles.begin(), sortedParticles.end(),
-			[](const auto& a, const auto& b) {
-				return a.second > b.second;
-			});
-
-		for (const auto& [particlePtr, depth] : sortedParticles) {
-			const auto& particle = *particlePtr;
-			Vector3f pos = particle.position;
-			float size = 0.04f * particle.scale;
-
-			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.v[0] - size, pos.v[1] + size, pos.v[2] });
-			drawTexCoords.push_back({ 0.0f, 1.0f });
-
-			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.v[0] - size, pos.v[1] - size, pos.v[2] });
-			drawTexCoords.push_back({ 0.0f, 0.0f });
-
-			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.v[0] + size, pos.v[1] - size, pos.v[2] });
-			drawTexCoords.push_back({ 1.0f, 0.0f });
-		}
-
-		drawDataDirty = false;
-	}
-
-	void SparkEmitter::draw(Renderer& renderer, float zoom, int screenWidth, int screenHeight) {
-		if (getActiveParticleCount() == 0) {
-			return;
-		}
-
-		if (!texture) {
-			return;
-		}
-
-		prepareDrawData();
-
-		if (drawPositions.empty()) {
-			return;
-		}
-
-		sparkQuad.data.PositionData = drawPositions;
-		sparkQuad.data.TexCoordData = drawTexCoords;
-		sparkQuad.RefreshVBO();
-
-		static const std::string defaultShaderName = "default";
-		static const std::string vPositionName = "vPosition";
-		static const std::string vTexCoordName = "vTexCoord";
-		static const std::string textureUniformName = "Texture";
-
-		renderer.shaderManager.PushShader(defaultShaderName);
-		renderer.RenderUniform1i(textureUniformName, 0);
-		renderer.EnableVertexAttribArray(vPositionName);
-		renderer.EnableVertexAttribArray(vTexCoordName);
-
-		float aspectRatio = static_cast<float>(screenWidth) / static_cast<float>(screenHeight);
-		renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5, aspectRatio, 1, 1000);
-
-		glBindTexture(GL_TEXTURE_2D, texture->getTexID());
-
-		glEnable(GL_BLEND);
-		glBlendFunc(GL_SRC_ALPHA, GL_ONE);// Аддитивное смешивание для эффекта свечения
-
-		renderer.PushMatrix();
-		renderer.LoadIdentity();
-		renderer.TranslateMatrix({ 0, 0, -1.0f * zoom });
-
-		renderer.DrawVertexRenderStruct(sparkQuad);
-
-		renderer.PopMatrix();
-		renderer.PopProjectionMatrix();
-
-		glDisable(GL_BLEND);
-
-		renderer.DisableVertexAttribArray(vPositionName);
-		renderer.DisableVertexAttribArray(vTexCoordName);
-		renderer.shaderManager.PopShader();
-	}
-
-	void SparkEmitter::update(float deltaTimeMs) {
-		auto currentTime = std::chrono::steady_clock::now();
-		auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
-			currentTime - lastEmissionTime).count();
-
-		if (isActive && elapsed >= emissionRate) {
-			emit();
-			lastEmissionTime = currentTime;
-			drawDataDirty = true;
-		}
-
-		bool anyChanged = false;
-		for (auto& particle : particles) {
-			if (particle.active) {
-				Vector3f oldPosition = particle.position;
-				float oldScale = particle.scale;
-
-				particle.position.v[0] += particle.velocity.v[0] * deltaTimeMs / 1000.0f;
-				particle.position.v[1] += particle.velocity.v[1] * deltaTimeMs / 1000.0f;
-				particle.position.v[2] += particle.velocity.v[2] * deltaTimeMs / 1000.0f;
-
-				particle.lifeTime += deltaTimeMs;
-
-				if (particle.lifeTime >= particle.maxLifeTime) {
-					particle.active = false;
-					anyChanged = true;
-				}
-				else {
-					float lifeRatio = particle.lifeTime / particle.maxLifeTime;
-					particle.scale = 1.0f - lifeRatio * 0.8f;
-
-					if (oldPosition.v[0] != particle.position.v[0] ||
-						oldPosition.v[1] != particle.position.v[1] ||
-						oldPosition.v[2] != particle.position.v[2] ||
-						oldScale != particle.scale) {
-						anyChanged = true;
-					}
-				}
-			}
-		}
-
-		if (anyChanged) {
-			drawDataDirty = true;
-		}
-	}
-
-	void SparkEmitter::emit() {
-		if (emissionPoints.empty()) return;
-		bool emitted = false;
-
-		for (int i = 0; i < emissionPoints.size(); ++i) {
-			bool particleFound = false;
-
-			for (auto& particle : particles) {
-				if (!particle.active) {
-					initParticle(particle, i);
-					particle.active = true;
-					particle.lifeTime = 0;
-					particle.position = emissionPoints[i];
-					particle.emitterIndex = i;
-					particleFound = true;
-					emitted = true;
-					break;
-				}
-			}
-
-			if (!particleFound && !particles.empty()) {
-				size_t oldestIndex = 0;
-				float maxLifeTime = 0;
-
-				for (size_t j = 0; j < particles.size(); ++j) {
-					if (particles[j].lifeTime > maxLifeTime) {
-						maxLifeTime = particles[j].lifeTime;
-						oldestIndex = j;
-					}
-				}
-
-				initParticle(particles[oldestIndex], i);
-				particles[oldestIndex].active = true;
-				particles[oldestIndex].lifeTime = 0;
-				particles[oldestIndex].position = emissionPoints[i];
-				particles[oldestIndex].emitterIndex = i;
-				emitted = true;
-			}
-		}
-
-		if (emitted) {
-			drawDataDirty = true;
-		}
-	}
-
-	void SparkEmitter::setEmissionPoints(const std::vector<Vector3f>& positions) {
-		emissionPoints = positions;
-		maxParticles = positions.size() * 100;
-		particles.resize(maxParticles);
-		drawDataDirty = true;
-	}
-
-	void SparkEmitter::initParticle(SparkParticle& particle, int emitterIndex) {
-		particle.velocity = getRandomVelocity(emitterIndex);
-		particle.scale = 1.0f;
-		particle.maxLifeTime = 800.0f + (rand() % 400);
-		particle.emitterIndex = emitterIndex;
-	}
-
-	Vector3f SparkEmitter::getRandomVelocity(int emitterIndex) {
-		static std::random_device rd;
-		static std::mt19937 gen(rd());
-		static std::uniform_real_distribution<> angleDist(0, 2 * M_PI);
-		static std::uniform_real_distribution<> speedDist(0.5f, 2.0f);
-		static std::uniform_real_distribution<> zSpeedDist(1.0f, 3.0f);
-
-		float angle = angleDist(gen);
-		float speed = speedDist(gen);
-		float zSpeed = zSpeedDist(gen);
-
-		if (emitterIndex == 0) {
-			return Vector3f{
-				cosf(angle) * speed - 0.3f,
-				sinf(angle) * speed,
-				zSpeed
-			};
-		}
-		else {
-			return Vector3f{
-				cosf(angle) * speed + 0.3f,
-				sinf(angle) * speed,
-				zSpeed
-			};
-		}
-	}
-
-	const std::vector<SparkParticle>& SparkEmitter::getParticles() const {
-		return particles;
-	}
-
-	size_t SparkEmitter::getActiveParticleCount() const {
-		size_t count = 0;
-		for (const auto& particle : particles) {
-			if (particle.active) {
-				count++;
-			}
-		}
-		return count;
-	}
-
-} // namespace ZL

SparkEmitter.h

@@ -1,66 +0,0 @@
-#pragma once
-
-#include "ZLMath.h"
-#include "Renderer.h"
-#include "TextureManager.h"
-#include <vector>
-#include <chrono>
-
-namespace ZL {
-
-	struct SparkParticle {
-		Vector3f position;
-		Vector3f velocity;
-		float scale;
-		float lifeTime;
-		float maxLifeTime;
-		bool active;
-		int emitterIndex;
-
-		SparkParticle() : position({ 0,0,0 }), velocity({ 0,0,0 }), scale(1.0f),
-			lifeTime(0), maxLifeTime(1000.0f), active(false), emitterIndex(0) {
-		}
-	};
-
-	class SparkEmitter {
-	private:
-		std::vector<SparkParticle> particles;
-		std::vector<Vector3f> emissionPoints;
-		std::chrono::steady_clock::time_point lastEmissionTime;
-		float emissionRate;
-		bool isActive;
-
-		std::vector<Vector3f> drawPositions;
-		std::vector<Vector2f> drawTexCoords;
-		bool drawDataDirty;
-		VertexRenderStruct sparkQuad;
-		std::shared_ptr<Texture> texture;
-
-		int maxParticles;
-
-		void prepareDrawData();
-
-	public:
-		SparkEmitter();
-		SparkEmitter(const std::vector<Vector3f>& positions, float rate = 100.0f);
-		SparkEmitter(const std::vector<Vector3f>& positions,
-			std::shared_ptr<Texture> tex,
-			float rate = 100.0f);
-
-		void setEmissionPoints(const std::vector<Vector3f>& positions);
-		void setTexture(std::shared_ptr<Texture> tex);
-
-		void update(float deltaTimeMs);
-		void emit();
-
-		void draw(Renderer& renderer, float zoom, int screenWidth, int screenHeight);
-
-		const std::vector<SparkParticle>& getParticles() const;
-		size_t getActiveParticleCount() const;
-
-	private:
-		void initParticle(SparkParticle& particle, int emitterIndex);
-		Vector3f getRandomVelocity(int emitterIndex);
-	};
-
-} // namespace ZL

shaders/default_desktop.fragment

@@ -5,8 +5,8 @@ varying vec2 texCoord;
 void main() 
 {
 	vec4 color = texture2D(Texture,texCoord).rgba;
-    //gl_FragColor = vec4(color.rgb*0.9 + vec3(0.1, 0.1, 0.1), 1.0);
+    gl_FragColor = vec4(color.rgb*0.9 + vec3(0.1, 0.1, 0.1), 1.0);
 	
-	gl_FragColor = color;
+	//gl_FragColor = color;
 	
 }