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

Add object naming and debug marker/regions to bloom sample

Browse source
This commit is contained in:
baldurk 2016-05-07 14:08:40 +02:00
parent d223dfa72b
commit a1d8558b89
2 changed files with 202 additions and 153 deletions
Download patch file Download diff file Expand all files Collapse all files

2
base/vulkanexamplebase.cpp
View file

@ -1359,6 +1359,8 @@ void VulkanExampleBase::setupDepthStencil()
err = vkAllocateMemory(device, &mem_alloc, nullptr, &depthStencil.mem); err = vkAllocateMemory(device, &mem_alloc, nullptr, &depthStencil.mem);
assert(!err); assert(!err);
vkDebug::SetObjectName(device, depthStencil.image, "Backbuffer depth-stencil");
err = vkBindImageMemory(device, depthStencil.image, depthStencil.mem, 0); err = vkBindImageMemory(device, depthStencil.image, depthStencil.mem, 0);
assert(!err); assert(!err);
vkTools::setImageLayout( vkTools::setImageLayout(

351
bloom/bloom.cpp
View file

@ -432,173 +432,184 @@ public:
VkResult err = vkBeginCommandBuffer(offScreenCmdBuffer, &cmdBufInfo); VkResult err = vkBeginCommandBuffer(offScreenCmdBuffer, &cmdBufInfo);
assert(!err); assert(!err);
VkViewport viewport = vkTools::initializers::viewport( {
(float)offScreenFrameBuf.width, vkDebug::DebugMarkerRegion offscreenBloom(offScreenCmdBuffer, "Off-screen bloom generation");
(float)offScreenFrameBuf.height,
0.0f,
1.0f);
vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport);
VkRect2D scissor = vkTools::initializers::rect2D( VkViewport viewport = vkTools::initializers::viewport(
offScreenFrameBuf.width, (float)offScreenFrameBuf.width,
offScreenFrameBuf.height, (float)offScreenFrameBuf.height,
0, 0.0f,
0); 1.0f);
vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor); vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport);
vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); VkRect2D scissor = vkTools::initializers::rect2D(
offScreenFrameBuf.width,
offScreenFrameBuf.height,
0,
0);
vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor);
vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL); vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass);
VkDeviceSize offsets[1] = { 0 }; vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL);
vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.ufoGlow.vertices.buf, offsets); vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass);
vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.ufoGlow.indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(offScreenCmdBuffer, meshes.ufoGlow.indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(offScreenCmdBuffer); vkDebug::insertDebugMarker(offScreenCmdBuffer, "UFO Glow");
// Make sure color writes to the framebuffer are finished before using it as transfer source VkDeviceSize offsets[1] = { 0 };
vkTools::setImageLayout( vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.ufoGlow.vertices.buf, offsets);
offScreenCmdBuffer, vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.ufoGlow.indices.buf, 0, VK_INDEX_TYPE_UINT32);
offScreenFrameBuf.color.image, vkCmdDrawIndexed(offScreenCmdBuffer, meshes.ufoGlow.indexCount, 1, 0, 0, 0);
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
// Transform texture target to transfer destination vkCmdEndRenderPass(offScreenCmdBuffer);
vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBuf.textureTarget.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
// Blit offscreen color buffer to our texture target // Make sure color writes to the framebuffer are finished before using it as transfer source
VkImageBlit imgBlit; vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBuf.color.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
imgBlit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; // Transform texture target to transfer destination
imgBlit.srcSubresource.mipLevel = 0; vkTools::setImageLayout(
imgBlit.srcSubresource.baseArrayLayer = 0; offScreenCmdBuffer,
imgBlit.srcSubresource.layerCount = 1; offScreenFrameBuf.textureTarget.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
imgBlit.srcOffsets[0] = { 0, 0, 0 }; // Blit offscreen color buffer to our texture target
imgBlit.srcOffsets[1].x = offScreenFrameBuf.width; VkImageBlit imgBlit;
imgBlit.srcOffsets[1].y = offScreenFrameBuf.height;
imgBlit.srcOffsets[1].z = 1;
imgBlit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; imgBlit.srcSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
imgBlit.dstSubresource.mipLevel = 0; imgBlit.srcSubresource.mipLevel = 0;
imgBlit.dstSubresource.baseArrayLayer = 0; imgBlit.srcSubresource.baseArrayLayer = 0;
imgBlit.dstSubresource.layerCount = 1; imgBlit.srcSubresource.layerCount = 1;
imgBlit.dstOffsets[0] = { 0, 0, 0 }; imgBlit.srcOffsets[0] = { 0, 0, 0 };
imgBlit.dstOffsets[1].x = offScreenFrameBuf.textureTarget.width; imgBlit.srcOffsets[1].x = offScreenFrameBuf.width;
imgBlit.dstOffsets[1].y = offScreenFrameBuf.textureTarget.height; imgBlit.srcOffsets[1].y = offScreenFrameBuf.height;
imgBlit.dstOffsets[1].z = 1; imgBlit.srcOffsets[1].z = 1;
// Blit from framebuffer image to texture image imgBlit.dstSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
// vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions imgBlit.dstSubresource.mipLevel = 0;
vkCmdBlitImage( imgBlit.dstSubresource.baseArrayLayer = 0;
offScreenCmdBuffer, imgBlit.dstSubresource.layerCount = 1;
offScreenFrameBuf.color.image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
offScreenFrameBuf.textureTarget.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&imgBlit,
VK_FILTER_LINEAR
);
// Transform framebuffer color attachment back imgBlit.dstOffsets[0] = { 0, 0, 0 };
vkTools::setImageLayout( imgBlit.dstOffsets[1].x = offScreenFrameBuf.textureTarget.width;
offScreenCmdBuffer, imgBlit.dstOffsets[1].y = offScreenFrameBuf.textureTarget.height;
offScreenFrameBuf.color.image, imgBlit.dstOffsets[1].z = 1;
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
// Transform texture target back to shader read vkDebug::insertDebugMarker(offScreenCmdBuffer, "Blit Framebuffer A -> textureTarget");
// Makes sure that writes to the texture are finished before
// it's accessed in the shader
vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBuf.textureTarget.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
// Vertical blur // Blit from framebuffer image to texture image
// Render the textured quad containing the scene into // vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions
// another offscreen buffer applying a vertical blur vkCmdBlitImage(
renderPassBeginInfo.framebuffer = offScreenFrameBufB.frameBuffer; offScreenCmdBuffer,
renderPassBeginInfo.renderArea.extent.width = offScreenFrameBufB.width; offScreenFrameBuf.color.image,
renderPassBeginInfo.renderArea.extent.height = offScreenFrameBufB.height; VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
offScreenFrameBuf.textureTarget.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&imgBlit,
VK_FILTER_LINEAR
);
viewport.width = offScreenFrameBuf.width; // Transform framebuffer color attachment back
viewport.height = offScreenFrameBuf.height; vkTools::setImageLayout(
vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport); offScreenCmdBuffer,
offScreenFrameBuf.color.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor); // Transform texture target back to shader read
// Makes sure that writes to the texture are finished before
// it's accessed in the shader
vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBuf.textureTarget.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); // Vertical blur
// Render the textured quad containing the scene into
// another offscreen buffer applying a vertical blur
renderPassBeginInfo.framebuffer = offScreenFrameBufB.frameBuffer;
renderPassBeginInfo.renderArea.extent.width = offScreenFrameBufB.width;
renderPassBeginInfo.renderArea.extent.height = offScreenFrameBufB.height;
// Draw horizontally blurred texture viewport.width = offScreenFrameBuf.width;
vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.verticalBlur, 0, NULL); viewport.height = offScreenFrameBuf.height;
vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.blurVert); vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport);
vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets);
vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.quad.indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(offScreenCmdBuffer, meshes.quad.indexCount, 1, 0, 0, 0);
vkCmdEndRenderPass(offScreenCmdBuffer); vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor);
// Make sure color writes to the framebuffer are finished before using it as transfer source vkCmdBeginRenderPass(offScreenCmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBufB.color.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
// Transform texture target to transfer destination vkDebug::insertDebugMarker(offScreenCmdBuffer, "Vertical Blur");
vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBufB.textureTarget.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
vkCmdBindDescriptorSets(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.verticalBlur, 0, NULL);
vkCmdBindPipeline(offScreenCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.blurVert);
vkCmdBindVertexBuffers(offScreenCmdBuffer, VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets);
vkCmdBindIndexBuffer(offScreenCmdBuffer, meshes.quad.indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(offScreenCmdBuffer, meshes.quad.indexCount, 1, 0, 0, 0);
// Blit from framebuffer image to texture image vkCmdEndRenderPass(offScreenCmdBuffer);
// vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions
vkCmdBlitImage(
offScreenCmdBuffer,
offScreenFrameBufB.color.image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
offScreenFrameBufB.textureTarget.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&imgBlit,
VK_FILTER_LINEAR
);
// Transform framebuffer color attachment back // Make sure color writes to the framebuffer are finished before using it as transfer source
vkTools::setImageLayout( vkTools::setImageLayout(
offScreenCmdBuffer, offScreenCmdBuffer,
offScreenFrameBufB.color.image, offScreenFrameBufB.color.image,
VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
// Transform texture target back to shader read // Transform texture target to transfer destination
// Makes sure that writes to the texture are finished before vkTools::setImageLayout(
// it's accessed in the shader offScreenCmdBuffer,
vkTools::setImageLayout( offScreenFrameBufB.textureTarget.image,
offScreenCmdBuffer, VK_IMAGE_ASPECT_COLOR_BIT,
offScreenFrameBufB.textureTarget.image, VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL); vkDebug::insertDebugMarker(offScreenCmdBuffer, "Blit Framebuffer B -> textureTarget");
// Blit from framebuffer image to texture image
// vkCmdBlitImage does scaling and (if necessary and possible) also does format conversions
vkCmdBlitImage(
offScreenCmdBuffer,
offScreenFrameBufB.color.image,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
offScreenFrameBufB.textureTarget.image,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
1,
&imgBlit,
VK_FILTER_LINEAR
);
// Transform framebuffer color attachment back
vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBufB.color.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL,
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
// Transform texture target back to shader read
// Makes sure that writes to the texture are finished before
// it's accessed in the shader
vkTools::setImageLayout(
offScreenCmdBuffer,
offScreenFrameBufB.textureTarget.image,
VK_IMAGE_ASPECT_COLOR_BIT,
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
} // end of "offscreen bloom generation" region
err = vkEndCommandBuffer(offScreenCmdBuffer); err = vkEndCommandBuffer(offScreenCmdBuffer);
assert(!err); assert(!err);
@ -610,6 +621,8 @@ public:
getAssetPath() + "textures/cubemap_space.ktx", getAssetPath() + "textures/cubemap_space.ktx",
VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_UNORM,
&textures.cubemap); &textures.cubemap);
vkDebug::SetObjectName(device, textures.cubemap.image, "textures/cubemap_space.ktx");
} }
void reBuildCommandBuffers() void reBuildCommandBuffers()
@ -667,25 +680,30 @@ public:
VkDeviceSize offsets[1] = { 0 }; VkDeviceSize offsets[1] = { 0 };
// Skybox {
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.skyBox, 0, NULL); vkDebug::DebugMarkerRegion scene(drawCmdBuffers[i], "3D Scene");
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.skyBox);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.skyBox.vertices.buf, offsets); vkDebug::insertDebugMarker(drawCmdBuffers[i], "Skybox");
vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.skyBox.indices.buf, 0, VK_INDEX_TYPE_UINT32); vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.skyBox, 0, NULL);
vkCmdDrawIndexed(drawCmdBuffers[i], meshes.skyBox.indexCount, 1, 0, 0, 0); vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.skyBox);
// 3D scene vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.skyBox.vertices.buf, offsets);
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL); vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.skyBox.indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass); vkCmdDrawIndexed(drawCmdBuffers[i], meshes.skyBox.indexCount, 1, 0, 0, 0);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.ufo.vertices.buf, offsets); vkDebug::insertDebugMarker(drawCmdBuffers[i], "UFO");
vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.ufo.indices.buf, 0, VK_INDEX_TYPE_UINT32); vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.scene, 0, 1, &descriptorSets.scene, 0, NULL);
vkCmdDrawIndexed(drawCmdBuffers[i], meshes.ufo.indexCount, 1, 0, 0, 0); vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.phongPass);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.ufo.vertices.buf, offsets);
vkCmdBindIndexBuffer(drawCmdBuffers[i], meshes.ufo.indices.buf, 0, VK_INDEX_TYPE_UINT32);
vkCmdDrawIndexed(drawCmdBuffers[i], meshes.ufo.indexCount, 1, 0, 0, 0);
}
// Render vertical blurred scene applying a horizontal blur // Render vertical blurred scene applying a horizontal blur
if (bloom) if (bloom)
{ {
vkDebug::insertDebugMarker(drawCmdBuffers[i], "Bloom Apply");
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.horizontalBlur, 0, NULL); vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayouts.radialBlur, 0, 1, &descriptorSets.horizontalBlur, 0, NULL);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.blurVert); vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.blurVert);
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets); vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &meshes.quad.vertices.buf, offsets);
@ -744,6 +762,13 @@ public:
loadMesh(getAssetPath() + "models/retroufo.dae", &meshes.ufo, vertexLayout, 0.05f); loadMesh(getAssetPath() + "models/retroufo.dae", &meshes.ufo, vertexLayout, 0.05f);
loadMesh(getAssetPath() + "models/retroufo_glow.dae", &meshes.ufoGlow, vertexLayout, 0.05f); loadMesh(getAssetPath() + "models/retroufo_glow.dae", &meshes.ufoGlow, vertexLayout, 0.05f);
loadMesh(getAssetPath() + "models/cube.obj", &meshes.skyBox, vertexLayout, 1.0f); loadMesh(getAssetPath() + "models/cube.obj", &meshes.skyBox, vertexLayout, 1.0f);
vkDebug::SetObjectName(device, meshes.ufo.vertices.buf, "UFO Vertices");
vkDebug::SetObjectName(device, meshes.ufo.indices.buf, "UFO Indices");
vkDebug::SetObjectName(device, meshes.ufoGlow.vertices.buf, "UFO Glow Vertices");
vkDebug::SetObjectName(device, meshes.ufoGlow.indices.buf, "UFO Glow Indices");
vkDebug::SetObjectName(device, meshes.skyBox.vertices.buf, "Skybox Vertices");
vkDebug::SetObjectName(device, meshes.skyBox.indices.buf, "Skybox Indices");
} }
// Setup vertices for a single uv-mapped quad // Setup vertices for a single uv-mapped quad
@ -777,12 +802,16 @@ public:
std::vector<uint32_t> indexBuffer = { 0,1,2, 2,3,0 }; std::vector<uint32_t> indexBuffer = { 0,1,2, 2,3,0 };
meshes.quad.indexCount = indexBuffer.size(); meshes.quad.indexCount = indexBuffer.size();
vkDebug::SetObjectName(device, meshes.quad.vertices.buf, "Quad Vertices");
createBuffer( createBuffer(
VK_BUFFER_USAGE_INDEX_BUFFER_BIT, VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
indexBuffer.size() * sizeof(uint32_t), indexBuffer.size() * sizeof(uint32_t),
indexBuffer.data(), indexBuffer.data(),
&meshes.quad.indices.buf, &meshes.quad.indices.buf,
&meshes.quad.indices.mem); &meshes.quad.indices.mem);
vkDebug::SetObjectName(device, meshes.quad.indices.buf, "Quad Indices");
} }
void setupVertexDescriptions() void setupVertexDescriptions()
@ -1075,6 +1104,9 @@ public:
shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/gaussblur.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/gaussblur.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/gaussblur.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/gaussblur.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/gaussblur.vert.spv");
vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/gaussblur.frag.spv");
VkGraphicsPipelineCreateInfo pipelineCreateInfo = VkGraphicsPipelineCreateInfo pipelineCreateInfo =
vkTools::initializers::pipelineCreateInfo( vkTools::initializers::pipelineCreateInfo(
pipelineLayouts.radialBlur, pipelineLayouts.radialBlur,
@ -1109,6 +1141,9 @@ public:
shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/phongpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/phongpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/phongpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/phongpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/phongpass.vert.spv");
vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/phongpass.frag.spv");
pipelineCreateInfo.layout = pipelineLayouts.scene; pipelineCreateInfo.layout = pipelineLayouts.scene;
blendAttachmentState.blendEnable = VK_FALSE; blendAttachmentState.blendEnable = VK_FALSE;
depthStencilState.depthWriteEnable = VK_TRUE; depthStencilState.depthWriteEnable = VK_TRUE;
@ -1120,6 +1155,9 @@ public:
shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/colorpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[0] = loadShader(getAssetPath() + "shaders/bloom/colorpass.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/colorpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/bloom/colorpass.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/colorpass.vert.spv");
vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/colorpass.frag.spv");
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.colorPass); err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.colorPass);
assert(!err); assert(!err);
@ -1130,6 +1168,9 @@ public:
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skyBox); err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.skyBox);
assert(!err); assert(!err);
vkDebug::SetObjectName(device, shaderStages[0].module, "shaders/bloom/skybox.vert.spv");
vkDebug::SetObjectName(device, shaderStages[1].module, "shaders/bloom/skybox.frag.spv");
} }
// Prepare and initialize uniform buffer containing shader uniforms // Prepare and initialize uniform buffer containing shader uniforms
@ -1259,6 +1300,8 @@ public:
prepareUniformBuffers(); prepareUniformBuffers();
prepareTextureTarget(&offScreenFrameBuf.textureTarget, TEX_DIM, TEX_DIM, TEX_FORMAT); prepareTextureTarget(&offScreenFrameBuf.textureTarget, TEX_DIM, TEX_DIM, TEX_FORMAT);
prepareTextureTarget(&offScreenFrameBufB.textureTarget, TEX_DIM, TEX_DIM, TEX_FORMAT); prepareTextureTarget(&offScreenFrameBufB.textureTarget, TEX_DIM, TEX_DIM, TEX_FORMAT);
vkDebug::SetObjectName(device, offScreenFrameBuf.textureTarget.image, "Off-screen A textureTarget");
vkDebug::SetObjectName(device, offScreenFrameBufB.textureTarget.image, "Off-screen B textureTarget");
setupDescriptorSetLayout(); setupDescriptorSetLayout();
preparePipelines(); preparePipelines();
setupDescriptorPool(); setupDescriptorPool();
@ -1266,6 +1309,10 @@ public:
createOffscreenCommandBuffer(); createOffscreenCommandBuffer();
prepareOffscreenFramebuffer(&offScreenFrameBuf); prepareOffscreenFramebuffer(&offScreenFrameBuf);
prepareOffscreenFramebuffer(&offScreenFrameBufB); prepareOffscreenFramebuffer(&offScreenFrameBufB);
vkDebug::SetObjectName(device, offScreenFrameBuf.color.image, "Off-screen A color framebuffer");
vkDebug::SetObjectName(device, offScreenFrameBuf.depth.image, "Off-screen A depth framebuffer");
vkDebug::SetObjectName(device, offScreenFrameBufB.color.image, "Off-screen B color framebuffer");
vkDebug::SetObjectName(device, offScreenFrameBufB.depth.image, "Off-screen B depth framebuffer");
buildCommandBuffers(); buildCommandBuffers();
prepared = true; prepared = true;
} }