space-game001/Game.cpp

#include "Game.h"
#include "AnimatedModel.h"
#include "BoneAnimatedModel.h"
#include "Utils.h"
#include "OpenGlExtensions.h"
#include <iostream>
#include "TextureManager.h"
#include "TextModel.h"
#include <random>
#include <cmath>

namespace ZL
{
#ifdef EMSCRIPTEN
    const char* CONST_ZIP_FILE = "space-game001.zip";
#else
    const char* CONST_ZIP_FILE = "";
#endif

    Vector4f generateRandomQuaternion(std::mt19937& gen)
    {
        // Ðàñïðåäåëåíèå äëÿ ãåíåðàöèè ñëó÷àéíûõ êîîðäèíàò êâàòåðíèîíà
        std::normal_distribution<> distrib(0.0, 1.0);

        // Ãåíåðèðóåì ÷åòûðå ñëó÷àéíûõ ÷èñëà èç íîðìàëüíîãî ðàñïðåäåëåíèÿ N(0, 1).
        // Íîðìàëèçàöèÿ ýòîãî âåêòîðà äàåò ðàâíîìåðíîå ðàñïðåäåëåíèå ïî 4D-ñôåðå (ò.å. êâàòåðíèîí åäèíè÷íîé äëèíû).
        Vector4f randomQuat = {
            (float)distrib(gen),
            (float)distrib(gen),
            (float)distrib(gen),
            (float)distrib(gen)
        };

        return randomQuat.normalized();
    }


    // --- Îñíîâíàÿ ôóíêöèÿ ãåíåðàöèè ---
    std::vector<BoxCoords> generateRandomBoxCoords(int N)
    {
        // Êîíñòàíòû
        const float MIN_DISTANCE = 3.0f;
        const float MIN_DISTANCE_SQUARED = MIN_DISTANCE * MIN_DISTANCE; // Ðàáîòàåì ñ êâàäðàòîì ðàññòîÿíèÿ
        const float MIN_COORD = -100.0f;
        const float MAX_COORD = 100.0f;
        const int MAX_ATTEMPTS = 1000; // Îãðàíè÷åíèå íà êîëè÷åñòâî ïîïûòîê, ÷òîáû èçáåæàòü áåñêîíå÷íîãî öèêëà

        std::vector<BoxCoords> boxCoordsArr;
        boxCoordsArr.reserve(N); // Ðåçåðâèðóåì ïàìÿòü

        // 1. Èíèöèàëèçàöèÿ ãåíåðàòîðà ïñåâäîñëó÷àéíûõ ÷èñåë
        // Èñïîëüçóåì Mersenne Twister (mt19937) êàê âûñîêîêà÷åñòâåííûé ãåíåðàòîð
        std::random_device rd;
        std::mt19937 gen(rd());

        // 2. Îïðåäåëåíèå ðàâíîìåðíîãî ðàñïðåäåëåíèÿ äëÿ êîîðäèíàò [MIN_COORD, MAX_COORD]
        std::uniform_real_distribution<> distrib(MIN_COORD, MAX_COORD);

        int generatedCount = 0;

        while (generatedCount < N)
        {
            bool accepted = false;
            int attempts = 0;

            // Ïîïûòêà íàéòè ïîäõîäÿùèå êîîðäèíàòû
            while (!accepted && attempts < MAX_ATTEMPTS)
            {
                // Ãåíåðèðóåì íîâûå ñëó÷àéíûå êîîðäèíàòû
                Vector3f newPos(
                    (float)distrib(gen),
                    (float)distrib(gen),
                    (float)distrib(gen)
                );

                // Ïðîâåðêà ðàññòîÿíèÿ äî âñåõ óæå ñóùåñòâóþùèõ îáúåêòîâ
                accepted = true; // Ïðåäïîëàãàåì, ÷òî ïîäõîäèò, ïîêà íå äîêàçàíî îáðàòíîå
                for (const auto& existingBox : boxCoordsArr)
                {
                    // Ðàñ÷åò âåêòîðà ðàçíîñòè
                    Vector3f diff = newPos - existingBox.pos;

                    // Ðàñ÷åò êâàäðàòà ðàññòîÿíèÿ
                    float distanceSquared = diff.squaredNorm();

                    // Åñëè êâàäðàò ðàññòîÿíèÿ ìåíüøå êâàäðàòà ìèíèìàëüíîãî ðàññòîÿíèÿ
                    if (distanceSquared < MIN_DISTANCE_SQUARED)
                    {
                        accepted = false; // Îòêëîíÿåì, ñëèøêîì áëèçêî
                        break;           // Íåò ñìûñëà ïðîâåðÿòü äàëüøå, åñëè îäíî íàðóøåíèå íàéäåíî
                    }
                }

                if (accepted)
                {
                    // 2. Ãåíåðèðóåì ñëó÷àéíûé êâàòåðíèîí
                    Vector4f randomQuat = generateRandomQuaternion(gen);

                    // 3. Ïðåîáðàçóåì åãî â ìàòðèöó âðàùåíèÿ
                    Matrix3f randomMatrix = QuatToMatrix(randomQuat);

                    // 4. Äîáàâëÿåì îáúåêò ñ íîâîé ñëó÷àéíîé ìàòðèöåé
                    boxCoordsArr.emplace_back(BoxCoords{ newPos, randomMatrix });
                    generatedCount++;
                }
                attempts++;
            }

            // Åñëè ïðåâûøåíî ìàêñèìàëüíîå êîëè÷åñòâî ïîïûòîê, âûõîäèì èç öèêëà, 
            // ÷òîáû èçáåæàòü çàâèñàíèÿ, åñëè N ñëèøêîì âåëèêî èëè äèàïàçîí ñëèøêîì ìàë.
            if (!accepted) {
                std::cerr << "Ïðåäóïðåæäåíèå: Íå óäàëîñü ñãåíåðèðîâàòü " << N << " îáúåêòîâ. Ñãåíåðèðîâàíî: " << generatedCount << std::endl;
                break;
            }
        }

        return boxCoordsArr;
    }

Game::Game() 
    : window(nullptr)
    , glContext(nullptr)
    , newTickCount(0)
    , lastTickCount(0)
{
}

Game::~Game() {
    if (glContext) {
        SDL_GL_DeleteContext(glContext);
    }
    if (window) {
        SDL_DestroyWindow(window);
    }
    SDL_Quit();
}

void Game::setup() {   
    glContext = SDL_GL_CreateContext(ZL::Environment::window);

    ZL::BindOpenGlFunctions();
    ZL::CheckGlError();

    // Initialize renderer

#ifdef EMSCRIPTEN
    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("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("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);

#endif
    
    cubemapTexture = std::make_shared<Texture>(
        std::array<TextureDataStruct, 6>{
            CreateTextureDataFromBmp24("./resources/sky/space_rt.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_dn.bmp", CONST_ZIP_FILE),
            CreateTextureDataFromBmp24("./resources/sky/space_bk.bmp", CONST_ZIP_FILE),
            CreateTextureDataFromBmp24("./resources/sky/space_ft.bmp", CONST_ZIP_FILE)
    });

    
    cubemap.data = ZL::CreateCubemap(500);
    cubemap.RefreshVBO();

    //Load texture
    spaceshipTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/DefaultMaterial_BaseColor.png", CONST_ZIP_FILE));
    spaceshipBase = LoadFromTextFile02("./resources/spaceship005.txt", CONST_ZIP_FILE);
    spaceshipBase.RotateByMatrix(QuatToMatrix(QuatFromRotateAroundY(M_PI / 2.0)));
    //spaceshipBase.Move(Vector3f{ -0.52998, -13, 0 });
    spaceshipBase.Move(Vector3f{ -0.52998, -10, 10 });

    spaceship.AssignFrom(spaceshipBase);
    spaceship.RefreshVBO();

    //Boxes
    boxTexture = std::make_unique<Texture>(CreateTextureDataFromPng("./resources/box/box.png", CONST_ZIP_FILE));
    boxBase = LoadFromTextFile02("./resources/box/box.txt", CONST_ZIP_FILE);

    boxCoordsArr = generateRandomBoxCoords(50);

    boxRenderArr.resize(boxCoordsArr.size());

    for (int i = 0; i < boxCoordsArr.size(); i++)
    {
        boxRenderArr[i].AssignFrom(boxBase);
        boxRenderArr[i].RefreshVBO();
    }

    renderer.InitOpenGL();
    
}

void Game::drawCubemap()
{
    static const std::string defaultShaderName = "default";
    static const std::string envShaderName = "env";
    static const std::string vPositionName = "vPosition";
    static const std::string vTexCoordName = "vTexCoord";
    static const std::string textureUniformName = "Texture";

    renderer.shaderManager.PushShader(envShaderName);
    renderer.RenderUniform1i(textureUniformName, 0);
    renderer.EnableVertexAttribArray(vPositionName);
    renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
        static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
        1, 1000);
    renderer.PushMatrix();
    renderer.LoadIdentity();
    renderer.RotateMatrix(Environment::inverseShipMatrix);

    CheckGlError();

    glBindTexture(GL_TEXTURE_CUBE_MAP, cubemapTexture->getTexID());
    renderer.DrawVertexRenderStruct(cubemap);

    CheckGlError();


    renderer.PopMatrix();
    renderer.PopProjectionMatrix();
    renderer.DisableVertexAttribArray(vPositionName);

    renderer.shaderManager.PopShader();
    CheckGlError();
}
void Game::drawShip()
{
    static const std::string defaultShaderName = "default";
    static const std::string envShaderName = "env";
    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);

    renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
        static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
        1, 1000);
    renderer.PushMatrix();

    renderer.LoadIdentity();
    renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });


    glBindTexture(GL_TEXTURE_2D, spaceshipTexture->getTexID());
    renderer.DrawVertexRenderStruct(spaceship);

    renderer.PopMatrix();
    renderer.PopProjectionMatrix();
    renderer.DisableVertexAttribArray(vPositionName);
    renderer.DisableVertexAttribArray(vTexCoordName);

    renderer.shaderManager.PopShader();
    CheckGlError();
}

void Game::drawBoxes()
{
    static const std::string defaultShaderName = "default";
    static const std::string envShaderName = "env";
    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);

    renderer.PushPerspectiveProjectionMatrix(1.0 / 1.5,
        static_cast<float>(Environment::width) / static_cast<float>(Environment::height),
        1, 1000);

    for (int i = 0; i < boxCoordsArr.size(); i++)
    {
        renderer.PushMatrix();

        renderer.LoadIdentity();
        renderer.TranslateMatrix({ 0,0, -1.0f * Environment::zoom });
        renderer.RotateMatrix(Environment::inverseShipMatrix);
        renderer.TranslateMatrix(-Environment::shipPosition);
        renderer.TranslateMatrix(boxCoordsArr[i].pos);
        renderer.RotateMatrix(boxCoordsArr[i].m);
        
        glBindTexture(GL_TEXTURE_2D, boxTexture->getTexID());
        renderer.DrawVertexRenderStruct(boxRenderArr[i]);

        renderer.PopMatrix();
    }
    renderer.PopProjectionMatrix();
    renderer.DisableVertexAttribArray(vPositionName);
    renderer.DisableVertexAttribArray(vTexCoordName);

    renderer.shaderManager.PopShader();
    CheckGlError();
}

void Game::drawScene() {
    static const std::string defaultShaderName = "default";
    static const std::string envShaderName = "env";
    static const std::string vPositionName = "vPosition";
    static const std::string vTexCoordName = "vTexCoord";
    static const std::string textureUniformName = "Texture";

    glClearColor(0.0f, 0.5f, 1.0f, 1.0f);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    
    glViewport(0, 0, Environment::width, Environment::height);

    CheckGlError();

    drawCubemap();
    drawShip();
    drawBoxes();
    
    CheckGlError();
}

void Game::processTickCount() {

    if (lastTickCount == 0) {
        lastTickCount = SDL_GetTicks64();
        return;
    }
    
    newTickCount = SDL_GetTicks64();
    if (newTickCount - lastTickCount > CONST_TIMER_INTERVAL) {
        size_t delta = (newTickCount - lastTickCount > CONST_MAX_TIME_INTERVAL) ? 
            CONST_MAX_TIME_INTERVAL : newTickCount - lastTickCount;
        
        //gameObjects.updateScene(delta);

        if (Environment::tapDownHold) {

            float diffx = Environment::tapDownCurrentPos.v[0] - Environment::tapDownStartPos.v[0];
            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);

                //std::cout << rotationPower << std::endl;

                float deltaAlpha = rotationPower * delta * M_PI / 500000.f;

                Vector3f rotationDirection = { diffy, diffx, 0 };

                rotationDirection = rotationDirection.normalized();

                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);

            }
        }

        if (fabs(Environment::shipVelocity) > 0.01f)
        {
            Vector3f velocityDirection = { 0,0, -Environment::shipVelocity*delta / 1000.f };
            Vector3f velocityDirectionAdjusted = MultMatrixVector(Environment::shipMatrix, velocityDirection);

            Environment::shipPosition = Environment::shipPosition + velocityDirectionAdjusted;
        }

        lastTickCount = newTickCount;
    }
}

void Game::render() {
    SDL_GL_MakeCurrent(ZL::Environment::window, glContext);
    ZL::CheckGlError();

    glClearColor(0.0f, 1.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    drawScene();
    processTickCount();

    SDL_GL_SwapWindow(ZL::Environment::window);
}
void Game::update() {
    SDL_Event event;
    while (SDL_PollEvent(&event)) {
        if (event.type == SDL_QUIT) {
            Environment::exitGameLoop = true;

        }
        else if (event.type == SDL_MOUSEBUTTONDOWN) {
            // 1. Îáðàáîòêà íàæàòèÿ êíîïêè ìûøè
            Environment::tapDownHold = true;
            // Êîîðäèíàòû íà÷àëüíîãî íàæàòèÿ
            Environment::tapDownStartPos.v[0] = event.button.x;
            Environment::tapDownStartPos.v[1] = event.button.y;
            // Íà÷àëüíàÿ ïîçèöèÿ òàêæå ñòàíîâèòñÿ òåêóùåé
            Environment::tapDownCurrentPos.v[0] = event.button.x;
            Environment::tapDownCurrentPos.v[1] = event.button.y;
        }
        else if (event.type == SDL_MOUSEBUTTONUP) {
            // 2. Îáðàáîòêà îòïóñêàíèÿ êíîïêè ìûøè
            Environment::tapDownHold = false;
        }
        else if (event.type == SDL_MOUSEMOTION) {
            // 3. Îáðàáîòêà ïåðåìåùåíèÿ ìûøè
            if (Environment::tapDownHold) {
                // Îáíîâëåíèå òåêóùåé ïîçèöèè, åñëè êíîïêà óäåðæèâàåòñÿ
                Environment::tapDownCurrentPos.v[0] = event.motion.x;
                Environment::tapDownCurrentPos.v[1] = event.motion.y;
            }
        }
        else if (event.type == SDL_MOUSEWHEEL) {
            static const float zoomstep = 2.0f;
            if (event.wheel.y > 0) {
                Environment::zoom -= zoomstep;
            }
            else if (event.wheel.y < 0) {
                Environment::zoom += zoomstep;
            }
            if (Environment::zoom < zoomstep) {
                Environment::zoom = zoomstep;
            }
        }
        else if (event.type == SDL_KEYUP)
        {
            if (event.key.keysym.sym == SDLK_i)
            {
                Environment::shipVelocity += 1.f;
            }
            if (event.key.keysym.sym == SDLK_k)
            {
                Environment::shipVelocity -= 1.f;
            }
        }
    }
    render();
}

}  // namespace ZL