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

Use vulkan result check macro

Browse source
This commit is contained in:
saschawillems 2016-05-14 19:27:23 +02:00
parent 2a05de5882
commit bbce1bd743
1 changed files with 41 additions and 95 deletions
Download patch file Download diff file Expand all files Collapse all files

136
shadowmapping/shadowmapping.cpp
View file

@ -196,8 +196,6 @@ public:
// the offscreen framebuffer // the offscreen framebuffer
void prepareTextureTarget(uint32_t width, uint32_t height, VkFormat format) void prepareTextureTarget(uint32_t width, uint32_t height, VkFormat format)
{ {
VkResult err;
// Get device properites for the requested texture format // Get device properites for the requested texture format
VkFormatProperties formatProperties; VkFormatProperties formatProperties;
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProperties); vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProperties);
@ -224,15 +222,12 @@ public:
VkMemoryAllocateInfo memAllocInfo = vkTools::initializers::memoryAllocateInfo(); VkMemoryAllocateInfo memAllocInfo = vkTools::initializers::memoryAllocateInfo();
VkMemoryRequirements memReqs; VkMemoryRequirements memReqs;
err = vkCreateImage(device, &imageCreateInfo, nullptr, &offScreenFrameBuf.textureTarget.image); VK_CHECK_RESULT(vkCreateImage(device, &imageCreateInfo, nullptr, &offScreenFrameBuf.textureTarget.image));
assert(!err);
vkGetImageMemoryRequirements(device, offScreenFrameBuf.textureTarget.image, &memReqs); vkGetImageMemoryRequirements(device, offScreenFrameBuf.textureTarget.image, &memReqs);
memAllocInfo.allocationSize = memReqs.size; memAllocInfo.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAllocInfo.memoryTypeIndex); memAllocInfo.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
err = vkAllocateMemory(device, &memAllocInfo, nullptr, &offScreenFrameBuf.textureTarget.deviceMemory); VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &offScreenFrameBuf.textureTarget.deviceMemory));
assert(!err); VK_CHECK_RESULT(vkBindImageMemory(device, offScreenFrameBuf.textureTarget.image, offScreenFrameBuf.textureTarget.deviceMemory, 0));
err = vkBindImageMemory(device, offScreenFrameBuf.textureTarget.image, offScreenFrameBuf.textureTarget.deviceMemory, 0);
assert(!err);
VkCommandBuffer layoutCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true); VkCommandBuffer layoutCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
@ -257,22 +252,18 @@ public:
sampler.mipLodBias = 0.0f; sampler.mipLodBias = 0.0f;
sampler.maxAnisotropy = 0; sampler.maxAnisotropy = 0;
sampler.minLod = 0.0f; sampler.minLod = 0.0f;
sampler.maxLod = 0.0f; sampler.maxLod = 1.0f;
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE; sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
err = vkCreateSampler(device, &sampler, nullptr, &offScreenFrameBuf.textureTarget.sampler); VK_CHECK_RESULT(vkCreateSampler(device, &sampler, nullptr, &offScreenFrameBuf.textureTarget.sampler));
assert(!err);
// Create image view // Create image view
VkImageViewCreateInfo view = {}; VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo();
view.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
view.pNext = NULL;
view.viewType = VK_IMAGE_VIEW_TYPE_2D; view.viewType = VK_IMAGE_VIEW_TYPE_2D;
view.format = format; view.format = format;
view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A }; view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
view.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 }; view.subresourceRange = { VK_IMAGE_ASPECT_DEPTH_BIT, 0, 1, 0, 1 };
view.image = offScreenFrameBuf.textureTarget.image; view.image = offScreenFrameBuf.textureTarget.image;
err = vkCreateImageView(device, &view, nullptr, &offScreenFrameBuf.textureTarget.view); VK_CHECK_RESULT(vkCreateImageView(device, &view, nullptr, &offScreenFrameBuf.textureTarget.view));
assert(!err);
} }
// Set up a separate render pass for the offscreen frame buffer // Set up a separate render pass for the offscreen frame buffer
@ -326,8 +317,7 @@ public:
renderPassCreateInfo.subpassCount = 1; renderPassCreateInfo.subpassCount = 1;
renderPassCreateInfo.pSubpasses = &subpass; renderPassCreateInfo.pSubpasses = &subpass;
VkResult err = vkCreateRenderPass(device, &renderPassCreateInfo, nullptr, &offScreenFrameBuf.renderPass); VK_CHECK_RESULT(vkCreateRenderPass(device, &renderPassCreateInfo, nullptr, &offScreenFrameBuf.renderPass));
assert(!err);
} }
void prepareOffscreenFramebuffer() void prepareOffscreenFramebuffer()
@ -337,8 +327,6 @@ public:
VkFormat fbColorFormat = FB_COLOR_FORMAT; VkFormat fbColorFormat = FB_COLOR_FORMAT;
VkResult err;
// Color attachment // Color attachment
VkImageCreateInfo image = vkTools::initializers::imageCreateInfo(); VkImageCreateInfo image = vkTools::initializers::imageCreateInfo();
image.imageType = VK_IMAGE_TYPE_2D; image.imageType = VK_IMAGE_TYPE_2D;
@ -354,6 +342,7 @@ public:
image.flags = 0; image.flags = 0;
VkMemoryAllocateInfo memAlloc = vkTools::initializers::memoryAllocateInfo(); VkMemoryAllocateInfo memAlloc = vkTools::initializers::memoryAllocateInfo();
VkMemoryRequirements memReqs;
VkImageViewCreateInfo colorImageView = vkTools::initializers::imageViewCreateInfo(); VkImageViewCreateInfo colorImageView = vkTools::initializers::imageViewCreateInfo();
colorImageView.viewType = VK_IMAGE_VIEW_TYPE_2D; colorImageView.viewType = VK_IMAGE_VIEW_TYPE_2D;
@ -365,18 +354,13 @@ public:
colorImageView.subresourceRange.levelCount = 1; colorImageView.subresourceRange.levelCount = 1;
colorImageView.subresourceRange.baseArrayLayer = 0; colorImageView.subresourceRange.baseArrayLayer = 0;
colorImageView.subresourceRange.layerCount = 1; colorImageView.subresourceRange.layerCount = 1;
VK_CHECK_RESULT(vkCreateImage(device, &image, nullptr, &offScreenFrameBuf.color.image));
VkMemoryRequirements memReqs;
err = vkCreateImage(device, &image, nullptr, &offScreenFrameBuf.color.image);
assert(!err);
vkGetImageMemoryRequirements(device, offScreenFrameBuf.color.image, &memReqs); vkGetImageMemoryRequirements(device, offScreenFrameBuf.color.image, &memReqs);
memAlloc.allocationSize = memReqs.size; memAlloc.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAlloc.memoryTypeIndex); memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
err = vkAllocateMemory(device, &memAlloc, nullptr, &offScreenFrameBuf.color.mem); VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &offScreenFrameBuf.color.mem));
assert(!err); VK_CHECK_RESULT(vkBindImageMemory(device, offScreenFrameBuf.color.image, offScreenFrameBuf.color.mem, 0));
err = vkBindImageMemory(device, offScreenFrameBuf.color.image, offScreenFrameBuf.color.mem, 0);
assert(!err);
VkCommandBuffer layoutCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true); VkCommandBuffer layoutCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
@ -388,8 +372,7 @@ public:
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL); VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL);
colorImageView.image = offScreenFrameBuf.color.image; colorImageView.image = offScreenFrameBuf.color.image;
err = vkCreateImageView(device, &colorImageView, nullptr, &offScreenFrameBuf.color.view); VK_CHECK_RESULT(vkCreateImageView(device, &colorImageView, nullptr, &offScreenFrameBuf.color.view));
assert(!err);
// Depth stencil attachment // Depth stencil attachment
image.format = DEPTH_FORMAT; image.format = DEPTH_FORMAT;
@ -405,17 +388,13 @@ public:
depthStencilView.subresourceRange.levelCount = 1; depthStencilView.subresourceRange.levelCount = 1;
depthStencilView.subresourceRange.baseArrayLayer = 0; depthStencilView.subresourceRange.baseArrayLayer = 0;
depthStencilView.subresourceRange.layerCount = 1; depthStencilView.subresourceRange.layerCount = 1;
VK_CHECK_RESULT(vkCreateImage(device, &image, nullptr, &offScreenFrameBuf.depth.image));
err = vkCreateImage(device, &image, nullptr, &offScreenFrameBuf.depth.image);
assert(!err);
vkGetImageMemoryRequirements(device, offScreenFrameBuf.depth.image, &memReqs); vkGetImageMemoryRequirements(device, offScreenFrameBuf.depth.image, &memReqs);
memAlloc.allocationSize = memReqs.size; memAlloc.allocationSize = memReqs.size;
getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, &memAlloc.memoryTypeIndex); memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
err = vkAllocateMemory(device, &memAlloc, nullptr, &offScreenFrameBuf.depth.mem); VK_CHECK_RESULT(vkAllocateMemory(device, &memAlloc, nullptr, &offScreenFrameBuf.depth.mem));
assert(!err); VK_CHECK_RESULT(vkBindImageMemory(device, offScreenFrameBuf.depth.image, offScreenFrameBuf.depth.mem, 0));
err = vkBindImageMemory(device, offScreenFrameBuf.depth.image, offScreenFrameBuf.depth.mem, 0);
assert(!err);
vkTools::setImageLayout( vkTools::setImageLayout(
layoutCmd, layoutCmd,
@ -427,8 +406,7 @@ public:
VulkanExampleBase::flushCommandBuffer(layoutCmd, queue, true); VulkanExampleBase::flushCommandBuffer(layoutCmd, queue, true);
depthStencilView.image = offScreenFrameBuf.depth.image; depthStencilView.image = offScreenFrameBuf.depth.image;
err = vkCreateImageView(device, &depthStencilView, nullptr, &offScreenFrameBuf.depth.view); VK_CHECK_RESULT(vkCreateImageView(device, &depthStencilView, nullptr, &offScreenFrameBuf.depth.view));
assert(!err);
VkImageView attachments[2]; VkImageView attachments[2];
attachments[0] = offScreenFrameBuf.color.view; attachments[0] = offScreenFrameBuf.color.view;
@ -445,14 +423,11 @@ public:
fbufCreateInfo.height = offScreenFrameBuf.height; fbufCreateInfo.height = offScreenFrameBuf.height;
fbufCreateInfo.layers = 1; fbufCreateInfo.layers = 1;
err = vkCreateFramebuffer(device, &fbufCreateInfo, nullptr, &offScreenFrameBuf.frameBuffer); VK_CHECK_RESULT(vkCreateFramebuffer(device, &fbufCreateInfo, nullptr, &offScreenFrameBuf.frameBuffer));
assert(!err);
} }
void buildOffscreenCommandBuffer() void buildOffscreenCommandBuffer()
{ {
VkResult err;
// Create separate command buffer for offscreen // Create separate command buffer for offscreen
// rendering // rendering
if (offScreenCmdBuffer == VK_NULL_HANDLE) if (offScreenCmdBuffer == VK_NULL_HANDLE)
@ -461,8 +436,7 @@ public:
cmdPool, cmdPool,
VK_COMMAND_BUFFER_LEVEL_PRIMARY, VK_COMMAND_BUFFER_LEVEL_PRIMARY,
1); 1);
VkResult vkRes = vkAllocateCommandBuffers(device, &cmd, &offScreenCmdBuffer); VK_CHECK_RESULT(vkAllocateCommandBuffers(device, &cmd, &offScreenCmdBuffer));
assert(!vkRes);
} }
// Create a semaphore used to synchronize offscreen rendering and usage // Create a semaphore used to synchronize offscreen rendering and usage
@ -485,21 +459,12 @@ public:
renderPassBeginInfo.clearValueCount = 2; renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = clearValues; renderPassBeginInfo.pClearValues = clearValues;
err = vkBeginCommandBuffer(offScreenCmdBuffer, &cmdBufInfo); VK_CHECK_RESULT(vkBeginCommandBuffer(offScreenCmdBuffer, &cmdBufInfo));
assert(!err);
VkViewport viewport = vkTools::initializers::viewport( VkViewport viewport = vkTools::initializers::viewport((float)offScreenFrameBuf.width, (float)offScreenFrameBuf.height, 0.0f, 1.0f);
(float)offScreenFrameBuf.width,
(float)offScreenFrameBuf.height,
0.0f,
1.0f);
vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport); vkCmdSetViewport(offScreenCmdBuffer, 0, 1, &viewport);
VkRect2D scissor = vkTools::initializers::rect2D( VkRect2D scissor = vkTools::initializers::rect2D(offScreenFrameBuf.width, offScreenFrameBuf.height, 0, 0);
offScreenFrameBuf.width,
offScreenFrameBuf.height,
0,
0);
vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor); vkCmdSetScissor(offScreenCmdBuffer, 0, 1, &scissor);
// Set depth bias (aka "Polygon offset") // Set depth bias (aka "Polygon offset")
@ -523,8 +488,7 @@ public:
updateTexture(); updateTexture();
err = vkEndCommandBuffer(offScreenCmdBuffer); VK_CHECK_RESULT(vkEndCommandBuffer(offScreenCmdBuffer));
assert(!err);
} }
void buildCommandBuffers() void buildCommandBuffers()
@ -544,15 +508,12 @@ public:
renderPassBeginInfo.clearValueCount = 2; renderPassBeginInfo.clearValueCount = 2;
renderPassBeginInfo.pClearValues = clearValues; renderPassBeginInfo.pClearValues = clearValues;
VkResult err;
for (int32_t i = 0; i < drawCmdBuffers.size(); ++i) for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
{ {
// Set target frame buffer // Set target frame buffer
renderPassBeginInfo.framebuffer = frameBuffers[i]; renderPassBeginInfo.framebuffer = frameBuffers[i];
err = vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo); VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
assert(!err);
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE); vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
@ -585,8 +546,7 @@ public:
vkCmdEndRenderPass(drawCmdBuffers[i]); vkCmdEndRenderPass(drawCmdBuffers[i]);
err = vkEndCommandBuffer(drawCmdBuffers[i]); VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
assert(!err);
} }
} }
@ -738,8 +698,7 @@ public:
poolSizes.data(), poolSizes.data(),
3); 3);
VkResult vkRes = vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool); VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
assert(!vkRes);
} }
void setupDescriptorSetLayout() void setupDescriptorSetLayout()
@ -764,20 +723,17 @@ public:
setLayoutBindings.data(), setLayoutBindings.data(),
setLayoutBindings.size()); setLayoutBindings.size());
VkResult err = vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout); VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
assert(!err);
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo = VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
vkTools::initializers::pipelineLayoutCreateInfo( vkTools::initializers::pipelineLayoutCreateInfo(
&descriptorSetLayout, &descriptorSetLayout,
1); 1);
err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.quad); VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.quad));
assert(!err);
// Offscreen pipeline layout // Offscreen pipeline layout
err = vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.offscreen); VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayouts.offscreen));
assert(!err);
} }
void setupDescriptorSets() void setupDescriptorSets()
@ -789,8 +745,7 @@ public:
&descriptorSetLayout, &descriptorSetLayout,
1); 1);
VkResult vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet); VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
assert(!vkRes);
// Image descriptor for the shadow map texture // Image descriptor for the shadow map texture
VkDescriptorImageInfo texDescriptor = VkDescriptorImageInfo texDescriptor =
@ -818,8 +773,7 @@ public:
vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL); vkUpdateDescriptorSets(device, writeDescriptorSets.size(), writeDescriptorSets.data(), 0, NULL);
// Offscreen // Offscreen
vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.offscreen); VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.offscreen));
assert(!vkRes);
std::vector<VkWriteDescriptorSet> offScreenWriteDescriptorSets = std::vector<VkWriteDescriptorSet> offScreenWriteDescriptorSets =
{ {
@ -833,8 +787,7 @@ public:
vkUpdateDescriptorSets(device, offScreenWriteDescriptorSets.size(), offScreenWriteDescriptorSets.data(), 0, NULL); vkUpdateDescriptorSets(device, offScreenWriteDescriptorSets.size(), offScreenWriteDescriptorSets.data(), 0, NULL);
// 3D scene // 3D scene
vkRes = vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.scene); VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSets.scene));
assert(!vkRes);
// Image descriptor for the shadow map texture // Image descriptor for the shadow map texture
texDescriptor.sampler = offScreenFrameBuf.textureTarget.sampler; texDescriptor.sampler = offScreenFrameBuf.textureTarget.sampler;
@ -934,15 +887,13 @@ public:
pipelineCreateInfo.stageCount = shaderStages.size(); pipelineCreateInfo.stageCount = shaderStages.size();
pipelineCreateInfo.pStages = shaderStages.data(); pipelineCreateInfo.pStages = shaderStages.data();
VkResult err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.quad); VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.quad));
assert(!err);
// 3D scene // 3D scene
shaderStages[0] = loadShader(getAssetPath() + "shaders/shadowmapping/scene.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[0] = loadShader(getAssetPath() + "shaders/shadowmapping/scene.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
shaderStages[1] = loadShader(getAssetPath() + "shaders/shadowmapping/scene.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT); shaderStages[1] = loadShader(getAssetPath() + "shaders/shadowmapping/scene.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
rasterizationState.cullMode = VK_CULL_MODE_NONE; rasterizationState.cullMode = VK_CULL_MODE_NONE;
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.scene); VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.scene));
assert(!err);
// Offscreen pipeline // Offscreen pipeline
shaderStages[0] = loadShader(getAssetPath() + "shaders/shadowmapping/offscreen.vert.spv", VK_SHADER_STAGE_VERTEX_BIT); shaderStages[0] = loadShader(getAssetPath() + "shaders/shadowmapping/offscreen.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
@ -960,8 +911,7 @@ public:
dynamicStateEnables.size(), dynamicStateEnables.size(),
0); 0);
err = vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.offscreen); VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.offscreen));
assert(!err);
} }
// Prepare and initialize uniform buffer containing shader uniforms // Prepare and initialize uniform buffer containing shader uniforms
@ -1016,8 +966,7 @@ public:
uboVSquad.model = glm::mat4(); uboVSquad.model = glm::mat4();
uint8_t *pData; uint8_t *pData;
VkResult err = vkMapMemory(device, uniformDataVS.memory, 0, sizeof(uboVSquad), 0, (void **)&pData); VK_CHECK_RESULT(vkMapMemory(device, uniformDataVS.memory, 0, sizeof(uboVSquad), 0, (void **)&pData));
assert(!err);
memcpy(pData, &uboVSquad, sizeof(uboVSquad)); memcpy(pData, &uboVSquad, sizeof(uboVSquad));
vkUnmapMemory(device, uniformDataVS.memory); vkUnmapMemory(device, uniformDataVS.memory);
@ -1043,9 +992,7 @@ public:
uboVSscene.depthBiasMVP = uboOffscreenVS.depthMVP; uboVSscene.depthBiasMVP = uboOffscreenVS.depthMVP;
pData; VK_CHECK_RESULT(vkMapMemory(device, uniformData.scene.memory, 0, sizeof(uboVSscene), 0, (void **)&pData));
err = vkMapMemory(device, uniformData.scene.memory, 0, sizeof(uboVSscene), 0, (void **)&pData);
assert(!err);
memcpy(pData, &uboVSscene, sizeof(uboVSscene)); memcpy(pData, &uboVSscene, sizeof(uboVSscene));
vkUnmapMemory(device, uniformData.scene.memory); vkUnmapMemory(device, uniformData.scene.memory);
} }
@ -1060,8 +1007,7 @@ public:
uboOffscreenVS.depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix; uboOffscreenVS.depthMVP = depthProjectionMatrix * depthViewMatrix * depthModelMatrix;
uint8_t *pData; uint8_t *pData;
VkResult err = vkMapMemory(device, uniformDataOffscreenVS.memory, 0, sizeof(uboOffscreenVS), 0, (void **)&pData); VK_CHECK_RESULT(vkMapMemory(device, uniformDataOffscreenVS.memory, 0, sizeof(uboOffscreenVS), 0, (void **)&pData));
assert(!err);
memcpy(pData, &uboOffscreenVS, sizeof(uboOffscreenVS)); memcpy(pData, &uboOffscreenVS, sizeof(uboOffscreenVS));
vkUnmapMemory(device, uniformDataOffscreenVS.memory); vkUnmapMemory(device, uniformDataOffscreenVS.memory);
} }