vktutorial/first_app.cpp

#include "first_app.hpp"
#include "simple_render_system.hpp"
#include "rainbow_system.hpp"
#include "gravity_physics_system.hpp"

// libs
#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#include <glm/glm.hpp>
#include <glm/gtc/constants.hpp>

// std
#include <stdexcept>
#include <array>


namespace hk
{
    FirstApp::FirstApp()
    {
        loadGameObjects();
    }

    FirstApp::~FirstApp()
    {
    }

    void FirstApp::runGravitySystem()
    {
        // Gravity Physics System 
        // Create some Models
        std::shared_ptr<Model> squareModel = createSquareModel(m_device, {.5f, .0f});
        std::shared_ptr<Model> circleModel = createCircleModel(m_device, 64);
        // Create Physics Objects
        std::vector<GameObject> physicsObjects{};
        auto red = GameObject::createGameObject();
        red.m_transform2d.scale = glm::vec2{.05f};
        red.m_transform2d.translation = {.5f, .5f};
        red.m_color = {1.f, 0.f, 0.f};
        red.m_rigidBody2d.velocity = {-.5f, .0f};
        red.m_model = circleModel;
        physicsObjects.push_back(std::move(red));
        auto blue = GameObject::createGameObject();
        blue.m_transform2d.scale = glm::vec2{.05f};
        blue.m_transform2d.translation = {-.45f, -.25f};
        blue.m_color = {0.f, 0.f, 1.f};
        blue.m_rigidBody2d.velocity = {.5f, .0f};
        blue.m_model = circleModel;
        physicsObjects.push_back(std::move(blue));

        // Create Vector Field 
        std::vector<GameObject> vectorField{};
        int gridCount = 40;
        for (int i = 0; i < gridCount; i++)
        {
            for(int j = 0; j < gridCount; j ++)
            {
                auto vf = GameObject::createGameObject();
                vf.m_transform2d.scale = glm::vec2{0.005f};
                vf.m_transform2d.translation = {-1.0f + (i + 0.5f) * 2.0f / gridCount, -1.0f + (j + 0.5f) * 2.0f / gridCount};
                vf.m_color = glm::vec3{1.0f};
                vf.m_model = squareModel;
                vectorField.push_back(std::move(vf));
            }
        }

        GravityPhysicsSystem gravitySystem(0.81f);
        Vec2FieldSystem vecFieldSystem{};

        SimpleRenderSystem simpleRenderSystem{m_device, m_renderer.getSwapChainRenderPass()};

        while(!m_window.shouldClose())
        {
            glfwPollEvents();

            if (auto commandBuffer = m_renderer.beginFrame())
            {
                // update system
                gravitySystem.update(physicsObjects, 1.f / 60, 5);
                vecFieldSystem.update(gravitySystem, physicsObjects, vectorField);

                // render system
                m_renderer.beginSwapChainRenderPass(commandBuffer);
                simpleRenderSystem.renderGameObjects(commandBuffer, physicsObjects);
                simpleRenderSystem.renderGameObjects(commandBuffer, vectorField);
                m_renderer.endSwapChainRenderPass(commandBuffer);
                m_renderer.endFrame();
            }

            vkDeviceWaitIdle(m_device.device());
        }
    }

    void FirstApp::run()
    {
        SimpleRenderSystem simpleRenderSystem{m_device, m_renderer.getSwapChainRenderPass()};
        RainbowSystem rainbowSystem(2000.0f);

        while (!m_window.shouldClose())
        {
            glfwPollEvents();
            
            // update objects color
            rainbowSystem.update(5.0f, m_gameObjects);

            if (auto commandBuffer = m_renderer.beginFrame())
            {
                m_renderer.beginSwapChainRenderPass(commandBuffer);
                simpleRenderSystem.renderGameObjects(commandBuffer, m_gameObjects);
                m_renderer.endSwapChainRenderPass(commandBuffer);
                m_renderer.endFrame();
            }
        }

        vkDeviceWaitIdle(m_device.device());
    }

    void FirstApp::loadGameObjects()
    {
        std::vector<Model::Vertex> vertices{
            {{0.0f, -0.5f}, {1.0f, 0.0f, 0.0f}},
            {{0.5f, 0.5f}, {0.0f, 1.0f, 0.0f}},
            {{-0.5f, 0.5f}, {0.0f, 0.0f, 1.0f}}
        };
        auto model = std::make_shared<Model>(m_device, vertices);

        auto triangle = GameObject::createGameObject();
        triangle.m_model = model;
        triangle.m_color = {.1f, .8f, .1f};
        triangle.m_transform2d.translation.x = .2f;
        triangle.m_transform2d.scale = {2.0f, .5f};
        triangle.m_transform2d.rotation = .25f * glm::two_pi<float>();
        
        m_gameObjects.push_back(std::move(triangle));
    }
} // namespace hk