Skip to content

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

Cleanup: using the proper Image subregion structure

VkImage use different structures to represent subregions: - VkImageSubresource (Single mip level, single layer) - VkImageSubresourceLayers (Single mip level, multiple layers) - VkImageSubresourceRange (Multiple mip levels, multiple layers) This cl changes the subregion structure used in vk::Image and in the Blitter so that it contains the information required for the current task and no more than that. Bug: b/159045555 Change-Id: I186a90ff321318319c01a0718a95bbae2d2eb26a Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/45788 Presubmit-Ready: Alexis Hétu <sugoi@google.com> Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com> Kokoro-Result: kokoro <noreply+kokoro@google.com> Tested-by: 's avatarAlexis Hétu <sugoi@google.com>
parent 9b152366
Showing with 149 additions and 154 deletions
src/Device/Blitter.cpp
...@@ -85,11 +85,10 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F ...@@ -85,11 +85,10 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F
return; return;
} }
VkImageSubresourceLayers subresLayers = { VkImageSubresource subres = {
subresourceRange.aspectMask, subresourceRange.aspectMask,
subresourceRange.baseMipLevel, subresourceRange.baseMipLevel,
subresourceRange.baseArrayLayer, subresourceRange.baseArrayLayer
1
}; };
uint32_t lastMipLevel = dest->getLastMipLevel(subresourceRange); uint32_t lastMipLevel = dest->getLastMipLevel(subresourceRange);
...@@ -102,9 +101,9 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F ...@@ -102,9 +101,9 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F
area = *renderArea; area = *renderArea;
} }
for(; subresLayers.mipLevel <= lastMipLevel; subresLayers.mipLevel++) for(; subres.mipLevel <= lastMipLevel; subres.mipLevel++)
{ {
VkExtent3D extent = dest->getMipLevelExtent(aspect, subresLayers.mipLevel); VkExtent3D extent = dest->getMipLevelExtent(aspect, subres.mipLevel);
if(!renderArea) if(!renderArea)
{ {
area.extent.width = extent.width; area.extent.width = extent.width;
...@@ -115,9 +114,9 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F ...@@ -115,9 +114,9 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F
pixel, nullptr, // source, dest pixel, nullptr, // source, dest
format.bytes(), // sPitchB format.bytes(), // sPitchB
dest->rowPitchBytes(aspect, subresLayers.mipLevel), // dPitchB dest->rowPitchBytes(aspect, subres.mipLevel), // dPitchB
0, // sSliceB (unused in clear operations) 0, // sSliceB (unused in clear operations)
dest->slicePitchBytes(aspect, subresLayers.mipLevel), // dSliceB dest->slicePitchBytes(aspect, subres.mipLevel), // dSliceB
0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, // x0, y0, z0, w, h, d 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, // x0, y0, z0, w, h, d
...@@ -133,21 +132,20 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F ...@@ -133,21 +132,20 @@ void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::F
if(renderArea && dest->is3DSlice()) if(renderArea && dest->is3DSlice())
{ {
// Reinterpret layers as depth slices // Reinterpret layers as depth slices
subresLayers.baseArrayLayer = 0; subres.arrayLayer = 0;
subresLayers.layerCount = 1;
for(uint32_t depth = subresourceRange.baseArrayLayer; depth <= lastLayer; depth++) for(uint32_t depth = subresourceRange.baseArrayLayer; depth <= lastLayer; depth++)
{ {
data.dest = dest->getTexelPointer({ 0, 0, static_cast<int32_t>(depth) }, subresLayers); data.dest = dest->getTexelPointer({ 0, 0, static_cast<int32_t>(depth) }, subres);
blitRoutine(&data); blitRoutine(&data);
} }
} }
else else
{ {
for(subresLayers.baseArrayLayer = subresourceRange.baseArrayLayer; subresLayers.baseArrayLayer <= lastLayer; subresLayers.baseArrayLayer++) for(subres.arrayLayer = subresourceRange.baseArrayLayer; subres.arrayLayer <= lastLayer; subres.arrayLayer++)
{ {
for(uint32_t depth = 0; depth < extent.depth; depth++) for(uint32_t depth = 0; depth < extent.depth; depth++)
{ {
data.dest = dest->getTexelPointer({ 0, 0, static_cast<int32_t>(depth) }, subresLayers); data.dest = dest->getTexelPointer({ 0, 0, static_cast<int32_t>(depth) }, subres);
blitRoutine(&data); blitRoutine(&data);
} }
...@@ -208,11 +206,10 @@ bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const v ...@@ -208,11 +206,10 @@ bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const v
return false; return false;
} }
VkImageSubresourceLayers subresLayers = { VkImageSubresource subres = {
subresourceRange.aspectMask, subresourceRange.aspectMask,
subresourceRange.baseMipLevel, subresourceRange.baseMipLevel,
subresourceRange.baseArrayLayer, subresourceRange.baseArrayLayer
1
}; };
uint32_t lastMipLevel = dest->getLastMipLevel(subresourceRange); uint32_t lastMipLevel = dest->getLastMipLevel(subresourceRange);
uint32_t lastLayer = dest->getLastLayerIndex(subresourceRange); uint32_t lastLayer = dest->getLastLayerIndex(subresourceRange);
...@@ -224,11 +221,11 @@ bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const v ...@@ -224,11 +221,11 @@ bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const v
area = *renderArea; area = *renderArea;
} }
for(; subresLayers.mipLevel <= lastMipLevel; subresLayers.mipLevel++) for(; subres.mipLevel <= lastMipLevel; subres.mipLevel++)
{ {
int rowPitchBytes = dest->rowPitchBytes(aspect, subresLayers.mipLevel); int rowPitchBytes = dest->rowPitchBytes(aspect, subres.mipLevel);
int slicePitchBytes = dest->slicePitchBytes(aspect, subresLayers.mipLevel); int slicePitchBytes = dest->slicePitchBytes(aspect, subres.mipLevel);
VkExtent3D extent = dest->getMipLevelExtent(aspect, subresLayers.mipLevel); VkExtent3D extent = dest->getMipLevelExtent(aspect, subres.mipLevel);
if(!renderArea) if(!renderArea)
{ {
area.extent.width = extent.width; area.extent.width = extent.width;
...@@ -239,12 +236,12 @@ bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const v ...@@ -239,12 +236,12 @@ bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const v
extent.depth = 1; // The 3D image is instead interpreted as a 2D image with layers extent.depth = 1; // The 3D image is instead interpreted as a 2D image with layers
} }
for(subresLayers.baseArrayLayer = subresourceRange.baseArrayLayer; subresLayers.baseArrayLayer <= lastLayer; subresLayers.baseArrayLayer++) for(subres.arrayLayer = subresourceRange.baseArrayLayer; subres.arrayLayer <= lastLayer; subres.arrayLayer++)
{ {
for(uint32_t depth = 0; depth < extent.depth; depth++) for(uint32_t depth = 0; depth < extent.depth; depth++)
{ {
uint8_t *slice = (uint8_t *)dest->getTexelPointer( uint8_t *slice = (uint8_t *)dest->getTexelPointer(
{ area.offset.x, area.offset.y, static_cast<int32_t>(depth) }, subresLayers); { area.offset.x, area.offset.y, static_cast<int32_t>(depth) }, subres);
for(int j = 0; j < dest->getSampleCountFlagBits(); j++) for(int j = 0; j < dest->getSampleCountFlagBits(); j++)
{ {
...@@ -1745,8 +1742,11 @@ void Blitter::blitToBuffer(const vk::Image *src, VkImageSubresourceLayers subres ...@@ -1745,8 +1742,11 @@ void Blitter::blitToBuffer(const vk::Image *src, VkImageSubresourceLayers subres
false, // filter3D false, // filter3D
}; };
VkImageSubresourceLayers srcSubresLayers = subresource; VkImageSubresource srcSubres = {
srcSubresLayers.layerCount = 1; subresource.aspectMask,
subresource.mipLevel,
subresource.baseArrayLayer
};
VkImageSubresourceRange srcSubresRange = { VkImageSubresourceRange srcSubresRange = {
subresource.aspectMask, subresource.aspectMask,
...@@ -1758,9 +1758,9 @@ void Blitter::blitToBuffer(const vk::Image *src, VkImageSubresourceLayers subres ...@@ -1758,9 +1758,9 @@ void Blitter::blitToBuffer(const vk::Image *src, VkImageSubresourceLayers subres
uint32_t lastLayer = src->getLastLayerIndex(srcSubresRange); uint32_t lastLayer = src->getLastLayerIndex(srcSubresRange);
for(; srcSubresLayers.baseArrayLayer <= lastLayer; srcSubresLayers.baseArrayLayer++) for(; srcSubres.arrayLayer <= lastLayer; srcSubres.arrayLayer++)
{ {
data.source = src->getTexelPointer({ 0, 0, 0 }, srcSubresLayers); data.source = src->getTexelPointer({ 0, 0, 0 }, srcSubres);
ASSERT(data.source < src->end()); ASSERT(data.source < src->end());
blitRoutine(&data); blitRoutine(&data);
} }
...@@ -1807,8 +1807,11 @@ void Blitter::blitFromBuffer(const vk::Image *dst, VkImageSubresourceLayers subr ...@@ -1807,8 +1807,11 @@ void Blitter::blitFromBuffer(const vk::Image *dst, VkImageSubresourceLayers subr
false, // filter3D false, // filter3D
}; };
VkImageSubresourceLayers dstSubresLayers = subresource; VkImageSubresource dstSubres = {
dstSubresLayers.layerCount = 1; subresource.aspectMask,
subresource.mipLevel,
subresource.baseArrayLayer
};
VkImageSubresourceRange dstSubresRange = { VkImageSubresourceRange dstSubresRange = {
subresource.aspectMask, subresource.aspectMask,
...@@ -1820,9 +1823,9 @@ void Blitter::blitFromBuffer(const vk::Image *dst, VkImageSubresourceLayers subr ...@@ -1820,9 +1823,9 @@ void Blitter::blitFromBuffer(const vk::Image *dst, VkImageSubresourceLayers subr
uint32_t lastLayer = dst->getLastLayerIndex(dstSubresRange); uint32_t lastLayer = dst->getLastLayerIndex(dstSubresRange);
for(; dstSubresLayers.baseArrayLayer <= lastLayer; dstSubresLayers.baseArrayLayer++) for(; dstSubres.arrayLayer <= lastLayer; dstSubres.arrayLayer++)
{ {
data.dest = dst->getTexelPointer({ 0, 0, 0 }, dstSubresLayers); data.dest = dst->getTexelPointer({ 0, 0, 0 }, dstSubres);
ASSERT(data.dest < dst->end()); ASSERT(data.dest < dst->end());
blitRoutine(&data); blitRoutine(&data);
} }
...@@ -1927,34 +1930,32 @@ void Blitter::blit(const vk::Image *src, vk::Image *dst, VkImageBlit region, VkF ...@@ -1927,34 +1930,32 @@ void Blitter::blit(const vk::Image *src, vk::Image *dst, VkImageBlit region, VkF
false, // filter3D false, // filter3D
}; };
VkImageSubresourceLayers srcSubresLayers = { VkImageSubresource srcSubres = {
region.srcSubresource.aspectMask, region.srcSubresource.aspectMask,
region.srcSubresource.mipLevel, region.srcSubresource.mipLevel,
region.srcSubresource.baseArrayLayer, region.srcSubresource.baseArrayLayer
1
}; };
VkImageSubresourceLayers dstSubresLayers = { VkImageSubresource dstSubres = {
region.dstSubresource.aspectMask, region.dstSubresource.aspectMask,
region.dstSubresource.mipLevel, region.dstSubresource.mipLevel,
region.dstSubresource.baseArrayLayer, region.dstSubresource.baseArrayLayer
1
}; };
VkImageSubresourceRange srcSubresRange = { VkImageSubresourceRange dstSubresRange = {
region.srcSubresource.aspectMask, region.dstSubresource.aspectMask,
region.srcSubresource.mipLevel, region.dstSubresource.mipLevel,
1, 1,
region.srcSubresource.baseArrayLayer, region.dstSubresource.baseArrayLayer,
region.srcSubresource.layerCount region.dstSubresource.layerCount
}; };
uint32_t lastLayer = src->getLastLayerIndex(srcSubresRange); uint32_t lastLayer = src->getLastLayerIndex(dstSubresRange);
for(; srcSubresLayers.baseArrayLayer <= lastLayer; srcSubresLayers.baseArrayLayer++, dstSubresLayers.baseArrayLayer++) for(; dstSubres.arrayLayer <= lastLayer; srcSubres.arrayLayer++, dstSubres.arrayLayer++)
{ {
data.source = src->getTexelPointer({ 0, 0, 0 }, srcSubresLayers); data.source = src->getTexelPointer({ 0, 0, 0 }, srcSubres);
data.dest = dst->getTexelPointer({ 0, 0, 0 }, dstSubresLayers); data.dest = dst->getTexelPointer({ 0, 0, 0 }, dstSubres);
ASSERT(data.source < src->end()); ASSERT(data.source < src->end());
ASSERT(data.dest < dst->end()); ASSERT(data.dest < dst->end());
...@@ -2011,25 +2012,24 @@ Blitter::CornerUpdateRoutineType Blitter::generateCornerUpdate(const State &stat ...@@ -2011,25 +2012,24 @@ Blitter::CornerUpdateRoutineType Blitter::generateCornerUpdate(const State &stat
return function("BlitRoutine"); return function("BlitRoutine");
} }
void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &subresourceLayers) void Blitter::updateBorders(vk::Image *image, const VkImageSubresource &subresource)
{ {
ASSERT(image->getArrayLayers() >= (subresourceLayers.baseArrayLayer + 6)); ASSERT(image->getArrayLayers() >= (subresource.arrayLayer + 6));
// From Vulkan 1.1 spec, section 11.5. Image Views: // From Vulkan 1.1 spec, section 11.5. Image Views:
// "For cube and cube array image views, the layers of the image view starting // "For cube and cube array image views, the layers of the image view starting
// at baseArrayLayer correspond to faces in the order +X, -X, +Y, -Y, +Z, -Z." // at baseArrayLayer correspond to faces in the order +X, -X, +Y, -Y, +Z, -Z."
VkImageSubresourceLayers posX = subresourceLayers; VkImageSubresource posX = subresource;
posX.layerCount = 1; VkImageSubresource negX = posX;
VkImageSubresourceLayers negX = posX; negX.arrayLayer++;
negX.baseArrayLayer++; VkImageSubresource posY = negX;
VkImageSubresourceLayers posY = negX; posY.arrayLayer++;
posY.baseArrayLayer++; VkImageSubresource negY = posY;
VkImageSubresourceLayers negY = posY; negY.arrayLayer++;
negY.baseArrayLayer++; VkImageSubresource posZ = negY;
VkImageSubresourceLayers posZ = negY; posZ.arrayLayer++;
posZ.baseArrayLayer++; VkImageSubresource negZ = posZ;
VkImageSubresourceLayers negZ = posZ; negZ.arrayLayer++;
negZ.baseArrayLayer++;
// Copy top / bottom // Copy top / bottom
copyCubeEdge(image, posX, BOTTOM, negY, RIGHT); copyCubeEdge(image, posX, BOTTOM, negY, RIGHT);
...@@ -2062,7 +2062,7 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su ...@@ -2062,7 +2062,7 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su
copyCubeEdge(image, negZ, LEFT, posX, RIGHT); copyCubeEdge(image, negZ, LEFT, posX, RIGHT);
// Compute corner colors // Compute corner colors
VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresourceLayers.aspectMask); VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask);
vk::Format format = image->getFormat(aspect); vk::Format format = image->getFormat(aspect);
VkSampleCountFlagBits samples = image->getSampleCountFlagBits(); VkSampleCountFlagBits samples = image->getSampleCountFlagBits();
State state(format, format, samples, samples, Options{ 0xF }); State state(format, format, samples, samples, Options{ 0xF });
...@@ -2077,10 +2077,10 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su ...@@ -2077,10 +2077,10 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su
return; return;
} }
VkExtent3D extent = image->getMipLevelExtent(aspect, subresourceLayers.mipLevel); VkExtent3D extent = image->getMipLevelExtent(aspect, subresource.mipLevel);
CubeBorderData data = { CubeBorderData data = {
image->getTexelPointer({ 0, 0, 0 }, posX), image->getTexelPointer({ 0, 0, 0 }, posX),
image->rowPitchBytes(aspect, subresourceLayers.mipLevel), image->rowPitchBytes(aspect, subresource.mipLevel),
static_cast<uint32_t>(image->getLayerSize(aspect)), static_cast<uint32_t>(image->getLayerSize(aspect)),
extent.width extent.width
}; };
...@@ -2088,14 +2088,12 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su ...@@ -2088,14 +2088,12 @@ void Blitter::updateBorders(vk::Image *image, const VkImageSubresourceLayers &su
} }
void Blitter::copyCubeEdge(vk::Image *image, void Blitter::copyCubeEdge(vk::Image *image,
const VkImageSubresourceLayers &dstSubresourceLayers, Edge dstEdge, const VkImageSubresource &dstSubresource, Edge dstEdge,
const VkImageSubresourceLayers &srcSubresourceLayers, Edge srcEdge) const VkImageSubresource &srcSubresource, Edge srcEdge)
{ {
ASSERT(srcSubresourceLayers.aspectMask == dstSubresourceLayers.aspectMask); ASSERT(srcSubresource.aspectMask == dstSubresource.aspectMask);
ASSERT(srcSubresourceLayers.mipLevel == dstSubresourceLayers.mipLevel); ASSERT(srcSubresource.mipLevel == dstSubresource.mipLevel);
ASSERT(srcSubresourceLayers.baseArrayLayer != dstSubresourceLayers.baseArrayLayer); ASSERT(srcSubresource.arrayLayer != dstSubresource.arrayLayer);
ASSERT(srcSubresourceLayers.layerCount == 1);
ASSERT(dstSubresourceLayers.layerCount == 1);
// Figure out if the edges to be copied in reverse order respectively from one another // Figure out if the edges to be copied in reverse order respectively from one another
// The copy should be reversed whenever the same edges are contiguous or if we're // The copy should be reversed whenever the same edges are contiguous or if we're
...@@ -2111,11 +2109,11 @@ void Blitter::copyCubeEdge(vk::Image *image, ...@@ -2111,11 +2109,11 @@ void Blitter::copyCubeEdge(vk::Image *image,
((srcEdge == BOTTOM) && (dstEdge == LEFT)) || ((srcEdge == BOTTOM) && (dstEdge == LEFT)) ||
((srcEdge == LEFT) && (dstEdge == BOTTOM)); ((srcEdge == LEFT) && (dstEdge == BOTTOM));
VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(srcSubresourceLayers.aspectMask); VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(srcSubresource.aspectMask);
int bytes = image->getFormat(aspect).bytes(); int bytes = image->getFormat(aspect).bytes();
int pitchB = image->rowPitchBytes(aspect, srcSubresourceLayers.mipLevel); int pitchB = image->rowPitchBytes(aspect, srcSubresource.mipLevel);
VkExtent3D extent = image->getMipLevelExtent(aspect, srcSubresourceLayers.mipLevel); VkExtent3D extent = image->getMipLevelExtent(aspect, srcSubresource.mipLevel);
int w = extent.width; int w = extent.width;
int h = extent.height; int h = extent.height;
if(w != h) if(w != h)
...@@ -2143,8 +2141,8 @@ void Blitter::copyCubeEdge(vk::Image *image, ...@@ -2143,8 +2141,8 @@ void Blitter::copyCubeEdge(vk::Image *image,
dstOffset.y += reverse ? h : 1; dstOffset.y += reverse ? h : 1;
} }
const uint8_t *src = static_cast<const uint8_t *>(image->getTexelPointer(srcOffset, srcSubresourceLayers)); const uint8_t *src = static_cast<const uint8_t *>(image->getTexelPointer(srcOffset, srcSubresource));
uint8_t *dst = static_cast<uint8_t *>(image->getTexelPointer(dstOffset, dstSubresourceLayers)); uint8_t *dst = static_cast<uint8_t *>(image->getTexelPointer(dstOffset, dstSubresource));
ASSERT((src < image->end()) && ((src + (w * srcDelta)) < image->end())); ASSERT((src < image->end()) && ((src + (w * srcDelta)) < image->end()));
ASSERT((dst < image->end()) && ((dst + (w * dstDelta)) < image->end())); ASSERT((dst < image->end()) && ((dst + (w * dstDelta)) < image->end()));
......
src/Device/Blitter.hpp
...@@ -147,7 +147,7 @@ public: ...@@ -147,7 +147,7 @@ public:
void blitToBuffer(const vk::Image *src, VkImageSubresourceLayers subresource, VkOffset3D offset, VkExtent3D extent, uint8_t *dst, int bufferRowPitch, int bufferSlicePitch); void blitToBuffer(const vk::Image *src, VkImageSubresourceLayers subresource, VkOffset3D offset, VkExtent3D extent, uint8_t *dst, int bufferRowPitch, int bufferSlicePitch);
void blitFromBuffer(const vk::Image *dst, VkImageSubresourceLayers subresource, VkOffset3D offset, VkExtent3D extent, uint8_t *src, int bufferRowPitch, int bufferSlicePitch); void blitFromBuffer(const vk::Image *dst, VkImageSubresourceLayers subresource, VkOffset3D offset, VkExtent3D extent, uint8_t *src, int bufferRowPitch, int bufferSlicePitch);
void updateBorders(vk::Image *image, const VkImageSubresourceLayers &subresourceLayers); void updateBorders(vk::Image *image, const VkImageSubresource &subresource);
private: private:
enum Edge enum Edge
...@@ -185,8 +185,8 @@ private: ...@@ -185,8 +185,8 @@ private:
void computeCubeCorner(Pointer<Byte> &layer, Int &x0, Int &x1, Int &y0, Int &y1, Int &pitchB, const State &state); void computeCubeCorner(Pointer<Byte> &layer, Int &x0, Int &x1, Int &y0, Int &y1, Int &pitchB, const State &state);
void copyCubeEdge(vk::Image *image, void copyCubeEdge(vk::Image *image,
const VkImageSubresourceLayers &dstSubresourceLayers, Edge dstEdge, const VkImageSubresource &dstSubresource, Edge dstEdge,
const VkImageSubresourceLayers &srcSubresourceLayers, Edge srcEdge); const VkImageSubresource &srcSubresource, Edge srcEdge);
marl::mutex blitMutex; marl::mutex blitMutex;
RoutineCache<State, BlitFunction::CFunctionType> blitCache GUARDED_BY(blitMutex); RoutineCache<State, BlitFunction::CFunctionType> blitCache GUARDED_BY(blitMutex);
......
src/Vulkan/VkImage.cpp
...@@ -345,8 +345,8 @@ void Image::copyTo(Image *dstImage, const VkImageCopy &region) const ...@@ -345,8 +345,8 @@ void Image::copyTo(Image *dstImage, const VkImageCopy &region) const
int srcBytesPerBlock = srcFormat.bytesPerBlock(); int srcBytesPerBlock = srcFormat.bytesPerBlock();
ASSERT(srcBytesPerBlock == dstFormat.bytesPerBlock()); ASSERT(srcBytesPerBlock == dstFormat.bytesPerBlock());
const uint8_t *srcMem = static_cast<const uint8_t *>(getTexelPointer(region.srcOffset, region.srcSubresource)); const uint8_t *srcMem = static_cast<const uint8_t *>(getTexelPointer(region.srcOffset, { region.srcSubresource.aspectMask, region.srcSubresource.mipLevel, region.srcSubresource.baseArrayLayer }));
uint8_t *dstMem = static_cast<uint8_t *>(dstImage->getTexelPointer(region.dstOffset, region.dstSubresource)); uint8_t *dstMem = static_cast<uint8_t *>(dstImage->getTexelPointer(region.dstOffset, { region.dstSubresource.aspectMask, region.dstSubresource.mipLevel, region.dstSubresource.baseArrayLayer }));
int srcRowPitchBytes = rowPitchBytes(srcAspect, region.srcSubresource.mipLevel); int srcRowPitchBytes = rowPitchBytes(srcAspect, region.srcSubresource.mipLevel);
int srcSlicePitchBytes = slicePitchBytes(srcAspect, region.srcSubresource.mipLevel); int srcSlicePitchBytes = slicePitchBytes(srcAspect, region.srcSubresource.mipLevel);
...@@ -460,7 +460,7 @@ void Image::copy(Buffer *buffer, const VkBufferImageCopy &region, bool bufferIsS ...@@ -460,7 +460,7 @@ void Image::copy(Buffer *buffer, const VkBufferImageCopy &region, bool bufferIsS
int bufferSlicePitchBytes = bufferExtent.height * bufferRowPitchBytes; int bufferSlicePitchBytes = bufferExtent.height * bufferRowPitchBytes;
uint8_t *bufferMemory = static_cast<uint8_t *>(buffer->getOffsetPointer(region.bufferOffset)); uint8_t *bufferMemory = static_cast<uint8_t *>(buffer->getOffsetPointer(region.bufferOffset));
uint8_t *imageMemory = static_cast<uint8_t *>(getTexelPointer(region.imageOffset, region.imageSubresource)); uint8_t *imageMemory = static_cast<uint8_t *>(getTexelPointer(region.imageOffset, { region.imageSubresource.aspectMask, region.imageSubresource.mipLevel, region.imageSubresource.baseArrayLayer }));
uint8_t *srcMemory = bufferIsSource ? bufferMemory : imageMemory; uint8_t *srcMemory = bufferIsSource ? bufferMemory : imageMemory;
uint8_t *dstMemory = bufferIsSource ? imageMemory : bufferMemory; uint8_t *dstMemory = bufferIsSource ? imageMemory : bufferMemory;
int imageRowPitchBytes = rowPitchBytes(aspect, region.imageSubresource.mipLevel); int imageRowPitchBytes = rowPitchBytes(aspect, region.imageSubresource.mipLevel);
...@@ -574,11 +574,11 @@ void Image::copyFrom(Buffer *srcBuffer, const VkBufferImageCopy &region) ...@@ -574,11 +574,11 @@ void Image::copyFrom(Buffer *srcBuffer, const VkBufferImageCopy &region)
copy(srcBuffer, region, true); copy(srcBuffer, region, true);
} }
void *Image::getTexelPointer(const VkOffset3D &offset, const VkImageSubresourceLayers &subresource) const void *Image::getTexelPointer(const VkOffset3D &offset, const VkImageSubresource &subresource) const
{ {
VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask); VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask);
return deviceMemory->getOffsetPointer(texelOffsetBytesInStorage(offset, subresource) + return deviceMemory->getOffsetPointer(texelOffsetBytesInStorage(offset, subresource) +
getMemoryOffset(aspect, subresource.mipLevel, subresource.baseArrayLayer)); getMemoryOffset(aspect, subresource.mipLevel, subresource.arrayLayer));
} }
VkExtent3D Image::imageExtentInBlocks(const VkExtent3D &extent, VkImageAspectFlagBits aspect) const VkExtent3D Image::imageExtentInBlocks(const VkExtent3D &extent, VkImageAspectFlagBits aspect) const
...@@ -652,7 +652,7 @@ int Image::borderSize() const ...@@ -652,7 +652,7 @@ int Image::borderSize() const
return (isCube() && !format.isCompressed()) ? 1 : 0; return (isCube() && !format.isCompressed()) ? 1 : 0;
} }
VkDeviceSize Image::texelOffsetBytesInStorage(const VkOffset3D &offset, const VkImageSubresourceLayers &subresource) const VkDeviceSize Image::texelOffsetBytesInStorage(const VkOffset3D &offset, const VkImageSubresource &subresource) const
{ {
VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask); VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask);
VkOffset3D adjustedOffset = imageOffsetInBlocks(offset, aspect); VkOffset3D adjustedOffset = imageOffsetInBlocks(offset, aspect);
...@@ -1012,6 +1012,40 @@ void Image::clear(const VkClearValue &clearValue, const vk::Format &viewFormat, ...@@ -1012,6 +1012,40 @@ void Image::clear(const VkClearValue &clearValue, const vk::Format &viewFormat,
void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange) void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange)
{ {
uint32_t lastLayer = getLastLayerIndex(subresourceRange);
uint32_t lastMipLevel = getLastMipLevel(subresourceRange);
VkImageSubresource subresource = {
subresourceRange.aspectMask,
subresourceRange.baseMipLevel,
subresourceRange.baseArrayLayer
};
// First, decompress all relevant dirty subregions
for(subresource.arrayLayer = subresourceRange.baseArrayLayer;
subresource.arrayLayer <= lastLayer;
subresource.arrayLayer++)
{
for(subresource.mipLevel = subresourceRange.baseMipLevel;
subresource.mipLevel <= lastMipLevel;
subresource.mipLevel++)
{
decompress(subresource);
}
}
// Second, update cubemap borders
subresource.arrayLayer = subresourceRange.baseArrayLayer;
for(subresource.mipLevel = subresourceRange.baseMipLevel;
subresource.mipLevel <= lastMipLevel;
subresource.mipLevel++)
{
updateCube(subresource);
}
}
void Image::decompress(const VkImageSubresource &subresource)
{
if(decompressedImage) if(decompressedImage)
{ {
switch(format) switch(format)
...@@ -1026,7 +1060,7 @@ void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange) ...@@ -1026,7 +1060,7 @@ void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange)
case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK: case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK: case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK: case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
decodeETC2(subresourceRange); decodeETC2(subresource);
break; break;
case VK_FORMAT_BC1_RGB_UNORM_BLOCK: case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
case VK_FORMAT_BC1_RGB_SRGB_BLOCK: case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
...@@ -1044,7 +1078,7 @@ void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange) ...@@ -1044,7 +1078,7 @@ void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange)
case VK_FORMAT_BC6H_SFLOAT_BLOCK: case VK_FORMAT_BC6H_SFLOAT_BLOCK:
case VK_FORMAT_BC7_UNORM_BLOCK: case VK_FORMAT_BC7_UNORM_BLOCK:
case VK_FORMAT_BC7_SRGB_BLOCK: case VK_FORMAT_BC7_SRGB_BLOCK:
decodeBC(subresourceRange); decodeBC(subresource);
break; break;
case VK_FORMAT_ASTC_4x4_UNORM_BLOCK: case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
case VK_FORMAT_ASTC_5x4_UNORM_BLOCK: case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
...@@ -1088,58 +1122,42 @@ void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange) ...@@ -1088,58 +1122,42 @@ void Image::prepareForSampling(const VkImageSubresourceRange &subresourceRange)
case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT: case VK_FORMAT_ASTC_10x10_SFLOAT_BLOCK_EXT:
case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT: case VK_FORMAT_ASTC_12x10_SFLOAT_BLOCK_EXT:
case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT: case VK_FORMAT_ASTC_12x12_SFLOAT_BLOCK_EXT:
decodeASTC(subresourceRange); decodeASTC(subresource);
break; break;
default: default:
break; break;
} }
} }
}
void Image::updateCube(const VkImageSubresource &subres)
{
if(isCube() && (arrayLayers >= 6)) if(isCube() && (arrayLayers >= 6))
{ {
VkImageSubresourceLayers subresourceLayers = { VkImageSubresource subresource = subres;
subresourceRange.aspectMask,
subresourceRange.baseMipLevel,
subresourceRange.baseArrayLayer,
6
};
// Update the borders of all the groups of 6 layers that can be part of a cubemaps but don't // Update the borders of all the groups of 6 layers that can be part of a cubemaps but don't
// touch leftover layers that cannot be part of cubemaps. // touch leftover layers that cannot be part of cubemaps.
uint32_t lastMipLevel = getLastMipLevel(subresourceRange); for(subresource.arrayLayer = 0; subresource.arrayLayer < arrayLayers - 5; subresource.arrayLayer += 6)
for(; subresourceLayers.mipLevel <= lastMipLevel; subresourceLayers.mipLevel++)
{ {
for(subresourceLayers.baseArrayLayer = 0; device->getBlitter()->updateBorders(decompressedImage ? decompressedImage : this, subresource);
subresourceLayers.baseArrayLayer < arrayLayers - 5;
subresourceLayers.baseArrayLayer += 6)
{
device->getBlitter()->updateBorders(decompressedImage ? decompressedImage : this, subresourceLayers);
}
} }
} }
} }
void Image::decodeETC2(const VkImageSubresourceRange &subresourceRange) const void Image::decodeETC2(const VkImageSubresource &subresource)
{ {
ASSERT(decompressedImage); ASSERT(decompressedImage);
ETC_Decoder::InputType inputType = GetInputType(format); ETC_Decoder::InputType inputType = GetInputType(format);
uint32_t lastLayer = getLastLayerIndex(subresourceRange);
uint32_t lastMipLevel = getLastMipLevel(subresourceRange);
int bytes = decompressedImage->format.bytes(); int bytes = decompressedImage->format.bytes();
bool fakeAlpha = (format == VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK) || (format == VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK); bool fakeAlpha = (format == VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK) || (format == VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK);
size_t sizeToWrite = 0; size_t sizeToWrite = 0;
VkImageSubresourceLayers subresourceLayers = { subresourceRange.aspectMask, subresourceRange.baseMipLevel, subresourceRange.baseArrayLayer, 1 }; VkExtent3D mipLevelExtent = getMipLevelExtent(static_cast<VkImageAspectFlagBits>(subresource.aspectMask), subresource.mipLevel);
for(; subresourceLayers.baseArrayLayer <= lastLayer; subresourceLayers.baseArrayLayer++)
{
for(; subresourceLayers.mipLevel <= lastMipLevel; subresourceLayers.mipLevel++)
{
VkExtent3D mipLevelExtent = getMipLevelExtent(static_cast<VkImageAspectFlagBits>(subresourceLayers.aspectMask), subresourceLayers.mipLevel);
int pitchB = decompressedImage->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresourceLayers.mipLevel); int pitchB = decompressedImage->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresource.mipLevel);
if(fakeAlpha) if(fakeAlpha)
{ {
...@@ -1151,8 +1169,8 @@ void Image::decodeETC2(const VkImageSubresourceRange &subresourceRange) const ...@@ -1151,8 +1169,8 @@ void Image::decodeETC2(const VkImageSubresourceRange &subresourceRange) const
for(int32_t depth = 0; depth < static_cast<int32_t>(mipLevelExtent.depth); depth++) for(int32_t depth = 0; depth < static_cast<int32_t>(mipLevelExtent.depth); depth++)
{ {
uint8_t *source = static_cast<uint8_t *>(getTexelPointer({ 0, 0, depth }, subresourceLayers)); uint8_t *source = static_cast<uint8_t *>(getTexelPointer({ 0, 0, depth }, subresource));
uint8_t *dest = static_cast<uint8_t *>(decompressedImage->getTexelPointer({ 0, 0, depth }, subresourceLayers)); uint8_t *dest = static_cast<uint8_t *>(decompressedImage->getTexelPointer({ 0, 0, depth }, subresource));
if(fakeAlpha) if(fakeAlpha)
{ {
...@@ -1163,44 +1181,32 @@ void Image::decodeETC2(const VkImageSubresourceRange &subresourceRange) const ...@@ -1163,44 +1181,32 @@ void Image::decodeETC2(const VkImageSubresourceRange &subresourceRange) const
ETC_Decoder::Decode(source, dest, mipLevelExtent.width, mipLevelExtent.height, ETC_Decoder::Decode(source, dest, mipLevelExtent.width, mipLevelExtent.height,
pitchB, bytes, inputType); pitchB, bytes, inputType);
} }
}
}
} }
void Image::decodeBC(const VkImageSubresourceRange &subresourceRange) const void Image::decodeBC(const VkImageSubresource &subresource)
{ {
ASSERT(decompressedImage); ASSERT(decompressedImage);
int n = GetBCn(format); int n = GetBCn(format);
int noAlphaU = GetNoAlphaOrUnsigned(format); int noAlphaU = GetNoAlphaOrUnsigned(format);
uint32_t lastLayer = getLastLayerIndex(subresourceRange);
uint32_t lastMipLevel = getLastMipLevel(subresourceRange);
int bytes = decompressedImage->format.bytes(); int bytes = decompressedImage->format.bytes();
VkImageSubresourceLayers subresourceLayers = { subresourceRange.aspectMask, subresourceRange.baseMipLevel, subresourceRange.baseArrayLayer, 1 }; VkExtent3D mipLevelExtent = getMipLevelExtent(static_cast<VkImageAspectFlagBits>(subresource.aspectMask), subresource.mipLevel);
for(; subresourceLayers.baseArrayLayer <= lastLayer; subresourceLayers.baseArrayLayer++)
{
for(; subresourceLayers.mipLevel <= lastMipLevel; subresourceLayers.mipLevel++)
{
VkExtent3D mipLevelExtent = getMipLevelExtent(static_cast<VkImageAspectFlagBits>(subresourceLayers.aspectMask), subresourceLayers.mipLevel);
int pitchB = decompressedImage->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresourceLayers.mipLevel); int pitchB = decompressedImage->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresource.mipLevel);
for(int32_t depth = 0; depth < static_cast<int32_t>(mipLevelExtent.depth); depth++) for(int32_t depth = 0; depth < static_cast<int32_t>(mipLevelExtent.depth); depth++)
{ {
uint8_t *source = static_cast<uint8_t *>(getTexelPointer({ 0, 0, depth }, subresourceLayers)); uint8_t *source = static_cast<uint8_t *>(getTexelPointer({ 0, 0, depth }, subresource));
uint8_t *dest = static_cast<uint8_t *>(decompressedImage->getTexelPointer({ 0, 0, depth }, subresourceLayers)); uint8_t *dest = static_cast<uint8_t *>(decompressedImage->getTexelPointer({ 0, 0, depth }, subresource));
BC_Decoder::Decode(source, dest, mipLevelExtent.width, mipLevelExtent.height, BC_Decoder::Decode(source, dest, mipLevelExtent.width, mipLevelExtent.height,
pitchB, bytes, n, noAlphaU); pitchB, bytes, n, noAlphaU);
} }
}
}
} }
void Image::decodeASTC(const VkImageSubresourceRange &subresourceRange) const void Image::decodeASTC(const VkImageSubresource &subresource)
{ {
ASSERT(decompressedImage); ASSERT(decompressedImage);
...@@ -1209,17 +1215,9 @@ void Image::decodeASTC(const VkImageSubresourceRange &subresourceRange) const ...@@ -1209,17 +1215,9 @@ void Image::decodeASTC(const VkImageSubresourceRange &subresourceRange) const
int zBlockSize = 1; int zBlockSize = 1;
bool isUnsigned = format.isUnsignedComponent(0); bool isUnsigned = format.isUnsignedComponent(0);
uint32_t lastLayer = getLastLayerIndex(subresourceRange);
uint32_t lastMipLevel = getLastMipLevel(subresourceRange);
int bytes = decompressedImage->format.bytes(); int bytes = decompressedImage->format.bytes();
VkImageSubresourceLayers subresourceLayers = { subresourceRange.aspectMask, subresourceRange.baseMipLevel, subresourceRange.baseArrayLayer, 1 }; VkExtent3D mipLevelExtent = getMipLevelExtent(static_cast<VkImageAspectFlagBits>(subresource.aspectMask), subresource.mipLevel);
for(; subresourceLayers.baseArrayLayer <= lastLayer; subresourceLayers.baseArrayLayer++)
{
for(; subresourceLayers.mipLevel <= lastMipLevel; subresourceLayers.mipLevel++)
{
VkExtent3D mipLevelExtent = getMipLevelExtent(static_cast<VkImageAspectFlagBits>(subresourceLayers.aspectMask), subresourceLayers.mipLevel);
int xblocks = (mipLevelExtent.width + xBlockSize - 1) / xBlockSize; int xblocks = (mipLevelExtent.width + xBlockSize - 1) / xBlockSize;
int yblocks = (mipLevelExtent.height + yBlockSize - 1) / yBlockSize; int yblocks = (mipLevelExtent.height + yBlockSize - 1) / yBlockSize;
...@@ -1227,22 +1225,20 @@ void Image::decodeASTC(const VkImageSubresourceRange &subresourceRange) const ...@@ -1227,22 +1225,20 @@ void Image::decodeASTC(const VkImageSubresourceRange &subresourceRange) const
if(xblocks <= 0 || yblocks <= 0 || zblocks <= 0) if(xblocks <= 0 || yblocks <= 0 || zblocks <= 0)
{ {
continue; return;
} }
int pitchB = decompressedImage->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresourceLayers.mipLevel); int pitchB = decompressedImage->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresource.mipLevel);
int sliceB = decompressedImage->slicePitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresourceLayers.mipLevel); int sliceB = decompressedImage->slicePitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, subresource.mipLevel);
for(int32_t depth = 0; depth < static_cast<int32_t>(mipLevelExtent.depth); depth++) for(int32_t depth = 0; depth < static_cast<int32_t>(mipLevelExtent.depth); depth++)
{ {
uint8_t *source = static_cast<uint8_t *>(getTexelPointer({ 0, 0, depth }, subresourceLayers)); uint8_t *source = static_cast<uint8_t *>(getTexelPointer({ 0, 0, depth }, subresource));
uint8_t *dest = static_cast<uint8_t *>(decompressedImage->getTexelPointer({ 0, 0, depth }, subresourceLayers)); uint8_t *dest = static_cast<uint8_t *>(decompressedImage->getTexelPointer({ 0, 0, depth }, subresource));
ASTC_Decoder::Decode(source, dest, mipLevelExtent.width, mipLevelExtent.height, mipLevelExtent.depth, bytes, pitchB, sliceB, ASTC_Decoder::Decode(source, dest, mipLevelExtent.width, mipLevelExtent.height, mipLevelExtent.depth, bytes, pitchB, sliceB,
xBlockSize, yBlockSize, zBlockSize, xblocks, yblocks, zblocks, isUnsigned); xBlockSize, yBlockSize, zBlockSize, xblocks, yblocks, zblocks, isUnsigned);
} }
}
}
} }
} // namespace vk } // namespace vk
src/Vulkan/VkImage.hpp
...@@ -77,7 +77,7 @@ public: ...@@ -77,7 +77,7 @@ public:
VkExtent3D getMipLevelExtent(VkImageAspectFlagBits aspect, uint32_t mipLevel) const; VkExtent3D getMipLevelExtent(VkImageAspectFlagBits aspect, uint32_t mipLevel) const;
int rowPitchBytes(VkImageAspectFlagBits aspect, uint32_t mipLevel) const; int rowPitchBytes(VkImageAspectFlagBits aspect, uint32_t mipLevel) const;
int slicePitchBytes(VkImageAspectFlagBits aspect, uint32_t mipLevel) const; int slicePitchBytes(VkImageAspectFlagBits aspect, uint32_t mipLevel) const;
void *getTexelPointer(const VkOffset3D &offset, const VkImageSubresourceLayers &subresource) const; void *getTexelPointer(const VkOffset3D &offset, const VkImageSubresource &subresource) const;
bool isCube() const; bool isCube() const;
bool is3DSlice() const; bool is3DSlice() const;
uint8_t *end() const; uint8_t *end() const;
...@@ -104,7 +104,7 @@ private: ...@@ -104,7 +104,7 @@ private:
VkDeviceSize getLayerOffset(VkImageAspectFlagBits aspect, uint32_t mipLevel) const; VkDeviceSize getLayerOffset(VkImageAspectFlagBits aspect, uint32_t mipLevel) const;
VkDeviceSize getMemoryOffset(VkImageAspectFlagBits aspect, uint32_t mipLevel) const; VkDeviceSize getMemoryOffset(VkImageAspectFlagBits aspect, uint32_t mipLevel) const;
VkDeviceSize getMemoryOffset(VkImageAspectFlagBits aspect, uint32_t mipLevel, uint32_t layer) const; VkDeviceSize getMemoryOffset(VkImageAspectFlagBits aspect, uint32_t mipLevel, uint32_t layer) const;
VkDeviceSize texelOffsetBytesInStorage(const VkOffset3D &offset, const VkImageSubresourceLayers &subresource) const; VkDeviceSize texelOffsetBytesInStorage(const VkOffset3D &offset, const VkImageSubresource &subresource) const;
VkDeviceSize getMemoryOffset(VkImageAspectFlagBits aspect) const; VkDeviceSize getMemoryOffset(VkImageAspectFlagBits aspect) const;
VkExtent3D imageExtentInBlocks(const VkExtent3D &extent, VkImageAspectFlagBits aspect) const; VkExtent3D imageExtentInBlocks(const VkExtent3D &extent, VkImageAspectFlagBits aspect) const;
VkOffset3D imageOffsetInBlocks(const VkOffset3D &offset, VkImageAspectFlagBits aspect) const; VkOffset3D imageOffsetInBlocks(const VkOffset3D &offset, VkImageAspectFlagBits aspect) const;
...@@ -112,9 +112,11 @@ private: ...@@ -112,9 +112,11 @@ private:
VkFormat getClearFormat() const; VkFormat getClearFormat() const;
void clear(void *pixelData, VkFormat pixelFormat, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D &renderArea); void clear(void *pixelData, VkFormat pixelFormat, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D &renderArea);
int borderSize() const; int borderSize() const;
void decodeETC2(const VkImageSubresourceRange &subresourceRange) const; void decompress(const VkImageSubresource &subresource);
void decodeBC(const VkImageSubresourceRange &subresourceRange) const; void updateCube(const VkImageSubresource &subresource);
void decodeASTC(const VkImageSubresourceRange &subresourceRange) const; void decodeETC2(const VkImageSubresource &subresource);
void decodeBC(const VkImageSubresource &subresource);
void decodeASTC(const VkImageSubresource &subresource);
const Device *const device = nullptr; const Device *const device = nullptr;
DeviceMemory *deviceMemory = nullptr; DeviceMemory *deviceMemory = nullptr;
......
src/Vulkan/VkImageView.cpp
...@@ -296,14 +296,13 @@ void *ImageView::getOffsetPointer(const VkOffset3D &offset, VkImageAspectFlagBit ...@@ -296,14 +296,13 @@ void *ImageView::getOffsetPointer(const VkOffset3D &offset, VkImageAspectFlagBit
{ {
ASSERT(mipLevel < subresourceRange.levelCount); ASSERT(mipLevel < subresourceRange.levelCount);
VkImageSubresourceLayers imageSubresourceLayers = { VkImageSubresource imageSubresource = {
static_cast<VkImageAspectFlags>(aspect), static_cast<VkImageAspectFlags>(aspect),
subresourceRange.baseMipLevel + mipLevel, subresourceRange.baseMipLevel + mipLevel,
subresourceRange.baseArrayLayer + layer, subresourceRange.baseArrayLayer + layer,
subresourceRange.layerCount
}; };
return getImage(usage)->getTexelPointer(offset, imageSubresourceLayers); return getImage(usage)->getTexelPointer(offset, imageSubresource);
} }
} // namespace vk } // namespace vk
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