protected override void GenerateMipmapsCore(Texture texture)
{
EnsureNoRenderPass();
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(texture);
vkTex.TransitionImageLayout(_cb, 0, 1, 0, vkTex.ArrayLayers, VkImageLayout.TransferSrcOptimal);
vkTex.TransitionImageLayout(_cb, 1, vkTex.MipLevels - 1, 0, vkTex.ArrayLayers, VkImageLayout.TransferDstOptimal);
VkImage deviceImage = vkTex.OptimalDeviceImage;
uint blitCount = vkTex.MipLevels - 1;
VkImageBlit *regions = stackalloc VkImageBlit[(int)blitCount];
for (uint level = 1; level < vkTex.MipLevels; level++)
{
uint blitIndex = level - 1;
regions[blitIndex].srcSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
baseArrayLayer = 0,
layerCount = vkTex.ArrayLayers,
mipLevel = 0
};
regions[blitIndex].srcOffsets_0 = new VkOffset3D();
regions[blitIndex].srcOffsets_1 = new VkOffset3D {
x = (int)vkTex.Width, y = (int)vkTex.Height, z = (int)vkTex.Depth
};
regions[blitIndex].dstOffsets_0 = new VkOffset3D();
regions[blitIndex].dstSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
baseArrayLayer = 0,
layerCount = vkTex.ArrayLayers,
mipLevel = level
};
Util.GetMipDimensions(vkTex, level, out uint mipWidth, out uint mipHeight, out uint mipDepth);
regions[blitIndex].dstOffsets_1 = new VkOffset3D {
x = (int)mipWidth, y = (int)mipHeight, z = (int)mipDepth
};
}
vkCmdBlitImage(
_cb,
deviceImage, VkImageLayout.TransferSrcOptimal,
deviceImage, VkImageLayout.TransferDstOptimal,
blitCount, regions,
_gd.GetFormatFilter(vkTex.VkFormat));
if ((vkTex.Usage & TextureUsage.Sampled) != 0)
{
// This is somewhat ugly -- the transition logic does not handle different source layouts, so we do two batches.
vkTex.TransitionImageLayout(_cb, 0, 1, 0, vkTex.ArrayLayers, VkImageLayout.ShaderReadOnlyOptimal);
vkTex.TransitionImageLayout(_cb, 1, vkTex.MipLevels - 1, 0, vkTex.ArrayLayers, VkImageLayout.ShaderReadOnlyOptimal);
}
}
public override void TransitionToFinalLayout(VkCommandBuffer cb)
{
foreach (FramebufferAttachment ca in ColorTargets)
{
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(ca.Target);
vkTex.SetImageLayout(ca.MipLevel, ca.ArrayLayer, VkImageLayout.ColorAttachmentOptimal);
if ((vkTex.Usage & TextureUsage.Sampled) != 0)
{
vkTex.TransitionImageLayout(
cb,
ca.MipLevel, 1,
ca.ArrayLayer, 1,
VkImageLayout.ShaderReadOnlyOptimal);
}
}
if (DepthTarget != null)
{
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(DepthTarget.Value.Target);
vkTex.SetImageLayout(
DepthTarget.Value.MipLevel,
DepthTarget.Value.ArrayLayer,
VkImageLayout.DepthStencilAttachmentOptimal);
if ((vkTex.Usage & TextureUsage.Sampled) != 0)
{
vkTex.TransitionImageLayout(
cb,
DepthTarget.Value.MipLevel, 1,
DepthTarget.Value.ArrayLayer, 1,
VkImageLayout.ShaderReadOnlyOptimal);
}
}
}
public override void TransitionToFinalLayout(VkCommandBuffer cb)
{
for (int i = 0; i < ColorTargets.Count; i++)
{
FramebufferAttachment ca = ColorTargets[i];
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(ca.Target);
if ((vkTex.Usage & TextureUsage.Sampled) != 0)
{
vkTex.TransitionImageLayout(
cb,
ca.MipLevel, 1,
ca.ArrayLayer, 1,
VkImageLayout.ShaderReadOnlyOptimal);
}
}
if (DepthTarget != null)
{
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(DepthTarget.Value.Target);
if ((vkTex.Usage & TextureUsage.Sampled) != 0)
{
vkTex.TransitionImageLayout(
cb,
DepthTarget.Value.MipLevel, 1,
DepthTarget.Value.ArrayLayer, 1,
VkImageLayout.ShaderReadOnlyOptimal);
}
}
}
public override void TransitionToFinalLayout(VkCommandBuffer cb)
{
foreach (FramebufferAttachment ca in ColorTargets)
{
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(ca.Target);
vkTex.TransitionImageLayout(cb, 0, 1, ca.ArrayLayer, 1, VkImageLayout.PresentSrcKHR);
}
}
public override void TransitionToFinalLayout(VkCommandBuffer cb)
{
for (int i = 0; i < ColorTargets.Count; i++)
{
FramebufferAttachment ca = ColorTargets[i];
VkTexture vkTex = Util.AssertSubtype <Texture, VkTexture>(ca.Target);
vkTex.TransitionImageLayout(cb, 0, 1, ca.ArrayLayer, 1, VkImageLayout.PresentSrcKHR);
}
}
protected override void ResolveTextureCore(Texture source, Texture destination)
{
if (_activeRenderPass != VkRenderPass.Null)
{
EndCurrentRenderPass();
}
VkTexture vkSource = Util.AssertSubtype <Texture, VkTexture>(source);
VkTexture vkDestination = Util.AssertSubtype <Texture, VkTexture>(destination);
VkImageAspectFlags aspectFlags = ((source.Usage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil)
? VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil
: VkImageAspectFlags.Color;
VkImageResolve region = new VkImageResolve
{
extent = new VkExtent3D {
width = source.Width, height = source.Height, depth = source.Depth
},
srcSubresource = new VkImageSubresourceLayers {
layerCount = 1, aspectMask = aspectFlags
},
dstSubresource = new VkImageSubresourceLayers {
layerCount = 1, aspectMask = aspectFlags
}
};
vkSource.TransitionImageLayout(_cb, 0, 1, 0, 1, VkImageLayout.TransferSrcOptimal);
vkDestination.TransitionImageLayout(_cb, 0, 1, 0, 1, VkImageLayout.TransferDstOptimal);
vkCmdResolveImage(
_cb,
vkSource.OptimalDeviceImage,
VkImageLayout.TransferSrcOptimal,
vkDestination.OptimalDeviceImage,
VkImageLayout.TransferDstOptimal,
1,
ref region);
if ((vkDestination.Usage & TextureUsage.Sampled) != 0)
{
vkDestination.TransitionImageLayout(_cb, 0, 1, 0, 1, VkImageLayout.ShaderReadOnlyOptimal);
}
}
internal static void CopyTextureCore_VkCommandBuffer(
VkCommandBuffer cb,
Texture source,
uint srcX, uint srcY, uint srcZ,
uint srcMipLevel,
uint srcBaseArrayLayer,
Texture destination,
uint dstX, uint dstY, uint dstZ,
uint dstMipLevel,
uint dstBaseArrayLayer,
uint width, uint height, uint depth,
uint layerCount)
{
VkTexture srcVkTexture = Util.AssertSubtype <Texture, VkTexture>(source);
VkTexture dstVkTexture = Util.AssertSubtype <Texture, VkTexture>(destination);
bool sourceIsStaging = (source.Usage & TextureUsage.Staging) == TextureUsage.Staging;
bool destIsStaging = (destination.Usage & TextureUsage.Staging) == TextureUsage.Staging;
if (!sourceIsStaging && !destIsStaging)
{
VkImageSubresourceLayers srcSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
layerCount = layerCount,
mipLevel = srcMipLevel,
baseArrayLayer = srcBaseArrayLayer
};
VkImageSubresourceLayers dstSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
layerCount = layerCount,
mipLevel = dstMipLevel,
baseArrayLayer = dstBaseArrayLayer
};
VkImageCopy region = new VkImageCopy
{
srcOffset = new VkOffset3D {
x = (int)srcX, y = (int)srcY, z = (int)srcZ
},
dstOffset = new VkOffset3D {
x = (int)dstX, y = (int)dstY, z = (int)dstZ
},
srcSubresource = srcSubresource,
dstSubresource = dstSubresource,
extent = new VkExtent3D {
width = width, height = height, depth = depth
}
};
srcVkTexture.TransitionImageLayout(
cb,
srcMipLevel,
1,
srcBaseArrayLayer,
layerCount,
VkImageLayout.TransferSrcOptimal);
dstVkTexture.TransitionImageLayout(
cb,
dstMipLevel,
1,
dstBaseArrayLayer,
layerCount,
VkImageLayout.TransferDstOptimal);
vkCmdCopyImage(
cb,
srcVkTexture.OptimalDeviceImage,
VkImageLayout.TransferSrcOptimal,
dstVkTexture.OptimalDeviceImage,
VkImageLayout.TransferDstOptimal,
1,
ref region);
}
else if (sourceIsStaging && !destIsStaging)
{
Vulkan.VkBuffer srcBuffer = srcVkTexture.StagingBuffer;
VkSubresourceLayout srcLayout = srcVkTexture.GetSubresourceLayout(
srcVkTexture.CalculateSubresource(srcMipLevel, srcBaseArrayLayer));
VkImage dstImage = dstVkTexture.OptimalDeviceImage;
dstVkTexture.TransitionImageLayout(
cb,
dstMipLevel,
1,
dstBaseArrayLayer,
layerCount,
VkImageLayout.TransferDstOptimal);
VkImageSubresourceLayers dstSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
layerCount = layerCount,
mipLevel = dstMipLevel,
baseArrayLayer = dstBaseArrayLayer
};
Util.GetMipDimensions(srcVkTexture, srcMipLevel, out uint mipWidth, out uint mipHeight, out uint mipDepth);
uint blockSize = FormatHelpers.IsCompressedFormat(srcVkTexture.Format) ? 4u : 1u;
uint bufferRowLength = Math.Max(mipWidth, blockSize);
uint bufferImageHeight = Math.Max(mipHeight, blockSize);
uint compressedX = srcX / blockSize;
uint compressedY = srcY / blockSize;
uint blockSizeInBytes = blockSize == 1
? FormatHelpers.GetSizeInBytes(srcVkTexture.Format)
: FormatHelpers.GetBlockSizeInBytes(srcVkTexture.Format);
uint rowPitch = FormatHelpers.GetRowPitch(bufferRowLength, srcVkTexture.Format);
uint depthPitch = FormatHelpers.GetDepthPitch(rowPitch, bufferImageHeight, srcVkTexture.Format);
VkBufferImageCopy regions = new VkBufferImageCopy
{
bufferOffset = srcLayout.offset
+ (srcZ * depthPitch)
+ (compressedY * rowPitch)
+ (compressedX * blockSizeInBytes),
bufferRowLength = bufferRowLength,
bufferImageHeight = bufferImageHeight,
imageExtent = new VkExtent3D {
width = width, height = height, depth = depth
},
imageOffset = new VkOffset3D {
x = (int)dstX, y = (int)dstY, z = (int)dstZ
},
imageSubresource = dstSubresource
};
vkCmdCopyBufferToImage(cb, srcBuffer, dstImage, VkImageLayout.TransferDstOptimal, 1, ref regions);
}
else if (!sourceIsStaging && destIsStaging)
{
VkImage srcImage = srcVkTexture.OptimalDeviceImage;
srcVkTexture.TransitionImageLayout(
cb,
srcMipLevel,
1,
srcBaseArrayLayer,
layerCount,
VkImageLayout.TransferSrcOptimal);
Vulkan.VkBuffer dstBuffer = dstVkTexture.StagingBuffer;
VkSubresourceLayout dstLayout = dstVkTexture.GetSubresourceLayout(
dstVkTexture.CalculateSubresource(dstMipLevel, dstBaseArrayLayer));
VkImageSubresourceLayers srcSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
layerCount = layerCount,
mipLevel = srcMipLevel,
baseArrayLayer = srcBaseArrayLayer
};
Util.GetMipDimensions(dstVkTexture, dstMipLevel, out uint mipWidth, out uint mipHeight, out uint mipDepth);
VkBufferImageCopy region = new VkBufferImageCopy
{
bufferRowLength = mipWidth,
bufferImageHeight = mipHeight,
bufferOffset = dstLayout.offset + (dstX * FormatHelpers.GetSizeInBytes(dstVkTexture.Format)),
imageExtent = new VkExtent3D {
width = width, height = height, depth = depth
},
imageOffset = new VkOffset3D {
x = (int)dstX, y = (int)dstY, z = (int)dstZ
},
imageSubresource = srcSubresource
};
vkCmdCopyImageToBuffer(cb, srcImage, VkImageLayout.TransferSrcOptimal, dstBuffer, 1, ref region);
}
else
{
Debug.Assert(sourceIsStaging && destIsStaging);
Vulkan.VkBuffer srcBuffer = srcVkTexture.StagingBuffer;
VkSubresourceLayout srcLayout = srcVkTexture.GetSubresourceLayout(
srcVkTexture.CalculateSubresource(srcMipLevel, srcBaseArrayLayer));
Vulkan.VkBuffer dstBuffer = dstVkTexture.StagingBuffer;
VkSubresourceLayout dstLayout = dstVkTexture.GetSubresourceLayout(
dstVkTexture.CalculateSubresource(dstMipLevel, dstBaseArrayLayer));
uint zLimit = Math.Max(depth, layerCount);
if (!FormatHelpers.IsCompressedFormat(source.Format))
{
uint pixelSize = FormatHelpers.GetSizeInBytes(srcVkTexture.Format);
for (uint zz = 0; zz < zLimit; zz++)
{
for (uint yy = 0; yy < height; yy++)
{
VkBufferCopy region = new VkBufferCopy
{
srcOffset = srcLayout.offset
+ srcLayout.depthPitch * (zz + srcZ)
+ srcLayout.rowPitch * (yy + srcY)
+ pixelSize * srcX,
dstOffset = dstLayout.offset
+ dstLayout.depthPitch * (zz + dstZ)
+ dstLayout.rowPitch * (yy + dstY)
+ pixelSize * dstX,
size = width * pixelSize,
};
vkCmdCopyBuffer(cb, srcBuffer, dstBuffer, 1, ref region);
}
}
}
else // IsCompressedFormat
{
uint denseRowSize = FormatHelpers.GetRowPitch(width, source.Format);
uint numRows = FormatHelpers.GetNumRows(height, source.Format);
uint compressedSrcX = srcX / 4;
uint compressedSrcY = srcY / 4;
uint compressedDstX = dstX / 4;
uint compressedDstY = dstY / 4;
uint blockSizeInBytes = FormatHelpers.GetBlockSizeInBytes(source.Format);
for (uint zz = 0; zz < zLimit; zz++)
{
for (uint row = 0; row < numRows; row++)
{
VkBufferCopy region = new VkBufferCopy
{
srcOffset = srcLayout.offset
+ srcLayout.depthPitch * (zz + srcZ)
+ srcLayout.rowPitch * (row + compressedSrcY)
+ blockSizeInBytes * compressedSrcX,
dstOffset = dstLayout.offset
+ dstLayout.depthPitch * (zz + dstZ)
+ dstLayout.rowPitch * (row + compressedDstY)
+ blockSizeInBytes * compressedDstX,
size = denseRowSize,
};
vkCmdCopyBuffer(cb, srcBuffer, dstBuffer, 1, ref region);
}
}
}
}
}
protected override void CopyTextureCore(
Texture source,
uint srcX, uint srcY, uint srcZ,
uint srcMipLevel,
uint srcBaseArrayLayer,
Texture destination,
uint dstX, uint dstY, uint dstZ,
uint dstMipLevel,
uint dstBaseArrayLayer,
uint width, uint height, uint depth,
uint layerCount)
{
EnsureNoRenderPass();
bool sourceIsStaging = (source.Usage & TextureUsage.Staging) == TextureUsage.Staging;
bool destIsStaging = (destination.Usage & TextureUsage.Staging) == TextureUsage.Staging;
if ((destIsStaging || sourceIsStaging) && layerCount > 1)
{
// Need to issue one copy per array layer.
throw new NotImplementedException();
}
VkImageSubresourceLayers srcSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
layerCount = layerCount,
mipLevel = sourceIsStaging ? 0 : srcMipLevel,
baseArrayLayer = sourceIsStaging ? 0 : srcBaseArrayLayer
};
VkImageSubresourceLayers dstSubresource = new VkImageSubresourceLayers
{
aspectMask = VkImageAspectFlags.Color,
layerCount = layerCount,
mipLevel = destIsStaging ? 0 : dstMipLevel,
baseArrayLayer = destIsStaging ? 0 : dstBaseArrayLayer
};
VkImageCopy region = new VkImageCopy
{
srcOffset = new VkOffset3D {
x = (int)srcX, y = (int)srcY, z = (int)srcZ
},
dstOffset = new VkOffset3D {
x = (int)dstX, y = (int)dstY, z = (int)dstZ
},
srcSubresource = srcSubresource,
dstSubresource = dstSubresource,
extent = new VkExtent3D {
width = width, height = height, depth = depth
}
};
VkTexture srcVkTexture = Util.AssertSubtype <Texture, VkTexture>(source);
VkTexture dstVkTexture = Util.AssertSubtype <Texture, VkTexture>(destination);
srcVkTexture.TransitionImageLayout(
_cb,
srcMipLevel,
1,
srcBaseArrayLayer,
layerCount,
VkImageLayout.TransferSrcOptimal);
dstVkTexture.TransitionImageLayout(
_cb,
dstMipLevel,
1,
dstBaseArrayLayer,
layerCount,
VkImageLayout.TransferDstOptimal);
VkImage srcImage = sourceIsStaging
? srcVkTexture.GetStagingImage(source.CalculateSubresource(srcMipLevel, srcBaseArrayLayer))
: srcVkTexture.OptimalDeviceImage;
VkImage dstImage = destIsStaging
? dstVkTexture.GetStagingImage(destination.CalculateSubresource(dstMipLevel, dstBaseArrayLayer))
: dstVkTexture.OptimalDeviceImage;
vkCmdCopyImage(
_cb,
srcImage,
VkImageLayout.TransferSrcOptimal,
dstImage,
VkImageLayout.TransferDstOptimal,
1,
ref region);
_referencedResources.Add(srcVkTexture);
_referencedResources.Add(dstVkTexture);
}
