| // Copyright 2016 The SwiftShader Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "Blitter.hpp" |
| |
| #include "Pipeline/ShaderCore.hpp" |
| #include "Reactor/Reactor.hpp" |
| #include "System/CPUID.hpp" |
| #include "System/Debug.hpp" |
| #include "System/Half.hpp" |
| #include "System/Memory.hpp" |
| #include "Vulkan/VkBuffer.hpp" |
| #include "Vulkan/VkImage.hpp" |
| |
| #include <utility> |
| |
| #if defined(__i386__) || defined(__x86_64__) |
| # include <xmmintrin.h> |
| # include <emmintrin.h> |
| #endif |
| |
| namespace { |
| rr::RValue<rr::Int> PackFields(rr::Int4 const &ints, const sw::int4 shifts) |
| { |
| return (rr::Int(ints.x) << shifts[0]) | |
| (rr::Int(ints.y) << shifts[1]) | |
| (rr::Int(ints.z) << shifts[2]) | |
| (rr::Int(ints.w) << shifts[3]); |
| } |
| } // namespace |
| |
| namespace sw { |
| |
| Blitter::Blitter() |
| : blitMutex() |
| , blitCache(1024) |
| , cornerUpdateMutex() |
| , cornerUpdateCache(64) // We only need one of these per format |
| { |
| } |
| |
| Blitter::~Blitter() |
| { |
| } |
| |
| void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D *renderArea) |
| { |
| VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresourceRange.aspectMask); |
| vk::Format dstFormat = viewFormat.getAspectFormat(aspect); |
| if(dstFormat == VK_FORMAT_UNDEFINED) |
| { |
| return; |
| } |
| |
| float *pPixel = static_cast<float *>(pixel); |
| if(viewFormat.isUnsignedNormalized() || viewFormat.isSRGBformat()) |
| { |
| pPixel[0] = sw::clamp(pPixel[0], 0.0f, 1.0f); |
| pPixel[1] = sw::clamp(pPixel[1], 0.0f, 1.0f); |
| pPixel[2] = sw::clamp(pPixel[2], 0.0f, 1.0f); |
| pPixel[3] = sw::clamp(pPixel[3], 0.0f, 1.0f); |
| } |
| else if(viewFormat.isSignedNormalized()) |
| { |
| pPixel[0] = sw::clamp(pPixel[0], -1.0f, 1.0f); |
| pPixel[1] = sw::clamp(pPixel[1], -1.0f, 1.0f); |
| pPixel[2] = sw::clamp(pPixel[2], -1.0f, 1.0f); |
| pPixel[3] = sw::clamp(pPixel[3], -1.0f, 1.0f); |
| } |
| |
| if(fastClear(pixel, format, dest, dstFormat, subresourceRange, renderArea)) |
| { |
| return; |
| } |
| |
| State state(format, dstFormat, 1, dest->getSampleCountFlagBits(), Options{ 0xF }); |
| auto blitRoutine = getBlitRoutine(state); |
| if(!blitRoutine) |
| { |
| return; |
| } |
| |
| VkImageSubresource subres = { |
| subresourceRange.aspectMask, |
| subresourceRange.baseMipLevel, |
| subresourceRange.baseArrayLayer |
| }; |
| |
| uint32_t lastMipLevel = dest->getLastMipLevel(subresourceRange); |
| uint32_t lastLayer = dest->getLastLayerIndex(subresourceRange); |
| |
| VkRect2D area = { { 0, 0 }, { 0, 0 } }; |
| if(renderArea) |
| { |
| ASSERT(subresourceRange.levelCount == 1); |
| area = *renderArea; |
| } |
| |
| for(; subres.mipLevel <= lastMipLevel; subres.mipLevel++) |
| { |
| VkExtent3D extent = dest->getMipLevelExtent(aspect, subres.mipLevel); |
| if(!renderArea) |
| { |
| area.extent.width = extent.width; |
| area.extent.height = extent.height; |
| } |
| |
| BlitData data = { |
| pixel, nullptr, // source, dest |
| |
| format.bytes(), // sPitchB |
| dest->rowPitchBytes(aspect, subres.mipLevel), // dPitchB |
| 0, // sSliceB (unused in clear operations) |
| dest->slicePitchBytes(aspect, subres.mipLevel), // dSliceB |
| |
| 0.5f, 0.5f, 0.5f, 0.0f, 0.0f, 0.0f, // x0, y0, z0, w, h, d |
| |
| area.offset.x, static_cast<int>(area.offset.x + area.extent.width), // x0d, x1d |
| area.offset.y, static_cast<int>(area.offset.y + area.extent.height), // y0d, y1d |
| 0, 1, // z0d, z1d |
| |
| 0, 0, 0, // sWidth, sHeight, sDepth |
| |
| false, // filter3D |
| }; |
| |
| if(renderArea && dest->is3DSlice()) |
| { |
| // Reinterpret layers as depth slices |
| subres.arrayLayer = 0; |
| for(uint32_t depth = subresourceRange.baseArrayLayer; depth <= lastLayer; depth++) |
| { |
| data.dest = dest->getTexelPointer({ 0, 0, static_cast<int32_t>(depth) }, subres); |
| blitRoutine(&data); |
| } |
| } |
| else |
| { |
| for(subres.arrayLayer = subresourceRange.baseArrayLayer; subres.arrayLayer <= lastLayer; subres.arrayLayer++) |
| { |
| for(uint32_t depth = 0; depth < extent.depth; depth++) |
| { |
| data.dest = dest->getTexelPointer({ 0, 0, static_cast<int32_t>(depth) }, subres); |
| |
| blitRoutine(&data); |
| } |
| } |
| } |
| } |
| dest->contentsChanged(subresourceRange); |
| } |
| |
| bool Blitter::fastClear(void *clearValue, vk::Format clearFormat, vk::Image *dest, const vk::Format &viewFormat, const VkImageSubresourceRange &subresourceRange, const VkRect2D *renderArea) |
| { |
| if(clearFormat != VK_FORMAT_R32G32B32A32_SFLOAT && |
| clearFormat != VK_FORMAT_D32_SFLOAT && |
| clearFormat != VK_FORMAT_S8_UINT) |
| { |
| return false; |
| } |
| |
| union ClearValue |
| { |
| struct |
| { |
| float r; |
| float g; |
| float b; |
| float a; |
| }; |
| |
| float rgb[3]; |
| |
| float d; |
| uint32_t d_as_u32; |
| |
| uint32_t s; |
| }; |
| |
| ClearValue &c = *reinterpret_cast<ClearValue *>(clearValue); |
| |
| uint32_t packed = 0; |
| |
| VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresourceRange.aspectMask); |
| switch(viewFormat) |
| { |
| case VK_FORMAT_R5G6B5_UNORM_PACK16: |
| packed = ((uint16_t)(31 * c.b + 0.5f) << 0) | |
| ((uint16_t)(63 * c.g + 0.5f) << 5) | |
| ((uint16_t)(31 * c.r + 0.5f) << 11); |
| break; |
| case VK_FORMAT_B5G6R5_UNORM_PACK16: |
| packed = ((uint16_t)(31 * c.r + 0.5f) << 0) | |
| ((uint16_t)(63 * c.g + 0.5f) << 5) | |
| ((uint16_t)(31 * c.b + 0.5f) << 11); |
| break; |
| case VK_FORMAT_A8B8G8R8_UINT_PACK32: |
| case VK_FORMAT_A8B8G8R8_UNORM_PACK32: |
| case VK_FORMAT_R8G8B8A8_UNORM: |
| packed = ((uint32_t)(255 * c.a + 0.5f) << 24) | |
| ((uint32_t)(255 * c.b + 0.5f) << 16) | |
| ((uint32_t)(255 * c.g + 0.5f) << 8) | |
| ((uint32_t)(255 * c.r + 0.5f) << 0); |
| break; |
| case VK_FORMAT_B8G8R8A8_UNORM: |
| packed = ((uint32_t)(255 * c.a + 0.5f) << 24) | |
| ((uint32_t)(255 * c.r + 0.5f) << 16) | |
| ((uint32_t)(255 * c.g + 0.5f) << 8) | |
| ((uint32_t)(255 * c.b + 0.5f) << 0); |
| break; |
| case VK_FORMAT_B10G11R11_UFLOAT_PACK32: |
| packed = R11G11B10F(c.rgb); |
| break; |
| case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: |
| packed = RGB9E5(c.rgb); |
| break; |
| case VK_FORMAT_D32_SFLOAT: |
| ASSERT(clearFormat == VK_FORMAT_D32_SFLOAT); |
| packed = c.d_as_u32; // float reinterpreted as uint32 |
| break; |
| case VK_FORMAT_S8_UINT: |
| ASSERT(clearFormat == VK_FORMAT_S8_UINT); |
| packed = static_cast<uint8_t>(c.s); |
| break; |
| default: |
| return false; |
| } |
| |
| VkImageSubresource subres = { |
| subresourceRange.aspectMask, |
| subresourceRange.baseMipLevel, |
| subresourceRange.baseArrayLayer |
| }; |
| uint32_t lastMipLevel = dest->getLastMipLevel(subresourceRange); |
| uint32_t lastLayer = dest->getLastLayerIndex(subresourceRange); |
| |
| VkRect2D area = { { 0, 0 }, { 0, 0 } }; |
| if(renderArea) |
| { |
| ASSERT(subresourceRange.levelCount == 1); |
| area = *renderArea; |
| } |
| |
| for(; subres.mipLevel <= lastMipLevel; subres.mipLevel++) |
| { |
| int rowPitchBytes = dest->rowPitchBytes(aspect, subres.mipLevel); |
| int slicePitchBytes = dest->slicePitchBytes(aspect, subres.mipLevel); |
| VkExtent3D extent = dest->getMipLevelExtent(aspect, subres.mipLevel); |
| if(!renderArea) |
| { |
| area.extent.width = extent.width; |
| area.extent.height = extent.height; |
| } |
| if(dest->is3DSlice()) |
| { |
| extent.depth = 1; // The 3D image is instead interpreted as a 2D image with layers |
| } |
| |
| for(subres.arrayLayer = subresourceRange.baseArrayLayer; subres.arrayLayer <= lastLayer; subres.arrayLayer++) |
| { |
| for(uint32_t depth = 0; depth < extent.depth; depth++) |
| { |
| uint8_t *slice = (uint8_t *)dest->getTexelPointer( |
| { area.offset.x, area.offset.y, static_cast<int32_t>(depth) }, subres); |
| |
| for(int j = 0; j < dest->getSampleCountFlagBits(); j++) |
| { |
| uint8_t *d = slice; |
| |
| switch(viewFormat.bytes()) |
| { |
| case 4: |
| for(uint32_t i = 0; i < area.extent.height; i++) |
| { |
| ASSERT(d < dest->end()); |
| sw::clear((uint32_t *)d, packed, area.extent.width); |
| d += rowPitchBytes; |
| } |
| break; |
| case 2: |
| for(uint32_t i = 0; i < area.extent.height; i++) |
| { |
| ASSERT(d < dest->end()); |
| sw::clear((uint16_t *)d, static_cast<uint16_t>(packed), area.extent.width); |
| d += rowPitchBytes; |
| } |
| break; |
| case 1: |
| for(uint32_t i = 0; i < area.extent.height; i++) |
| { |
| ASSERT(d < dest->end()); |
| memset(d, packed, area.extent.width); |
| d += rowPitchBytes; |
| } |
| break; |
| default: |
| assert(false); |
| } |
| |
| slice += slicePitchBytes; |
| } |
| } |
| } |
| } |
| dest->contentsChanged(subresourceRange); |
| |
| return true; |
| } |
| |
| Float4 Blitter::readFloat4(Pointer<Byte> element, const State &state) |
| { |
| Float4 c(0.0f, 0.0f, 0.0f, 1.0f); |
| |
| switch(state.sourceFormat) |
| { |
| case VK_FORMAT_B4G4R4A4_UNORM_PACK16: |
| c.w = Float(Int(*Pointer<Byte>(element)) & Int(0xF)); |
| c.x = Float((Int(*Pointer<Byte>(element)) >> 4) & Int(0xF)); |
| c.y = Float(Int(*Pointer<Byte>(element + 1)) & Int(0xF)); |
| c.z = Float((Int(*Pointer<Byte>(element + 1)) >> 4) & Int(0xF)); |
| break; |
| case VK_FORMAT_R8_SINT: |
| case VK_FORMAT_R8_SNORM: |
| c.x = Float(Int(*Pointer<SByte>(element))); |
| c.w = float(0x7F); |
| break; |
| case VK_FORMAT_R8_UNORM: |
| case VK_FORMAT_R8_UINT: |
| case VK_FORMAT_R8_SRGB: |
| c.x = Float(Int(*Pointer<Byte>(element))); |
| c.w = float(0xFF); |
| break; |
| case VK_FORMAT_R16_SINT: |
| case VK_FORMAT_R16_SNORM: |
| c.x = Float(Int(*Pointer<Short>(element))); |
| c.w = float(0x7FFF); |
| break; |
| case VK_FORMAT_R16_UNORM: |
| case VK_FORMAT_R16_UINT: |
| c.x = Float(Int(*Pointer<UShort>(element))); |
| c.w = float(0xFFFF); |
| break; |
| case VK_FORMAT_R32_SINT: |
| c.x = Float(*Pointer<Int>(element)); |
| c.w = float(0x7FFFFFFF); |
| break; |
| case VK_FORMAT_R32_UINT: |
| c.x = Float(*Pointer<UInt>(element)); |
| c.w = float(0xFFFFFFFF); |
| break; |
| case VK_FORMAT_B8G8R8A8_SRGB: |
| case VK_FORMAT_B8G8R8A8_UNORM: |
| c = Float4(*Pointer<Byte4>(element)).zyxw; |
| break; |
| case VK_FORMAT_A8B8G8R8_SINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_SINT: |
| case VK_FORMAT_A8B8G8R8_SNORM_PACK32: |
| case VK_FORMAT_R8G8B8A8_SNORM: |
| c = Float4(*Pointer<SByte4>(element)); |
| break; |
| case VK_FORMAT_A8B8G8R8_UINT_PACK32: |
| case VK_FORMAT_A8B8G8R8_UNORM_PACK32: |
| case VK_FORMAT_R8G8B8A8_UNORM: |
| case VK_FORMAT_R8G8B8A8_UINT: |
| case VK_FORMAT_A8B8G8R8_SRGB_PACK32: |
| case VK_FORMAT_R8G8B8A8_SRGB: |
| c = Float4(*Pointer<Byte4>(element)); |
| break; |
| case VK_FORMAT_R16G16B16A16_SINT: |
| case VK_FORMAT_R16G16B16A16_SNORM: |
| c = Float4(*Pointer<Short4>(element)); |
| break; |
| case VK_FORMAT_R16G16B16A16_UNORM: |
| case VK_FORMAT_R16G16B16A16_UINT: |
| c = Float4(*Pointer<UShort4>(element)); |
| break; |
| case VK_FORMAT_R32G32B32A32_SINT: |
| c = Float4(*Pointer<Int4>(element)); |
| break; |
| case VK_FORMAT_R32G32B32A32_UINT: |
| c = Float4(*Pointer<UInt4>(element)); |
| break; |
| case VK_FORMAT_R8G8_SINT: |
| case VK_FORMAT_R8G8_SNORM: |
| c.x = Float(Int(*Pointer<SByte>(element + 0))); |
| c.y = Float(Int(*Pointer<SByte>(element + 1))); |
| c.w = float(0x7F); |
| break; |
| case VK_FORMAT_R8G8_UNORM: |
| case VK_FORMAT_R8G8_UINT: |
| case VK_FORMAT_R8G8_SRGB: |
| c.x = Float(Int(*Pointer<Byte>(element + 0))); |
| c.y = Float(Int(*Pointer<Byte>(element + 1))); |
| c.w = float(0xFF); |
| break; |
| case VK_FORMAT_R16G16_SINT: |
| case VK_FORMAT_R16G16_SNORM: |
| c.x = Float(Int(*Pointer<Short>(element + 0))); |
| c.y = Float(Int(*Pointer<Short>(element + 2))); |
| c.w = float(0x7FFF); |
| break; |
| case VK_FORMAT_R16G16_UNORM: |
| case VK_FORMAT_R16G16_UINT: |
| c.x = Float(Int(*Pointer<UShort>(element + 0))); |
| c.y = Float(Int(*Pointer<UShort>(element + 2))); |
| c.w = float(0xFFFF); |
| break; |
| case VK_FORMAT_R32G32_SINT: |
| c.x = Float(*Pointer<Int>(element + 0)); |
| c.y = Float(*Pointer<Int>(element + 4)); |
| c.w = float(0x7FFFFFFF); |
| break; |
| case VK_FORMAT_R32G32_UINT: |
| c.x = Float(*Pointer<UInt>(element + 0)); |
| c.y = Float(*Pointer<UInt>(element + 4)); |
| c.w = float(0xFFFFFFFF); |
| break; |
| case VK_FORMAT_R32G32B32A32_SFLOAT: |
| c = *Pointer<Float4>(element); |
| break; |
| case VK_FORMAT_R32G32_SFLOAT: |
| c.x = *Pointer<Float>(element + 0); |
| c.y = *Pointer<Float>(element + 4); |
| break; |
| case VK_FORMAT_R32_SFLOAT: |
| c.x = *Pointer<Float>(element); |
| break; |
| case VK_FORMAT_R16G16B16A16_SFLOAT: |
| c.w = Float(*Pointer<Half>(element + 6)); |
| case VK_FORMAT_R16G16B16_SFLOAT: |
| c.z = Float(*Pointer<Half>(element + 4)); |
| case VK_FORMAT_R16G16_SFLOAT: |
| c.y = Float(*Pointer<Half>(element + 2)); |
| case VK_FORMAT_R16_SFLOAT: |
| c.x = Float(*Pointer<Half>(element)); |
| break; |
| case VK_FORMAT_B10G11R11_UFLOAT_PACK32: |
| c = r11g11b10Unpack(*Pointer<UInt>(element)); |
| break; |
| case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: |
| // This type contains a common 5 bit exponent (E) and a 9 bit the mantissa for R, G and B. |
| c.x = Float(*Pointer<UInt>(element) & UInt(0x000001FF)); // R's mantissa (bits 0-8) |
| c.y = Float((*Pointer<UInt>(element) & UInt(0x0003FE00)) >> 9); // G's mantissa (bits 9-17) |
| c.z = Float((*Pointer<UInt>(element) & UInt(0x07FC0000)) >> 18); // B's mantissa (bits 18-26) |
| c *= Float4( |
| // 2^E, using the exponent (bits 27-31) and treating it as an unsigned integer value |
| Float(UInt(1) << ((*Pointer<UInt>(element) & UInt(0xF8000000)) >> 27)) * |
| // Since the 9 bit mantissa values currently stored in RGB were converted straight |
| // from int to float (in the [0, 1<<9] range instead of the [0, 1] range), they |
| // are (1 << 9) times too high. |
| // Also, the exponent has 5 bits and we compute the exponent bias of floating point |
| // formats using "2^(k-1) - 1", so, in this case, the exponent bias is 2^(5-1)-1 = 15 |
| // Exponent bias (15) + number of mantissa bits per component (9) = 24 |
| Float(1.0f / (1 << 24))); |
| c.w = 1.0f; |
| break; |
| case VK_FORMAT_R5G6B5_UNORM_PACK16: |
| c.x = Float(Int((*Pointer<UShort>(element) & UShort(0xF800)) >> UShort(11))); |
| c.y = Float(Int((*Pointer<UShort>(element) & UShort(0x07E0)) >> UShort(5))); |
| c.z = Float(Int(*Pointer<UShort>(element) & UShort(0x001F))); |
| break; |
| case VK_FORMAT_A1R5G5B5_UNORM_PACK16: |
| c.w = Float(Int((*Pointer<UShort>(element) & UShort(0x8000)) >> UShort(15))); |
| c.x = Float(Int((*Pointer<UShort>(element) & UShort(0x7C00)) >> UShort(10))); |
| c.y = Float(Int((*Pointer<UShort>(element) & UShort(0x03E0)) >> UShort(5))); |
| c.z = Float(Int(*Pointer<UShort>(element) & UShort(0x001F))); |
| break; |
| case VK_FORMAT_A2B10G10R10_UNORM_PACK32: |
| case VK_FORMAT_A2B10G10R10_UINT_PACK32: |
| c.x = Float(Int((*Pointer<UInt>(element) & UInt(0x000003FF)))); |
| c.y = Float(Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10)); |
| c.z = Float(Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20)); |
| c.w = Float(Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30)); |
| break; |
| case VK_FORMAT_A2R10G10B10_UNORM_PACK32: |
| case VK_FORMAT_A2R10G10B10_UINT_PACK32: |
| c.z = Float(Int((*Pointer<UInt>(element) & UInt(0x000003FF)))); |
| c.y = Float(Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10)); |
| c.x = Float(Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20)); |
| c.w = Float(Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30)); |
| break; |
| case VK_FORMAT_D16_UNORM: |
| c.x = Float(Int((*Pointer<UShort>(element)))); |
| break; |
| case VK_FORMAT_X8_D24_UNORM_PACK32: |
| c.x = Float(Int((*Pointer<UInt>(element) & UInt(0xFFFFFF00)) >> 8)); |
| break; |
| case VK_FORMAT_D32_SFLOAT: |
| c.x = *Pointer<Float>(element); |
| break; |
| case VK_FORMAT_S8_UINT: |
| c.x = Float(Int(*Pointer<Byte>(element))); |
| break; |
| default: |
| UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat); |
| } |
| |
| return c; |
| } |
| |
| void Blitter::write(Float4 &c, Pointer<Byte> element, const State &state) |
| { |
| bool writeR = state.writeRed; |
| bool writeG = state.writeGreen; |
| bool writeB = state.writeBlue; |
| bool writeA = state.writeAlpha; |
| bool writeRGBA = writeR && writeG && writeB && writeA; |
| |
| switch(state.destFormat) |
| { |
| case VK_FORMAT_R4G4_UNORM_PACK8: |
| if(writeR | writeG) |
| { |
| if(!writeR) |
| { |
| *Pointer<Byte>(element) = (Byte(RoundInt(Float(c.y))) & Byte(0xF)) | |
| (*Pointer<Byte>(element) & Byte(0xF0)); |
| } |
| else if(!writeG) |
| { |
| *Pointer<Byte>(element) = (*Pointer<Byte>(element) & Byte(0xF)) | |
| (Byte(RoundInt(Float(c.x))) << Byte(4)); |
| } |
| else |
| { |
| *Pointer<Byte>(element) = (Byte(RoundInt(Float(c.y))) & Byte(0xF)) | |
| (Byte(RoundInt(Float(c.x))) << Byte(4)); |
| } |
| } |
| break; |
| case VK_FORMAT_R4G4B4A4_UNORM_PACK16: |
| if(writeR || writeG || writeB || writeA) |
| { |
| *Pointer<UShort>(element) = (writeR ? ((UShort(RoundInt(Float(c.x))) & UShort(0xF)) << UShort(12)) : (*Pointer<UShort>(element) & UShort(0x000F))) | |
| (writeG ? ((UShort(RoundInt(Float(c.y))) & UShort(0xF)) << UShort(8)) : (*Pointer<UShort>(element) & UShort(0x00F0))) | |
| (writeB ? ((UShort(RoundInt(Float(c.z))) & UShort(0xF)) << UShort(4)) : (*Pointer<UShort>(element) & UShort(0x0F00))) | |
| (writeA ? (UShort(RoundInt(Float(c.w))) & UShort(0xF)) : (*Pointer<UShort>(element) & UShort(0xF000))); |
| } |
| break; |
| case VK_FORMAT_B4G4R4A4_UNORM_PACK16: |
| if(writeRGBA) |
| { |
| *Pointer<UShort>(element) = UShort(RoundInt(Float(c.w)) & Int(0xF)) | |
| UShort((RoundInt(Float(c.x)) & Int(0xF)) << 4) | |
| UShort((RoundInt(Float(c.y)) & Int(0xF)) << 8) | |
| UShort((RoundInt(Float(c.z)) & Int(0xF)) << 12); |
| } |
| else |
| { |
| unsigned short mask = (writeA ? 0x000F : 0x0000) | |
| (writeR ? 0x00F0 : 0x0000) | |
| (writeG ? 0x0F00 : 0x0000) | |
| (writeB ? 0xF000 : 0x0000); |
| unsigned short unmask = ~mask; |
| *Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) | |
| ((UShort(RoundInt(Float(c.w)) & Int(0xF)) | |
| UShort((RoundInt(Float(c.x)) & Int(0xF)) << 4) | |
| UShort((RoundInt(Float(c.y)) & Int(0xF)) << 8) | |
| UShort((RoundInt(Float(c.z)) & Int(0xF)) << 12)) & |
| UShort(mask)); |
| } |
| break; |
| case VK_FORMAT_B8G8R8A8_SRGB: |
| case VK_FORMAT_B8G8R8A8_UNORM: |
| if(writeRGBA) |
| { |
| Short4 c0 = RoundShort4(c.zyxw); |
| *Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0)); |
| } |
| else |
| { |
| if(writeB) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.z))); } |
| if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); } |
| if(writeR) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.x))); } |
| if(writeA) { *Pointer<Byte>(element + 3) = Byte(RoundInt(Float(c.w))); } |
| } |
| break; |
| case VK_FORMAT_B8G8R8_SNORM: |
| if(writeB) { *Pointer<SByte>(element + 0) = SByte(RoundInt(Float(c.z))); } |
| if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); } |
| if(writeR) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.x))); } |
| break; |
| case VK_FORMAT_B8G8R8_UNORM: |
| case VK_FORMAT_B8G8R8_SRGB: |
| if(writeB) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.z))); } |
| if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); } |
| if(writeR) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.x))); } |
| break; |
| case VK_FORMAT_A8B8G8R8_UNORM_PACK32: |
| case VK_FORMAT_R8G8B8A8_UNORM: |
| case VK_FORMAT_A8B8G8R8_SRGB_PACK32: |
| case VK_FORMAT_R8G8B8A8_SRGB: |
| case VK_FORMAT_A8B8G8R8_UINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_UINT: |
| case VK_FORMAT_R8G8B8A8_USCALED: |
| case VK_FORMAT_A8B8G8R8_USCALED_PACK32: |
| if(writeRGBA) |
| { |
| Short4 c0 = RoundShort4(c); |
| *Pointer<Byte4>(element) = Byte4(PackUnsigned(c0, c0)); |
| } |
| else |
| { |
| if(writeR) { *Pointer<Byte>(element + 0) = Byte(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); } |
| if(writeB) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.z))); } |
| if(writeA) { *Pointer<Byte>(element + 3) = Byte(RoundInt(Float(c.w))); } |
| } |
| break; |
| case VK_FORMAT_R32G32B32A32_SFLOAT: |
| if(writeRGBA) |
| { |
| *Pointer<Float4>(element) = c; |
| } |
| else |
| { |
| if(writeR) { *Pointer<Float>(element) = c.x; } |
| if(writeG) { *Pointer<Float>(element + 4) = c.y; } |
| if(writeB) { *Pointer<Float>(element + 8) = c.z; } |
| if(writeA) { *Pointer<Float>(element + 12) = c.w; } |
| } |
| break; |
| case VK_FORMAT_R32G32B32_SFLOAT: |
| if(writeR) { *Pointer<Float>(element) = c.x; } |
| if(writeG) { *Pointer<Float>(element + 4) = c.y; } |
| if(writeB) { *Pointer<Float>(element + 8) = c.z; } |
| break; |
| case VK_FORMAT_R32G32_SFLOAT: |
| if(writeR && writeG) |
| { |
| *Pointer<Float2>(element) = Float2(c); |
| } |
| else |
| { |
| if(writeR) { *Pointer<Float>(element) = c.x; } |
| if(writeG) { *Pointer<Float>(element + 4) = c.y; } |
| } |
| break; |
| case VK_FORMAT_R32_SFLOAT: |
| if(writeR) { *Pointer<Float>(element) = c.x; } |
| break; |
| case VK_FORMAT_R16G16B16A16_SFLOAT: |
| if(writeA) { *Pointer<Half>(element + 6) = Half(c.w); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16B16_SFLOAT: |
| if(writeB) { *Pointer<Half>(element + 4) = Half(c.z); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16_SFLOAT: |
| if(writeG) { *Pointer<Half>(element + 2) = Half(c.y); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16_SFLOAT: |
| if(writeR) { *Pointer<Half>(element) = Half(c.x); } |
| break; |
| case VK_FORMAT_B10G11R11_UFLOAT_PACK32: |
| { |
| UInt rgb = r11g11b10Pack(c); |
| |
| UInt old = *Pointer<UInt>(element); |
| |
| unsigned int mask = (writeR ? 0x000007FF : 0) | |
| (writeG ? 0x003FF800 : 0) | |
| (writeB ? 0xFFC00000 : 0); |
| |
| *Pointer<UInt>(element) = (rgb & mask) | (old & ~mask); |
| } |
| break; |
| case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32: |
| { |
| ASSERT(writeRGBA); // Can't sensibly write just part of this format. |
| |
| // Vulkan 1.1.117 section 15.2.1 RGB to Shared Exponent Conversion |
| |
| constexpr int N = 9; // number of mantissa bits per component |
| constexpr int B = 15; // exponent bias |
| constexpr int E_max = 31; // maximum possible biased exponent value |
| |
| // Maximum representable value. |
| constexpr float sharedexp_max = ((static_cast<float>(1 << N) - 1) / static_cast<float>(1 << N)) * static_cast<float>(1 << (E_max - B)); |
| |
| // Clamp components to valid range. NaN becomes 0. |
| Float red_c = Min(IfThenElse(!(c.x > 0), Float(0), Float(c.x)), sharedexp_max); |
| Float green_c = Min(IfThenElse(!(c.y > 0), Float(0), Float(c.y)), sharedexp_max); |
| Float blue_c = Min(IfThenElse(!(c.z > 0), Float(0), Float(c.z)), sharedexp_max); |
| |
| // We're reducing the mantissa to 9 bits, so we must round up if the next |
| // bit is 1. In other words add 0.5 to the new mantissa's position and |
| // allow overflow into the exponent so we can scale correctly. |
| constexpr int half = 1 << (23 - N); |
| Float red_r = As<Float>(As<Int>(red_c) + half); |
| Float green_r = As<Float>(As<Int>(green_c) + half); |
| Float blue_r = As<Float>(As<Int>(blue_c) + half); |
| |
| // The largest component determines the shared exponent. It can't be lower |
| // than 0 (after bias subtraction) so also limit to the mimimum representable. |
| constexpr float min_s = 0.5f / (1 << B); |
| Float max_s = Max(Max(red_r, green_r), Max(blue_r, min_s)); |
| |
| // Obtain the reciprocal of the shared exponent by inverting the bits, |
| // and scale by the new mantissa's size. Note that the IEEE-754 single-precision |
| // format has an implicit leading 1, but this shared component format does not. |
| Float scale = As<Float>((As<Int>(max_s) & 0x7F800000) ^ 0x7F800000) * (1 << (N - 2)); |
| |
| UInt R9 = RoundInt(red_c * scale); |
| UInt G9 = UInt(RoundInt(green_c * scale)); |
| UInt B9 = UInt(RoundInt(blue_c * scale)); |
| UInt E5 = (As<UInt>(max_s) >> 23) - 127 + 15 + 1; |
| |
| UInt E5B9G9R9 = (E5 << 27) | (B9 << 18) | (G9 << 9) | R9; |
| |
| *Pointer<UInt>(element) = E5B9G9R9; |
| } |
| break; |
| case VK_FORMAT_B8G8R8A8_SNORM: |
| if(writeB) { *Pointer<SByte>(element) = SByte(RoundInt(Float(c.z))); } |
| if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); } |
| if(writeR) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.x))); } |
| if(writeA) { *Pointer<SByte>(element + 3) = SByte(RoundInt(Float(c.w))); } |
| break; |
| case VK_FORMAT_A8B8G8R8_SINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_SINT: |
| case VK_FORMAT_A8B8G8R8_SNORM_PACK32: |
| case VK_FORMAT_R8G8B8A8_SNORM: |
| case VK_FORMAT_R8G8B8A8_SSCALED: |
| case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: |
| if(writeA) { *Pointer<SByte>(element + 3) = SByte(RoundInt(Float(c.w))); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8B8_SINT: |
| case VK_FORMAT_R8G8B8_SNORM: |
| case VK_FORMAT_R8G8B8_SSCALED: |
| if(writeB) { *Pointer<SByte>(element + 2) = SByte(RoundInt(Float(c.z))); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8_SINT: |
| case VK_FORMAT_R8G8_SNORM: |
| case VK_FORMAT_R8G8_SSCALED: |
| if(writeG) { *Pointer<SByte>(element + 1) = SByte(RoundInt(Float(c.y))); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8_SINT: |
| case VK_FORMAT_R8_SNORM: |
| case VK_FORMAT_R8_SSCALED: |
| if(writeR) { *Pointer<SByte>(element) = SByte(RoundInt(Float(c.x))); } |
| break; |
| case VK_FORMAT_R8G8B8_UINT: |
| case VK_FORMAT_R8G8B8_UNORM: |
| case VK_FORMAT_R8G8B8_USCALED: |
| case VK_FORMAT_R8G8B8_SRGB: |
| if(writeB) { *Pointer<Byte>(element + 2) = Byte(RoundInt(Float(c.z))); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8_UINT: |
| case VK_FORMAT_R8G8_UNORM: |
| case VK_FORMAT_R8G8_USCALED: |
| case VK_FORMAT_R8G8_SRGB: |
| if(writeG) { *Pointer<Byte>(element + 1) = Byte(RoundInt(Float(c.y))); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8_UINT: |
| case VK_FORMAT_R8_UNORM: |
| case VK_FORMAT_R8_USCALED: |
| case VK_FORMAT_R8_SRGB: |
| if(writeR) { *Pointer<Byte>(element) = Byte(RoundInt(Float(c.x))); } |
| break; |
| case VK_FORMAT_R16G16B16A16_SINT: |
| case VK_FORMAT_R16G16B16A16_SNORM: |
| case VK_FORMAT_R16G16B16A16_SSCALED: |
| if(writeRGBA) |
| { |
| *Pointer<Short4>(element) = Short4(RoundInt(c)); |
| } |
| else |
| { |
| if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); } |
| if(writeB) { *Pointer<Short>(element + 4) = Short(RoundInt(Float(c.z))); } |
| if(writeA) { *Pointer<Short>(element + 6) = Short(RoundInt(Float(c.w))); } |
| } |
| break; |
| case VK_FORMAT_R16G16B16_SINT: |
| case VK_FORMAT_R16G16B16_SNORM: |
| case VK_FORMAT_R16G16B16_SSCALED: |
| if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); } |
| if(writeB) { *Pointer<Short>(element + 4) = Short(RoundInt(Float(c.z))); } |
| break; |
| case VK_FORMAT_R16G16_SINT: |
| case VK_FORMAT_R16G16_SNORM: |
| case VK_FORMAT_R16G16_SSCALED: |
| if(writeR && writeG) |
| { |
| *Pointer<Short2>(element) = Short2(Short4(RoundInt(c))); |
| } |
| else |
| { |
| if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<Short>(element + 2) = Short(RoundInt(Float(c.y))); } |
| } |
| break; |
| case VK_FORMAT_R16_SINT: |
| case VK_FORMAT_R16_SNORM: |
| case VK_FORMAT_R16_SSCALED: |
| if(writeR) { *Pointer<Short>(element) = Short(RoundInt(Float(c.x))); } |
| break; |
| case VK_FORMAT_R16G16B16A16_UINT: |
| case VK_FORMAT_R16G16B16A16_UNORM: |
| case VK_FORMAT_R16G16B16A16_USCALED: |
| if(writeRGBA) |
| { |
| *Pointer<UShort4>(element) = UShort4(RoundInt(c)); |
| } |
| else |
| { |
| if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); } |
| if(writeB) { *Pointer<UShort>(element + 4) = UShort(RoundInt(Float(c.z))); } |
| if(writeA) { *Pointer<UShort>(element + 6) = UShort(RoundInt(Float(c.w))); } |
| } |
| break; |
| case VK_FORMAT_R16G16B16_UINT: |
| case VK_FORMAT_R16G16B16_UNORM: |
| case VK_FORMAT_R16G16B16_USCALED: |
| if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); } |
| if(writeB) { *Pointer<UShort>(element + 4) = UShort(RoundInt(Float(c.z))); } |
| break; |
| case VK_FORMAT_R16G16_UINT: |
| case VK_FORMAT_R16G16_UNORM: |
| case VK_FORMAT_R16G16_USCALED: |
| if(writeR && writeG) |
| { |
| *Pointer<UShort2>(element) = UShort2(UShort4(RoundInt(c))); |
| } |
| else |
| { |
| if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<UShort>(element + 2) = UShort(RoundInt(Float(c.y))); } |
| } |
| break; |
| case VK_FORMAT_R16_UINT: |
| case VK_FORMAT_R16_UNORM: |
| case VK_FORMAT_R16_USCALED: |
| if(writeR) { *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); } |
| break; |
| case VK_FORMAT_R32G32B32A32_SINT: |
| if(writeRGBA) |
| { |
| *Pointer<Int4>(element) = RoundInt(c); |
| } |
| else |
| { |
| if(writeR) { *Pointer<Int>(element) = RoundInt(Float(c.x)); } |
| if(writeG) { *Pointer<Int>(element + 4) = RoundInt(Float(c.y)); } |
| if(writeB) { *Pointer<Int>(element + 8) = RoundInt(Float(c.z)); } |
| if(writeA) { *Pointer<Int>(element + 12) = RoundInt(Float(c.w)); } |
| } |
| break; |
| case VK_FORMAT_R32G32B32_SINT: |
| if(writeB) { *Pointer<Int>(element + 8) = RoundInt(Float(c.z)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R32G32_SINT: |
| if(writeG) { *Pointer<Int>(element + 4) = RoundInt(Float(c.y)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R32_SINT: |
| if(writeR) { *Pointer<Int>(element) = RoundInt(Float(c.x)); } |
| break; |
| case VK_FORMAT_R32G32B32A32_UINT: |
| if(writeRGBA) |
| { |
| *Pointer<UInt4>(element) = UInt4(RoundInt(c)); |
| } |
| else |
| { |
| if(writeR) { *Pointer<UInt>(element) = As<UInt>(RoundInt(Float(c.x))); } |
| if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(RoundInt(Float(c.y))); } |
| if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(RoundInt(Float(c.z))); } |
| if(writeA) { *Pointer<UInt>(element + 12) = As<UInt>(RoundInt(Float(c.w))); } |
| } |
| break; |
| case VK_FORMAT_R32G32B32_UINT: |
| if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(RoundInt(Float(c.z))); } |
| // [[fallthrough]] |
| case VK_FORMAT_R32G32_UINT: |
| if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(RoundInt(Float(c.y))); } |
| // [[fallthrough]] |
| case VK_FORMAT_R32_UINT: |
| if(writeR) { *Pointer<UInt>(element) = As<UInt>(RoundInt(Float(c.x))); } |
| break; |
| case VK_FORMAT_R5G6B5_UNORM_PACK16: |
| if(writeR && writeG && writeB) |
| { |
| *Pointer<UShort>(element) = UShort(PackFields(RoundInt(c.xyzz), { 11, 5, 0, 0 })); |
| } |
| else |
| { |
| unsigned short mask = (writeB ? 0x001F : 0x0000) | (writeG ? 0x07E0 : 0x0000) | (writeR ? 0xF800 : 0x0000); |
| unsigned short unmask = ~mask; |
| *Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) | |
| (UShort(PackFields(RoundInt(c.xyzz), { 11, 5, 0, 0 })) & |
| UShort(mask)); |
| } |
| break; |
| case VK_FORMAT_R5G5B5A1_UNORM_PACK16: |
| if(writeRGBA) |
| { |
| *Pointer<UShort>(element) = UShort(PackFields(RoundInt(c), { 11, 6, 1, 0 })); |
| } |
| else |
| { |
| unsigned short mask = (writeA ? 0x8000 : 0x0000) | |
| (writeR ? 0x7C00 : 0x0000) | |
| (writeG ? 0x03E0 : 0x0000) | |
| (writeB ? 0x001F : 0x0000); |
| unsigned short unmask = ~mask; |
| *Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) | |
| (UShort(PackFields(RoundInt(c), { 11, 6, 1, 0 })) & |
| UShort(mask)); |
| } |
| break; |
| case VK_FORMAT_B5G5R5A1_UNORM_PACK16: |
| if(writeRGBA) |
| { |
| *Pointer<UShort>(element) = UShort(PackFields(RoundInt(c), { 1, 6, 11, 0 })); |
| } |
| else |
| { |
| unsigned short mask = (writeA ? 0x8000 : 0x0000) | |
| (writeR ? 0x7C00 : 0x0000) | |
| (writeG ? 0x03E0 : 0x0000) | |
| (writeB ? 0x001F : 0x0000); |
| unsigned short unmask = ~mask; |
| *Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) | |
| (UShort(PackFields(RoundInt(c), { 1, 6, 11, 0 })) & |
| UShort(mask)); |
| } |
| break; |
| case VK_FORMAT_A1R5G5B5_UNORM_PACK16: |
| if(writeRGBA) |
| { |
| *Pointer<UShort>(element) = UShort(PackFields(RoundInt(c), { 10, 5, 0, 15 })); |
| } |
| else |
| { |
| unsigned short mask = (writeA ? 0x8000 : 0x0000) | |
| (writeR ? 0x7C00 : 0x0000) | |
| (writeG ? 0x03E0 : 0x0000) | |
| (writeB ? 0x001F : 0x0000); |
| unsigned short unmask = ~mask; |
| *Pointer<UShort>(element) = (*Pointer<UShort>(element) & UShort(unmask)) | |
| (UShort(PackFields(RoundInt(c), { 10, 5, 0, 15 })) & |
| UShort(mask)); |
| } |
| break; |
| case VK_FORMAT_A2B10G10R10_UNORM_PACK32: |
| case VK_FORMAT_A2B10G10R10_UINT_PACK32: |
| case VK_FORMAT_A2B10G10R10_SNORM_PACK32: |
| if(writeRGBA) |
| { |
| *Pointer<UInt>(element) = As<UInt>(PackFields(RoundInt(c), { 0, 10, 20, 30 })); |
| } |
| else |
| { |
| unsigned int mask = (writeA ? 0xC0000000 : 0x0000) | |
| (writeB ? 0x3FF00000 : 0x0000) | |
| (writeG ? 0x000FFC00 : 0x0000) | |
| (writeR ? 0x000003FF : 0x0000); |
| unsigned int unmask = ~mask; |
| *Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) | |
| (As<UInt>(PackFields(RoundInt(c), { 0, 10, 20, 30 })) & |
| UInt(mask)); |
| } |
| break; |
| case VK_FORMAT_A2R10G10B10_UNORM_PACK32: |
| case VK_FORMAT_A2R10G10B10_UINT_PACK32: |
| case VK_FORMAT_A2R10G10B10_SNORM_PACK32: |
| if(writeRGBA) |
| { |
| *Pointer<UInt>(element) = As<UInt>(PackFields(RoundInt(c), { 20, 10, 0, 30 })); |
| } |
| else |
| { |
| unsigned int mask = (writeA ? 0xC0000000 : 0x0000) | |
| (writeR ? 0x3FF00000 : 0x0000) | |
| (writeG ? 0x000FFC00 : 0x0000) | |
| (writeB ? 0x000003FF : 0x0000); |
| unsigned int unmask = ~mask; |
| *Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) | |
| (As<UInt>(PackFields(RoundInt(c), { 20, 10, 0, 30 })) & |
| UInt(mask)); |
| } |
| break; |
| case VK_FORMAT_D16_UNORM: |
| *Pointer<UShort>(element) = UShort(RoundInt(Float(c.x))); |
| break; |
| case VK_FORMAT_X8_D24_UNORM_PACK32: |
| *Pointer<UInt>(element) = UInt(RoundInt(Float(c.x)) << 8); |
| break; |
| case VK_FORMAT_D32_SFLOAT: |
| *Pointer<Float>(element) = c.x; |
| break; |
| case VK_FORMAT_S8_UINT: |
| *Pointer<Byte>(element) = Byte(RoundInt(Float(c.x))); |
| break; |
| default: |
| UNSUPPORTED("Blitter destination format %d", (int)state.destFormat); |
| break; |
| } |
| } |
| |
| Int4 Blitter::readInt4(Pointer<Byte> element, const State &state) |
| { |
| Int4 c(0, 0, 0, 1); |
| |
| switch(state.sourceFormat) |
| { |
| case VK_FORMAT_A8B8G8R8_SINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_SINT: |
| c = Insert(c, Int(*Pointer<SByte>(element + 3)), 3); |
| c = Insert(c, Int(*Pointer<SByte>(element + 2)), 2); |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8_SINT: |
| c = Insert(c, Int(*Pointer<SByte>(element + 1)), 1); |
| // [[fallthrough]] |
| case VK_FORMAT_R8_SINT: |
| c = Insert(c, Int(*Pointer<SByte>(element)), 0); |
| break; |
| case VK_FORMAT_A2B10G10R10_UINT_PACK32: |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000003FF))), 0); |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10), 1); |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20), 2); |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30), 3); |
| break; |
| case VK_FORMAT_A2R10G10B10_UINT_PACK32: |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000003FF))), 2); |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x000FFC00)) >> 10), 1); |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0x3FF00000)) >> 20), 0); |
| c = Insert(c, Int((*Pointer<UInt>(element) & UInt(0xC0000000)) >> 30), 3); |
| break; |
| case VK_FORMAT_A8B8G8R8_UINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_UINT: |
| c = Insert(c, Int(*Pointer<Byte>(element + 3)), 3); |
| c = Insert(c, Int(*Pointer<Byte>(element + 2)), 2); |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8_UINT: |
| c = Insert(c, Int(*Pointer<Byte>(element + 1)), 1); |
| // [[fallthrough]] |
| case VK_FORMAT_R8_UINT: |
| case VK_FORMAT_S8_UINT: |
| c = Insert(c, Int(*Pointer<Byte>(element)), 0); |
| break; |
| case VK_FORMAT_R16G16B16A16_SINT: |
| c = Insert(c, Int(*Pointer<Short>(element + 6)), 3); |
| c = Insert(c, Int(*Pointer<Short>(element + 4)), 2); |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16_SINT: |
| c = Insert(c, Int(*Pointer<Short>(element + 2)), 1); |
| // [[fallthrough]] |
| case VK_FORMAT_R16_SINT: |
| c = Insert(c, Int(*Pointer<Short>(element)), 0); |
| break; |
| case VK_FORMAT_R16G16B16A16_UINT: |
| c = Insert(c, Int(*Pointer<UShort>(element + 6)), 3); |
| c = Insert(c, Int(*Pointer<UShort>(element + 4)), 2); |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16_UINT: |
| c = Insert(c, Int(*Pointer<UShort>(element + 2)), 1); |
| // [[fallthrough]] |
| case VK_FORMAT_R16_UINT: |
| c = Insert(c, Int(*Pointer<UShort>(element)), 0); |
| break; |
| case VK_FORMAT_R32G32B32A32_SINT: |
| case VK_FORMAT_R32G32B32A32_UINT: |
| c = *Pointer<Int4>(element); |
| break; |
| case VK_FORMAT_R32G32_SINT: |
| case VK_FORMAT_R32G32_UINT: |
| c = Insert(c, *Pointer<Int>(element + 4), 1); |
| // [[fallthrough]] |
| case VK_FORMAT_R32_SINT: |
| case VK_FORMAT_R32_UINT: |
| c = Insert(c, *Pointer<Int>(element), 0); |
| break; |
| default: |
| UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat); |
| } |
| |
| return c; |
| } |
| |
| void Blitter::write(Int4 &c, Pointer<Byte> element, const State &state) |
| { |
| bool writeR = state.writeRed; |
| bool writeG = state.writeGreen; |
| bool writeB = state.writeBlue; |
| bool writeA = state.writeAlpha; |
| bool writeRGBA = writeR && writeG && writeB && writeA; |
| |
| switch(state.destFormat) |
| { |
| case VK_FORMAT_A2B10G10R10_UINT_PACK32: |
| case VK_FORMAT_A2R10G10B10_UINT_PACK32: |
| c = Min(As<UInt4>(c), UInt4(0x03FF, 0x03FF, 0x03FF, 0x0003)); |
| break; |
| case VK_FORMAT_A8B8G8R8_UINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_UINT: |
| case VK_FORMAT_R8G8B8_UINT: |
| case VK_FORMAT_R8G8_UINT: |
| case VK_FORMAT_R8_UINT: |
| case VK_FORMAT_R8G8B8A8_USCALED: |
| case VK_FORMAT_R8G8B8_USCALED: |
| case VK_FORMAT_R8G8_USCALED: |
| case VK_FORMAT_R8_USCALED: |
| case VK_FORMAT_S8_UINT: |
| c = Min(As<UInt4>(c), UInt4(0xFF)); |
| break; |
| case VK_FORMAT_R16G16B16A16_UINT: |
| case VK_FORMAT_R16G16B16_UINT: |
| case VK_FORMAT_R16G16_UINT: |
| case VK_FORMAT_R16_UINT: |
| case VK_FORMAT_R16G16B16A16_USCALED: |
| case VK_FORMAT_R16G16B16_USCALED: |
| case VK_FORMAT_R16G16_USCALED: |
| case VK_FORMAT_R16_USCALED: |
| c = Min(As<UInt4>(c), UInt4(0xFFFF)); |
| break; |
| case VK_FORMAT_A8B8G8R8_SINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_SINT: |
| case VK_FORMAT_R8G8_SINT: |
| case VK_FORMAT_R8_SINT: |
| case VK_FORMAT_R8G8B8A8_SSCALED: |
| case VK_FORMAT_R8G8B8_SSCALED: |
| case VK_FORMAT_R8G8_SSCALED: |
| case VK_FORMAT_R8_SSCALED: |
| c = Min(Max(c, Int4(-0x80)), Int4(0x7F)); |
| break; |
| case VK_FORMAT_R16G16B16A16_SINT: |
| case VK_FORMAT_R16G16B16_SINT: |
| case VK_FORMAT_R16G16_SINT: |
| case VK_FORMAT_R16_SINT: |
| case VK_FORMAT_R16G16B16A16_SSCALED: |
| case VK_FORMAT_R16G16B16_SSCALED: |
| case VK_FORMAT_R16G16_SSCALED: |
| case VK_FORMAT_R16_SSCALED: |
| c = Min(Max(c, Int4(-0x8000)), Int4(0x7FFF)); |
| break; |
| default: |
| break; |
| } |
| |
| switch(state.destFormat) |
| { |
| case VK_FORMAT_B8G8R8A8_SINT: |
| case VK_FORMAT_B8G8R8A8_SSCALED: |
| if(writeA) { *Pointer<SByte>(element + 3) = SByte(Extract(c, 3)); } |
| // [[fallthrough]] |
| case VK_FORMAT_B8G8R8_SINT: |
| case VK_FORMAT_B8G8R8_SSCALED: |
| if(writeB) { *Pointer<SByte>(element) = SByte(Extract(c, 2)); } |
| if(writeG) { *Pointer<SByte>(element + 1) = SByte(Extract(c, 1)); } |
| if(writeR) { *Pointer<SByte>(element + 2) = SByte(Extract(c, 0)); } |
| break; |
| case VK_FORMAT_A8B8G8R8_SINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_SINT: |
| case VK_FORMAT_R8G8B8A8_SSCALED: |
| case VK_FORMAT_A8B8G8R8_SSCALED_PACK32: |
| if(writeA) { *Pointer<SByte>(element + 3) = SByte(Extract(c, 3)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8B8_SINT: |
| case VK_FORMAT_R8G8B8_SSCALED: |
| if(writeB) { *Pointer<SByte>(element + 2) = SByte(Extract(c, 2)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8_SINT: |
| case VK_FORMAT_R8G8_SSCALED: |
| if(writeG) { *Pointer<SByte>(element + 1) = SByte(Extract(c, 1)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8_SINT: |
| case VK_FORMAT_R8_SSCALED: |
| if(writeR) { *Pointer<SByte>(element) = SByte(Extract(c, 0)); } |
| break; |
| case VK_FORMAT_A2B10G10R10_UINT_PACK32: |
| case VK_FORMAT_A2B10G10R10_SINT_PACK32: |
| case VK_FORMAT_A2B10G10R10_USCALED_PACK32: |
| case VK_FORMAT_A2B10G10R10_SSCALED_PACK32: |
| if(writeRGBA) |
| { |
| *Pointer<UInt>(element) = As<UInt>(PackFields(c, { 0, 10, 20, 30 })); |
| } |
| else |
| { |
| unsigned int mask = (writeA ? 0xC0000000 : 0x0000) | |
| (writeB ? 0x3FF00000 : 0x0000) | |
| (writeG ? 0x000FFC00 : 0x0000) | |
| (writeR ? 0x000003FF : 0x0000); |
| unsigned int unmask = ~mask; |
| *Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) | |
| (As<UInt>(PackFields(c, { 0, 10, 20, 30 })) & UInt(mask)); |
| } |
| break; |
| case VK_FORMAT_A2R10G10B10_UINT_PACK32: |
| case VK_FORMAT_A2R10G10B10_SINT_PACK32: |
| case VK_FORMAT_A2R10G10B10_USCALED_PACK32: |
| case VK_FORMAT_A2R10G10B10_SSCALED_PACK32: |
| if(writeRGBA) |
| { |
| *Pointer<UInt>(element) = As<UInt>(PackFields(c, { 20, 10, 0, 30 })); |
| } |
| else |
| { |
| unsigned int mask = (writeA ? 0xC0000000 : 0x0000) | |
| (writeR ? 0x3FF00000 : 0x0000) | |
| (writeG ? 0x000FFC00 : 0x0000) | |
| (writeB ? 0x000003FF : 0x0000); |
| unsigned int unmask = ~mask; |
| *Pointer<UInt>(element) = (*Pointer<UInt>(element) & UInt(unmask)) | |
| (As<UInt>(PackFields(c, { 20, 10, 0, 30 })) & UInt(mask)); |
| } |
| break; |
| case VK_FORMAT_B8G8R8A8_UINT: |
| case VK_FORMAT_B8G8R8A8_USCALED: |
| if(writeA) { *Pointer<Byte>(element + 3) = Byte(Extract(c, 3)); } |
| // [[fallthrough]] |
| case VK_FORMAT_B8G8R8_UINT: |
| case VK_FORMAT_B8G8R8_USCALED: |
| case VK_FORMAT_B8G8R8_SRGB: |
| if(writeB) { *Pointer<Byte>(element) = Byte(Extract(c, 2)); } |
| if(writeG) { *Pointer<Byte>(element + 1) = Byte(Extract(c, 1)); } |
| if(writeR) { *Pointer<Byte>(element + 2) = Byte(Extract(c, 0)); } |
| break; |
| case VK_FORMAT_A8B8G8R8_UINT_PACK32: |
| case VK_FORMAT_R8G8B8A8_UINT: |
| case VK_FORMAT_R8G8B8A8_USCALED: |
| case VK_FORMAT_A8B8G8R8_USCALED_PACK32: |
| if(writeA) { *Pointer<Byte>(element + 3) = Byte(Extract(c, 3)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8B8_UINT: |
| case VK_FORMAT_R8G8B8_USCALED: |
| if(writeB) { *Pointer<Byte>(element + 2) = Byte(Extract(c, 2)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8G8_UINT: |
| case VK_FORMAT_R8G8_USCALED: |
| if(writeG) { *Pointer<Byte>(element + 1) = Byte(Extract(c, 1)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R8_UINT: |
| case VK_FORMAT_R8_USCALED: |
| case VK_FORMAT_S8_UINT: |
| if(writeR) { *Pointer<Byte>(element) = Byte(Extract(c, 0)); } |
| break; |
| case VK_FORMAT_R16G16B16A16_SINT: |
| case VK_FORMAT_R16G16B16A16_SSCALED: |
| if(writeA) { *Pointer<Short>(element + 6) = Short(Extract(c, 3)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16B16_SINT: |
| case VK_FORMAT_R16G16B16_SSCALED: |
| if(writeB) { *Pointer<Short>(element + 4) = Short(Extract(c, 2)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16_SINT: |
| case VK_FORMAT_R16G16_SSCALED: |
| if(writeG) { *Pointer<Short>(element + 2) = Short(Extract(c, 1)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16_SINT: |
| case VK_FORMAT_R16_SSCALED: |
| if(writeR) { *Pointer<Short>(element) = Short(Extract(c, 0)); } |
| break; |
| case VK_FORMAT_R16G16B16A16_UINT: |
| case VK_FORMAT_R16G16B16A16_USCALED: |
| if(writeA) { *Pointer<UShort>(element + 6) = UShort(Extract(c, 3)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16B16_UINT: |
| case VK_FORMAT_R16G16B16_USCALED: |
| if(writeB) { *Pointer<UShort>(element + 4) = UShort(Extract(c, 2)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16G16_UINT: |
| case VK_FORMAT_R16G16_USCALED: |
| if(writeG) { *Pointer<UShort>(element + 2) = UShort(Extract(c, 1)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R16_UINT: |
| case VK_FORMAT_R16_USCALED: |
| if(writeR) { *Pointer<UShort>(element) = UShort(Extract(c, 0)); } |
| break; |
| case VK_FORMAT_R32G32B32A32_SINT: |
| if(writeRGBA) |
| { |
| *Pointer<Int4>(element) = c; |
| } |
| else |
| { |
| if(writeR) { *Pointer<Int>(element) = Extract(c, 0); } |
| if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); } |
| if(writeB) { *Pointer<Int>(element + 8) = Extract(c, 2); } |
| if(writeA) { *Pointer<Int>(element + 12) = Extract(c, 3); } |
| } |
| break; |
| case VK_FORMAT_R32G32B32_SINT: |
| if(writeR) { *Pointer<Int>(element) = Extract(c, 0); } |
| if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); } |
| if(writeB) { *Pointer<Int>(element + 8) = Extract(c, 2); } |
| break; |
| case VK_FORMAT_R32G32_SINT: |
| if(writeR) { *Pointer<Int>(element) = Extract(c, 0); } |
| if(writeG) { *Pointer<Int>(element + 4) = Extract(c, 1); } |
| break; |
| case VK_FORMAT_R32_SINT: |
| if(writeR) { *Pointer<Int>(element) = Extract(c, 0); } |
| break; |
| case VK_FORMAT_R32G32B32A32_UINT: |
| if(writeRGBA) |
| { |
| *Pointer<UInt4>(element) = As<UInt4>(c); |
| } |
| else |
| { |
| if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); } |
| if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(Extract(c, 1)); } |
| if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(Extract(c, 2)); } |
| if(writeA) { *Pointer<UInt>(element + 12) = As<UInt>(Extract(c, 3)); } |
| } |
| break; |
| case VK_FORMAT_R32G32B32_UINT: |
| if(writeB) { *Pointer<UInt>(element + 8) = As<UInt>(Extract(c, 2)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R32G32_UINT: |
| if(writeG) { *Pointer<UInt>(element + 4) = As<UInt>(Extract(c, 1)); } |
| // [[fallthrough]] |
| case VK_FORMAT_R32_UINT: |
| if(writeR) { *Pointer<UInt>(element) = As<UInt>(Extract(c, 0)); } |
| break; |
| default: |
| UNSUPPORTED("Blitter destination format %d", (int)state.destFormat); |
| } |
| } |
| |
| void Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled) |
| { |
| float4 scale{}, unscale{}; |
| |
| if(state.clearOperation && |
| state.sourceFormat.isUnnormalizedInteger() && |
| !state.destFormat.isUnnormalizedInteger()) |
| { |
| // If we're clearing a buffer from an int or uint color into a normalized color, |
| // then the whole range of the int or uint color must be scaled between 0 and 1. |
| switch(state.sourceFormat) |
| { |
| case VK_FORMAT_R32G32B32A32_SINT: |
| unscale = float4(static_cast<float>(0x7FFFFFFF)); |
| break; |
| case VK_FORMAT_R32G32B32A32_UINT: |
| unscale = float4(static_cast<float>(0xFFFFFFFF)); |
| break; |
| default: |
| UNSUPPORTED("Blitter source format %d", (int)state.sourceFormat); |
| } |
| } |
| else |
| { |
| unscale = state.sourceFormat.getScale(); |
| } |
| |
| scale = state.destFormat.getScale(); |
| |
| bool srcSRGB = state.sourceFormat.isSRGBformat(); |
| bool dstSRGB = state.destFormat.isSRGBformat(); |
| |
| if(state.allowSRGBConversion && ((srcSRGB && !preScaled) || dstSRGB)) // One of the formats is sRGB encoded. |
| { |
| value *= preScaled ? Float4(1.0f / scale.x, 1.0f / scale.y, 1.0f / scale.z, 1.0f / scale.w) : // Unapply scale |
| Float4(1.0f / unscale.x, 1.0f / unscale.y, 1.0f / unscale.z, 1.0f / unscale.w); // Apply unscale |
| value = (srcSRGB && !preScaled) ? sRGBtoLinear(value) : LinearToSRGB(value); |
| value *= Float4(scale.x, scale.y, scale.z, scale.w); // Apply scale |
| } |
| else if(unscale != scale) |
| { |
| value *= Float4(scale.x / unscale.x, scale.y / unscale.y, scale.z / unscale.z, scale.w / unscale.w); |
| } |
| |
| if(state.sourceFormat.isFloatFormat() && !state.destFormat.isFloatFormat()) |
| { |
| value = Min(value, Float4(scale.x, scale.y, scale.z, scale.w)); |
| |
| value = Max(value, Float4(state.destFormat.isUnsignedComponent(0) ? 0.0f : -scale.x, |
| state.destFormat.isUnsignedComponent(1) ? 0.0f : -scale.y, |
| state.destFormat.isUnsignedComponent(2) ? 0.0f : -scale.z, |
| state.destFormat.isUnsignedComponent(3) ? 0.0f : -scale.w)); |
| } |
| } |
| |
| Int Blitter::ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes) |
| { |
| return y * pitchB + x * bytes; |
| } |
| |
| Int Blitter::ComputeOffset(Int &x, Int &y, Int &z, Int &sliceB, Int &pitchB, int bytes) |
| { |
| return z * sliceB + y * pitchB + x * bytes; |
| } |
| |
| Float4 Blitter::LinearToSRGB(const Float4 &c) |
| { |
| Float4 lc = Min(c, Float4(0.0031308f)) * Float4(12.92f); |
| Float4 ec = Float4(1.055f) * power(c, Float4(1.0f / 2.4f)) - Float4(0.055f); |
| |
| Float4 s = c; |
| s.xyz = Max(lc, ec); |
| |
| return s; |
| } |
| |
| Float4 Blitter::sRGBtoLinear(const Float4 &c) |
| { |
| Float4 lc = c * Float4(1.0f / 12.92f); |
| Float4 ec = power((c + Float4(0.055f)) * Float4(1.0f / 1.055f), Float4(2.4f)); |
| |
| Int4 linear = CmpLT(c, Float4(0.04045f)); |
| |
| Float4 s = c; |
| s.xyz = As<Float4>((linear & As<Int4>(lc)) | (~linear & As<Int4>(ec))); // TODO: IfThenElse() |
| |
| return s; |
| } |
| |
| Float4 Blitter::sample(Pointer<Byte> &source, Float &x, Float &y, Float &z, |
| Int &sWidth, Int &sHeight, Int &sDepth, |
| Int &sSliceB, Int &sPitchB, const State &state) |
| { |
| bool intSrc = state.sourceFormat.isUnnormalizedInteger(); |
| int srcBytes = state.sourceFormat.bytes(); |
| |
| Float4 color; |
| |
| bool preScaled = false; |
| if(!state.filter || intSrc) |
| { |
| Int X = Int(x); |
| Int Y = Int(y); |
| Int Z = Int(z); |
| |
| if(state.clampToEdge) |
| { |
| X = Clamp(X, 0, sWidth - 1); |
| Y = Clamp(Y, 0, sHeight - 1); |
| Z = Clamp(Z, 0, sDepth - 1); |
| } |
| |
| Pointer<Byte> s = source + ComputeOffset(X, Y, Z, sSliceB, sPitchB, srcBytes); |
| |
| color = readFloat4(s, state); |
| |
| if(state.srcSamples > 1) // Resolve multisampled source |
| { |
| if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat()) // sRGB -> RGB |
| { |
| ApplyScaleAndClamp(color, state); |
| preScaled = true; |
| } |
| Float4 accum = color; |
| for(int sample = 1; sample < state.srcSamples; sample++) |
| { |
| s += sSliceB; |
| color = readFloat4(s, state); |
| |
| if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat()) // sRGB -> RGB |
| { |
| ApplyScaleAndClamp(color, state); |
| preScaled = true; |
| } |
| accum += color; |
| } |
| color = accum * Float4(1.0f / static_cast<float>(state.srcSamples)); |
| } |
| } |
| else // Bilinear filtering |
| { |
| Float X = x; |
| Float Y = y; |
| Float Z = z; |
| |
| if(state.clampToEdge) |
| { |
| X = Min(Max(x, 0.5f), Float(sWidth) - 0.5f); |
| Y = Min(Max(y, 0.5f), Float(sHeight) - 0.5f); |
| Z = Min(Max(z, 0.5f), Float(sDepth) - 0.5f); |
| } |
| |
| Float x0 = X - 0.5f; |
| Float y0 = Y - 0.5f; |
| Float z0 = Z - 0.5f; |
| |
| Int X0 = Max(Int(x0), 0); |
| Int Y0 = Max(Int(y0), 0); |
| Int Z0 = Max(Int(z0), 0); |
| |
| Int X1 = X0 + 1; |
| Int Y1 = Y0 + 1; |
| X1 = IfThenElse(X1 >= sWidth, X0, X1); |
| Y1 = IfThenElse(Y1 >= sHeight, Y0, Y1); |
| |
| if(state.filter3D) |
| { |
| Int Z1 = Z0 + 1; |
| Z1 = IfThenElse(Z1 >= sHeight, Z0, Z1); |
| |
| Pointer<Byte> s000 = source + ComputeOffset(X0, Y0, Z0, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s010 = source + ComputeOffset(X1, Y0, Z0, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s100 = source + ComputeOffset(X0, Y1, Z0, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s110 = source + ComputeOffset(X1, Y1, Z0, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s001 = source + ComputeOffset(X0, Y0, Z1, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s011 = source + ComputeOffset(X1, Y0, Z1, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s101 = source + ComputeOffset(X0, Y1, Z1, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s111 = source + ComputeOffset(X1, Y1, Z1, sSliceB, sPitchB, srcBytes); |
| |
| Float4 c000 = readFloat4(s000, state); |
| Float4 c010 = readFloat4(s010, state); |
| Float4 c100 = readFloat4(s100, state); |
| Float4 c110 = readFloat4(s110, state); |
| Float4 c001 = readFloat4(s001, state); |
| Float4 c011 = readFloat4(s011, state); |
| Float4 c101 = readFloat4(s101, state); |
| Float4 c111 = readFloat4(s111, state); |
| |
| if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat()) // sRGB -> RGB |
| { |
| ApplyScaleAndClamp(c000, state); |
| ApplyScaleAndClamp(c010, state); |
| ApplyScaleAndClamp(c100, state); |
| ApplyScaleAndClamp(c110, state); |
| ApplyScaleAndClamp(c001, state); |
| ApplyScaleAndClamp(c011, state); |
| ApplyScaleAndClamp(c101, state); |
| ApplyScaleAndClamp(c111, state); |
| preScaled = true; |
| } |
| |
| Float4 fx = Float4(x0 - Float(X0)); |
| Float4 fy = Float4(y0 - Float(Y0)); |
| Float4 fz = Float4(z0 - Float(Z0)); |
| Float4 ix = Float4(1.0f) - fx; |
| Float4 iy = Float4(1.0f) - fy; |
| Float4 iz = Float4(1.0f) - fz; |
| |
| color = ((c000 * ix + c010 * fx) * iy + |
| (c100 * ix + c110 * fx) * fy) * |
| iz + |
| ((c001 * ix + c011 * fx) * iy + |
| (c101 * ix + c111 * fx) * fy) * |
| fz; |
| } |
| else |
| { |
| Pointer<Byte> s00 = source + ComputeOffset(X0, Y0, Z0, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s01 = source + ComputeOffset(X1, Y0, Z0, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s10 = source + ComputeOffset(X0, Y1, Z0, sSliceB, sPitchB, srcBytes); |
| Pointer<Byte> s11 = source + ComputeOffset(X1, Y1, Z0, sSliceB, sPitchB, srcBytes); |
| |
| Float4 c00 = readFloat4(s00, state); |
| Float4 c01 = readFloat4(s01, state); |
| Float4 c10 = readFloat4(s10, state); |
| Float4 c11 = readFloat4(s11, state); |
| |
| if(state.allowSRGBConversion && state.sourceFormat.isSRGBformat()) // sRGB -> RGB |
| { |
| ApplyScaleAndClamp(c00, state); |
| ApplyScaleAndClamp(c01, state); |
| ApplyScaleAndClamp(c10, state); |
| ApplyScaleAndClamp(c11, state); |
| preScaled = true; |
| } |
| |
| Float4 fx = Float4(x0 - Float(X0)); |
| Float4 fy = Float4(y0 - Float(Y0)); |
| Float4 ix = Float4(1.0f) - fx; |
| Float4 iy = Float4(1.0f) - fy; |
| |
| color = (c00 * ix + c01 * fx) * iy + |
| (c10 * ix + c11 * fx) * fy; |
| } |
| } |
| |
| ApplyScaleAndClamp(color, state, preScaled); |
| |
| return color; |
| } |
| |
| Blitter::BlitRoutineType Blitter::generate(const State &state) |
| { |
| BlitFunction function; |
| { |
| Pointer<Byte> blit(function.Arg<0>()); |
| |
| Pointer<Byte> source = *Pointer<Pointer<Byte>>(blit + OFFSET(BlitData, source)); |
| Pointer<Byte> dest = *Pointer<Pointer<Byte>>(blit + OFFSET(BlitData, dest)); |
| Int sPitchB = *Pointer<Int>(blit + OFFSET(BlitData, sPitchB)); |
| Int dPitchB = *Pointer<Int>(blit + OFFSET(BlitData, dPitchB)); |
| Int sSliceB = *Pointer<Int>(blit + OFFSET(BlitData, sSliceB)); |
| Int dSliceB = *Pointer<Int>(blit + OFFSET(BlitData, dSliceB)); |
| |
| Float x0 = *Pointer<Float>(blit + OFFSET(BlitData, x0)); |
| Float y0 = *Pointer<Float>(blit + OFFSET(BlitData, y0)); |
| Float z0 = *Pointer<Float>(blit + OFFSET(BlitData, z0)); |
| Float w = *Pointer<Float>(blit + OFFSET(BlitData, w)); |
| Float h = *Pointer<Float>(blit + OFFSET(BlitData, h)); |
| Float d = *Pointer<Float>(blit + OFFSET(BlitData, d)); |
| |
| Int x0d = *Pointer<Int>(blit + OFFSET(BlitData, x0d)); |
| Int x1d = *Pointer<Int>(blit + OFFSET(BlitData, x1d)); |
| Int y0d = *Pointer<Int>(blit + OFFSET(BlitData, y0d)); |
| Int y1d = *Pointer<Int>(blit + OFFSET(BlitData, y1d)); |
| Int z0d = *Pointer<Int>(blit + OFFSET(BlitData, z0d)); |
| Int z1d = *Pointer<Int>(blit + OFFSET(BlitData, z1d)); |
| |
| Int sWidth = *Pointer<Int>(blit + OFFSET(BlitData, sWidth)); |
| Int sHeight = *Pointer<Int>(blit + OFFSET(BlitData, sHeight)); |
| Int sDepth = *Pointer<Int>(blit + OFFSET(BlitData, sDepth)); |
| |
| bool intSrc = state.sourceFormat.isUnnormalizedInteger(); |
| bool intDst = state.destFormat.isUnnormalizedInteger(); |
| bool intBoth = intSrc && intDst; |
| int srcBytes = state.sourceFormat.bytes(); |
| int dstBytes = state.destFormat.bytes(); |
| |
| bool hasConstantColorI = false; |
| Int4 constantColorI; |
| bool hasConstantColorF = false; |
| Float4 constantColorF; |
| if(state.clearOperation) |
| { |
| if(intBoth) // Integer types |
| { |
| constantColorI = readInt4(source, state); |
| hasConstantColorI = true; |
| } |
| else |
| { |
| constantColorF = readFloat4(source, state); |
| hasConstantColorF = true; |
| |
| ApplyScaleAndClamp(constantColorF, state); |
| } |
| } |
| |
| For(Int k = z0d, k < z1d, k++) |
| { |
| Float z = state.clearOperation ? RValue<Float>(z0) : z0 + Float(k) * d; |
| Pointer<Byte> destSlice = dest + k * dSliceB; |
| |
| For(Int j = y0d, j < y1d, j++) |
| { |
| Float y = state.clearOperation ? RValue<Float>(y0) : y0 + Float(j) * h; |
| Pointer<Byte> destLine = destSlice + j * dPitchB; |
| |
| For(Int i = x0d, i < x1d, i++) |
| { |
| Float x = state.clearOperation ? RValue<Float>(x0) : x0 + Float(i) * w; |
| Pointer<Byte> d = destLine + i * dstBytes; |
| |
| if(hasConstantColorI) |
| { |
| for(int s = 0; s < state.destSamples; s++) |
| { |
| write(constantColorI, d, state); |
| |
| d += dSliceB; |
| } |
| } |
| else if(hasConstantColorF) |
| { |
| for(int s = 0; s < state.destSamples; s++) |
| { |
| write(constantColorF, d, state); |
| |
| d += dSliceB; |
| } |
| } |
| else if(intBoth) // Integer types do not support filtering |
| { |
| Int X = Int(x); |
| Int Y = Int(y); |
| Int Z = Int(z); |
| |
| if(state.clampToEdge) |
| { |
| X = Clamp(X, 0, sWidth - 1); |
| Y = Clamp(Y, 0, sHeight - 1); |
| Z = Clamp(Z, 0, sDepth - 1); |
| } |
| |
| Pointer<Byte> s = source + ComputeOffset(X, Y, Z, sSliceB, sPitchB, srcBytes); |
| |
| // When both formats are true integer types, we don't go to float to avoid losing precision |
| Int4 color = readInt4(s, state); |
| for(int s = 0; s < state.destSamples; s++) |
| { |
| write(color, d, state); |
| |
| d += dSliceB; |
| } |
| } |
| else |
| { |
| Float4 color = sample(source, x, y, z, sWidth, sHeight, sDepth, sSliceB, sPitchB, state); |
| |
| for(int s = 0; s < state.destSamples; s++) |
| { |
| write(color, d, state); |
| |
| d += dSliceB; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return function("BlitRoutine"); |
| } |
| |
| Blitter::BlitRoutineType Blitter::getBlitRoutine(const State &state) |
| { |
| marl::lock lock(blitMutex); |
| auto blitRoutine = blitCache.lookup(state); |
| |
| if(!blitRoutine) |
| { |
| blitRoutine = generate(state); |
| blitCache.add(state, blitRoutine); |
| } |
| |
| return blitRoutine; |
| } |
| |
| Blitter::CornerUpdateRoutineType Blitter::getCornerUpdateRoutine(const State &state) |
| { |
| marl::lock lock(cornerUpdateMutex); |
| auto cornerUpdateRoutine = cornerUpdateCache.lookup(state); |
| |
| if(!cornerUpdateRoutine) |
| { |
| cornerUpdateRoutine = generateCornerUpdate(state); |
| cornerUpdateCache.add(state, cornerUpdateRoutine); |
| } |
| |
| return cornerUpdateRoutine; |
| } |
| |
| void Blitter::blit(const vk::Image *src, vk::Image *dst, VkImageBlit region, VkFilter filter) |
| { |
| ASSERT(src->getFormat() != VK_FORMAT_UNDEFINED); |
| ASSERT(dst->getFormat() != VK_FORMAT_UNDEFINED); |
| |
| // Vulkan 1.2 section 18.5. Image Copies with Scaling: |
| // "The layerCount member of srcSubresource and dstSubresource must match" |
| // "The aspectMask member of srcSubresource and dstSubresource must match" |
| ASSERT(region.srcSubresource.layerCount == region.dstSubresource.layerCount); |
| ASSERT(region.srcSubresource.aspectMask == region.dstSubresource.aspectMask); |
| |
| if(region.dstOffsets[0].x > region.dstOffsets[1].x) |
| { |
| std::swap(region.srcOffsets[0].x, region.srcOffsets[1].x); |
| std::swap(region.dstOffsets[0].x, region.dstOffsets[1].x); |
| } |
| |
| if(region.dstOffsets[0].y > region.dstOffsets[1].y) |
| { |
| std::swap(region.srcOffsets[0].y, region.srcOffsets[1].y); |
| std::swap(region.dstOffsets[0].y, region.dstOffsets[1].y); |
| } |
| |
| if(region.dstOffsets[0].z > region.dstOffsets[1].z) |
| { |
| std::swap(region.srcOffsets[0].z, region.srcOffsets[1].z); |
| std::swap(region.dstOffsets[0].z, region.dstOffsets[1].z); |
| } |
| |
| VkImageAspectFlagBits srcAspect = static_cast<VkImageAspectFlagBits>(region.srcSubresource.aspectMask); |
| VkImageAspectFlagBits dstAspect = static_cast<VkImageAspectFlagBits>(region.dstSubresource.aspectMask); |
| VkExtent3D srcExtent = src->getMipLevelExtent(srcAspect, region.srcSubresource.mipLevel); |
| |
| float widthRatio = static_cast<float>(region.srcOffsets[1].x - region.srcOffsets[0].x) / |
| static_cast<float>(region.dstOffsets[1].x - region.dstOffsets[0].x); |
| float heightRatio = static_cast<float>(region.srcOffsets[1].y - region.srcOffsets[0].y) / |
| static_cast<float>(region.dstOffsets[1].y - region.dstOffsets[0].y); |
| float depthRatio = static_cast<float>(region.srcOffsets[1].z - region.srcOffsets[0].z) / |
| static_cast<float>(region.dstOffsets[1].z - region.dstOffsets[0].z); |
| float x0 = region.srcOffsets[0].x + (0.5f - region.dstOffsets[0].x) * widthRatio; |
| float y0 = region.srcOffsets[0].y + (0.5f - region.dstOffsets[0].y) * heightRatio; |
| float z0 = region.srcOffsets[0].z + (0.5f - region.dstOffsets[0].z) * depthRatio; |
| |
| auto srcFormat = src->getFormat(srcAspect); |
| auto dstFormat = dst->getFormat(dstAspect); |
| |
| bool doFilter = (filter != VK_FILTER_NEAREST); |
| bool allowSRGBConversion = |
| doFilter || |
| (src->getSampleCountFlagBits() > 1) || |
| (srcFormat.isSRGBformat() != dstFormat.isSRGBformat()); |
| |
| State state(src->getFormat(srcAspect), dst->getFormat(dstAspect), src->getSampleCountFlagBits(), dst->getSampleCountFlagBits(), |
| Options{ doFilter, allowSRGBConversion }); |
| state.clampToEdge = (region.srcOffsets[0].x < 0) || |
| (region.srcOffsets[0].y < 0) || |
| (static_cast<uint32_t>(region.srcOffsets[1].x) > srcExtent.width) || |
| (static_cast<uint32_t>(region.srcOffsets[1].y) > srcExtent.height) || |
| (doFilter && ((x0 < 0.5f) || (y0 < 0.5f))); |
| state.filter3D = (region.srcOffsets[1].z - region.srcOffsets[0].z) != |
| (region.dstOffsets[1].z - region.dstOffsets[0].z); |
| |
| auto blitRoutine = getBlitRoutine(state); |
| if(!blitRoutine) |
| { |
| return; |
| } |
| |
| BlitData data = { |
| nullptr, // source |
| nullptr, // dest |
| src->rowPitchBytes(srcAspect, region.srcSubresource.mipLevel), // sPitchB |
| dst->rowPitchBytes(dstAspect, region.dstSubresource.mipLevel), // dPitchB |
| src->slicePitchBytes(srcAspect, region.srcSubresource.mipLevel), // sSliceB |
| dst->slicePitchBytes(dstAspect, region.dstSubresource.mipLevel), // dSliceB |
| |
| x0, |
| y0, |
| z0, |
| widthRatio, |
| heightRatio, |
| depthRatio, |
| |
| region.dstOffsets[0].x, // x0d |
| region.dstOffsets[1].x, // x1d |
| region.dstOffsets[0].y, // y0d |
| region.dstOffsets[1].y, // y1d |
| region.dstOffsets[0].z, // z0d |
| region.dstOffsets[1].z, // z1d |
| |
| static_cast<int>(srcExtent.width), // sWidth |
| static_cast<int>(srcExtent.height), // sHeight |
| static_cast<int>(srcExtent.depth), // sDepth |
| |
| false, // filter3D |
| }; |
| |
| VkImageSubresource srcSubres = { |
| region.srcSubresource.aspectMask, |
| region.srcSubresource.mipLevel, |
| region.srcSubresource.baseArrayLayer |
| }; |
| |
| VkImageSubresource dstSubres = { |
| region.dstSubresource.aspectMask, |
| region.dstSubresource.mipLevel, |
| region.dstSubresource.baseArrayLayer |
| }; |
| |
| VkImageSubresourceRange dstSubresRange = { |
| region.dstSubresource.aspectMask, |
| region.dstSubresource.mipLevel, |
| 1, // levelCount |
| region.dstSubresource.baseArrayLayer, |
| region.dstSubresource.layerCount |
| }; |
| |
| uint32_t lastLayer = src->getLastLayerIndex(dstSubresRange); |
| |
| for(; dstSubres.arrayLayer <= lastLayer; srcSubres.arrayLayer++, dstSubres.arrayLayer++) |
| { |
| data.source = src->getTexelPointer({ 0, 0, 0 }, srcSubres); |
| data.dest = dst->getTexelPointer({ 0, 0, 0 }, dstSubres); |
| |
| ASSERT(data.source < src->end()); |
| ASSERT(data.dest < dst->end()); |
| |
| blitRoutine(&data); |
| } |
| |
| dst->contentsChanged(dstSubresRange); |
| } |
| |
| void Blitter::resolve(const vk::Image *src, vk::Image *dst, VkImageResolve region) |
| { |
| // "The aspectMask member of srcSubresource and dstSubresource must only contain VK_IMAGE_ASPECT_COLOR_BIT" |
| ASSERT(region.srcSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT); |
| ASSERT(region.dstSubresource.aspectMask == VK_IMAGE_ASPECT_COLOR_BIT); |
| // "The layerCount member of srcSubresource and dstSubresource must match" |
| ASSERT(region.srcSubresource.layerCount == region.dstSubresource.layerCount); |
| |
| // We use this method both for explicit resolves from vkCmdResolveImage, and implicit ones for resolve attachments. |
| // - vkCmdResolveImage: "srcImage and dstImage must have been created with the same image format." |
| // - VkSubpassDescription: "each resolve attachment that is not VK_ATTACHMENT_UNUSED must have the same VkFormat as its corresponding color attachment." |
| ASSERT(src->getFormat() == dst->getFormat()); |
| |
| if(fastResolve(src, dst, region)) |
| { |
| return; |
| } |
| |
| // Fall back to a generic blit which performs the resolve. |
| VkImageBlit blitRegion; |
| |
| blitRegion.srcOffsets[0] = blitRegion.srcOffsets[1] = region.srcOffset; |
| blitRegion.srcOffsets[1].x += region.extent.width; |
| blitRegion.srcOffsets[1].y += region.extent.height; |
| blitRegion.srcOffsets[1].z += region.extent.depth; |
| |
| blitRegion.dstOffsets[0] = blitRegion.dstOffsets[1] = region.dstOffset; |
| blitRegion.dstOffsets[1].x += region.extent.width; |
| blitRegion.dstOffsets[1].y += region.extent.height; |
| blitRegion.dstOffsets[1].z += region.extent.depth; |
| |
| blitRegion.srcSubresource = region.srcSubresource; |
| blitRegion.dstSubresource = region.dstSubresource; |
| |
| blit(src, dst, blitRegion, VK_FILTER_NEAREST); |
| } |
| |
| static inline uint32_t averageByte4(uint32_t x, uint32_t y) |
| { |
| return (x & y) + (((x ^ y) >> 1) & 0x7F7F7F7F) + ((x ^ y) & 0x01010101); |
| } |
| |
| bool Blitter::fastResolve(const vk::Image *src, vk::Image *dst, VkImageResolve region) |
| { |
| if(region.dstOffset != VkOffset3D{ 0, 0, 0 }) |
| { |
| return false; |
| } |
| |
| if(region.srcOffset != VkOffset3D{ 0, 0, 0 }) |
| { |
| return false; |
| } |
| |
| if(region.srcSubresource.layerCount != 1) |
| { |
| return false; |
| } |
| |
| if(region.extent != src->getExtent() || |
| region.extent != dst->getExtent() || |
| region.extent.depth != 1) |
| { |
| return false; |
| } |
| |
| VkImageSubresource srcSubresource = { |
| region.srcSubresource.aspectMask, |
| region.srcSubresource.mipLevel, |
| region.srcSubresource.baseArrayLayer |
| }; |
| |
| VkImageSubresource dstSubresource = { |
| region.dstSubresource.aspectMask, |
| region.dstSubresource.mipLevel, |
| region.dstSubresource.baseArrayLayer |
| }; |
| |
| VkImageSubresourceRange dstSubresourceRange = { |
| region.dstSubresource.aspectMask, |
| region.dstSubresource.mipLevel, |
| 1, // levelCount |
| region.dstSubresource.baseArrayLayer, |
| region.dstSubresource.layerCount |
| }; |
| |
| void *source = src->getTexelPointer({ 0, 0, 0 }, srcSubresource); |
| uint8_t *dest = reinterpret_cast<uint8_t *>(dst->getTexelPointer({ 0, 0, 0 }, dstSubresource)); |
| |
| auto format = src->getFormat(); |
| auto samples = src->getSampleCountFlagBits(); |
| auto extent = src->getExtent(); |
| |
| int width = extent.width; |
| int height = extent.height; |
| int pitch = src->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, region.srcSubresource.mipLevel); |
| int slice = src->slicePitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, region.srcSubresource.mipLevel); |
| |
| uint8_t *source0 = (uint8_t *)source; |
| uint8_t *source1 = source0 + slice; |
| uint8_t *source2 = source1 + slice; |
| uint8_t *source3 = source2 + slice; |
| |
| const bool SSE2 = CPUID::supportsSSE2(); |
| |
| if(format == VK_FORMAT_R8G8B8A8_UNORM || format == VK_FORMAT_B8G8R8A8_UNORM || format == VK_FORMAT_A8B8G8R8_UNORM_PACK32) |
| { |
| if(samples == 4) |
| { |
| for(int y = 0; y < height; y++) |
| { |
| int x = 0; |
| |
| #if defined(__i386__) || defined(__x86_64__) |
| if(SSE2) |
| { |
| for(; (x + 3) < width; x += 4) |
| { |
| __m128i c0 = _mm_loadu_si128((__m128i *)(source0 + 4 * x)); |
| __m128i c1 = _mm_loadu_si128((__m128i *)(source1 + 4 * x)); |
| __m128i c2 = _mm_loadu_si128((__m128i *)(source2 + 4 * x)); |
| __m128i c3 = _mm_loadu_si128((__m128i *)(source3 + 4 * x)); |
| |
| c0 = _mm_avg_epu8(c0, c1); |
| c2 = _mm_avg_epu8(c2, c3); |
| c0 = _mm_avg_epu8(c0, c2); |
| |
| _mm_storeu_si128((__m128i *)(dest + 4 * x), c0); |
| } |
| } |
| #endif |
| |
| for(; x < width; x++) |
| { |
| uint32_t c0 = *(uint32_t *)(source0 + 4 * x); |
| uint32_t c1 = *(uint32_t *)(source1 + 4 * x); |
| uint32_t c2 = *(uint32_t *)(source2 + 4 * x); |
| uint32_t c3 = *(uint32_t *)(source3 + 4 * x); |
| |
| uint32_t c01 = averageByte4(c0, c1); |
| uint32_t c23 = averageByte4(c2, c3); |
| uint32_t c03 = averageByte4(c01, c23); |
| |
| *(uint32_t *)(dest + 4 * x) = c03; |
| } |
| |
| source0 += pitch; |
| source1 += pitch; |
| source2 += pitch; |
| source3 += pitch; |
| dest += pitch; |
| |
| ASSERT(source0 < src->end()); |
| ASSERT(source3 < src->end()); |
| ASSERT(dest < dst->end()); |
| } |
| } |
| else |
| UNSUPPORTED("Samples: %d", samples); |
| } |
| else |
| { |
| return false; |
| } |
| |
| dst->contentsChanged(dstSubresourceRange); |
| |
| return true; |
| } |
| |
| void Blitter::copy(const vk::Image *src, uint8_t *dst, unsigned int dstPitch) |
| { |
| VkExtent3D extent = src->getExtent(); |
| size_t rowBytes = src->getFormat(VK_IMAGE_ASPECT_COLOR_BIT).bytes() * extent.width; |
| unsigned int srcPitch = src->rowPitchBytes(VK_IMAGE_ASPECT_COLOR_BIT, 0); |
| ASSERT(dstPitch >= rowBytes && srcPitch >= rowBytes && src->getMipLevelExtent(VK_IMAGE_ASPECT_COLOR_BIT, 0).height >= extent.height); |
| |
| const uint8_t *s = (uint8_t *)src->getTexelPointer({ 0, 0, 0 }, { VK_IMAGE_ASPECT_COLOR_BIT, 0, 0 }); |
| uint8_t *d = dst; |
| |
| for(uint32_t y = 0; y < extent.height; y++) |
| { |
| memcpy(d, s, rowBytes); |
| |
| s += srcPitch; |
| d += dstPitch; |
| } |
| } |
| |
| void Blitter::computeCubeCorner(Pointer<Byte> &layer, Int &x0, Int &x1, Int &y0, Int &y1, Int &pitchB, const State &state) |
| { |
| int bytes = state.sourceFormat.bytes(); |
| |
| Float4 c = readFloat4(layer + ComputeOffset(x0, y1, pitchB, bytes), state) + |
| readFloat4(layer + ComputeOffset(x1, y0, pitchB, bytes), state) + |
| readFloat4(layer + ComputeOffset(x1, y1, pitchB, bytes), state); |
| |
| c *= Float4(1.0f / 3.0f); |
| |
| write(c, layer + ComputeOffset(x0, y0, pitchB, bytes), state); |
| } |
| |
| Blitter::CornerUpdateRoutineType Blitter::generateCornerUpdate(const State &state) |
| { |
| // Reading and writing from/to the same image |
| ASSERT(state.sourceFormat == state.destFormat); |
| ASSERT(state.srcSamples == state.destSamples); |
| |
| // Vulkan 1.2: "If samples is not VK_SAMPLE_COUNT_1_BIT, then imageType must be |
| // VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT" |
| ASSERT(state.srcSamples == 1); |
| |
| CornerUpdateFunction function; |
| { |
| Pointer<Byte> blit(function.Arg<0>()); |
| |
| Pointer<Byte> layers = *Pointer<Pointer<Byte>>(blit + OFFSET(CubeBorderData, layers)); |
| Int pitchB = *Pointer<Int>(blit + OFFSET(CubeBorderData, pitchB)); |
| UInt layerSize = *Pointer<Int>(blit + OFFSET(CubeBorderData, layerSize)); |
| UInt dim = *Pointer<Int>(blit + OFFSET(CubeBorderData, dim)); |
| |
| // Low Border, Low Pixel, High Border, High Pixel |
| Int LB(-1), LP(0), HB(dim), HP(dim - 1); |
| |
| for(int face = 0; face < 6; face++) |
| { |
| computeCubeCorner(layers, LB, LP, LB, LP, pitchB, state); |
| computeCubeCorner(layers, LB, LP, HB, HP, pitchB, state); |
| computeCubeCorner(layers, HB, HP, LB, LP, pitchB, state); |
| computeCubeCorner(layers, HB, HP, HB, HP, pitchB, state); |
| layers = layers + layerSize; |
| } |
| } |
| |
| return function("BlitRoutine"); |
| } |
| |
| void Blitter::updateBorders(vk::Image *image, const VkImageSubresource &subresource) |
| { |
| ASSERT(image->getArrayLayers() >= (subresource.arrayLayer + 6)); |
| |
| // From Vulkan 1.1 spec, section 11.5. Image Views: |
| // "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." |
| VkImageSubresource posX = subresource; |
| VkImageSubresource negX = posX; |
| negX.arrayLayer++; |
| VkImageSubresource posY = negX; |
| posY.arrayLayer++; |
| VkImageSubresource negY = posY; |
| negY.arrayLayer++; |
| VkImageSubresource posZ = negY; |
| posZ.arrayLayer++; |
| VkImageSubresource negZ = posZ; |
| negZ.arrayLayer++; |
| |
| // Copy top / bottom |
| copyCubeEdge(image, posX, BOTTOM, negY, RIGHT); |
| copyCubeEdge(image, posY, BOTTOM, posZ, TOP); |
| copyCubeEdge(image, posZ, BOTTOM, negY, TOP); |
| copyCubeEdge(image, negX, BOTTOM, negY, LEFT); |
| copyCubeEdge(image, negY, BOTTOM, negZ, BOTTOM); |
| copyCubeEdge(image, negZ, BOTTOM, negY, BOTTOM); |
| |
| copyCubeEdge(image, posX, TOP, posY, RIGHT); |
| copyCubeEdge(image, posY, TOP, negZ, TOP); |
| copyCubeEdge(image, posZ, TOP, posY, BOTTOM); |
| copyCubeEdge(image, negX, TOP, posY, LEFT); |
| copyCubeEdge(image, negY, TOP, posZ, BOTTOM); |
| copyCubeEdge(image, negZ, TOP, posY, TOP); |
| |
| // Copy left / right |
| copyCubeEdge(image, posX, RIGHT, negZ, LEFT); |
| copyCubeEdge(image, posY, RIGHT, posX, TOP); |
| copyCubeEdge(image, posZ, RIGHT, posX, LEFT); |
| copyCubeEdge(image, negX, RIGHT, posZ, LEFT); |
| copyCubeEdge(image, negY, RIGHT, posX, BOTTOM); |
| copyCubeEdge(image, negZ, RIGHT, negX, LEFT); |
| |
| copyCubeEdge(image, posX, LEFT, posZ, RIGHT); |
| copyCubeEdge(image, posY, LEFT, negX, TOP); |
| copyCubeEdge(image, posZ, LEFT, negX, RIGHT); |
| copyCubeEdge(image, negX, LEFT, negZ, RIGHT); |
| copyCubeEdge(image, negY, LEFT, negX, BOTTOM); |
| copyCubeEdge(image, negZ, LEFT, posX, RIGHT); |
| |
| // Compute corner colors |
| VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresource.aspectMask); |
| vk::Format format = image->getFormat(aspect); |
| VkSampleCountFlagBits samples = image->getSampleCountFlagBits(); |
| State state(format, format, samples, samples, Options{ 0xF }); |
| |
| // Vulkan 1.2: "If samples is not VK_SAMPLE_COUNT_1_BIT, then imageType must be |
| // VK_IMAGE_TYPE_2D, flags must not contain VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT" |
| ASSERT(samples == VK_SAMPLE_COUNT_1_BIT); |
| |
| auto cornerUpdateRoutine = getCornerUpdateRoutine(state); |
| if(!cornerUpdateRoutine) |
| { |
| return; |
| } |
| |
| VkExtent3D extent = image->getMipLevelExtent(aspect, subresource.mipLevel); |
| CubeBorderData data = { |
| image->getTexelPointer({ 0, 0, 0 }, posX), |
| image->rowPitchBytes(aspect, subresource.mipLevel), |
| static_cast<uint32_t>(image->getLayerSize(aspect)), |
| extent.width |
| }; |
| cornerUpdateRoutine(&data); |
| } |
| |
| void Blitter::copyCubeEdge(vk::Image *image, |
| const VkImageSubresource &dstSubresource, Edge dstEdge, |
| const VkImageSubresource &srcSubresource, Edge srcEdge) |
| { |
| ASSERT(srcSubresource.aspectMask == dstSubresource.aspectMask); |
| ASSERT(srcSubresource.mipLevel == dstSubresource.mipLevel); |
| ASSERT(srcSubresource.arrayLayer != dstSubresource.arrayLayer); |
| |
| // 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 |
| // copying top <-> right or bottom <-> left. This is explained by the layout, which is: |
| // |
| // | +y | |
| // | -x | +z | +x | -z | |
| // | -y | |
| |
| bool reverse = (srcEdge == dstEdge) || |
| ((srcEdge == TOP) && (dstEdge == RIGHT)) || |
| ((srcEdge == RIGHT) && (dstEdge == TOP)) || |
| ((srcEdge == BOTTOM) && (dstEdge == LEFT)) || |
| ((srcEdge == LEFT) && (dstEdge == BOTTOM)); |
| |
| VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(srcSubresource.aspectMask); |
| int bytes = image->getFormat(aspect).bytes(); |
| int pitchB = image->rowPitchBytes(aspect, srcSubresource.mipLevel); |
| |
| VkExtent3D extent = image->getMipLevelExtent(aspect, srcSubresource.mipLevel); |
| int w = extent.width; |
| int h = extent.height; |
| if(w != h) |
| { |
| UNSUPPORTED("Cube doesn't have square faces : (%d, %d)", w, h); |
| } |
| |
| // Src is expressed in the regular [0, width-1], [0, height-1] space |
| bool srcHorizontal = ((srcEdge == TOP) || (srcEdge == BOTTOM)); |
| int srcDelta = srcHorizontal ? bytes : pitchB; |
| VkOffset3D srcOffset = { (srcEdge == RIGHT) ? (w - 1) : 0, (srcEdge == BOTTOM) ? (h - 1) : 0, 0 }; |
| |
| // Dst contains borders, so it is expressed in the [-1, width], [-1, height] space |
| bool dstHorizontal = ((dstEdge == TOP) || (dstEdge == BOTTOM)); |
| int dstDelta = (dstHorizontal ? bytes : pitchB) * (reverse ? -1 : 1); |
| VkOffset3D dstOffset = { (dstEdge == RIGHT) ? w : -1, (dstEdge == BOTTOM) ? h : -1, 0 }; |
| |
| // Don't write in the corners |
| if(dstHorizontal) |
| { |
| dstOffset.x += reverse ? w : 1; |
| } |
| else |
| { |
| dstOffset.y += reverse ? h : 1; |
| } |
| |
| const uint8_t *src = static_cast<const uint8_t *>(image->getTexelPointer(srcOffset, srcSubresource)); |
| uint8_t *dst = static_cast<uint8_t *>(image->getTexelPointer(dstOffset, dstSubresource)); |
| ASSERT((src < image->end()) && ((src + (w * srcDelta)) < image->end())); |
| ASSERT((dst < image->end()) && ((dst + (w * dstDelta)) < image->end())); |
| |
| for(int i = 0; i < w; ++i, dst += dstDelta, src += srcDelta) |
| { |
| memcpy(dst, src, bytes); |
| } |
| } |
| |
| } // namespace sw |