claude_code/procedural-3d-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Use application wide submit info and semaphores (Fixes #66, Fixes #65, Fixes#60), removed no longer functional code loading GLSL (Fixes #62)

Browse source
This commit is contained in:
saschawillems 2016-03-06 20:15:05 +01:00
parent 0240cde57a
commit 8cd5041111
26 changed files with 226 additions and 961 deletions
Download patch file Download diff file Expand all files Collapse all files

58
bloom/bloom.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Texture properties
@ -692,16 +691,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -715,46 +704,35 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Gather command buffers to be sumitted to the queue
std::vector<VkCommandBuffer> submitCmdBuffers;
// Submit offscreen rendering command buffer
if (bloom)
{
submitCmdBuffers.push_back(offScreenCmdBuffer);
}
submitCmdBuffers.push_back(drawCmdBuffers[currentBuffer]);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitInfo.commandBufferCount = submitCmdBuffers.size();
submitInfo.pCommandBuffers = submitCmdBuffers.data();
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(err == VK_SUCCESS);
assert(!err);
}
void loadMeshes()
@ -1090,13 +1068,8 @@ public:
// Vertical gauss blur
// Load shaders
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/bloom/gaussblur.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/bloom/gaussblur.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/bloom/gaussblur.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/bloom/gaussblur.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -1129,13 +1102,8 @@ public:
assert(!err);
// Phong pass (3D model)
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/bloom/phongpass.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/bloom/phongpass.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/bloom/phongpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/bloom/phongpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
pipelineCreateInfo.layout = pipelineLayouts.scene;
blendAttachmentState.blendEnable = VK_FALSE;
@ -1145,25 +1113,15 @@ public:
assert(!err);
// Color only pass (offscreen blur base)
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/bloom/colorpass.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/bloom/colorpass.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/bloom/colorpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/bloom/colorpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.colorPass);
assert(!err);
// Skybox (cubemap
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/bloom/skybox.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/bloom/skybox.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/bloom/skybox.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/bloom/skybox.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
depthStencilState.depthWriteEnable = VK_FALSE;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skyBox);
assert(!err);

43
computeparticles/computeparticles.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
#define PARTICLE_COUNT 8 * 1024
@ -202,16 +201,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -235,33 +224,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
@ -519,13 +501,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo,2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/computeparticles/particle.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/computeparticles/particle.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/computeparticles/particle.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/computeparticles/particle.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -635,11 +612,7 @@ public:
vkTools::initializers::computePipelineCreateInfo(
computePipelineLayout,
0);
#ifdef USE_GLSL
computePipelineCreateInfo.stage = loadShaderGLSL("./../data/shaders/computeparticles/particle.comp", VK_SHADER_STAGE_COMPUTE_BIT);
#else
computePipelineCreateInfo.stage = loadShader("./../data/shaders/computeparticles/particle.comp.spv", VK_SHADER_STAGE_COMPUTE_BIT);
#endif
err = vkCreateComputePipelines(device, pipelineCache, 1, &computePipelineCreateInfo, nullptr, &pipelines.compute);
assert(!err);
}

46
computeshader/computeshader.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -279,16 +278,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -313,33 +302,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
@ -613,13 +595,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo,2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/computeshader/texture.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/computeshader/texture.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/computeshader/texture.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/computeshader/texture.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -737,13 +714,8 @@ public:
for (auto& shaderName : shaderNames)
{
std::string fileName = "./../data/shaders/computeshader/" + shaderName + ".comp";
#ifdef USE_GLSL
computePipelineCreateInfo.stage = loadShaderGLSL(fileName.c_str(), VK_SHADER_STAGE_COMPUTE_BIT);
#else
fileName += ".spv";
std::string fileName = "./../data/shaders/computeshader/" + shaderName + ".comp.spv";
computePipelineCreateInfo.stage = loadShader(fileName.c_str(), VK_SHADER_STAGE_COMPUTE_BIT);
#endif
VkPipeline pipeline;
err = vkCreateComputePipelines(device, pipelineCache, 1, &computePipelineCreateInfo, nullptr, &pipeline);
assert(!err);

51
deferred/deferred.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Texture properties
@ -717,16 +716,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -735,41 +724,32 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Gather command buffers to be sumitted to the queue
std::vector<VkCommandBuffer> submitCmdBuffers = {
offScreenCmdBuffer,
drawCmdBuffers[currentBuffer],
};
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitInfo.commandBufferCount = submitCmdBuffers.size();
submitInfo.pCommandBuffers = submitCmdBuffers.data();
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(err == VK_SUCCESS);
assert(!err);
}
void loadMeshes()
@ -1100,13 +1080,8 @@ public:
// Final fullscreen pass pipeline
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/deferred/deferred.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/deferred/deferred.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/deferred/deferred.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/deferred/deferred.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -1129,24 +1104,14 @@ public:
assert(!err);
// Debug display pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/deferred/debug.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/deferred/debug.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/deferred/debug.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/deferred/debug.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.debug);
assert(!err);
// Offscreen pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/deferred/mrt.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/deferred/mrt.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/deferred/mrt.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/deferred/mrt.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
// Separate render pass
pipelineCreateInfo.renderPass = offScreenFrameBuf.renderPass;

44
displacement/displacement.cpp
View file

@ -22,7 +22,6 @@
#include "vulkanMeshLoader.hpp"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
std::vector<vkMeshLoader::VertexLayout> vertexLayout =
@ -199,16 +198,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -217,31 +206,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -472,17 +456,10 @@ public:
// Tessellation pipeline
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 4> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/displacement/base.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/displacement/base.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
shaderStages[2] = loadShaderGLSL("./../data/shaders/displacement/displacement.tesc", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShaderGLSL("./../data/shaders/displacement/displacement.tese", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/displacement/base.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/displacement/base.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
shaderStages[2] = loadShader("./../data/shaders/displacement/displacement.tesc.spv", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShader("./../data/shaders/displacement/displacement.tese.spv", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -513,13 +490,8 @@ public:
// Pass through pipelines
// Load pass through tessellation shaders (Vert and frag are reused)
#ifdef USE_GLSL
shaderStages[2] = loadShaderGLSL("./../data/shaders/displacement/passthrough.tesc", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShaderGLSL("./../data/shaders/displacement/passthrough.tese", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#else
shaderStages[2] = loadShader("./../data/shaders/displacement/passthrough.tesc.spv", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShader("./../data/shaders/displacement/passthrough.tese.spv", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#endif
// Solid
rasterizationState.polygonMode = VK_POLYGON_MODE_FILL;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solidPassThrough);

47
distancefieldfonts/distancefieldfonts.cpp
View file

@ -24,7 +24,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -260,7 +259,6 @@ public:
if (splitScreen)
{
viewport.y = (float)height / 2.0f;
// viewport.x = (float)width / 2.0f;
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSets.bitmap, 0, NULL);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.bitmap);
@ -269,19 +267,8 @@ public:
vkCmdDrawIndexed(drawCmdBuffers[i], indices.count, 1, 0, 0, 0);
}
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -290,33 +277,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -648,13 +628,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo,2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/distancefieldfonts/sdf.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/distancefieldfonts/sdf.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/distancefieldfonts/sdf.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/distancefieldfonts/sdf.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -677,16 +652,10 @@ public:
assert(!err);
// Default bitmap font rendering pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/distancefieldfonts/bitmap.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/distancefieldfonts/bitmap.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/distancefieldfonts/bitmap.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/distancefieldfonts/bitmap.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.bitmap);
assert(!err);
}
// Prepare and initialize uniform buffer containing shader uniforms

39
gears/gears.cpp
View file

@ -21,7 +21,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
class VulkanExample : public VulkanExampleBase
@ -117,16 +116,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -135,33 +124,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -351,13 +333,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/gears.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/gears.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/gears.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/gears.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(

43
geometryshader/geometryshader.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -154,16 +153,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -172,31 +161,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -390,15 +374,9 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 3> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/geometryshader/base.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/geometryshader/base.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
shaderStages[2] = loadShaderGLSL("./../data/shaders/geometryshader/normaldebug.geom", VK_SHADER_STAGE_GEOMETRY_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/geometryshader/base.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/geometryshader/base.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
shaderStages[2] = loadShader("./../data/shaders/geometryshader/normaldebug.geom.spv", VK_SHADER_STAGE_GEOMETRY_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -424,13 +402,8 @@ public:
// Solid rendering pipeline
// Shader
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/geometryshader/mesh.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/geometryshader/mesh.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/geometryshader/mesh.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/geometryshader/mesh.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
pipelineCreateInfo.stageCount = 2;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solid);
assert(!err);

39
instancing/instancing.cpp
View file

@ -21,7 +21,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
#define INSTANCING_RANGE 3
@ -163,16 +162,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -181,33 +170,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -387,13 +369,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/instancing/instancing.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/instancing/instancing.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/instancing/instancing.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/instancing/instancing.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(

39
mesh/mesh.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout used in this example
@ -165,16 +164,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -183,33 +172,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -472,13 +454,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/mesh/mesh.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/mesh/mesh.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/mesh/mesh.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/mesh/mesh.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(

23
multithreading/multithreading.cpp
View file

@ -356,16 +356,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -381,12 +371,11 @@ public:
VkResult err;
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
@ -407,13 +396,13 @@ public:
} while (err == VK_TIMEOUT);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroyFence(device, renderFence, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}

51
occlusionquery/occlusionquery.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout used in this example
@ -318,16 +317,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -336,33 +325,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
@ -555,13 +537,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/occlusionquery/mesh.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/occlusionquery/mesh.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/occlusionquery/mesh.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/occlusionquery/mesh.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -584,28 +561,16 @@ public:
assert(!err);
// Simple pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/occlusionquery/simple.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/occlusionquery/simple.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/occlusionquery/simple.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/occlusionquery/simple.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
rasterizationState.cullMode = VK_CULL_MODE_NONE;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.simple);
assert(!err);
// Visual pipeline for the occluder
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/occlusionquery/occluder.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/occlusionquery/occluder.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/occlusionquery/occluder.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/occlusionquery/occluder.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
// Enable blending
blendAttachmentState.blendEnable = VK_TRUE;

52
offscreen/offscreen.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Texture properties
@ -597,17 +596,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
VkImageMemoryBarrier *pMemoryBarrier = &prePresentBarrier;
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -616,41 +604,32 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Gather command buffers to be sumitted to the queue
std::vector<VkCommandBuffer> submitCmdBuffers = {
offScreenCmdBuffer,
drawCmdBuffers[currentBuffer],
};
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitInfo.commandBufferCount = submitCmdBuffers.size();
submitInfo.pCommandBuffers = submitCmdBuffers.data();
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(err == VK_SUCCESS);
assert(!err);
}
void loadMeshes()
@ -971,13 +950,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/offscreen/quad.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/offscreen/quad.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/offscreen/quad.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/offscreen/quad.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -1000,25 +974,15 @@ public:
assert(!err);
// Mirror
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/offscreen/mirror.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/offscreen/mirror.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/offscreen/mirror.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/offscreen/mirror.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.mirror);
assert(!err);
// Solid shading pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/offscreen/offscreen.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/offscreen/offscreen.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/offscreen/offscreen.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/offscreen/offscreen.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
pipelineCreateInfo.layout = pipelineLayouts.offscreen;

46
parallaxmapping/parallaxmapping.cpp
View file

@ -21,7 +21,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -207,16 +206,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -225,33 +214,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -486,13 +468,8 @@ public:
// Parallax mapping pipeline
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/parallax/parallax.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/parallax/parallax.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/parallax/parallax.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/parallax/parallax.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -515,17 +492,10 @@ public:
assert(!err);
// Normal mapping (no parallax effect)
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/parallax/normalmap.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/parallax/normalmap.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/parallax/normalmap.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/parallax/normalmap.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.normalMapping);
assert(!err);
}
void prepareUniformBuffers()

47
pipelines/pipelines.cpp
View file

@ -22,7 +22,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -174,16 +173,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -192,33 +181,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -483,13 +465,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/pipelines/base.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/pipelines/color.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/pipelines/base.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/pipelines/color.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -518,11 +495,7 @@ public:
// Pipeline for textured rendering
// Use different fragment shader
#ifdef USE_GLSL
shaderStages[1] = loadShaderGLSL("./../data/shaders/pipelines/texture.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[1] = loadShader("./../data/shaders/pipelines/texture.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.texture);
assert(!err);
@ -530,11 +503,7 @@ public:
// Solid polygon fill
rasterizationState.polygonMode = VK_POLYGON_MODE_LINE;
// Use different fragment shader
#ifdef USE_GLSL
shaderStages[1] = loadShaderGLSL("./../data/shaders/pipelines/wireframe.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[1] = loadShader("./../data/shaders/pipelines/wireframe.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.wireFrame);
assert(!err);
}

51
pushconstants/pushconstants.cpp
View file

@ -1,5 +1,5 @@
/*
* Vulkan Example - Push constants example
* Vulkan Example - Push constants example (small shader block accessed outside of uniforms for fast updates)
*
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de
*
@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -192,16 +191,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -210,41 +199,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
err = vkQueueWaitIdle(queue);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Gather command buffers to be sumitted to the queue
std::vector<VkCommandBuffer> submitCmdBuffers = {
drawCmdBuffers[currentBuffer]
};
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitInfo.commandBufferCount = submitCmdBuffers.size();
submitInfo.pCommandBuffers = submitCmdBuffers.data();
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -441,13 +415,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/pushconstants/lights.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/pushconstants/lights.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/pushconstants/lights.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/pushconstants/lights.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(

55
radialblur/radialblur.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Texture properties
@ -583,17 +582,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
VkImageMemoryBarrier *pMemoryBarrier = &prePresentBarrier;
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -602,41 +590,32 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Gather command buffers to be sumitted to the queue
std::vector<VkCommandBuffer> submitCmdBuffers = {
offScreenCmdBuffer,
drawCmdBuffers[currentBuffer]
drawCmdBuffers[currentBuffer],
};
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitInfo.commandBufferCount = submitCmdBuffers.size();
submitInfo.pCommandBuffers = submitCmdBuffers.data();
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(err == VK_SUCCESS);
assert(!err);
}
void loadMeshes()
@ -905,13 +884,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/radialblur/radialblur.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/radialblur/radialblur.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/radialblur/radialblur.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/radialblur/radialblur.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -949,13 +923,8 @@ public:
assert(!err);
// Phong pass
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/radialblur/phongpass.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/radialblur/phongpass.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/radialblur/phongpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/radialblur/phongpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
pipelineCreateInfo.layout = pipelineLayouts.scene;
blendAttachmentState.blendEnable = VK_FALSE;
@ -965,17 +934,11 @@ public:
assert(!err);
// Color only pass (offscreen blur base)
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/radialblur/colorpass.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/radialblur/colorpass.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/radialblur/colorpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/radialblur/colorpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.colorPass);
assert(!err);
}
// Prepare and initialize uniform buffer containing shader uniforms

43
shadowmapping/shadowmapping.cpp
View file

@ -26,7 +26,6 @@
#include "vulkanMeshLoader.hpp"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// 16 bits of depth is enough for such a small scene
@ -525,41 +524,30 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Gather command buffers to be sumitted to the queue
std::vector<VkCommandBuffer> submitCmdBuffers = {
offScreenCmdBuffer,
drawCmdBuffers[currentBuffer],
};
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitInfo.commandBufferCount = submitCmdBuffers.size();
submitInfo.pCommandBuffers = submitCmdBuffers.data();
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -845,13 +833,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/shadowmapping/quad.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/shadowmapping/quad.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/shadowmapping/quad.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/shadowmapping/quad.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -876,36 +859,20 @@ public:
assert(!err);
// 3D scene
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/shadowmapping/scene.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/shadowmapping/scene.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/shadowmapping/scene.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/shadowmapping/scene.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
rasterizationState.cullMode = VK_CULL_MODE_NONE;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.scene);
assert(!err);
// Offscreen pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/shadowmapping/offscreen.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/shadowmapping/offscreen.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/shadowmapping/offscreen.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/shadowmapping/offscreen.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
pipelineCreateInfo.layout = pipelineLayouts.offscreen;
// Cull front faces
depthStencilState.depthCompareOp = VK_COMPARE_OP_LESS_OR_EQUAL;
// Enable depth bias
rasterizationState.depthBiasEnable = VK_TRUE;
// Add depth bias to dynamic state, so we can change it at runtime
dynamicStateEnables.push_back(VK_DYNAMIC_STATE_DEPTH_BIAS);
dynamicState =

52
shadowmappingomni/shadowmappingomni.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Texture properties
@ -654,16 +653,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -672,40 +661,32 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Gather command buffers to be sumitted to the queue
std::vector<VkCommandBuffer> submitCmdBuffers = {
offScreenCmdBuffer,
drawCmdBuffers[currentBuffer],
};
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitInfo.commandBufferCount = submitCmdBuffers.size();
submitInfo.pCommandBuffers = submitCmdBuffers.data();
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(err == VK_SUCCESS);
assert(!err);
}
void loadMeshes()
@ -938,13 +919,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/shadowmapomni/scene.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/shadowmapomni/scene.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/shadowmapomni/scene.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/shadowmapomni/scene.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -967,29 +943,17 @@ public:
assert(!err);
// Cube map display pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/shadowmapomni/cubemapdisplay.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/shadowmapomni/cubemapdisplay.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/shadowmapomni/cubemapdisplay.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/shadowmapomni/cubemapdisplay.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
rasterizationState.cullMode = VK_CULL_MODE_FRONT_BIT;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.cubeMap);
assert(!err);
// Offscreen pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/shadowmapomni/offscreen.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/shadowmapomni/offscreen.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/shadowmapomni/offscreen.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/shadowmapomni/offscreen.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
rasterizationState.cullMode = VK_CULL_MODE_BACK_BIT;
pipelineCreateInfo.layout = pipelineLayouts.offscreen;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.offscreen);
assert(!err);
}

41
skeletalanimation/skeletalanimation.cpp
View file

@ -21,7 +21,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout used in this example
@ -217,16 +216,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -235,38 +224,31 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
// todo : comment
// Load bone information from ASSIMP mesh
void loadBones(uint32_t meshIndex, const aiMesh* pMesh, std::vector<VertexBoneData>& Bones)
{
for (uint32_t i = 0; i < pMesh->mNumBones; i++)
@ -772,13 +754,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/skeletalanimation/mesh.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/skeletalanimation/mesh.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/skeletalanimation/mesh.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/skeletalanimation/mesh.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(

61
sphericalenvmapping/sphericalenvmapping.cpp
View file

@ -1,6 +1,8 @@
/*
* Vulkan Example - Spherical Environment Mapping, using different mat caps
*
* Use +/-/space toggle through different material captures
*
* Based on https://www.clicktorelease.com/blog/creating-spherical-environment-mapping-shader
*
* Copyright (C) 2016 by Sascha Willems - www.saschawillems.de
@ -24,7 +26,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -171,35 +172,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -399,13 +391,8 @@ public:
// Spherical environment rendering pipeline
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/sphericalenvmapping/sem.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/sphericalenvmapping/sem.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/sphericalenvmapping/sem.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/sphericalenvmapping/sem.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -495,16 +482,30 @@ public:
updateUniformBuffers();
}
virtual void keyPressed(uint32_t keyCode)
{
switch (keyCode)
{
case 0x6B:
case 0x20:
changeMatCapIndex(1);
break;
case 0x6D:
changeMatCapIndex(-1);
break;
}
}
void changeMatCapIndex(uint32_t delta)
{
uboVS.texIndex += delta;
if (uboVS.texIndex < 0)
{
uboVS.texIndex = 0;
uboVS.texIndex = textures.matCapArray.layerCount-1;
}
if (uboVS.texIndex > textures.matCapArray.layerCount)
if (uboVS.texIndex >= textures.matCapArray.layerCount)
{
uboVS.texIndex = textures.matCapArray.layerCount;
uboVS.texIndex = 0;
}
updateUniformBuffers();
}
@ -520,18 +521,6 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
if (vulkanExample != NULL)
{
vulkanExample->handleMessages(hWnd, uMsg, wParam, lParam);
if (uMsg == WM_KEYDOWN)
{
switch (wParam)
{
case VK_ADD:
vulkanExample->changeMatCapIndex(1);
break;
case VK_SUBTRACT:
vulkanExample->changeMatCapIndex(-1);
break;
}
}
}
return (DefWindowProc(hWnd, uMsg, wParam, lParam));
}

45
tessellation/tessellation.cpp
View file

@ -23,7 +23,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -185,16 +184,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -203,31 +192,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
assert(!err);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -448,17 +432,10 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 4> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/tessellation/base.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/tessellation/base.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
shaderStages[2] = loadShaderGLSL("./../data/shaders/tessellation/pntriangles.tesc", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShaderGLSL("./../data/shaders/tessellation/pntriangles.tese", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/tessellation/base.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/tessellation/base.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
shaderStages[2] = loadShader("./../data/shaders/tessellation/pntriangles.tesc.spv", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShader("./../data/shaders/tessellation/pntriangles.tese.spv", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -490,13 +467,9 @@ public:
// Pass through pipelines
// Load pass through tessellation shaders (Vert and frag are reused)
#ifdef USE_GLSL
shaderStages[2] = loadShaderGLSL("./../data/shaders/tessellation/passthrough.tesc", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShaderGLSL("./../data/shaders/tessellation/passthrough.tese", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#else
shaderStages[2] = loadShader("./../data/shaders/tessellation/passthrough.tesc.spv", VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT);
shaderStages[3] = loadShader("./../data/shaders/tessellation/passthrough.tese.spv", VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT);
#endif
// Solid
rasterizationState.polygonMode = VK_POLYGON_MODE_FILL;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solidPassThrough);

39
texture/texture.cpp
View file

@ -20,7 +20,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -509,16 +508,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -527,33 +516,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -765,13 +747,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo,2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/texture.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/texture.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/texture.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/texture.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(

39
texturearray/texturearray.cpp
View file

@ -21,7 +21,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -380,16 +379,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -398,33 +387,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -637,13 +619,8 @@ public:
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/texturearray/instancing.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/texturearray/instancing.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/texturearray/instancing.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/texturearray/instancing.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(

44
texturecubemap/texturecubemap.cpp
View file

@ -22,7 +22,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
// Vertex layout for this example
@ -373,16 +372,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -391,33 +380,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -631,13 +613,8 @@ public:
// Skybox pipeline (background cube)
std::array<VkPipelineShaderStageCreateInfo,2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/cubemap/skybox.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/cubemap/skybox.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/cubemap/skybox.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/cubemap/skybox.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -660,13 +637,8 @@ public:
assert(!err);
// Cube map reflect pipeline
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/cubemap/reflect.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/cubemap/reflect.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/cubemap/reflect.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/cubemap/reflect.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
depthStencilState.depthWriteEnable = VK_TRUE;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.reflect);
assert(!err);

49
vulkanscene/vulkanscene.cpp
View file

@ -25,7 +25,6 @@
#include "vulkanexamplebase.h"
#define VERTEX_BUFFER_BIND_ID 0
//#define USE_GLSL
#define ENABLE_VALIDATION false
class VulkanExample : public VulkanExampleBase
@ -173,16 +172,6 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]);
VkImageMemoryBarrier prePresentBarrier = vkTools::prePresentBarrier(swapChain.buffers[i].image);
vkCmdPipelineBarrier(
drawCmdBuffers[i],
VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
VK_FLAGS_NONE,
0, nullptr,
0, nullptr,
1, &prePresentBarrier);
err = vkEndCommandBuffer(drawCmdBuffers[i]);
assert(!err);
}
@ -191,33 +180,26 @@ public:
void draw()
{
VkResult err;
VkSemaphore presentCompleteSemaphore;
VkSemaphoreCreateInfo presentCompleteSemaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
err = vkCreateSemaphore(device, &presentCompleteSemaphoreCreateInfo, nullptr, &presentCompleteSemaphore);
assert(!err);
// Get next image in the swap chain (back/front buffer)
err = swapChain.acquireNextImage(presentCompleteSemaphore, &currentBuffer);
err = swapChain.acquireNextImage(semaphores.presentComplete, &currentBuffer);
assert(!err);
VkSubmitInfo submitInfo = vkTools::initializers::submitInfo();
submitInfo.waitSemaphoreCount = 1;
submitInfo.pWaitSemaphores = &presentCompleteSemaphore;
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
// Command buffer to be sumitted to the queue
submitInfo.commandBufferCount = 1;
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
// Submit draw command buffer
// Submit to queue
err = vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
assert(!err);
err = swapChain.queuePresent(queue, currentBuffer);
submitPrePresentBarrier(swapChain.buffers[currentBuffer].image);
err = swapChain.queuePresent(queue, currentBuffer, semaphores.renderComplete);
assert(!err);
vkDestroySemaphore(device, presentCompleteSemaphore, nullptr);
submitPostPresentBarrier(swapChain.buffers[currentBuffer].image);
err = vkQueueWaitIdle(queue);
assert(!err);
}
@ -495,13 +477,8 @@ public:
// Pipeline for the meshes (armadillo, bunny, etc.)
// Load shaders
std::array<VkPipelineShaderStageCreateInfo, 2> shaderStages;
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/vulkanscene/mesh.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/vulkanscene/mesh.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/vulkanscene/mesh.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/vulkanscene/mesh.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo(
@ -524,26 +501,16 @@ public:
assert(!err);
// Pipeline for the logos
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/vulkanscene/logo.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/vulkanscene/logo.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/vulkanscene/logo.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/vulkanscene/logo.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.logos);
assert(!err);
// Pipeline for the sky sphere (todo)
rasterizationState.cullMode = VK_CULL_MODE_FRONT_BIT; // Inverted culling
depthStencilState.depthWriteEnable = VK_FALSE; // No depth writes
#ifdef USE_GLSL
shaderStages[0] = loadShaderGLSL("./../data/shaders/vulkanscene/skybox.vert", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShaderGLSL("./../data/shaders/vulkanscene/skybox.frag", VK_SHADER_STAGE_FRAGMENT_BIT);
#else
shaderStages[0] = loadShader("./../data/shaders/vulkanscene/skybox.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader("./../data/shaders/vulkanscene/skybox.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
#endif
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skybox);
assert(!err);