graph/src/main.cpp

#include <SDL.h>
#include <SDL_vulkan.h>
#include <iostream>

#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>

#include "renderer.h"
#include "platform.h"
#include "world.h"
#include "mesh.h"

SDL_Window* window = nullptr;

std::vector<const char*> platform::getRequiredExtensions() {
    uint32_t count = 0;
    SDL_Vulkan_GetInstanceExtensions(window, &count, nullptr);

    std::vector<const char*> names(count);
    SDL_Vulkan_GetInstanceExtensions(window, &count, names.data());

    return names;
}

uint32_t platform::getTime() {
    return SDL_GetTicks();
}

int main(int, char*[]) {
    window = SDL_CreateWindow("Graph", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_VULKAN | SDL_WINDOW_RESIZABLE);
    if(!window)
        return -1;

    Renderer* renderer = new Renderer();

    VkSurfaceKHR surface = nullptr;
    SDL_Vulkan_CreateSurface(window, renderer->getInstance(), &surface);

    RenderTarget* target = renderer->createSurfaceRenderTarget(surface);

    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile("suzanne.obj", aiProcess_Triangulate);

    aiMesh* m = scene->mMeshes[0];
    Mesh* mesh = new Mesh();

    for(unsigned int i = 0; i < m->mNumVertices; i++) {
        Vertex vertex;
        vertex.position = glm::vec3(m->mVertices[i].x, m->mVertices[i].y, m->mVertices[i].z);
        vertex.normal = glm::vec3(m->mNormals[i].x, m->mNormals[i].y, m->mNormals[i].z);
        
        mesh->vertices.push_back(vertex);
    }

    for(unsigned int i = 0; i < m->mNumFaces; i++) {
        aiFace face = m->mFaces[i];
        for(unsigned int j = 0; j < face.mNumIndices; j++)
            mesh->indices.push_back(face.mIndices[j]);
    }

    renderer->fillMeshBuffers(mesh);

    World world;
    world.meshes.push_back(mesh);

    bool running = true;
    while(running) {
        SDL_Event event = {};
        while(SDL_PollEvent(&event)) {
            if(event.type == SDL_QUIT)
                running = false;

            if(event.type == SDL_WINDOWEVENT) {
                if(event.window.event == SDL_WINDOWEVENT_RESIZED)
                    target = renderer->createSurfaceRenderTarget(surface, target);
            }
        }

        renderer->render(world, target);
    }

    renderer->destroyMeshBuffers(mesh);

    renderer->destroyRenderTarget(target);

    vkDestroySurfaceKHR(renderer->getInstance(), surface, nullptr);

    delete renderer;

    SDL_DestroyWindow(window);

    return 0;
}