From 2a1aeb65d359591804e1e6082c19a786401d144b Mon Sep 17 00:00:00 2001
From: Tobias Frisch <tfrisch@uni-koblenz.de>
Date: Fri, 9 Jul 2021 12:10:53 +0200
Subject: [PATCH] [#56] Removed cmd_sync_test sources
Signed-off-by: Tobias Frisch <tfrisch@uni-koblenz.de>
---
projects/cmd_sync_test/src/main.cpp | 317 ----------------------------
1 file changed, 317 deletions(-)
delete mode 100644 projects/cmd_sync_test/src/main.cpp
diff --git a/projects/cmd_sync_test/src/main.cpp b/projects/cmd_sync_test/src/main.cpp
deleted file mode 100644
index 6e53eb8c..00000000
--- a/projects/cmd_sync_test/src/main.cpp
+++ /dev/null
@@ -1,317 +0,0 @@
-#include <iostream>
-#include <vkcv/Core.hpp>
-#include <GLFW/glfw3.h>
-#include <vkcv/camera/CameraManager.hpp>
-#include <chrono>
-#include <vkcv/asset/asset_loader.hpp>
-
-int main(int argc, const char** argv) {
- const char* applicationName = "First Mesh";
-
- uint32_t windowWidth = 800;
- uint32_t windowHeight = 600;
-
- vkcv::Window window = vkcv::Window::create(
- applicationName,
- windowWidth,
- windowHeight,
- true
- );
-
- vkcv::camera::CameraManager cameraManager(window);
- uint32_t camIndex = cameraManager.addCamera(vkcv::camera::ControllerType::PILOT);
- uint32_t camIndex2 = cameraManager.addCamera(vkcv::camera::ControllerType::TRACKBALL);
-
- cameraManager.getCamera(camIndex).setPosition(glm::vec3(0.f, 0.f, 3.f));
- cameraManager.getCamera(camIndex).setNearFar(0.1f, 30.0f);
- cameraManager.getCamera(camIndex).setYaw(180.0f);
-
- cameraManager.getCamera(camIndex2).setNearFar(0.1f, 30.0f);
-
- window.initEvents();
-
- vkcv::Core core = vkcv::Core::create(
- window,
- applicationName,
- VK_MAKE_VERSION(0, 0, 1),
- { vk::QueueFlagBits::eTransfer,vk::QueueFlagBits::eGraphics, vk::QueueFlagBits::eCompute },
- {},
- { "VK_KHR_swapchain" }
- );
-
- vkcv::asset::Scene mesh;
-
- const char* path = argc > 1 ? argv[1] : "resources/cube/cube.gltf";
- int result = vkcv::asset::loadScene(path, mesh);
-
- if (result == 1) {
- std::cout << "Mesh loading successful!" << std::endl;
- }
- else {
- std::cout << "Mesh loading failed: " << result << std::endl;
- return 1;
- }
-
- assert(mesh.vertexGroups.size() > 0);
- auto vertexBuffer = core.createBuffer<uint8_t>(
- vkcv::BufferType::VERTEX,
- mesh.vertexGroups[0].vertexBuffer.data.size(),
- vkcv::BufferMemoryType::DEVICE_LOCAL
- );
-
- vertexBuffer.fill(mesh.vertexGroups[0].vertexBuffer.data);
-
- auto indexBuffer = core.createBuffer<uint8_t>(
- vkcv::BufferType::INDEX,
- mesh.vertexGroups[0].indexBuffer.data.size(),
- vkcv::BufferMemoryType::DEVICE_LOCAL
- );
-
- indexBuffer.fill(mesh.vertexGroups[0].indexBuffer.data);
-
- auto& attributes = mesh.vertexGroups[0].vertexBuffer.attributes;
-
- std::sort(attributes.begin(), attributes.end(), [](const vkcv::asset::VertexAttribute& x, const vkcv::asset::VertexAttribute& y) {
- return static_cast<uint32_t>(x.type) < static_cast<uint32_t>(y.type);
- });
-
- const std::vector<vkcv::VertexBufferBinding> vertexBufferBindings = {
- vkcv::VertexBufferBinding(attributes[0].offset, vertexBuffer.getVulkanHandle()),
- vkcv::VertexBufferBinding(attributes[1].offset, vertexBuffer.getVulkanHandle()),
- vkcv::VertexBufferBinding(attributes[2].offset, vertexBuffer.getVulkanHandle()) };
-
- const vkcv::Mesh loadedMesh(vertexBufferBindings, indexBuffer.getVulkanHandle(), mesh.vertexGroups[0].numIndices);
-
- // an example attachment for passes that output to the window
- const vkcv::AttachmentDescription present_color_attachment(
- vkcv::AttachmentOperation::STORE,
- vkcv::AttachmentOperation::CLEAR,
- core.getSwapchain().getFormat()
- );
-
- const vkcv::AttachmentDescription depth_attachment(
- vkcv::AttachmentOperation::STORE,
- vkcv::AttachmentOperation::CLEAR,
- vk::Format::eD32Sfloat
- );
-
- vkcv::PassConfig firstMeshPassDefinition({ present_color_attachment, depth_attachment });
- vkcv::PassHandle firstMeshPass = core.createPass(firstMeshPassDefinition);
-
- if (!firstMeshPass) {
- std::cout << "Error. Could not create renderpass. Exiting." << std::endl;
- return EXIT_FAILURE;
- }
-
- vkcv::ShaderProgram firstMeshProgram{};
- firstMeshProgram.addShader(vkcv::ShaderStage::VERTEX, std::filesystem::path("resources/shaders/vert.spv"));
- firstMeshProgram.addShader(vkcv::ShaderStage::FRAGMENT, std::filesystem::path("resources/shaders/frag.spv"));
-
- const std::vector<vkcv::VertexAttachment> vertexAttachments = firstMeshProgram.getVertexAttachments();
-
- std::vector<vkcv::VertexBinding> bindings;
- for (size_t i = 0; i < vertexAttachments.size(); i++) {
- bindings.push_back(vkcv::VertexBinding(i, { vertexAttachments[i] }));
- }
-
- const vkcv::VertexLayout firstMeshLayout (bindings);
-
- std::vector<vkcv::DescriptorBinding> descriptorBindings = { firstMeshProgram.getReflectedDescriptors()[0] };
- vkcv::DescriptorSetHandle descriptorSet = core.createDescriptorSet(descriptorBindings);
-
- const vkcv::PipelineConfig firstMeshPipelineConfig {
- firstMeshProgram,
- windowWidth,
- windowHeight,
- firstMeshPass,
- firstMeshLayout,
- { core.getDescriptorSet(descriptorSet).layout },
- true
- };
-
- vkcv::PipelineHandle firstMeshPipeline = core.createGraphicsPipeline(firstMeshPipelineConfig);
-
- if (!firstMeshPipeline) {
- std::cout << "Error. Could not create graphics pipeline. Exiting." << std::endl;
- return EXIT_FAILURE;
- }
-
- //vkcv::Image texture = core.createImage(vk::Format::eR8G8B8A8Srgb, mesh.texture_hack.w, mesh.texture_hack.h);
- //texture.fill(mesh.texture_hack.img);
- vkcv::asset::Texture &tex = mesh.textures[0];
- vkcv::Image texture = core.createImage(vk::Format::eR8G8B8A8Srgb, tex.w, tex.h);
- texture.fill(tex.data.data());
-
- vkcv::SamplerHandle sampler = core.createSampler(
- vkcv::SamplerFilterType::LINEAR,
- vkcv::SamplerFilterType::LINEAR,
- vkcv::SamplerMipmapMode::LINEAR,
- vkcv::SamplerAddressMode::REPEAT
- );
-
- vkcv::SamplerHandle shadowSampler = core.createSampler(
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerFilterType::NEAREST,
- vkcv::SamplerMipmapMode::NEAREST,
- vkcv::SamplerAddressMode::CLAMP_TO_EDGE
- );
-
- vkcv::ImageHandle depthBuffer = core.createImage(vk::Format::eD32Sfloat, windowWidth, windowHeight).getHandle();
-
- const vkcv::ImageHandle swapchainInput = vkcv::ImageHandle::createSwapchainImageHandle();
-
- const vkcv::DescriptorSetUsage descriptorUsage(0, core.getDescriptorSet(descriptorSet).vulkanHandle);
-
- const std::vector<glm::vec3> instancePositions = {
- glm::vec3( 0.f, -2.f, 0.f),
- glm::vec3( 3.f, 0.f, 0.f),
- glm::vec3(-3.f, 0.f, 0.f),
- glm::vec3( 0.f, 2.f, 0.f),
- glm::vec3( 0.f, -5.f, 0.f)
- };
-
- std::vector<glm::mat4> modelMatrices;
- std::vector<vkcv::DrawcallInfo> drawcalls;
- std::vector<vkcv::DrawcallInfo> shadowDrawcalls;
- for (const auto& position : instancePositions) {
- modelMatrices.push_back(glm::translate(glm::mat4(1.f), position));
- drawcalls.push_back(vkcv::DrawcallInfo(loadedMesh, { descriptorUsage },1));
- shadowDrawcalls.push_back(vkcv::DrawcallInfo(loadedMesh, {},1));
- }
-
- modelMatrices.back() *= glm::scale(glm::mat4(1.f), glm::vec3(10.f, 1.f, 10.f));
-
- std::vector<std::array<glm::mat4, 2>> mainPassMatrices;
- std::vector<glm::mat4> mvpLight;
-
- vkcv::ShaderProgram shadowShader;
- shadowShader.addShader(vkcv::ShaderStage::VERTEX, "resources/shaders/shadow_vert.spv");
- shadowShader.addShader(vkcv::ShaderStage::FRAGMENT, "resources/shaders/shadow_frag.spv");
-
- const vk::Format shadowMapFormat = vk::Format::eD16Unorm;
- const std::vector<vkcv::AttachmentDescription> shadowAttachments = {
- vkcv::AttachmentDescription(vkcv::AttachmentOperation::STORE, vkcv::AttachmentOperation::CLEAR, shadowMapFormat)
- };
- const vkcv::PassConfig shadowPassConfig(shadowAttachments);
- const vkcv::PassHandle shadowPass = core.createPass(shadowPassConfig);
-
- const uint32_t shadowMapResolution = 1024;
- const vkcv::Image shadowMap = core.createImage(shadowMapFormat, shadowMapResolution, shadowMapResolution, 1);
- const vkcv::PipelineConfig shadowPipeConfig {
- shadowShader,
- shadowMapResolution,
- shadowMapResolution,
- shadowPass,
- firstMeshLayout,
- {},
- false
- };
-
- const vkcv::PipelineHandle shadowPipe = core.createGraphicsPipeline(shadowPipeConfig);
-
- struct LightInfo {
- glm::vec3 direction;
- float padding;
- glm::mat4 lightMatrix;
- };
- LightInfo lightInfo;
- vkcv::Buffer lightBuffer = core.createBuffer<LightInfo>(vkcv::BufferType::UNIFORM, sizeof(glm::vec3));
-
- vkcv::DescriptorWrites setWrites;
- setWrites.sampledImageWrites = {
- vkcv::SampledImageDescriptorWrite(0, texture.getHandle()),
- vkcv::SampledImageDescriptorWrite(3, shadowMap.getHandle()) };
- setWrites.samplerWrites = {
- vkcv::SamplerDescriptorWrite(1, sampler),
- vkcv::SamplerDescriptorWrite(4, shadowSampler) };
- setWrites.uniformBufferWrites = { vkcv::UniformBufferDescriptorWrite(2, lightBuffer.getHandle()) };
- core.writeDescriptorSet(descriptorSet, setWrites);
-
- auto start = std::chrono::system_clock::now();
- const auto appStartTime = start;
- while (window.isWindowOpen()) {
- window.pollEvents();
-
- uint32_t swapchainWidth, swapchainHeight;
- if (!core.beginFrame(swapchainWidth, swapchainHeight)) {
- continue;
- }
-
- if ((swapchainWidth != windowWidth) || ((swapchainHeight != windowHeight))) {
- depthBuffer = core.createImage(vk::Format::eD32Sfloat, swapchainWidth, swapchainHeight).getHandle();
-
- windowWidth = swapchainWidth;
- windowHeight = swapchainHeight;
- }
-
- auto end = std::chrono::system_clock::now();
- auto deltatime = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
-
- start = end;
- cameraManager.update(0.000001 * static_cast<double>(deltatime.count()));
-
- auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - appStartTime);
-
- const float sunTheta = 0.001f * static_cast<float>(duration.count());
- lightInfo.direction = glm::normalize(glm::vec3(std::cos(sunTheta), 1, std::sin(sunTheta)));
-
- const float shadowProjectionSize = 5.f;
- glm::mat4 projectionLight = glm::ortho(
- -shadowProjectionSize,
- shadowProjectionSize,
- -shadowProjectionSize,
- shadowProjectionSize,
- -shadowProjectionSize,
- shadowProjectionSize);
-
- glm::mat4 vulkanCorrectionMatrix(1.f);
- vulkanCorrectionMatrix[2][2] = 0.5;
- vulkanCorrectionMatrix[3][2] = 0.5;
- projectionLight = vulkanCorrectionMatrix * projectionLight;
-
- const glm::mat4 viewLight = glm::lookAt(glm::vec3(0), -lightInfo.direction, glm::vec3(0, -1, 0));
-
- lightInfo.lightMatrix = projectionLight * viewLight;
- lightBuffer.fill({ lightInfo });
-
- const glm::mat4 viewProjectionCamera = cameraManager.getActiveCamera().getMVP();
-
- mainPassMatrices.clear();
- mvpLight.clear();
- for (const auto& m : modelMatrices) {
- mainPassMatrices.push_back({ viewProjectionCamera * m, m });
- mvpLight.push_back(lightInfo.lightMatrix* m);
- }
-
- vkcv::PushConstantData pushConstantData((void*)mainPassMatrices.data(), 2 * sizeof(glm::mat4));
- const std::vector<vkcv::ImageHandle> renderTargets = { swapchainInput, depthBuffer };
-
- vkcv::PushConstantData shadowPushConstantData((void*)mvpLight.data(), sizeof(glm::mat4));
-
- auto cmdStream = core.createCommandStream(vkcv::QueueType::Graphics);
-
- core.recordDrawcallsToCmdStream(
- cmdStream,
- shadowPass,
- shadowPipe,
- shadowPushConstantData,
- shadowDrawcalls,
- { shadowMap.getHandle() });
-
- core.prepareImageForSampling(cmdStream, shadowMap.getHandle());
-
- core.recordDrawcallsToCmdStream(
- cmdStream,
- firstMeshPass,
- firstMeshPipeline,
- pushConstantData,
- drawcalls,
- renderTargets);
- core.prepareSwapchainImageForPresent(cmdStream);
- core.submitCommandStream(cmdStream);
-
- core.endFrame();
- }
-
- return 0;
-}
--
GitLab