sophia/sandbox/main.cpp

#define GLFW_INCLUDE_VULKAN
#include <GLFW/glfw3.h>
#include <spirv_reflect.h>

#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <sophia/components.hpp>
#include <sophia/scene_registry.hpp>
#include <sophia/scene_view.hpp>
#include <tracy/Tracy.hpp>
#include <vulkan/vulkan.hpp>

#include "renderer/render_context.hpp"
#include "renderer/render_graph.hpp"
#include "renderer/scene_renderer.hpp"
#include "resources/resource_registry.hpp"
#include "vulkan/buffer.hpp"
#include "vulkan/device.hpp"
#include "vulkan/shader.hpp"
#include "window.hpp"

// local includes
#include "material.hpp"

constexpr uint32_t WIDTH = 1280;
constexpr uint32_t HEIGHT = 720;
constexpr const char* NAME = "sandbox";

void immediate_submit(sophia::Device& device,
                      std::function<void(VkCommandBuffer cmd)>&& function) {
  auto command = device.beginSingleTimeCommands();
  function(command);
  device.endSingleTimeCommands(command);
}

void triangle_test() {
  sophia::Window window{WIDTH, HEIGHT, NAME};
  sophia::Device device{&window};
  sophia::RenderContext renderContext{window, device};
  sophia::ResourceRegistry resourceRegistry{device,
                                            renderContext.getImageFormat()};

  sophia::SceneRegistry sceneRegistry;
  sophia::SceneRenderer sceneRenderer{sceneRegistry, resourceRegistry, device,
                                      renderContext.getImageFormat()};

  sophia::SceneHandle sceneHandle = sceneRegistry.create();
  sophia::Scene& scene = sceneRegistry.get(sceneHandle);
  sophia::Entity camera = scene.createCamera();

  // {
  //   auto& transform = camera.getComponent<sophia::TransformComponent>();
  //   transform.position.z += 60;
  // }

  sophia::SceneView view;
  view.scene = sceneHandle;
  view.clearColor = {0.01f, 0.01f, 0.02f, 1.0f};
  view.camera = camera;

  auto vertexShader = sophia::Shader::Builder()
                          .fromGLSL(SANDBOX_SHADER_DIR "/triangle.vert")
                          .setStage(sophia::ShaderStage::VERTEX)
                          .build();
  auto fragmentShader = sophia::Shader::Builder()
                            .fromGLSL(SANDBOX_SHADER_DIR "/triangle.frag")
                            .setStage(sophia::ShaderStage::FRAGMENT)
                            .build();
  vk::Format depthFormat = resourceRegistry.renderTargetPool.getDepthFormat();
  sophia::Material material{device, std::move(vertexShader),
                            std::move(fragmentShader),
                            renderContext.getImageFormat(), depthFormat};

  struct TriangleVertex {
    sophia::vec4 vertex;
    sophia::vec4 color;
  };

  TriangleVertex verticies[] = {
      {{-1.f, 1.f, 0.0f, 0.0f}, {1.0f, 0.0f, 0.0f, 0.0f}},
      {{1.f, 1.f, 0.0f, 0.0f}, {0.0f, 1.0f, 0.0f, 0.0f}},
      {{0.f, -1.f, 0.0f, 0.0f}, {0.0f, 0.0f, 1.0f, 0.0f}}};
  sophia::u32 triangleVerticiesCount = 3;

  sophia::Buffer triangleBuffer{device, sizeof(TriangleVertex),
                                triangleVerticiesCount,
                                vk::BufferUsageFlagBits::eShaderDeviceAddress,
                                vk::MemoryPropertyFlagBits::eHostVisible |
                                    vk::MemoryPropertyFlagBits::eHostCoherent};
  triangleBuffer.map();

  triangleBuffer.writeToBuffer(verticies);

  vk::DeviceAddress address = triangleBuffer.getDeviceAddress();

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

    vk::CommandBuffer commandBuffer = renderContext.beginFrame();
    if (!commandBuffer) {
      continue;
    }

    sceneRenderer.beginFrame(renderContext.getFrameIndex());

    sophia::RenderGraph graph{renderContext.getTracyContext()};
    sophia::ImageRef color = graph.importImage(renderContext.getCurrentImage(),
                                               sophia::Access::Present);
    sophia::ImageRef depth = graph.importImage(
        renderContext.getCurrentDepthImage(), sophia::Access::DepthWrite);

    graph.addPass(
        "sandbox",
        [&](sophia::RenderGraph::PassBuilder& pass) {
          const sophia::vec4& c = view.clearColor;
          pass.writeColor(color, vk::AttachmentLoadOp::eClear,
                          {c.r, c.g, c.b, c.a});
          pass.writeDepth(depth, vk::AttachmentLoadOp::eClear);
        },
        [&](vk::CommandBuffer commandBuffer) {
          ZoneScopedN("main sandbox pass");
          material.bind(commandBuffer);
          sophia::Material::PushConstants push;
          push.data0 = address;

          commandBuffer.pushConstants(
              material.getLayout(), vk::ShaderStageFlagBits::eVertex, 0,
              sizeof(sophia::Material::PushConstants), &push);
          commandBuffer.draw(3, 1, 0, 0);
        });

    /*
    graph.addPass(
      "scene",
      [&](sophia::RenderGraph::PassBuilder& pass) {
        const sophia::vec4& c = view.clearColor;
        pass.writeColor(color, vk::AttachmentLoadOp::eClear,
        {c.r, c.g, c.b, c.a});
        pass.writeDepth(depth, vk::AttachmentLoadOp::eClear);
      },
      [&](vk::CommandBuffer commandBuffer) {
        ZoneScopedN("scene pass");
        sceneRenderer.render(commandBuffer, view, view.camera,
        renderContext.getExtent());
      });
      */

    graph.execute(commandBuffer);

    renderContext.endFrame();
    FrameMark;
  }

  device.waitIdle();
}

int main() {
  {
    using namespace sophia;

    auto shader = Shader::Builder()
                      .fromGLSL(SANDBOX_SHADER_DIR "/shader.comp")
                      .setStage(ShaderStage::VERTEX)
                      .build();

    std::vector<u32> spirv = shader.get()->getSpirv();
    size_t spirv_size = spirv.size() * sizeof(u32);
    void* spirv_code = spirv.data();

    SpvReflectShaderModule module;
    SpvReflectResult result =
        spvReflectCreateShaderModule(spirv_size, spirv_code, &module);
    assert(result == SPV_REFLECT_RESULT_SUCCESS);

    {
      log::print();
      log::info("Reflecting Input Variables");

      uint32_t count = 0;
      result = spvReflectEnumerateInputVariables(&module, &count, NULL);
      assert(result == SPV_REFLECT_RESULT_SUCCESS);
      SpvReflectInterfaceVariable** vars =
          (SpvReflectInterfaceVariable**)malloc(
              count * sizeof(SpvReflectInterfaceVariable*));
      result = spvReflectEnumerateInputVariables(&module, &count, vars);
      assert(result == SPV_REFLECT_RESULT_SUCCESS);

      for (size_t i = 0; i < count; i++) {
        SpvReflectInterfaceVariable* var = vars[i];
        assert(var != nullptr);

        std::cout << "{" << std::endl;
        log::print("\tname: {},", var->name);
        std::cout << "}" << std::endl;
        std::cout << std::endl;
      }
    }

    {
      log::print();
      log::info("Reflecting Output Variables");

      u32 count = 0;
      result = spvReflectEnumerateOutputVariables(&module, &count, NULL);
      assert(result == SPV_REFLECT_RESULT_SUCCESS);

      SpvReflectInterfaceVariable** vars =
          (SpvReflectInterfaceVariable**)malloc(
              count * sizeof(SpvReflectInterfaceVariable*));

      result = spvReflectEnumerateOutputVariables(&module, &count, vars);
      assert(result == SPV_REFLECT_RESULT_SUCCESS);
    }

    spvReflectDestroyShaderModule(&module);
  }

  // triangle_test();
  return EXIT_SUCCESS;
}