Skip to content

S
swiftshader
Commit e0b5a4b0 by Alexis Hetu Committed by Alexis Hétu
Options

Support for combined Depth and Stencil formats

Added implementation for Depth and Stencil which currently allocates Depth and Stencil as 2 contiguous image planes in memory. Copying to and from depth and stencil planes is now supported which fixes all failures in: dEQP-VK.api.copy_and_blit.core.image_to_image.all_formats.depth_stencil Which were the last remaining failures in: dEQP-VK.api.copy_and_blit.core.image_to_image Bug b/119620767 Change-Id: Ie90737c219c70d9c8a68c024ed33292812a3b7f4 Reviewed-on: https://swiftshader-review.googlesource.com/c/23209Tested-by: 's avatarAlexis Hétu <sugoi@google.com> Reviewed-by: 's avatarChris Forbes <chrisforbes@google.com>
parent 0459596b
Showing with 163 additions and 93 deletions
src/Device/Surface.cpp
...@@ -1963,14 +1963,14 @@ namespace sw ...@@ -1963,14 +1963,14 @@ namespace sw
{ {
switch(format) switch(format)
{ {
case VK_FORMAT_D16_UNORM: case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_D32_SFLOAT:
return false;
case VK_FORMAT_D24_UNORM_S8_UINT: case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_S8_UINT: case VK_FORMAT_S8_UINT:
case VK_FORMAT_D32_SFLOAT_S8_UINT: case VK_FORMAT_D32_SFLOAT_S8_UINT:
return true; return true;
case VK_FORMAT_D16_UNORM:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_D32_SFLOAT:
default: default:
return false; return false;
} }
...@@ -1981,13 +1981,13 @@ namespace sw ...@@ -1981,13 +1981,13 @@ namespace sw
switch(format) switch(format)
{ {
case VK_FORMAT_D16_UNORM: case VK_FORMAT_D16_UNORM:
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_X8_D24_UNORM_PACK32: case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_D24_UNORM_S8_UINT: case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT: case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT: case VK_FORMAT_D32_SFLOAT_S8_UINT:
return true; return true;
case VK_FORMAT_S8_UINT: case VK_FORMAT_S8_UINT:
return false;
default: default:
return false; return false;
} }
......
src/Vulkan/VkBuffer.cpp
...@@ -59,17 +59,17 @@ void Buffer::copyFrom(const void* srcMemory, VkDeviceSize pSize, VkDeviceSize pO ...@@ -59,17 +59,17 @@ void Buffer::copyFrom(const void* srcMemory, VkDeviceSize pSize, VkDeviceSize pO
{ {
ASSERT((pSize + pOffset) <= size); ASSERT((pSize + pOffset) <= size);
memcpy(map(pOffset), srcMemory, pSize); memcpy(getOffsetPointer(pOffset), srcMemory, pSize);
} }
void Buffer::copyTo(void* dstMemory, VkDeviceSize pSize, VkDeviceSize pOffset) const void Buffer::copyTo(void* dstMemory, VkDeviceSize pSize, VkDeviceSize pOffset) const
{ {
ASSERT((pSize + pOffset) <= size); ASSERT((pSize + pOffset) <= size);
memcpy(dstMemory, map(pOffset), pSize); memcpy(dstMemory, getOffsetPointer(pOffset), pSize);
} }
void* Buffer::map(VkDeviceSize offset) const void* Buffer::getOffsetPointer(VkDeviceSize offset) const
{ {
return reinterpret_cast<char*>(memory) + offset; return reinterpret_cast<char*>(memory) + offset;
} }
......
src/Vulkan/VkBuffer.hpp
...@@ -33,7 +33,7 @@ public: ...@@ -33,7 +33,7 @@ public:
void bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset); void bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset);
void copyFrom(const void* srcMemory, VkDeviceSize size, VkDeviceSize offset); void copyFrom(const void* srcMemory, VkDeviceSize size, VkDeviceSize offset);
void copyTo(void* dstMemory, VkDeviceSize size, VkDeviceSize offset) const; void copyTo(void* dstMemory, VkDeviceSize size, VkDeviceSize offset) const;
void* map(VkDeviceSize offset) const; void* getOffsetPointer(VkDeviceSize offset) const;
private: private:
void* memory = nullptr; void* memory = nullptr;
......
src/Vulkan/VkCommandBuffer.cpp
...@@ -134,7 +134,7 @@ struct Draw : public CommandBuffer::Command ...@@ -134,7 +134,7 @@ struct Draw : public CommandBuffer::Command
{ {
const auto& vertexInput = executionState.vertexInputBindings[i]; const auto& vertexInput = executionState.vertexInputBindings[i];
Buffer* buffer = Cast(vertexInput.buffer); Buffer* buffer = Cast(vertexInput.buffer);
context.input[i].buffer = buffer ? buffer->map(vertexInput.offset) : nullptr; context.input[i].buffer = buffer ? buffer->getOffsetPointer(vertexInput.offset) : nullptr;
} }
executionState.renderer->setContext(context); executionState.renderer->setContext(context);
......
src/Vulkan/VkImage.cpp
...@@ -48,7 +48,7 @@ const VkMemoryRequirements Image::getMemoryRequirements() const ...@@ -48,7 +48,7 @@ const VkMemoryRequirements Image::getMemoryRequirements() const
VkMemoryRequirements memoryRequirements; VkMemoryRequirements memoryRequirements;
memoryRequirements.alignment = vk::REQUIRED_MEMORY_ALIGNMENT; memoryRequirements.alignment = vk::REQUIRED_MEMORY_ALIGNMENT;
memoryRequirements.memoryTypeBits = vk::MEMORY_TYPE_GENERIC_BIT; memoryRequirements.memoryTypeBits = vk::MEMORY_TYPE_GENERIC_BIT;
memoryRequirements.size = getStorageSize(); memoryRequirements.size = getStorageSize(flags);
return memoryRequirements; return memoryRequirements;
} }
...@@ -63,8 +63,8 @@ void Image::copyTo(VkImage dstImage, const VkImageCopy& pRegion) ...@@ -63,8 +63,8 @@ void Image::copyTo(VkImage dstImage, const VkImageCopy& pRegion)
// Image copy does not perform any conversion, it simply copies memory from // Image copy does not perform any conversion, it simply copies memory from
// an image to another image that has the same number of bytes per pixel. // an image to another image that has the same number of bytes per pixel.
Image* dst = Cast(dstImage); Image* dst = Cast(dstImage);
int srcBytesPerTexel = bytesPerTexel(); int srcBytesPerTexel = bytesPerTexel(pRegion.srcSubresource.aspectMask);
ASSERT(srcBytesPerTexel == dst->bytesPerTexel()); ASSERT(srcBytesPerTexel == dst->bytesPerTexel(pRegion.dstSubresource.aspectMask));
if(!((pRegion.srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) || if(!((pRegion.srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) ||
(pRegion.srcSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) || (pRegion.srcSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) ||
...@@ -82,13 +82,15 @@ void Image::copyTo(VkImage dstImage, const VkImageCopy& pRegion) ...@@ -82,13 +82,15 @@ void Image::copyTo(VkImage dstImage, const VkImageCopy& pRegion)
UNIMPLEMENTED(); UNIMPLEMENTED();
} }
const char* srcMem = static_cast<const char*>(getTexelPointer(pRegion.srcOffset, pRegion.srcSubresource.baseArrayLayer)); const char* srcMem = static_cast<const char*>(
char* dstMem = static_cast<char*>(dst->getTexelPointer(pRegion.dstOffset, pRegion.dstSubresource.baseArrayLayer)); getTexelPointer(pRegion.srcOffset, pRegion.srcSubresource.baseArrayLayer, pRegion.srcSubresource.aspectMask));
char* dstMem = static_cast<char*>(
dst->getTexelPointer(pRegion.dstOffset, pRegion.dstSubresource.baseArrayLayer, pRegion.dstSubresource.aspectMask));
int srcRowPitchBytes = rowPitchBytes(); int srcRowPitchBytes = rowPitchBytes(pRegion.srcSubresource.aspectMask);
int srcSlicePitchBytes = slicePitchBytes(); int srcSlicePitchBytes = slicePitchBytes(pRegion.srcSubresource.aspectMask);
int dstRowPitchBytes = dst->rowPitchBytes(); int dstRowPitchBytes = dst->rowPitchBytes(pRegion.dstSubresource.aspectMask);
int dstSlicePitchBytes = dst->slicePitchBytes(); int dstSlicePitchBytes = dst->slicePitchBytes(pRegion.dstSubresource.aspectMask);
bool isSinglePlane = (pRegion.extent.depth == 1); bool isSinglePlane = (pRegion.extent.depth == 1);
bool isSingleLine = (pRegion.extent.height == 1) && isSinglePlane; bool isSingleLine = (pRegion.extent.height == 1) && isSinglePlane;
...@@ -131,96 +133,138 @@ void Image::copyTo(VkImage dstImage, const VkImageCopy& pRegion) ...@@ -131,96 +133,138 @@ void Image::copyTo(VkImage dstImage, const VkImageCopy& pRegion)
} }
} }
void Image::copyTo(VkBuffer dstBuffer, const VkBufferImageCopy& pRegion) void Image::copy(VkBuffer buffer, const VkBufferImageCopy& region, bool bufferIsSource)
{ {
if((pRegion.imageExtent.width != extent.width) || if((region.imageExtent.width != extent.width) ||
(pRegion.imageExtent.height != extent.height) || (region.imageExtent.height != extent.height) ||
(pRegion.imageExtent.depth != extent.depth) || (region.imageExtent.depth != extent.depth) ||
!((pRegion.imageSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) || !((region.imageSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) ||
(pRegion.imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) || (region.imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) ||
(pRegion.imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT)) || (region.imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT)) ||
(pRegion.imageSubresource.mipLevel != 0) || (region.imageSubresource.mipLevel != 0) ||
(pRegion.imageOffset.x != 0) || (region.imageOffset.x != 0) ||
(pRegion.imageOffset.y != 0) || (region.imageOffset.y != 0) ||
(pRegion.imageOffset.z != 0) || (region.imageOffset.z != 0) ||
(pRegion.bufferRowLength != extent.width) || (region.bufferRowLength != extent.width) ||
(pRegion.bufferImageHeight != extent.height)) (region.bufferImageHeight != extent.height))
{ {
UNIMPLEMENTED(); UNIMPLEMENTED();
} }
Buffer* dst = Cast(dstBuffer); VkDeviceSize copySize = slicePitchBytes(region.imageSubresource.aspectMask) * region.imageExtent.depth;
VkDeviceSize copySize = slicePitchBytes() * pRegion.imageExtent.depth; VkDeviceSize layerSize = slicePitchBytes(region.imageSubresource.aspectMask) * extent.depth;
VkDeviceSize layerSize = slicePitchBytes() * extent.depth; char* bufferMemory = static_cast<char*>(Cast(buffer)->getOffsetPointer(region.bufferOffset));
VkDeviceSize srcOffset = memoryOffset; char* imageMemory = static_cast<char*>(deviceMemory->getOffsetPointer(getMemoryOffset(region.imageSubresource.aspectMask)));
VkDeviceSize dstOffset = pRegion.bufferOffset; char* srcMemory = bufferIsSource ? bufferMemory : imageMemory;
char* dstMemory = bufferIsSource ? imageMemory : bufferMemory;
uint32_t firstLayer = pRegion.imageSubresource.baseArrayLayer; uint32_t firstLayer = region.imageSubresource.baseArrayLayer;
uint32_t lastLayer = firstLayer + pRegion.imageSubresource.layerCount - 1; uint32_t lastLayer = firstLayer + region.imageSubresource.layerCount - 1;
for(uint32_t layer = firstLayer; layer <= lastLayer; layer++) for(uint32_t layer = firstLayer; layer <= lastLayer; layer++)
{ {
dst->copyFrom(deviceMemory->getOffsetPointer(srcOffset), copySize, dstOffset); memcpy(dstMemory, srcMemory, copySize);
srcOffset += layerSize; srcMemory += layerSize;
dstOffset += layerSize; dstMemory += layerSize;
} }
} }
void Image::copyFrom(VkBuffer srcBuffer, const VkBufferImageCopy& pRegion) void Image::copyTo(VkBuffer dstBuffer, const VkBufferImageCopy& region)
{ {
if((pRegion.imageExtent.width != extent.width) || copy(dstBuffer, region, false);
(pRegion.imageExtent.height != extent.height) || }
(pRegion.imageExtent.depth != extent.depth) ||
!((pRegion.imageSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) ||
(pRegion.imageSubresource.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) ||
(pRegion.imageSubresource.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT)) ||
(pRegion.imageSubresource.mipLevel != 0) ||
(pRegion.imageOffset.x != 0) ||
(pRegion.imageOffset.y != 0) ||
(pRegion.imageOffset.z != 0) ||
(pRegion.bufferRowLength != extent.width) ||
(pRegion.bufferImageHeight != extent.height))
{
UNIMPLEMENTED();
}
Buffer* src = Cast(srcBuffer); void Image::copyFrom(VkBuffer srcBuffer, const VkBufferImageCopy& region)
VkDeviceSize copySize = slicePitchBytes() * pRegion.imageExtent.depth; {
VkDeviceSize layerSize = slicePitchBytes() * extent.depth; copy(srcBuffer, region, true);
VkDeviceSize srcOffset = pRegion.bufferOffset; }
VkDeviceSize dstOffset = memoryOffset;
uint32_t lastLayer = pRegion.imageSubresource.baseArrayLayer + pRegion.imageSubresource.layerCount - 1; void* Image::getTexelPointer(const VkOffset3D& offset, uint32_t baseArrayLayer, const VkImageAspectFlags& flags) const
for(uint32_t layer = pRegion.imageSubresource.baseArrayLayer; layer <= lastLayer; layer++) {
{ return deviceMemory->getOffsetPointer(texelOffsetBytesInStorage(offset, baseArrayLayer, flags) + getMemoryOffset(flags));
src->copyTo(deviceMemory->getOffsetPointer(dstOffset), copySize, srcOffset);
srcOffset += layerSize;
dstOffset += layerSize;
}
} }
void* Image::getTexelPointer(const VkOffset3D& offset, uint32_t baseArrayLayer) const VkDeviceSize Image::texelOffsetBytesInStorage(const VkOffset3D& offset, uint32_t baseArrayLayer, const VkImageAspectFlags& flags) const
{ {
return deviceMemory->getOffsetPointer(texelOffsetBytesInStorage(offset, baseArrayLayer) + memoryOffset); return (baseArrayLayer * extent.depth + offset.z) * slicePitchBytes(flags) + offset.y * rowPitchBytes(flags) + offset.x * bytesPerTexel(flags);
} }
VkDeviceSize Image::texelOffsetBytesInStorage(const VkOffset3D& offset, uint32_t baseArrayLayer) const VkDeviceSize Image::getMemoryOffset(const VkImageAspectFlags& flags) const
{ {
return (baseArrayLayer * extent.depth + offset.z) * slicePitchBytes() + offset.y * rowPitchBytes() + offset.x * bytesPerTexel(); switch(format)
{
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
if(flags == VK_IMAGE_ASPECT_STENCIL_BIT)
{
// Offset by depth buffer to get to stencil buffer
return memoryOffset + getStorageSize(VK_IMAGE_ASPECT_DEPTH_BIT);
}
break;
default:
break;
}
return memoryOffset;
} }
int Image::rowPitchBytes() const int Image::rowPitchBytes(const VkImageAspectFlags& flags) const
{ {
return sw::Surface::pitchB(extent.width, getBorder(), format, false); // Depth and Stencil pitch should be computed separately
ASSERT((flags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) !=
(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT));
return sw::Surface::pitchB(extent.width, getBorder(), getFormat(flags), false);
} }
int Image::slicePitchBytes() const int Image::slicePitchBytes(const VkImageAspectFlags& flags) const
{ {
return sw::Surface::sliceB(extent.width, extent.height, getBorder(), format, false); // Depth and Stencil slice should be computed separately
ASSERT((flags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) !=
(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT));
return sw::Surface::sliceB(extent.width, extent.height, getBorder(), getFormat(flags), false);
} }
int Image::bytesPerTexel() const int Image::bytesPerTexel(const VkImageAspectFlags& flags) const
{ {
return sw::Surface::bytes(format); // Depth and Stencil bytes should be computed separately
ASSERT((flags & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) !=
(VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT));
return sw::Surface::bytes(getFormat(flags));
}
VkFormat Image::getFormat(const VkImageAspectFlags& flags) const
{
switch(flags)
{
case VK_IMAGE_ASPECT_DEPTH_BIT:
switch(format)
{
case VK_FORMAT_D16_UNORM_S8_UINT:
return VK_FORMAT_D16_UNORM;
case VK_FORMAT_D24_UNORM_S8_UINT:
return VK_FORMAT_X8_D24_UNORM_PACK32; // FIXME: This will allocate an extra byte per pixel
case VK_FORMAT_D32_SFLOAT_S8_UINT:
return VK_FORMAT_D32_SFLOAT;
default:
break;
}
break;
case VK_IMAGE_ASPECT_STENCIL_BIT:
switch(format)
{
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
return VK_FORMAT_S8_UINT;
default:
break;
}
break;
default:
break;
}
return format;
} }
int Image::getBorder() const int Image::getBorder() const
...@@ -228,19 +272,41 @@ int Image::getBorder() const ...@@ -228,19 +272,41 @@ int Image::getBorder() const
return ((flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && (imageType == VK_IMAGE_TYPE_2D)) ? 1 : 0; return ((flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT) && (imageType == VK_IMAGE_TYPE_2D)) ? 1 : 0;
} }
VkDeviceSize Image::getStorageSize() const VkDeviceSize Image::getStorageSize(const VkImageAspectFlags& flags) const
{ {
if(mipLevels > 1) if(mipLevels > 1)
{ {
UNIMPLEMENTED(); UNIMPLEMENTED();
} }
return arrayLayers * extent.depth * slicePitchBytes(); int slicePitchB = 0;
if(sw::Surface::isDepth(format) && sw::Surface::isStencil(format))
{
switch(flags)
{
case VK_IMAGE_ASPECT_DEPTH_BIT:
case VK_IMAGE_ASPECT_STENCIL_BIT:
slicePitchB = slicePitchBytes(flags);
break;
default:
// Allow allocating both depth and stencil contiguously
slicePitchB = (slicePitchBytes(VK_IMAGE_ASPECT_DEPTH_BIT) + slicePitchBytes(VK_IMAGE_ASPECT_STENCIL_BIT));
break;
}
}
else
{
slicePitchB = slicePitchBytes(flags);
}
return arrayLayers * extent.depth * slicePitchB;
} }
void Image::clear(const VkClearValue& clearValue, const VkRect2D& renderArea, const VkImageSubresourceRange& subresourceRange) void Image::clear(const VkClearValue& clearValue, const VkRect2D& renderArea, const VkImageSubresourceRange& subresourceRange)
{ {
if((subresourceRange.aspectMask != VK_IMAGE_ASPECT_COLOR_BIT) || if(!((subresourceRange.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT) ||
(subresourceRange.aspectMask == VK_IMAGE_ASPECT_DEPTH_BIT) ||
(subresourceRange.aspectMask == VK_IMAGE_ASPECT_STENCIL_BIT)) ||
(subresourceRange.baseMipLevel != 0) || (subresourceRange.baseMipLevel != 0) ||
(subresourceRange.levelCount != 1) || (subresourceRange.levelCount != 1) ||
(subresourceRange.baseArrayLayer != 0) || (subresourceRange.baseArrayLayer != 0) ||
...@@ -266,8 +332,9 @@ void Image::clear(const VkClearValue& clearValue, const VkRect2D& renderArea, co ...@@ -266,8 +332,9 @@ void Image::clear(const VkClearValue& clearValue, const VkRect2D& renderArea, co
renderArea.offset.y + renderArea.extent.height); renderArea.offset.y + renderArea.extent.height);
const sw::SliceRect dRect(rect); const sw::SliceRect dRect(rect);
sw::Surface* surface = sw::Surface::create(extent.width, extent.height, extent.depth, format, sw::Surface* surface = sw::Surface::create(extent.width, extent.height, extent.depth,
deviceMemory->getOffsetPointer(memoryOffset), rowPitchBytes(), slicePitchBytes()); getFormat(subresourceRange.aspectMask), deviceMemory->getOffsetPointer(memoryOffset),
rowPitchBytes(subresourceRange.aspectMask), slicePitchBytes(subresourceRange.aspectMask));
sw::Blitter blitter; sw::Blitter blitter;
blitter.clear((void*)clearValue.color.float32, clearFormat, surface, dRect, 0xF); blitter.clear((void*)clearValue.color.float32, clearFormat, surface, dRect, 0xF);
delete surface; delete surface;
......
src/Vulkan/VkImage.hpp
...@@ -39,8 +39,8 @@ public: ...@@ -39,8 +39,8 @@ public:
const VkMemoryRequirements getMemoryRequirements() const; const VkMemoryRequirements getMemoryRequirements() const;
void bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset); void bind(VkDeviceMemory pDeviceMemory, VkDeviceSize pMemoryOffset);
void copyTo(VkImage dstImage, const VkImageCopy& pRegion); void copyTo(VkImage dstImage, const VkImageCopy& pRegion);
void copyTo(VkBuffer dstBuffer, const VkBufferImageCopy& pRegion); void copyTo(VkBuffer dstBuffer, const VkBufferImageCopy& region);
void copyFrom(VkBuffer srcBuffer, const VkBufferImageCopy& pRegion); void copyFrom(VkBuffer srcBuffer, const VkBufferImageCopy& region);
void clear(const VkClearValue& clearValue, const VkRect2D& renderArea, const VkImageSubresourceRange& subresourceRange); void clear(const VkClearValue& clearValue, const VkRect2D& renderArea, const VkImageSubresourceRange& subresourceRange);
...@@ -48,12 +48,15 @@ public: ...@@ -48,12 +48,15 @@ public:
VkFormat getFormat() const { return format; } VkFormat getFormat() const { return format; }
private: private:
VkDeviceSize getStorageSize() const; void copy(VkBuffer buffer, const VkBufferImageCopy& region, bool bufferIsSource);
void* getTexelPointer(const VkOffset3D& offset, uint32_t baseArrayLayer) const; VkDeviceSize getStorageSize(const VkImageAspectFlags& flags) const;
VkDeviceSize texelOffsetBytesInStorage(const VkOffset3D& offset, uint32_t baseArrayLayer) const; void* getTexelPointer(const VkOffset3D& offset, uint32_t baseArrayLayer, const VkImageAspectFlags& flags) const;
int rowPitchBytes() const; VkDeviceSize texelOffsetBytesInStorage(const VkOffset3D& offset, uint32_t baseArrayLayer, const VkImageAspectFlags& flags) const;
int slicePitchBytes() const; VkDeviceSize getMemoryOffset(const VkImageAspectFlags& flags) const;
int bytesPerTexel() const; int rowPitchBytes(const VkImageAspectFlags& flags) const;
int slicePitchBytes(const VkImageAspectFlags& flags) const;
int bytesPerTexel(const VkImageAspectFlags& flags) const;
VkFormat getFormat(const VkImageAspectFlags& flags) const;
int getBorder() const; int getBorder() const;
DeviceMemory* deviceMemory = nullptr; DeviceMemory* deviceMemory = nullptr;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment