I’ve noticed after switching to shader objects I noticed my depth image is no longer being written to anyone know why this is
Im setting up the attachment like so
subResourceRange : VkImageSubresourceRange = .{};
{
using subResourceRange;
aspectMask = .COLOR_BIT;
baseMipLevel = 0;
levelCount = VK_REMAINING_MIP_LEVELS;
baseArrayLayer = 0;
layerCount = VK_REMAINING_ARRAY_LAYERS;
}
depthSubResourceRange : VkImageSubresourceRange = .{};
{
using depthSubResourceRange;
aspectMask = .VK_IMAGE_ASPECT_DEPTH_BIT | .VK_IMAGE_ASPECT_STENCIL_BIT;
baseMipLevel = 0;
levelCount = VK_REMAINING_MIP_LEVELS;
baseArrayLayer = 0;
layerCount = VK_REMAINING_ARRAY_LAYERS;
}
// Change layout of image to be optimal for clearing
imgMemoryBarrier : VkImageMemoryBarrier = .{};
{
using imgMemoryBarrier;
srcAccessMask = 0;
dstAccessMask = .TRANSFER_WRITE_BIT;
oldLayout = .UNDEFINED;
newLayout = .TRANSFER_DST_OPTIMAL;
srcQueueFamilyIndex = r.pipeline.queueIndex;
dstQueueFamilyIndex = r.pipeline.queueIndex;
image = r.pipeline.imgs[imageIndex];
subresourceRange = subResourceRange;
}
depthBarrier : VkImageMemoryBarrier = .{};
{
using depthBarrier;
srcAccessMask = 0 ;
dstAccessMask = .VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT ;
oldLayout = .UNDEFINED;
newLayout = .VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL;
srcQueueFamilyIndex = r.pipeline.queueIndex;
dstQueueFamilyIndex = r.pipeline.queueIndex;
image = r.pipeline.depthimg;
subresourceRange = depthSubResourceRange;
}
vkCmdPipelineBarrier(commandBuffers[index], .TRANSFER_BIT, .TRANSFER_BIT,
0, 0, null, 0, null, 1, *imgMemoryBarrier);
clearColor : VkClearColorValue = .{.[0.01176, 0, 0.03922,1]};
vkCmdClearColorImage(commandBuffers[index], r.pipeline.imgs[imageIndex], .TRANSFER_DST_OPTIMAL, *clearColor, 1, *subResourceRange);
// Change layout of image to be optimal for presenting
imgMemoryBarrier.srcAccessMask = .TRANSFER_WRITE_BIT;
imgMemoryBarrier.dstAccessMask = .MEMORY_READ_BIT;
imgMemoryBarrier.oldLayout = .TRANSFER_DST_OPTIMAL;
imgMemoryBarrier.newLayout = .PRESENT_SRC_KHR;
cAttInfo:VkRenderingAttachmentInfo = attachment_info(r.pipeline.ImageViews[imageIndex],null,.VK_IMAGE_LAYOUT_GENERAL);
dAttInfo:VkRenderingAttachmentInfo = depth_attachment_info(r.pipeline.depthImgView,.DEPTH_STENCIL_ATTACHMENT_OPTIMAL);
renInf:VkRenderingInfo = rendering_info(r.pipeline.Extent,*cAttInfo,*dAttInfo);
(keep in mind the jai vulkan bindings already have stype filled out for you)
with depth_attachment_info and rendering_info being
depth_attachment_info :: (view:VkImageView, layout:VkImageLayout) -> VkRenderingAttachmentInfo
{
depthAttachment: VkRenderingAttachmentInfo = .{};
depthAttachment.sType = .VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO;
depthAttachment.pNext = null;
depthAttachment.imageView = view;
depthAttachment.imageLayout = layout;
depthAttachment.loadOp = .VK_ATTACHMENT_LOAD_OP_CLEAR;
depthAttachment.storeOp = .VK_ATTACHMENT_STORE_OP_STORE;
depthAttachment.clearValue.depthStencil.depth = 0;
return depthAttachment;
}
rendering_info :: (renderExtent:VkExtent2D, colorAttachment:*VkRenderingAttachmentInfo,depthAttachment:*VkRenderingAttachmentInfo) -> VkRenderingInfo
{
renderInfo:VkRenderingInfo = .{};
renderInfo.sType = .VK_STRUCTURE_TYPE_RENDERING_INFO;
renderInfo.pNext = null;
renderInfo.renderArea = VkRect2D.{ VkOffset2D.{ 0, 0 }, renderExtent };
renderInfo.layerCount = 1;
renderInfo.colorAttachmentCount = 1;
renderInfo.pColorAttachments = colorAttachment;
renderInfo.pDepthAttachment = depthAttachment;
renderInfo.pStencilAttachment = null;
return renderInfo;
}
and then setting the pipeline state like so
vkCmdBeginRendering(r.pipeline.g_Pipeline.commandBuffers[index],*renInf);
vkCmdSetColorWriteMaskEXT(commandBuffers[index],0,1,VkColorComponentFlags.[.R_BIT | .G_BIT | .B_BIT | .A_BIT].data);
vkCmdSetColorBlendEnableEXT(commandBuffers[index],0,1,VkBool32.[VK_TRUE].data);
vkCmdSetLogicOpEnableEXT(commandBuffers[index],VK_FALSE);
vkCmdSetRasterizerDiscardEnable(commandBuffers[index],VK_FALSE);
vkCmdSetPolygonModeEXT(commandBuffers[index],.FILL);
vkCmdSetPrimitiveTopology(commandBuffers[index],.VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST);
vkCmdSetPrimitiveRestartEnable(commandBuffers[index],VK_FALSE);
vkCmdSetDepthTestEnable(commandBuffers[index],VK_TRUE);
vkCmdSetDepthBiasEnable(commandBuffers[index],VK_FALSE);
vkCmdSetDepthClampEnableEXT(commandBuffers[index],VK_TRUE);
vkCmdSetDepthClipEnableEXT(commandBuffers[index],VK_TRUE);
vkCmdSetStencilTestEnable(commandBuffers[index],VK_FALSE);
vkCmdSetDepthWriteEnable(commandBuffers[index],VK_TRUE);
vkCmdSetDepthBoundsTestEnable(commandBuffers[index],VK_TRUE);
vkCmdSetSampleMaskEXT(commandBuffers[index],0x1,u32.[1,1,1,1].data); // ! Hack to get around validation errors
vkCmdSetAlphaToCoverageEnableEXT(commandBuffers[index],VK_FALSE);
vkCmdSetRasterizationSamplesEXT(commandBuffers[index],.VK_SAMPLE_COUNT_1_BIT);
vkCmdSetCullMode(commandBuffers[index],.NONE);
cbEQ:VkColorBlendEquationEXT;
cbEQ.srcColorBlendFactor = .VK_BLEND_FACTOR_SRC_ALPHA;
cbEQ.dstColorBlendFactor = .VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
cbEQ.colorBlendOp = .VK_BLEND_OP_ADD;
cbEQ.srcAlphaBlendFactor = .VK_BLEND_FACTOR_ONE;
cbEQ.dstAlphaBlendFactor = .VK_BLEND_FACTOR_ZERO;
cbEQ.alphaBlendOp = .VK_BLEND_OP_ADD;
vkCmdSetColorBlendEquationEXT(commandBuffers[index],0,1,*cbEQ);
vkCmdSetDepthBounds(commandBuffers[index],0,1);
vkCmdSetDepthCompareOp(commandBuffers[index],.GREATER_OR_EQUAL);
vkCmdSetAlphaToOneEnableEXT(commandBuffers[index],VK_TRUE);
and the depth image very simply being created with
dimgCreateInfo:VkImageCreateInfo = .{};
dimgCreateInfo.imageType = ._3D;
dimgCreateInfo.extent.width = pipeline.Extent.width;
dimgCreateInfo.extent.height = pipeline.Extent.height;
dimgCreateInfo.extent.depth = 1;
dimgCreateInfo.mipLevels = 1;
dimgCreateInfo.arrayLayers = 1;
dimgCreateInfo.format = .VK_FORMAT_D32_SFLOAT_S8_UINT;
dimgCreateInfo.tiling = .VK_IMAGE_TILING_OPTIMAL;
dimgCreateInfo.initialLayout = .VK_IMAGE_LAYOUT_UNDEFINED;
dimgCreateInfo.usage = .VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT;
dimgCreateInfo.samples = .VK_SAMPLE_COUNT_1_BIT;
dimgCreateInfo.sharingMode = .VK_SHARING_MODE_EXCLUSIVE;
vkCreateImage(pipeline.lDevice,*dimgCreateInfo,null,*pipeline.depthimg);
pmemRequirements:VkPhysicalDeviceMemoryProperties = .{};
vkGetPhysicalDeviceMemoryProperties(pipeline.pDevice,*pmemRequirements);
memRequirements:VkMemoryRequirements = .{};
vkGetImageMemoryRequirements(pipeline.lDevice, pipeline.depthimg, *memRequirements);
allocInfo:VkMemoryAllocateInfo = .{};
allocInfo.sType = .VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
memindex:u32;
for 0..pmemRequirements.memoryTypes.count - 1 {
if (memRequirements.memoryTypeBits & (1 << it)) && (pmemRequirements.memoryTypes[it].propertyFlags & .VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) == .VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT { memindex = xx it; break; }
}
allocInfo.memoryTypeIndex = memindex;
if (vkAllocateMemory(pipeline.lDevice, *allocInfo, null, *pipeline.depthimgmem) != .VK_SUCCESS) {
log(.Error, "could not create depth memory");
}
vkBindImageMemory(pipeline.lDevice, pipeline.depthimg, pipeline.depthimgmem, 0);
dCreateInfo: VkImageViewCreateInfo = .{};
dCreateInfo.image = pipeline.depthimg;
dCreateInfo.viewType = .VK_IMAGE_VIEW_TYPE_3D;
dCreateInfo.format = .VK_FORMAT_D32_SFLOAT_S8_UINT;
dCreateInfo.components.r = .VK_COMPONENT_SWIZZLE_IDENTITY;
dCreateInfo.components.g = .VK_COMPONENT_SWIZZLE_IDENTITY;
dCreateInfo.components.b = .VK_COMPONENT_SWIZZLE_IDENTITY;
dCreateInfo.components.a = .VK_COMPONENT_SWIZZLE_IDENTITY;
dCreateInfo.subresourceRange.aspectMask = .VK_IMAGE_ASPECT_DEPTH_BIT | .VK_IMAGE_ASPECT_STENCIL_BIT;
dCreateInfo.subresourceRange.baseMipLevel = 0;
dCreateInfo.subresourceRange.levelCount = 1;
dCreateInfo.subresourceRange.baseArrayLayer = 0;
dCreateInfo.subresourceRange.layerCount = 1;
result := vkCreateImageView(pipeline.lDevice, *dCreateInfo, null, *pipeline.depthImgView);
if result != .VK_SUCCESS {
log(.Warning,sprint("Could not create image view % because %",dCreateInfo.image,result));
}