public VkSubresourceLayout GetSubresourceLayout(VkImageSubresource subresource)
{
var result = new VkSubresourceLayout();
Device.Commands.getSubresourceLayout(Device.Native, image, ref subresource, out result);
return(result);
}
public VkSubresourceLayout GetSubresourceLayout(VkImageAspectFlags aspectMask = VkImageAspectFlags.Color, uint mipLevel = 0, uint arrayLayer = 0)
{
VkImageSubresource subresource = new VkImageSubresource {
aspectMask = aspectMask,
mipLevel = mipLevel,
arrayLayer = arrayLayer
};
vkGetImageSubresourceLayout(Dev.VkDev, this.handle, ref subresource, out VkSubresourceLayout result);
return(result);
}
internal VkSubresourceLayout GetSubresourceLayout(uint subresource)
{
bool staging = _stagingBuffer.Handle != 0;
Util.GetMipLevelAndArrayLayer(this, subresource, out uint mipLevel, out uint arrayLayer);
if (!staging)
{
VkImageAspectFlags aspect = (Usage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil
? (VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil)
: VkImageAspectFlags.Color;
VkImageSubresource imageSubresource = new VkImageSubresource
{
arrayLayer = arrayLayer,
mipLevel = mipLevel,
aspectMask = aspect,
};
vkGetImageSubresourceLayout(_gd.Device, _optimalImage, ref imageSubresource, out VkSubresourceLayout layout);
return(layout);
}
else
{
uint blockSize = FormatHelpers.IsCompressedFormat(Format) ? 4u : 1u;
Util.GetMipDimensions(this, mipLevel, out uint mipWidth, out uint mipHeight, out uint mipDepth);
uint rowPitch = FormatHelpers.GetRowPitch(mipWidth, Format);
uint depthPitch = FormatHelpers.GetDepthPitch(rowPitch, mipHeight, Format);
VkSubresourceLayout layout = new VkSubresourceLayout()
{
rowPitch = rowPitch,
depthPitch = depthPitch,
arrayPitch = depthPitch,
size = depthPitch,
};
layout.offset = Util.ComputeSubresourceOffset(this, mipLevel, arrayLayer);
return(layout);
}
}
internal VkSubresourceLayout GetSubresourceLayout(uint subresource)
{
bool staging = _stagingImages != null;
Util.GetMipLevelAndArrayLayer(this, subresource, out uint mipLevel, out uint arrayLayer);
VkImageAspectFlags aspect = (Usage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil
? (VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil)
: VkImageAspectFlags.Color;
VkImageSubresource imageSubresource = new VkImageSubresource
{
arrayLayer = staging ? 0 : arrayLayer,
mipLevel = staging ? 0 : mipLevel,
aspectMask = aspect,
};
VkImage image = staging
? _stagingImages[subresource]
: _optimalImage;
vkGetImageSubresourceLayout(_gd.Device, image, ref imageSubresource, out VkSubresourceLayout layout);
return(layout);
}
internal VkSubresourceLayout GetSubresourceLayout(uint subresource)
{
bool staging = _stagingBuffer != null;
Util.GetMipLevelAndArrayLayer(this, subresource, out uint mipLevel, out uint arrayLayer);
if (!staging)
{
VkImageAspectFlags aspect = (Usage & TextureUsage.DepthStencil) == TextureUsage.DepthStencil
? (VkImageAspectFlags.Depth | VkImageAspectFlags.Stencil)
: VkImageAspectFlags.Color;
VkImageSubresource imageSubresource = new VkImageSubresource
{
arrayLayer = arrayLayer,
mipLevel = mipLevel,
aspectMask = aspect,
};
vkGetImageSubresourceLayout(_gd.Device, _optimalImage, ref imageSubresource, out VkSubresourceLayout layout);
return(layout);
}
else
{
uint pixelSize = FormatHelpers.GetSizeInBytes(Format);
Util.GetMipDimensions(this, mipLevel, out uint mipWidth, out uint mipHeight, out uint mipDepth);
VkSubresourceLayout layout = new VkSubresourceLayout()
{
rowPitch = mipWidth * pixelSize,
depthPitch = mipWidth * mipHeight * pixelSize,
arrayPitch = mipWidth * mipHeight * pixelSize,
size = mipWidth * mipHeight * mipDepth * pixelSize
};
layout.offset = Util.ComputeSubresourceOffset(this, mipLevel, arrayLayer);
return(layout);
}
}
public static extern void GetImageSubresourceLayout(
VkDevice device,
VkImage image,
ref VkImageSubresource pSubresource,
out VkSubresourceLayout pLayout
);
public override void UpdateTextureCube(
Texture textureCube,
IntPtr source,
uint sizeInBytes,
CubeFace face,
uint x,
uint y,
uint width,
uint height,
uint mipLevel,
uint arrayLayer)
{
VkTexture vkTexCube = Util.AssertSubtype <Texture, VkTexture>(textureCube);
if (x != 0 || y != 0)
{
throw new NotImplementedException();
}
// First, create a staging texture.
CreateImage(
_gd.Device,
_gd.PhysicalDeviceMemProperties,
_gd.MemoryManager,
width,
height,
1,
1,
VkFormats.VdToVkPixelFormat(vkTexCube.Format),
VkImageTiling.Linear,
VkImageUsageFlags.TransferSrc,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent,
out VkImage stagingImage,
out VkMemoryBlock stagingMemory);
VkImageSubresource subresource = new VkImageSubresource();
subresource.aspectMask = VkImageAspectFlags.Color;
subresource.mipLevel = 0;
subresource.arrayLayer = 0;
vkGetImageSubresourceLayout(_gd.Device, stagingImage, ref subresource, out VkSubresourceLayout stagingLayout);
ulong rowPitch = stagingLayout.rowPitch;
void * mappedPtr;
VkResult result = vkMapMemory(_gd.Device, stagingMemory.DeviceMemory, stagingMemory.Offset, stagingLayout.size, 0, &mappedPtr);
CheckResult(result);
if (rowPitch == width)
{
System.Buffer.MemoryCopy(source.ToPointer(), mappedPtr, sizeInBytes, sizeInBytes);
}
else
{
uint pixelSizeInBytes = FormatHelpers.GetSizeInBytes(vkTexCube.Format);
for (uint yy = 0; yy < height; yy++)
{
byte *dstRowStart = ((byte *)mappedPtr) + (rowPitch * yy);
byte *srcRowStart = ((byte *)source.ToPointer()) + (width * yy * pixelSizeInBytes);
Unsafe.CopyBlock(dstRowStart, srcRowStart, width * pixelSizeInBytes);
}
}
vkUnmapMemory(_gd.Device, stagingMemory.DeviceMemory);
uint cubeArrayLayer = GetArrayLayer(face);
// TODO: These transitions are sub-optimal.
TransitionImageLayout(stagingImage, 0, 1, 0, 1, VkImageLayout.Preinitialized, VkImageLayout.TransferSrcOptimal);
TransitionImageLayout(vkTexCube.DeviceImage, 0, 1, 0, 6, vkTexCube.ImageLayouts[0], VkImageLayout.TransferDstOptimal);
CopyImage(stagingImage, 0, vkTexCube.DeviceImage, mipLevel, width, height, cubeArrayLayer);
TransitionImageLayout(vkTexCube.DeviceImage, 0, 1, 0, 6, VkImageLayout.TransferDstOptimal, VkImageLayout.ShaderReadOnlyOptimal);
vkTexCube.ImageLayouts[0] = VkImageLayout.ShaderReadOnlyOptimal;
if (_imagesToDestroy == null)
{
_imagesToDestroy = new List <VkImage>();
}
_imagesToDestroy.Add(stagingImage);
if (_memoriesToFree == null)
{
_memoriesToFree = new List <VkMemoryBlock>();
}
_memoriesToFree.Add(stagingMemory);
}
public void SetTextureData(int mipLevel, int x, int y, int width, int height, IntPtr data, int dataSizeInBytes)
{
if (x != 0 || y != 0)
{
throw new NotImplementedException();
}
// First, create a staging texture.
CreateImage(
_device,
_physicalDevice,
_memoryManager,
(uint)width,
(uint)height,
1,
Format,
VkImageTiling.Linear,
VkImageUsageFlags.TransferSrc,
VkMemoryPropertyFlags.HostVisible | VkMemoryPropertyFlags.HostCoherent,
out VkImage stagingImage,
out VkMemoryBlock stagingMemory);
VkImageSubresource subresource = new VkImageSubresource();
subresource.aspectMask = VkImageAspectFlags.Color;
subresource.mipLevel = 0;
subresource.arrayLayer = 0;
vkGetImageSubresourceLayout(_device, stagingImage, ref subresource, out VkSubresourceLayout stagingLayout);
ulong rowPitch = stagingLayout.rowPitch;
void * mappedPtr;
VkResult result = vkMapMemory(_device, stagingMemory.DeviceMemory, stagingMemory.Offset, stagingLayout.size, 0, &mappedPtr);
CheckResult(result);
if (rowPitch == (ulong)width)
{
Buffer.MemoryCopy(data.ToPointer(), mappedPtr, dataSizeInBytes, dataSizeInBytes);
}
else
{
int pixelSizeInBytes = FormatHelpers.GetPixelSizeInBytes(_veldridFormat);
for (uint yy = 0; yy < height; yy++)
{
byte *dstRowStart = ((byte *)mappedPtr) + (rowPitch * yy);
byte *srcRowStart = ((byte *)data.ToPointer()) + (width * yy * pixelSizeInBytes);
Unsafe.CopyBlock(dstRowStart, srcRowStart, (uint)(width * pixelSizeInBytes));
}
}
vkUnmapMemory(_device, stagingMemory.DeviceMemory);
TransitionImageLayout(stagingImage, 1, VkImageLayout.Preinitialized, VkImageLayout.TransferSrcOptimal);
TransitionImageLayout(_image, (uint)MipLevels, _imageLayout, VkImageLayout.TransferDstOptimal);
CopyImage(stagingImage, 0, _image, (uint)mipLevel, (uint)width, (uint)height);
TransitionImageLayout(_image, (uint)MipLevels, VkImageLayout.TransferDstOptimal, VkImageLayout.ShaderReadOnlyOptimal);
_imageLayout = VkImageLayout.ShaderReadOnlyOptimal;
vkDestroyImage(_device, stagingImage, null);
_memoryManager.Free(stagingMemory);
}
