graph/src/main.cpp

#include <SDL.h>
#include <SDL_vulkan.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <json.hpp>
#include <assimp/Importer.hpp>
#include <assimp/scene.h>
#include <assimp/postprocess.h>
#include <imgui.h>

#include "renderer.h"
#include "platform.h"
#include "world.h"
#include "mesh.h"
#include "light.h"
#include "camera.h"
#include "cinematic.h"
#include "material.h"
#include "config.h"

SDL_Window* window = nullptr;
Renderer* renderer = 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 windowX = SDL_WINDOWPOS_CENTERED;
int windowY = SDL_WINDOWPOS_CENTERED;
int windowWidth = 640;
int windowHeight = 480;
int windowFullscreen = 0;
std::string currentGraphicsPreset = "Medium";
GraphicsConfig graphicsConfig;

int toInt(const std::string &str) {
    std::stringstream ss(str);

    int num;
    if((ss >> num).fail())
        return -1;

    return num;
}

void loadGraphicsConfig() {
    Config config;
    if(!config.load("data/graphics_presets.cfg"))
        return;

    graphicsConfig.shadowResolution = toInt(config.get(currentGraphicsPreset.c_str(), "shadowResolution"));
    graphicsConfig.dofDownscale = toInt(config.get(currentGraphicsPreset.c_str(), "dofDownscale"));
}

void readConfig() {
    Config config;
    if(!config.load("user.cfg"))
        return;

    windowX = toInt(config.get("Window", "x"));
    windowY = toInt(config.get("Window", "y"));
    windowWidth = toInt(config.get("Window", "width"));
    windowHeight = toInt(config.get("Window", "height"));
    windowFullscreen = toInt(config.get("Window", "fullscreen"));

    currentGraphicsPreset = config.get("Graphics", "preset");
    graphicsConfig.vsync = toInt(config.get("Graphics", "vsync"));

    loadGraphicsConfig();
}

void writeConfig() {
    Config config;

    config.set("Window", "x", std::to_string(windowX));
    config.set("Window", "y", std::to_string(windowY));
    config.set("Window", "width", std::to_string(windowWidth));
    config.set("Window", "height", std::to_string(windowHeight));
    config.set("Window", "fullscreen", std::to_string(windowFullscreen));

    config.set("Graphics", "preset", currentGraphicsPreset);
    config.set("Graphics", "vsync", std::to_string(graphicsConfig.vsync));

    config.save("user.cfg");
}

Mesh* loadMesh(const char* path) {
    Assimp::Importer importer;
    const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate);

    Mesh* mesh = new Mesh();

    unsigned int indexOffset = 0;
    for(unsigned mi = 0; mi < scene->mNumMeshes; mi++) {
        aiMesh* m = scene->mMeshes[mi];

        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);
            vertex.uv = glm::vec2(m->mTextureCoords[0][i].x, m->mTextureCoords[0][i].y);

            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(indexOffset + face.mIndices[j]);
        }

        indexOffset += m->mNumVertices;
    }

    renderer->fillMeshBuffers(mesh);

    return mesh;
}

std::vector<std::string> tokenize(const std::string& str) {
  size_t lastPos = str.find_first_not_of(',', 0);
  size_t pos = str.find_first_of(',', lastPos);

  std::vector<std::string> tokens;
  while(pos != std::string::npos || lastPos != std::string::npos) {
    tokens.push_back(str.substr(lastPos, pos - lastPos));

    lastPos = str.find_first_not_of(',', pos);
    pos = str.find_first_of(',', lastPos);
  }

  return tokens;
}

Cinematic* loadCinematic(const char* path) {
    std::ifstream file(path);
    if(!file)
        return nullptr;

    nlohmann::json json;
    file >> json;

    auto cinematic = new Cinematic();
    for(auto shotObject : json["shots"]) {
        Shot* shot = new Shot();
        shot->start = shotObject["start"];
        shot->end = shotObject["end"];

        for(auto meshObject : shotObject["meshes"]) {
            Mesh* mesh = loadMesh(meshObject["path"].get<std::string>().c_str());
            mesh->name = meshObject["name"];

            shot->meshes.push_back(mesh);
        }

        for(auto animationObject : shotObject["animations"]) {
            auto animation = new Animation();
            for(auto mesh : shot->meshes) {
                if(mesh->name == animationObject["target"])
                    animation->target = mesh;
            }

            const auto property = animationObject["property"];
            if(property == "position")
                animation->property = AnimationProperty::Position;

            for(auto keyframeObject : animationObject["keyframes"]) {
                Keyframe keyframe;
                keyframe.time = keyframeObject["time"];

                auto tokens = tokenize(keyframeObject["value"]);

                keyframe.value[0] = atof(tokens[0].c_str());
                keyframe.value[1] = atof(tokens[1].c_str());
                keyframe.value[2] = atof(tokens[2].c_str());

                animation->keyframes.push_back(keyframe);
            }

            shot->animations.push_back(animation);
        }

        cinematic->shots.push_back(shot);
    }

    return cinematic;
}

Cinematic* cinematic = nullptr;

int main(int argc, char* argv[]) {
    readConfig();

    bool cinematicMode = false;
    if(argc > 2 && strcmp(argv[1], "--cinematic") == 0)
        cinematicMode = true;

    window = SDL_CreateWindow("Graph",
                              windowX,
                              windowY,
                              windowWidth,
                              windowHeight,
                              SDL_WINDOW_VULKAN |
                              SDL_WINDOW_RESIZABLE);
    if(window == nullptr)
        return -1;

    SDL_SetWindowFullscreen(window, windowFullscreen == 1 ? SDL_WINDOW_FULLSCREEN_DESKTOP : 0);

    ImGui::CreateContext();

    auto& io = ImGui::GetIO();
    io.DisplaySize = ImVec2(windowWidth, windowHeight);

    ImGui::StyleColorsDark();

    renderer = new Renderer(graphicsConfig);

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

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

    World world;

    auto light = new Light();
    light->type = LightType::Directional;
    light->position = glm::vec3(66, 56, 25);

    world.lights.push_back(light);

    Camera camera;
    camera.position = {5.0, 5.0, 5.0};

    if(cinematicMode)
        cinematic = loadCinematic(argv[2]);
    else {
        Material* material = new Material();
        material->albedoTexturePath = "data/tile.jpg";

        renderer->fillMaterialBuffers(material);

        Mesh* mesh = loadMesh("data/scene.obj");
        mesh->material = material;

        world.meshes.push_back(mesh);
    }

    float currentTime = 0.0f, lastTime = 0.0f, animationTime = 0.0f;
    Shot* currentShot = nullptr;

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

            if(event.type == SDL_WINDOWEVENT) {
                if(event.window.event == SDL_WINDOWEVENT_RESIZED) {
                    io.DisplaySize = ImVec2(event.window.data1, event.window.data2);

                    target = renderer->createSurfaceRenderTarget(surface, target);
                }
            }

            if(event.type == SDL_KEYDOWN && event.key.keysym.scancode == SDL_SCANCODE_F11) {
                if(windowFullscreen == 1) {
                    SDL_SetWindowFullscreen(window, 0);
                    windowFullscreen = 0;
                } else {
                    SDL_SetWindowFullscreen(window, SDL_WINDOW_FULLSCREEN_DESKTOP);
                    windowFullscreen = 1;
                }

                target = renderer->createSurfaceRenderTarget(surface, target);
            }

            if(event.type == SDL_KEYDOWN && event.key.keysym.scancode == SDL_SCANCODE_F7) {
                renderer->takeScreenshot("screenshot.ppm", target);
            }
        }

        if(cinematicMode) {
            float endTime = 0.0f;
            for(auto shot : cinematic->shots) {
                if(shot->end > endTime)
                    endTime = shot->end;

                if(animationTime >= shot->start && animationTime < shot->end && currentShot != shot) {
                    if(currentShot != nullptr) {
                        world.meshes.clear();
                    }

                    for(auto mesh : shot->meshes)
                        world.meshes.push_back(mesh);

                    currentShot = shot;
                }
            }

            // we have reached the end of the cinematic
            if(animationTime >= endTime) {
                currentShot = nullptr;

                world.meshes.clear();
            }

            if(currentShot != nullptr) {
                for(auto animation : currentShot->animations) {
                    unsigned int frameIndex = 0;
                    for(size_t i = 0; i < animation->keyframes.size(); i++) {
                        if(animationTime < animation->keyframes[i + 1].time) {
                            frameIndex = i;
                            break;
                        }
                    }

                    const auto currentFrame = animation->keyframes[frameIndex];
                    const auto nextFrame = animation->keyframes[(frameIndex + 1) % animation->keyframes.size()];

                    const float delta = (animationTime - currentFrame.time) / (nextFrame.time - currentFrame.time);

                    glm::vec3 pos = currentFrame.value + delta * (nextFrame.value - currentFrame.value);

                    if(animation->target != nullptr)
                        animation->target->position = pos;
                    else
                        camera.position = pos;
                }
            }
        }

        currentTime = SDL_GetTicks() / 1000.0f;
        const float deltaTime = currentTime - lastTime;
        lastTime = currentTime;

        ImGui::NewFrame();

        io.DeltaTime = deltaTime;

        int mouseX = 0, mouseY = 0;
        const Uint32 mouseButtons = SDL_GetMouseState(&mouseX, &mouseY);
        io.MouseDown[0] = (mouseButtons & SDL_BUTTON(SDL_BUTTON_LEFT)) != 0;
        io.MouseDown[1] = (mouseButtons & SDL_BUTTON(SDL_BUTTON_RIGHT)) != 0;
        io.MouseDown[2] = (mouseButtons & SDL_BUTTON(SDL_BUTTON_MIDDLE)) != 0;

        if(SDL_GetWindowFlags(window) & SDL_WINDOW_INPUT_FOCUS)
            io.MousePos = ImVec2(static_cast<float>(mouseX), static_cast<float>(mouseY));

        ImGui::DragFloat3("Light Position", &world.lights[0]->position[0]);
        ImGui::DragFloat3("Camera Position", &camera.position[0], 0.1f);
        ImGui::DragFloat3("Target", &camera.target[0], 0.1f);
        ImGui::DragFloat("Aperture", &camera.aperture, 0.01f, 0.0f, 1.0f);
        ImGui::DragFloat("Focus Distance", &camera.focusDistance);
        ImGui::Text("dpack[2] = %f", (100 - camera.focusDistance) / 100.0f);

        ImGui::Render();
        renderer->render(world, camera, target);

        if(cinematicMode) {
            animationTime += deltaTime;

            static int frameNum = 0;
            std::string screenshotName = "frame" + std::to_string(frameNum) + ".ppm";
            frameNum++;

            renderer->takeScreenshot(screenshotName.c_str(), target);
        }
    }

    if(cinematic == nullptr) {
        renderer->destroyMaterialBuffers(world.meshes[0]->material);
        delete world.meshes[0]->material;

        renderer->destroyMeshBuffers(world.meshes[0]);
        delete world.meshes[0];
    }

    delete light;

    renderer->destroyRenderTarget(target);

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

    delete renderer;

    writeConfig();

    SDL_DestroyWindow(window);

    return 0;
}