Skip to content

S
swiftshader
Commit 25ec7b0c by Alexis Hetu Committed by Alexis Hétu
Options

Removed references to sw::Surface

Removed sw::Surface dependency from: - Blitter - Context - PixelProcessor - PixelRoutine - Renderer - VkFramebuffer No behavior changes should be happen with this cl. Bug b/126883332 Change-Id: I4146f043ba8e5008eb3d44465c26a0f34a2e1acc Reviewed-on: https://swiftshader-review.googlesource.com/c/SwiftShader/+/26969Tested-by: 's avatarAlexis Hétu <sugoi@google.com> Presubmit-Ready: Alexis Hétu <sugoi@google.com> Kokoro-Presubmit: kokoro <noreply+kokoro@google.com> Reviewed-by: 's avatarNicolas Capens <nicolascapens@google.com> Reviewed-by: 's avatarChris Forbes <chrisforbes@google.com>
parent 1407297b
Showing with 546 additions and 493 deletions
src/Device/Blitter.cpp
...@@ -32,20 +32,7 @@ namespace sw ...@@ -32,20 +32,7 @@ namespace sw
delete blitCache; delete blitCache;
} }
void Blitter::clear(void *pixel, VkFormat format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask) void Blitter::clear(void *pixel, vk::Format format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea)
{
if(fastClear(pixel, format, dest, dRect, rgbaMask))
{
return;
}
sw::Surface *color = sw::Surface::create(1, 1, 1, format, pixel, sw::Surface::bytes(format), sw::Surface::bytes(format));
SliceRectF sRect(0.5f, 0.5f, 0.5f, 0.5f, 0); // Sample from the middle.
blit(color, sRect, dest, dRect, {rgbaMask});
delete color;
}
void Blitter::clear(void *pixel, VkFormat format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea)
{ {
VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresourceRange.aspectMask); VkImageAspectFlagBits aspect = static_cast<VkImageAspectFlagBits>(subresourceRange.aspectMask);
if(dest->getFormat(aspect) == VK_FORMAT_UNDEFINED) if(dest->getFormat(aspect) == VK_FORMAT_UNDEFINED)
...@@ -98,7 +85,7 @@ namespace sw ...@@ -98,7 +85,7 @@ namespace sw
{ {
pixel, nullptr, // source, dest pixel, nullptr, // source, dest
sw::Surface::bytes(format), // sPitchB format.bytes(), // sPitchB
dest->rowPitchBytes(aspect, subresLayers.mipLevel), // dPitchB dest->rowPitchBytes(aspect, subresLayers.mipLevel), // dPitchB
dest->slicePitchBytes(aspect, subresLayers.mipLevel), // dSliceB dest->slicePitchBytes(aspect, subresLayers.mipLevel), // dSliceB
...@@ -122,7 +109,7 @@ namespace sw ...@@ -122,7 +109,7 @@ namespace sw
} }
} }
bool Blitter::fastClear(void *pixel, VkFormat format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea) bool Blitter::fastClear(void *pixel, vk::Format format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea)
{ {
if(format != VK_FORMAT_R32G32B32A32_SFLOAT) if(format != VK_FORMAT_R32G32B32A32_SFLOAT)
{ {
...@@ -213,7 +200,7 @@ namespace sw ...@@ -213,7 +200,7 @@ namespace sw
{ {
uint8_t *d = slice; uint8_t *d = slice;
switch(Surface::bytes(dest->getFormat(aspect))) switch(dest->getFormat(aspect).bytes())
{ {
case 2: case 2:
for(uint32_t i = 0; i < area.extent.height; i++) for(uint32_t i = 0; i < area.extent.height; i++)
...@@ -242,183 +229,6 @@ namespace sw ...@@ -242,183 +229,6 @@ namespace sw
return true; return true;
} }
bool Blitter::fastClear(void *pixel, VkFormat format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask)
{
if(format != VK_FORMAT_R32G32B32A32_SFLOAT)
{
return false;
}
float *color = (float*)pixel;
float r = color[0];
float g = color[1];
float b = color[2];
float a = color[3];
uint32_t packed;
switch(dest->getFormat())
{
case VK_FORMAT_R5G6B5_UNORM_PACK16:
if((rgbaMask & 0x7) != 0x7) return false;
packed = ((uint16_t)(31 * b + 0.5f) << 0) |
((uint16_t)(63 * g + 0.5f) << 5) |
((uint16_t)(31 * r + 0.5f) << 11);
break;
case VK_FORMAT_B5G6R5_UNORM_PACK16:
if((rgbaMask & 0x7) != 0x7) return false;
packed = ((uint16_t)(31 * r + 0.5f) << 0) |
((uint16_t)(63 * g + 0.5f) << 5) |
((uint16_t)(31 * b + 0.5f) << 11);
break;
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_R8G8B8A8_UNORM:
if((rgbaMask & 0xF) != 0xF) return false;
packed = ((uint32_t)(255 * a + 0.5f) << 24) |
((uint32_t)(255 * b + 0.5f) << 16) |
((uint32_t)(255 * g + 0.5f) << 8) |
((uint32_t)(255 * r + 0.5f) << 0);
break;
case VK_FORMAT_B8G8R8A8_UNORM:
if((rgbaMask & 0xF) != 0xF) return false;
packed = ((uint32_t)(255 * a + 0.5f) << 24) |
((uint32_t)(255 * r + 0.5f) << 16) |
((uint32_t)(255 * g + 0.5f) << 8) |
((uint32_t)(255 * b + 0.5f) << 0);
break;
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
if((rgbaMask & 0x7) != 0x7) return false;
packed = R11G11B10F(color);
break;
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
if((rgbaMask & 0x7) != 0x7) return false;
packed = RGB9E5(color);
break;
default:
return false;
}
bool useDestInternal = !dest->isExternalDirty();
uint8_t *slice = (uint8_t*)dest->lock(dRect.x0, dRect.y0, dRect.slice, sw::LOCK_WRITEONLY, sw::PUBLIC, useDestInternal);
for(int j = 0; j < dest->getSamples(); j++)
{
uint8_t *d = slice;
switch(Surface::bytes(dest->getFormat()))
{
case 2:
for(int i = dRect.y0; i < dRect.y1; i++)
{
sw::clear((uint16_t*)d, packed, dRect.x1 - dRect.x0);
d += dest->getPitchB(useDestInternal);
}
break;
case 4:
for(int i = dRect.y0; i < dRect.y1; i++)
{
sw::clear((uint32_t*)d, packed, dRect.x1 - dRect.x0);
d += dest->getPitchB(useDestInternal);
}
break;
default:
assert(false);
}
slice += dest->getSliceB(useDestInternal);
}
dest->unlock(useDestInternal);
return true;
}
void Blitter::blit(Surface *source, const SliceRectF &sourceRect, Surface *dest, const SliceRect &destRect, const Blitter::Options& options)
{
if(dest->getInternalFormat() == VK_FORMAT_UNDEFINED)
{
return;
}
if(blitReactor(source, sourceRect, dest, destRect, options))
{
return;
}
SliceRectF sRect = sourceRect;
SliceRect dRect = destRect;
bool flipX = destRect.x0 > destRect.x1;
bool flipY = destRect.y0 > destRect.y1;
if(flipX)
{
swap(dRect.x0, dRect.x1);
swap(sRect.x0, sRect.x1);
}
if(flipY)
{
swap(dRect.y0, dRect.y1);
swap(sRect.y0, sRect.y1);
}
source->lockInternal(0, 0, sRect.slice, sw::LOCK_READONLY, sw::PUBLIC);
dest->lockInternal(0, 0, dRect.slice, sw::LOCK_WRITEONLY, sw::PUBLIC);
float w = sRect.width() / dRect.width();
float h = sRect.height() / dRect.height();
float xStart = sRect.x0 + (0.5f - dRect.x0) * w;
float yStart = sRect.y0 + (0.5f - dRect.y0) * h;
for(int j = dRect.y0; j < dRect.y1; j++)
{
float y = yStart + j * h;
for(int i = dRect.x0; i < dRect.x1; i++)
{
float x = xStart + i * w;
// FIXME: Support RGBA mask
dest->copyInternal(source, i, j, x, y, options.filter);
}
}
source->unlockInternal();
dest->unlockInternal();
}
void Blitter::blit3D(Surface *source, Surface *dest)
{
source->lockInternal(0, 0, 0, sw::LOCK_READONLY, sw::PUBLIC);
dest->lockInternal(0, 0, 0, sw::LOCK_WRITEONLY, sw::PUBLIC);
float w = static_cast<float>(source->getWidth()) / static_cast<float>(dest->getWidth());
float h = static_cast<float>(source->getHeight()) / static_cast<float>(dest->getHeight());
float d = static_cast<float>(source->getDepth()) / static_cast<float>(dest->getDepth());
for(int k = 0; k < dest->getDepth(); k++)
{
float z = (k + 0.5f) * d;
for(int j = 0; j < dest->getHeight(); j++)
{
float y = (j + 0.5f) * h;
for(int i = 0; i < dest->getWidth(); i++)
{
float x = (i + 0.5f) * w;
dest->copyInternal(source, i, j, k, x, y, z, true);
}
}
}
source->unlockInternal();
dest->unlockInternal();
}
bool Blitter::read(Float4 &c, Pointer<Byte> element, const State &state) bool Blitter::read(Float4 &c, Pointer<Byte> element, const State &state)
{ {
c = Float4(0.0f, 0.0f, 0.0f, 1.0f); c = Float4(0.0f, 0.0f, 0.0f, 1.0f);
...@@ -1368,164 +1178,12 @@ namespace sw ...@@ -1368,164 +1178,12 @@ namespace sw
return true; return true;
} }
bool Blitter::GetScale(float4 &scale, VkFormat format)
{
switch(format)
{
case VK_FORMAT_R4G4_UNORM_PACK8:
case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
scale = vector(0xF, 0xF, 0xF, 0xF);
break;
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8B8_UNORM:
case VK_FORMAT_B8G8R8_UNORM:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_B8G8R8A8_UNORM:
case VK_FORMAT_R8_SRGB:
case VK_FORMAT_R8G8_SRGB:
case VK_FORMAT_R8G8B8_SRGB:
case VK_FORMAT_B8G8R8_SRGB:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_B8G8R8A8_SRGB:
scale = vector(0xFF, 0xFF, 0xFF, 0xFF);
break;
case VK_FORMAT_R8_SNORM:
case VK_FORMAT_R8G8_SNORM:
case VK_FORMAT_R8G8B8_SNORM:
case VK_FORMAT_B8G8R8_SNORM:
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
case VK_FORMAT_R8G8B8A8_SNORM:
case VK_FORMAT_B8G8R8A8_SNORM:
scale = vector(0x7F, 0x7F, 0x7F, 0x7F);
break;
case VK_FORMAT_R16_UNORM:
case VK_FORMAT_R16G16_UNORM:
case VK_FORMAT_R16G16B16_UNORM:
case VK_FORMAT_R16G16B16A16_UNORM:
scale = vector(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
break;
case VK_FORMAT_R16_SNORM:
case VK_FORMAT_R16G16_SNORM:
case VK_FORMAT_R16G16B16_SNORM:
case VK_FORMAT_R16G16B16A16_SNORM:
scale = vector(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF);
break;
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8G8_SINT:
case VK_FORMAT_R8G8_UINT:
case VK_FORMAT_R8G8B8_SINT:
case VK_FORMAT_R8G8B8_UINT:
case VK_FORMAT_B8G8R8_SINT:
case VK_FORMAT_B8G8R8_UINT:
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_R8G8B8A8_UINT:
case VK_FORMAT_A8B8G8R8_SINT_PACK32:
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
case VK_FORMAT_B8G8R8A8_SINT:
case VK_FORMAT_B8G8R8A8_UINT:
case VK_FORMAT_R8_USCALED:
case VK_FORMAT_R8G8_USCALED:
case VK_FORMAT_R8G8B8_USCALED:
case VK_FORMAT_B8G8R8_USCALED:
case VK_FORMAT_R8G8B8A8_USCALED:
case VK_FORMAT_B8G8R8A8_USCALED:
case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8B8_SSCALED:
case VK_FORMAT_B8G8R8_SSCALED:
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
case VK_FORMAT_R16_SINT:
case VK_FORMAT_R16_UINT:
case VK_FORMAT_R16G16_SINT:
case VK_FORMAT_R16G16_UINT:
case VK_FORMAT_R16G16B16A16_SINT:
case VK_FORMAT_R16G16B16A16_UINT:
case VK_FORMAT_R16_SSCALED:
case VK_FORMAT_R16G16_SSCALED:
case VK_FORMAT_R16G16B16_SSCALED:
case VK_FORMAT_R16G16B16A16_SSCALED:
case VK_FORMAT_R16_USCALED:
case VK_FORMAT_R16G16_USCALED:
case VK_FORMAT_R16G16B16_USCALED:
case VK_FORMAT_R16G16B16A16_USCALED:
case VK_FORMAT_R32_SINT:
case VK_FORMAT_R32_UINT:
case VK_FORMAT_R32G32_SINT:
case VK_FORMAT_R32G32_UINT:
case VK_FORMAT_R32G32B32_SINT:
case VK_FORMAT_R32G32B32_UINT:
case VK_FORMAT_R32G32B32A32_SINT:
case VK_FORMAT_R32G32B32A32_UINT:
case VK_FORMAT_R32G32B32A32_SFLOAT:
case VK_FORMAT_R32G32B32_SFLOAT:
case VK_FORMAT_R32G32_SFLOAT:
case VK_FORMAT_R32_SFLOAT:
case VK_FORMAT_R16G16B16A16_SFLOAT:
case VK_FORMAT_R16G16B16_SFLOAT:
case VK_FORMAT_R16G16_SFLOAT:
case VK_FORMAT_R16_SFLOAT:
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
case VK_FORMAT_A2R10G10B10_UINT_PACK32:
case VK_FORMAT_A2R10G10B10_SINT_PACK32:
case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
case VK_FORMAT_A2B10G10R10_UINT_PACK32:
case VK_FORMAT_A2B10G10R10_SINT_PACK32:
scale = vector(1.0f, 1.0f, 1.0f, 1.0f);
break;
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
scale = vector(0x1F, 0x1F, 0x1F, 0x01);
break;
case VK_FORMAT_R5G6B5_UNORM_PACK16:
case VK_FORMAT_B5G6R5_UNORM_PACK16:
scale = vector(0x1F, 0x3F, 0x1F, 1.0f);
break;
case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
scale = vector(0x3FF, 0x3FF, 0x3FF, 0x03);
break;
case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
scale = vector(0x1FF, 0x1FF, 0x1FF, 0x01);
break;
case VK_FORMAT_D16_UNORM:
scale = vector(0xFFFF, 0.0f, 0.0f, 0.0f);
break;
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_X8_D24_UNORM_PACK32:
scale = vector(0xFFFFFF, 0.0f, 0.0f, 0.0f);
break;
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_S8_UINT:
scale = vector(1.0f, 1.0f, 1.0f, 1.0f);
break;
default:
return false;
}
return true;
}
bool Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled) bool Blitter::ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled)
{ {
float4 scale, unscale; float4 scale, unscale;
if(state.clearOperation && if(state.clearOperation &&
Surface::isNonNormalizedInteger(state.sourceFormat) && state.sourceFormat.isNonNormalizedInteger() &&
!Surface::isNonNormalizedInteger(state.destFormat)) !state.destFormat.isNonNormalizedInteger())
{ {
// If we're clearing a buffer from an int or uint color into a normalized color, // 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. // then the whole range of the int or uint color must be scaled between 0 and 1.
...@@ -1541,18 +1199,18 @@ namespace sw ...@@ -1541,18 +1199,18 @@ namespace sw
return false; return false;
} }
} }
else if(!GetScale(unscale, state.sourceFormat)) else if(!state.sourceFormat.getScale(unscale))
{ {
return false; return false;
} }
if(!GetScale(scale, state.destFormat)) if(!state.destFormat.getScale(scale))
{ {
return false; return false;
} }
bool srcSRGB = Surface::isSRGBformat(state.sourceFormat); bool srcSRGB = state.sourceFormat.isSRGBformat();
bool dstSRGB = Surface::isSRGBformat(state.destFormat); bool dstSRGB = state.destFormat.isSRGBformat();
if(state.convertSRGB && ((srcSRGB && !preScaled) || dstSRGB)) // One of the formats is sRGB encoded. if(state.convertSRGB && ((srcSRGB && !preScaled) || dstSRGB)) // One of the formats is sRGB encoded.
{ {
...@@ -1566,14 +1224,14 @@ namespace sw ...@@ -1566,14 +1224,14 @@ namespace sw
value *= Float4(scale.x / unscale.x, scale.y / unscale.y, scale.z / unscale.z, scale.w / unscale.w); value *= Float4(scale.x / unscale.x, scale.y / unscale.y, scale.z / unscale.z, scale.w / unscale.w);
} }
if(Surface::isFloatFormat(state.sourceFormat) && !Surface::isFloatFormat(state.destFormat)) if(state.sourceFormat.isFloatFormat() && !state.destFormat.isFloatFormat())
{ {
value = Min(value, Float4(scale.x, scale.y, scale.z, scale.w)); value = Min(value, Float4(scale.x, scale.y, scale.z, scale.w));
value = Max(value, Float4(Surface::isUnsignedComponent(state.destFormat, 0) ? 0.0f : -scale.x, value = Max(value, Float4(state.destFormat.isUnsignedComponent(0) ? 0.0f : -scale.x,
Surface::isUnsignedComponent(state.destFormat, 1) ? 0.0f : -scale.y, state.destFormat.isUnsignedComponent(1) ? 0.0f : -scale.y,
Surface::isUnsignedComponent(state.destFormat, 2) ? 0.0f : -scale.z, state.destFormat.isUnsignedComponent(2) ? 0.0f : -scale.z,
Surface::isUnsignedComponent(state.destFormat, 3) ? 0.0f : -scale.w)); state.destFormat.isUnsignedComponent(3) ? 0.0f : -scale.w));
} }
return true; return true;
...@@ -1641,13 +1299,13 @@ namespace sw ...@@ -1641,13 +1299,13 @@ namespace sw
Int sWidth = *Pointer<Int>(blit + OFFSET(BlitData,sWidth)); Int sWidth = *Pointer<Int>(blit + OFFSET(BlitData,sWidth));
Int sHeight = *Pointer<Int>(blit + OFFSET(BlitData,sHeight)); Int sHeight = *Pointer<Int>(blit + OFFSET(BlitData,sHeight));
bool intSrc = Surface::isNonNormalizedInteger(state.sourceFormat); bool intSrc = state.sourceFormat.isNonNormalizedInteger();
bool intDst = Surface::isNonNormalizedInteger(state.destFormat); bool intDst = state.destFormat.isNonNormalizedInteger();
bool intBoth = intSrc && intDst; bool intBoth = intSrc && intDst;
bool srcQuadLayout = Surface::hasQuadLayout(state.sourceFormat); bool srcQuadLayout = state.sourceFormat.hasQuadLayout();
bool dstQuadLayout = Surface::hasQuadLayout(state.destFormat); bool dstQuadLayout = state.destFormat.hasQuadLayout();
int srcBytes = Surface::bytes(state.sourceFormat); int srcBytes = state.sourceFormat.bytes();
int dstBytes = Surface::bytes(state.destFormat); int dstBytes = state.destFormat.bytes();
bool hasConstantColorI = false; bool hasConstantColorI = false;
Int4 constantColorI; Int4 constantColorI;
...@@ -1786,7 +1444,7 @@ namespace sw ...@@ -1786,7 +1444,7 @@ namespace sw
Float4 c10; if(!read(c10, s10, state)) return nullptr; Float4 c10; if(!read(c10, s10, state)) return nullptr;
Float4 c11; if(!read(c11, s11, state)) return nullptr; Float4 c11; if(!read(c11, s11, state)) return nullptr;
if(state.convertSRGB && Surface::isSRGBformat(state.sourceFormat)) // sRGB -> RGB if(state.convertSRGB && state.sourceFormat.isSRGBformat()) // sRGB -> RGB
{ {
if(!ApplyScaleAndClamp(c00, state)) return nullptr; if(!ApplyScaleAndClamp(c00, state)) return nullptr;
if(!ApplyScaleAndClamp(c01, state)) return nullptr; if(!ApplyScaleAndClamp(c01, state)) return nullptr;
...@@ -1850,87 +1508,6 @@ namespace sw ...@@ -1850,87 +1508,6 @@ namespace sw
return blitRoutine; return blitRoutine;
} }
bool Blitter::blitReactor(Surface *source, const SliceRectF &sourceRect, Surface *dest, const SliceRect &destRect, const Blitter::Options &options)
{
ASSERT(!options.clearOperation || ((source->getWidth() == 1) && (source->getHeight() == 1) && (source->getDepth() == 1)));
Rect dRect = destRect;
RectF sRect = sourceRect;
if(destRect.x0 > destRect.x1)
{
swap(dRect.x0, dRect.x1);
swap(sRect.x0, sRect.x1);
}
if(destRect.y0 > destRect.y1)
{
swap(dRect.y0, dRect.y1);
swap(sRect.y0, sRect.y1);
}
State state(options);
state.clampToEdge = (sourceRect.x0 < 0.0f) ||
(sourceRect.y0 < 0.0f) ||
(sourceRect.x1 > (float)source->getWidth()) ||
(sourceRect.y1 > (float)source->getHeight());
bool useSourceInternal = !source->isExternalDirty();
bool useDestInternal = !dest->isExternalDirty();
bool isStencil = options.useStencil;
state.sourceFormat = isStencil ? source->getStencilFormat() : source->getFormat(useSourceInternal);
state.destFormat = isStencil ? dest->getStencilFormat() : dest->getFormat(useDestInternal);
state.destSamples = dest->getSamples();
Routine *blitRoutine = getRoutine(state);
if(!blitRoutine)
{
return false;
}
void (*blitFunction)(const BlitData *data) = (void(*)(const BlitData*))blitRoutine->getEntry();
BlitData data;
bool isRGBA = options.writeMask == 0xF;
bool isEntireDest = dest->isEntire(destRect);
data.source = isStencil ? source->lockStencil(0, 0, 0, sw::PUBLIC) :
source->lock(0, 0, sourceRect.slice, sw::LOCK_READONLY, sw::PUBLIC, useSourceInternal);
data.dest = isStencil ? dest->lockStencil(0, 0, 0, sw::PUBLIC) :
dest->lock(0, 0, destRect.slice, isRGBA ? (isEntireDest ? sw::LOCK_DISCARD : sw::LOCK_WRITEONLY) : sw::LOCK_READWRITE, sw::PUBLIC, useDestInternal);
data.sPitchB = isStencil ? source->getStencilPitchB() : source->getPitchB(useSourceInternal);
data.dPitchB = isStencil ? dest->getStencilPitchB() : dest->getPitchB(useDestInternal);
data.dSliceB = isStencil ? dest->getStencilSliceB() : dest->getSliceB(useDestInternal);
data.w = sRect.width() / dRect.width();
data.h = sRect.height() / dRect.height();
data.x0 = sRect.x0 + (0.5f - dRect.x0) * data.w;
data.y0 = sRect.y0 + (0.5f - dRect.y0) * data.h;
data.x0d = dRect.x0;
data.x1d = dRect.x1;
data.y0d = dRect.y0;
data.y1d = dRect.y1;
data.sWidth = source->getWidth();
data.sHeight = source->getHeight();
blitFunction(&data);
if(isStencil)
{
source->unlockStencil();
dest->unlockStencil();
}
else
{
source->unlock(useSourceInternal);
dest->unlock(useDestInternal);
}
return true;
}
void Blitter::blit(vk::Image *src, vk::Image *dst, VkImageBlit region, VkFilter filter) void Blitter::blit(vk::Image *src, vk::Image *dst, VkImageBlit region, VkFilter filter)
{ {
if(dst->getFormat() == VK_FORMAT_UNDEFINED) if(dst->getFormat() == VK_FORMAT_UNDEFINED)
......
src/Device/Blitter.hpp
...@@ -15,9 +15,10 @@ ...@@ -15,9 +15,10 @@
#ifndef sw_Blitter_hpp #ifndef sw_Blitter_hpp
#define sw_Blitter_hpp #define sw_Blitter_hpp
#include "Surface.hpp"
#include "RoutineCache.hpp" #include "RoutineCache.hpp"
#include "Reactor/Reactor.hpp" #include "Reactor/Reactor.hpp"
#include "System/MutexLock.hpp"
#include "Vulkan/VkFormat.h"
#include <string.h> #include <string.h>
...@@ -62,7 +63,7 @@ namespace sw ...@@ -62,7 +63,7 @@ namespace sw
{ {
State() = default; State() = default;
State(const Options &options) : Options(options) {} State(const Options &options) : Options(options) {}
State(VkFormat sourceFormat, VkFormat destFormat, int destSamples, const Options &options) : State(vk::Format sourceFormat, vk::Format destFormat, int destSamples, const Options &options) :
Options(options), sourceFormat(sourceFormat), destFormat(destFormat), destSamples(destSamples) {} Options(options), sourceFormat(sourceFormat), destFormat(destFormat), destSamples(destSamples) {}
bool operator==(const State &state) const bool operator==(const State &state) const
...@@ -70,9 +71,9 @@ namespace sw ...@@ -70,9 +71,9 @@ namespace sw
return memcmp(this, &state, sizeof(State)) == 0; return memcmp(this, &state, sizeof(State)) == 0;
} }
VkFormat sourceFormat; vk::Format sourceFormat = VK_FORMAT_UNDEFINED;
VkFormat destFormat; vk::Format destFormat = VK_FORMAT_UNDEFINED;
int destSamples; int destSamples = 0;
}; };
struct BlitData struct BlitData
...@@ -101,27 +102,21 @@ namespace sw ...@@ -101,27 +102,21 @@ namespace sw
Blitter(); Blitter();
virtual ~Blitter(); virtual ~Blitter();
void clear(void *pixel, VkFormat format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask); void clear(void *pixel, vk::Format format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea = nullptr);
void clear(void *pixel, VkFormat format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea = nullptr);
void blit(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, const Options &options);
void blit(vk::Image *src, vk::Image *dst, VkImageBlit region, VkFilter filter); void blit(vk::Image *src, vk::Image *dst, VkImageBlit region, VkFilter filter);
void blit3D(Surface *source, Surface *dest);
private: private:
bool fastClear(void *pixel, VkFormat format, Surface *dest, const SliceRect &dRect, unsigned int rgbaMask); bool fastClear(void *pixel, vk::Format format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea);
bool fastClear(void *pixel, VkFormat format, vk::Image *dest, const VkImageSubresourceRange& subresourceRange, const VkRect2D* renderArea);
bool read(Float4 &color, Pointer<Byte> element, const State &state); bool read(Float4 &color, Pointer<Byte> element, const State &state);
bool write(Float4 &color, Pointer<Byte> element, const State &state); bool write(Float4 &color, Pointer<Byte> element, const State &state);
bool read(Int4 &color, Pointer<Byte> element, const State &state); bool read(Int4 &color, Pointer<Byte> element, const State &state);
bool write(Int4 &color, Pointer<Byte> element, const State &state); bool write(Int4 &color, Pointer<Byte> element, const State &state);
static bool GetScale(float4& scale, VkFormat format);
static bool ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled = false); static bool ApplyScaleAndClamp(Float4 &value, const State &state, bool preScaled = false);
static Int ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout); static Int ComputeOffset(Int &x, Int &y, Int &pitchB, int bytes, bool quadLayout);
static Float4 LinearToSRGB(Float4 &color); static Float4 LinearToSRGB(Float4 &color);
static Float4 sRGBtoLinear(Float4 &color); static Float4 sRGBtoLinear(Float4 &color);
bool blitReactor(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, const Options &options);
Routine *getRoutine(const State &state); Routine *getRoutine(const State &state);
Routine *generate(const State &state); Routine *generate(const State &state);
......
src/Device/Context.cpp
...@@ -15,7 +15,6 @@ ...@@ -15,7 +15,6 @@
#include "Context.hpp" #include "Context.hpp"
#include "Primitive.hpp" #include "Primitive.hpp"
#include "Surface.hpp"
#include "System/Memory.hpp" #include "System/Memory.hpp"
#include "Vulkan/VkDebug.hpp" #include "Vulkan/VkDebug.hpp"
#include "Vulkan/VkImageView.hpp" #include "Vulkan/VkImageView.hpp"
......
src/Device/PixelProcessor.cpp
...@@ -14,7 +14,6 @@ ...@@ -14,7 +14,6 @@
#include "PixelProcessor.hpp" #include "PixelProcessor.hpp"
#include "Surface.hpp"
#include "Primitive.hpp" #include "Primitive.hpp"
#include "Pipeline/PixelProgram.hpp" #include "Pipeline/PixelProgram.hpp"
#include "Pipeline/Constants.hpp" #include "Pipeline/Constants.hpp"
...@@ -401,7 +400,7 @@ namespace sw ...@@ -401,7 +400,7 @@ namespace sw
{ {
state.depthTestActive = true; state.depthTestActive = true;
state.depthCompareMode = context->depthCompareMode; state.depthCompareMode = context->depthCompareMode;
state.quadLayoutDepthBuffer = Surface::hasQuadLayout(context->depthBuffer->getFormat()); state.quadLayoutDepthBuffer = context->depthBuffer->getFormat().hasQuadLayout();
state.depthFormat = context->depthBuffer->getFormat(); state.depthFormat = context->depthBuffer->getFormat();
} }
...@@ -427,7 +426,7 @@ namespace sw ...@@ -427,7 +426,7 @@ namespace sw
state.targetFormat[i] = context->renderTargetInternalFormat(i); state.targetFormat[i] = context->renderTargetInternalFormat(i);
} }
state.writeSRGB = context->writeSRGB && context->renderTarget[0] && Surface::isSRGBwritable(context->renderTarget[0]->getFormat()); state.writeSRGB = context->writeSRGB && context->renderTarget[0] && context->renderTarget[0]->getFormat().isSRGBwritable();
state.multiSample = context->sampleCount; state.multiSample = context->sampleCount;
state.multiSampleMask = context->multiSampleMask; state.multiSampleMask = context->multiSampleMask;
......
src/Device/Renderer.cpp
...@@ -15,7 +15,6 @@ ...@@ -15,7 +15,6 @@
#include "Renderer.hpp" #include "Renderer.hpp"
#include "Clipper.hpp" #include "Clipper.hpp"
#include "Surface.hpp"
#include "Primitive.hpp" #include "Primitive.hpp"
#include "Polygon.hpp" #include "Polygon.hpp"
#include "WSI/FrameBuffer.hpp" #include "WSI/FrameBuffer.hpp"
...@@ -478,21 +477,6 @@ namespace sw ...@@ -478,21 +477,6 @@ namespace sw
} }
} }
void Renderer::clear(void *value, VkFormat format, Surface *dest, const Rect &clearRect, unsigned int rgbaMask)
{
blitter->clear(value, format, dest, clearRect, rgbaMask);
}
void Renderer::blit(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, bool filter, bool isStencil, bool sRGBconversion)
{
blitter->blit(source, sRect, dest, dRect, {filter, isStencil, sRGBconversion});
}
void Renderer::blit3D(Surface *source, Surface *dest)
{
blitter->blit3D(source, dest);
}
void Renderer::threadFunction(void *parameters) void Renderer::threadFunction(void *parameters)
{ {
Renderer *renderer = static_cast<Parameters*>(parameters)->renderer; Renderer *renderer = static_cast<Parameters*>(parameters)->renderer;
......
src/Device/Renderer.hpp
...@@ -249,10 +249,6 @@ namespace sw ...@@ -249,10 +249,6 @@ namespace sw
void draw(DrawType drawType, unsigned int count, bool update = true); void draw(DrawType drawType, unsigned int count, bool update = true);
void clear(void *value, VkFormat format, Surface *dest, const Rect &rect, unsigned int rgbaMask);
void blit(Surface *source, const SliceRectF &sRect, Surface *dest, const SliceRect &dRect, bool filter, bool isStencil = false, bool sRGBconversion = true);
void blit3D(Surface *source, Surface *dest);
void setContext(const sw::Context& context); void setContext(const sw::Context& context);
void setMultiSampleMask(unsigned int mask); void setMultiSampleMask(unsigned int mask);
......
src/Pipeline/PixelRoutine.cpp
...@@ -18,7 +18,6 @@ ...@@ -18,7 +18,6 @@
#include "Constants.hpp" #include "Constants.hpp"
#include "Device/Renderer.hpp" #include "Device/Renderer.hpp"
#include "Device/QuadRasterizer.hpp" #include "Device/QuadRasterizer.hpp"
#include "Device/Surface.hpp"
#include "Device/Primitive.hpp" #include "Device/Primitive.hpp"
#include "Vulkan/VkDebug.hpp" #include "Vulkan/VkDebug.hpp"
...@@ -988,7 +987,7 @@ namespace sw ...@@ -988,7 +987,7 @@ namespace sw
bool PixelRoutine::isSRGB(int index) const bool PixelRoutine::isSRGB(int index) const
{ {
return Surface::isSRGBformat(state.targetFormat[index]); return vk::Format(state.targetFormat[index]).isSRGBformat();
} }
void PixelRoutine::readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel) void PixelRoutine::readPixel(int index, Pointer<Byte> &cBuffer, Int &x, Vector4s &pixel)
...@@ -1787,13 +1786,14 @@ namespace sw ...@@ -1787,13 +1786,14 @@ namespace sw
Short4 c23; Short4 c23;
Float4 one; Float4 one;
if(Surface::isFloatFormat(state.targetFormat[index])) vk::Format format(state.targetFormat[index]);
if(format.isFloatFormat())
{ {
one = Float4(1.0f); one = Float4(1.0f);
} }
else if(Surface::isNonNormalizedInteger(state.targetFormat[index])) else if(format.isNonNormalizedInteger())
{ {
one = As<Float4>(Surface::isUnsignedComponent(state.targetFormat[index], 0) ? Int4(0xFFFFFFFF) : Int4(0x7FFFFFFF)); one = As<Float4>(format.isUnsignedComponent(0) ? Int4(0xFFFFFFFF) : Int4(0x7FFFFFFF));
} }
switch(state.targetFormat[index]) switch(state.targetFormat[index])
......
src/Vulkan/VkFormat.cpp
...@@ -81,6 +81,11 @@ bool Format::isUnsignedNonNormalizedInteger() const ...@@ -81,6 +81,11 @@ bool Format::isUnsignedNonNormalizedInteger() const
} }
} }
bool Format::isNonNormalizedInteger() const
{
return isSignedNonNormalizedInteger() || isUnsignedNonNormalizedInteger();
}
bool Format::isStencil() const bool Format::isStencil() const
{ {
switch(format) switch(format)
...@@ -115,6 +120,336 @@ bool Format::isDepth() const ...@@ -115,6 +120,336 @@ bool Format::isDepth() const
} }
} }
bool Format::hasQuadLayout() const
{
return false;
}
bool Format::isSRGBformat() const
{
switch(format)
{
case VK_FORMAT_R8_SRGB:
case VK_FORMAT_R8G8_SRGB:
case VK_FORMAT_R8G8B8_SRGB:
case VK_FORMAT_B8G8R8_SRGB:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_B8G8R8A8_SRGB:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
return true;
default:
return false;
}
}
bool Format::isSRGBwritable() const
{
// Keep in sync with Capabilities::isSRGBwritable
switch(format)
{
case VK_FORMAT_UNDEFINED:
case VK_FORMAT_B8G8R8A8_UNORM:
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_R5G6B5_UNORM_PACK16:
return true;
default:
return false;
}
}
bool Format::isFloatFormat() const
{
switch(format)
{
case VK_FORMAT_R4G4_UNORM_PACK8:
case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
case VK_FORMAT_R5G6B5_UNORM_PACK16:
case VK_FORMAT_B5G6R5_UNORM_PACK16:
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_SNORM:
case VK_FORMAT_R8_USCALED:
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R8_SRGB:
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8_SNORM:
case VK_FORMAT_R8G8_USCALED:
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8_UINT:
case VK_FORMAT_R8G8_SINT:
case VK_FORMAT_R8G8_SRGB:
case VK_FORMAT_R8G8B8_UNORM:
case VK_FORMAT_R8G8B8_SNORM:
case VK_FORMAT_R8G8B8_USCALED:
case VK_FORMAT_R8G8B8_SSCALED:
case VK_FORMAT_R8G8B8_UINT:
case VK_FORMAT_R8G8B8_SINT:
case VK_FORMAT_R8G8B8_SRGB:
case VK_FORMAT_B8G8R8_UNORM:
case VK_FORMAT_B8G8R8_SNORM:
case VK_FORMAT_B8G8R8_USCALED:
case VK_FORMAT_B8G8R8_SSCALED:
case VK_FORMAT_B8G8R8_UINT:
case VK_FORMAT_B8G8R8_SINT:
case VK_FORMAT_B8G8R8_SRGB:
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_R8G8B8A8_SNORM:
case VK_FORMAT_R8G8B8A8_USCALED:
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_R8G8B8A8_UINT:
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_B8G8R8A8_UNORM:
case VK_FORMAT_B8G8R8A8_SNORM:
case VK_FORMAT_B8G8R8A8_USCALED:
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_UINT:
case VK_FORMAT_B8G8R8A8_SINT:
case VK_FORMAT_B8G8R8A8_SRGB:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
case VK_FORMAT_A8B8G8R8_SINT_PACK32:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
case VK_FORMAT_A2R10G10B10_UINT_PACK32:
case VK_FORMAT_A2R10G10B10_SINT_PACK32:
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
case VK_FORMAT_A2B10G10R10_UINT_PACK32:
case VK_FORMAT_A2B10G10R10_SINT_PACK32:
case VK_FORMAT_R16_UNORM:
case VK_FORMAT_R16_SNORM:
case VK_FORMAT_R16_USCALED:
case VK_FORMAT_R16_SSCALED:
case VK_FORMAT_R16_UINT:
case VK_FORMAT_R16_SINT:
case VK_FORMAT_R16G16_UNORM:
case VK_FORMAT_R16G16_SNORM:
case VK_FORMAT_R16G16_USCALED:
case VK_FORMAT_R16G16_SSCALED:
case VK_FORMAT_R16G16_UINT:
case VK_FORMAT_R16G16_SINT:
case VK_FORMAT_R16G16B16_UNORM:
case VK_FORMAT_R16G16B16_SNORM:
case VK_FORMAT_R16G16B16_USCALED:
case VK_FORMAT_R16G16B16_SSCALED:
case VK_FORMAT_R16G16B16_UINT:
case VK_FORMAT_R16G16B16_SINT:
case VK_FORMAT_R16G16B16A16_UNORM:
case VK_FORMAT_R16G16B16A16_SNORM:
case VK_FORMAT_R16G16B16A16_USCALED:
case VK_FORMAT_R16G16B16A16_SSCALED:
case VK_FORMAT_R16G16B16A16_UINT:
case VK_FORMAT_R16G16B16A16_SINT:
case VK_FORMAT_R32_UINT:
case VK_FORMAT_R32_SINT:
case VK_FORMAT_R32G32_UINT:
case VK_FORMAT_R32G32_SINT:
case VK_FORMAT_R32G32B32_UINT:
case VK_FORMAT_R32G32B32_SINT:
case VK_FORMAT_R32G32B32A32_UINT:
case VK_FORMAT_R32G32B32A32_SINT:
case VK_FORMAT_R64_UINT:
case VK_FORMAT_R64_SINT:
case VK_FORMAT_R64G64_UINT:
case VK_FORMAT_R64G64_SINT:
case VK_FORMAT_R64G64B64_UINT:
case VK_FORMAT_R64G64B64_SINT:
case VK_FORMAT_R64G64B64A64_UINT:
case VK_FORMAT_R64G64B64A64_SINT:
case VK_FORMAT_D16_UNORM:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_S8_UINT:
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
return false;
case VK_FORMAT_R16_SFLOAT:
case VK_FORMAT_R16G16_SFLOAT:
case VK_FORMAT_R16G16B16_SFLOAT:
case VK_FORMAT_R16G16B16A16_SFLOAT:
case VK_FORMAT_R32_SFLOAT:
case VK_FORMAT_R32G32_SFLOAT:
case VK_FORMAT_R32G32B32_SFLOAT:
case VK_FORMAT_R32G32B32A32_SFLOAT:
case VK_FORMAT_R64_SFLOAT:
case VK_FORMAT_R64G64_SFLOAT:
case VK_FORMAT_R64G64B64_SFLOAT:
case VK_FORMAT_R64G64B64A64_SFLOAT:
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
return true;
default:
ASSERT(false);
}
return false;
}
bool Format::isUnsignedComponent(int component) const
{
switch(format)
{
case VK_FORMAT_UNDEFINED:
case VK_FORMAT_R4G4_UNORM_PACK8:
case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
case VK_FORMAT_R5G6B5_UNORM_PACK16:
case VK_FORMAT_B5G6R5_UNORM_PACK16:
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8_SRGB:
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8_USCALED:
case VK_FORMAT_R8G8_UINT:
case VK_FORMAT_R8G8_SRGB:
case VK_FORMAT_R8G8B8_UNORM:
case VK_FORMAT_R8G8B8_USCALED:
case VK_FORMAT_R8G8B8_UINT:
case VK_FORMAT_R8G8B8_SRGB:
case VK_FORMAT_B8G8R8_UNORM:
case VK_FORMAT_B8G8R8_USCALED:
case VK_FORMAT_B8G8R8_UINT:
case VK_FORMAT_B8G8R8_SRGB:
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_R8G8B8A8_USCALED:
case VK_FORMAT_R8G8B8A8_UINT:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_B8G8R8A8_UNORM:
case VK_FORMAT_B8G8R8A8_USCALED:
case VK_FORMAT_B8G8R8A8_UINT:
case VK_FORMAT_B8G8R8A8_SRGB:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
case VK_FORMAT_A2R10G10B10_UINT_PACK32:
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
case VK_FORMAT_A2B10G10R10_UINT_PACK32:
case VK_FORMAT_R16_UNORM:
case VK_FORMAT_R16_USCALED:
case VK_FORMAT_R16_UINT:
case VK_FORMAT_R16G16_UNORM:
case VK_FORMAT_R16G16_USCALED:
case VK_FORMAT_R16G16_UINT:
case VK_FORMAT_R16G16B16_UNORM:
case VK_FORMAT_R16G16B16_USCALED:
case VK_FORMAT_R16G16B16_UINT:
case VK_FORMAT_R16G16B16A16_UNORM:
case VK_FORMAT_R16G16B16A16_USCALED:
case VK_FORMAT_R16G16B16A16_UINT:
case VK_FORMAT_R32_UINT:
case VK_FORMAT_R32G32_UINT:
case VK_FORMAT_R32G32B32_UINT:
case VK_FORMAT_R32G32B32A32_UINT:
case VK_FORMAT_R64_UINT:
case VK_FORMAT_R64G64_UINT:
case VK_FORMAT_R64G64B64_UINT:
case VK_FORMAT_R64G64B64A64_UINT:
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
case VK_FORMAT_D16_UNORM:
case VK_FORMAT_X8_D24_UNORM_PACK32:
case VK_FORMAT_S8_UINT:
case VK_FORMAT_D16_UNORM_S8_UINT:
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
return true;
case VK_FORMAT_R8G8B8A8_SNORM:
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_B8G8R8A8_SNORM:
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_SINT:
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
case VK_FORMAT_A8B8G8R8_SINT_PACK32:
case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
case VK_FORMAT_A2R10G10B10_SINT_PACK32:
case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
case VK_FORMAT_A2B10G10R10_SINT_PACK32:
case VK_FORMAT_R16G16B16A16_SNORM:
case VK_FORMAT_R16G16B16A16_SSCALED:
case VK_FORMAT_R16G16B16A16_SINT:
case VK_FORMAT_R16G16B16A16_SFLOAT:
case VK_FORMAT_R32G32B32A32_SINT:
case VK_FORMAT_R32G32B32A32_SFLOAT:
case VK_FORMAT_R64G64B64A64_SINT:
case VK_FORMAT_R64G64B64A64_SFLOAT:
return false;
case VK_FORMAT_R8_SNORM:
case VK_FORMAT_R8_USCALED:
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R16_SNORM:
case VK_FORMAT_R16_SSCALED:
case VK_FORMAT_R16_SINT:
case VK_FORMAT_R16_SFLOAT:
case VK_FORMAT_R32_SINT:
case VK_FORMAT_R32_SFLOAT:
case VK_FORMAT_R64_SINT:
case VK_FORMAT_R64_SFLOAT:
return component >= 1;
case VK_FORMAT_R8G8_SNORM:
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8_SINT:
case VK_FORMAT_R16G16_SNORM:
case VK_FORMAT_R16G16_SSCALED:
case VK_FORMAT_R16G16_SINT:
case VK_FORMAT_R16G16_SFLOAT:
case VK_FORMAT_R32G32_SINT:
case VK_FORMAT_R32G32_SFLOAT:
case VK_FORMAT_R64G64_SINT:
case VK_FORMAT_R64G64_SFLOAT:
return component >= 2;
case VK_FORMAT_R8G8B8_SNORM:
case VK_FORMAT_R8G8B8_SSCALED:
case VK_FORMAT_R8G8B8_SINT:
case VK_FORMAT_B8G8R8_SNORM:
case VK_FORMAT_B8G8R8_SSCALED:
case VK_FORMAT_B8G8R8_SINT:
case VK_FORMAT_R16G16B16_SNORM:
case VK_FORMAT_R16G16B16_SSCALED:
case VK_FORMAT_R16G16B16_SINT:
case VK_FORMAT_R16G16B16_SFLOAT:
case VK_FORMAT_R32G32B32_SINT:
case VK_FORMAT_R32G32B32_SFLOAT:
case VK_FORMAT_R64G64B64_SINT:
case VK_FORMAT_R64G64B64_SFLOAT:
return component >= 3;
default:
ASSERT(false);
}
return false;
}
int Format::bytes() const int Format::bytes() const
{ {
switch(format) switch(format)
...@@ -460,4 +795,156 @@ int Format::sliceB(int width, int height, int border, bool target) const ...@@ -460,4 +795,156 @@ int Format::sliceB(int width, int height, int border, bool target) const
} }
} }
bool Format::getScale(sw::float4 &scale) const
{
switch(format)
{
case VK_FORMAT_R4G4_UNORM_PACK8:
case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
scale = sw::vector(0xF, 0xF, 0xF, 0xF);
break;
case VK_FORMAT_R8_UNORM:
case VK_FORMAT_R8G8_UNORM:
case VK_FORMAT_R8G8B8_UNORM:
case VK_FORMAT_B8G8R8_UNORM:
case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
case VK_FORMAT_R8G8B8A8_UNORM:
case VK_FORMAT_B8G8R8A8_UNORM:
case VK_FORMAT_R8_SRGB:
case VK_FORMAT_R8G8_SRGB:
case VK_FORMAT_R8G8B8_SRGB:
case VK_FORMAT_B8G8R8_SRGB:
case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
case VK_FORMAT_R8G8B8A8_SRGB:
case VK_FORMAT_B8G8R8A8_SRGB:
scale = sw::vector(0xFF, 0xFF, 0xFF, 0xFF);
break;
case VK_FORMAT_R8_SNORM:
case VK_FORMAT_R8G8_SNORM:
case VK_FORMAT_R8G8B8_SNORM:
case VK_FORMAT_B8G8R8_SNORM:
case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
case VK_FORMAT_R8G8B8A8_SNORM:
case VK_FORMAT_B8G8R8A8_SNORM:
scale = sw::vector(0x7F, 0x7F, 0x7F, 0x7F);
break;
case VK_FORMAT_R16_UNORM:
case VK_FORMAT_R16G16_UNORM:
case VK_FORMAT_R16G16B16_UNORM:
case VK_FORMAT_R16G16B16A16_UNORM:
scale = sw::vector(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF);
break;
case VK_FORMAT_R16_SNORM:
case VK_FORMAT_R16G16_SNORM:
case VK_FORMAT_R16G16B16_SNORM:
case VK_FORMAT_R16G16B16A16_SNORM:
scale = sw::vector(0x7FFF, 0x7FFF, 0x7FFF, 0x7FFF);
break;
case VK_FORMAT_R8_SINT:
case VK_FORMAT_R8_UINT:
case VK_FORMAT_R8G8_SINT:
case VK_FORMAT_R8G8_UINT:
case VK_FORMAT_R8G8B8_SINT:
case VK_FORMAT_R8G8B8_UINT:
case VK_FORMAT_B8G8R8_SINT:
case VK_FORMAT_B8G8R8_UINT:
case VK_FORMAT_R8G8B8A8_SINT:
case VK_FORMAT_R8G8B8A8_UINT:
case VK_FORMAT_A8B8G8R8_SINT_PACK32:
case VK_FORMAT_A8B8G8R8_UINT_PACK32:
case VK_FORMAT_B8G8R8A8_SINT:
case VK_FORMAT_B8G8R8A8_UINT:
case VK_FORMAT_R8_USCALED:
case VK_FORMAT_R8G8_USCALED:
case VK_FORMAT_R8G8B8_USCALED:
case VK_FORMAT_B8G8R8_USCALED:
case VK_FORMAT_R8G8B8A8_USCALED:
case VK_FORMAT_B8G8R8A8_USCALED:
case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
case VK_FORMAT_R8_SSCALED:
case VK_FORMAT_R8G8_SSCALED:
case VK_FORMAT_R8G8B8_SSCALED:
case VK_FORMAT_B8G8R8_SSCALED:
case VK_FORMAT_R8G8B8A8_SSCALED:
case VK_FORMAT_B8G8R8A8_SSCALED:
case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
case VK_FORMAT_R16_SINT:
case VK_FORMAT_R16_UINT:
case VK_FORMAT_R16G16_SINT:
case VK_FORMAT_R16G16_UINT:
case VK_FORMAT_R16G16B16A16_SINT:
case VK_FORMAT_R16G16B16A16_UINT:
case VK_FORMAT_R16_SSCALED:
case VK_FORMAT_R16G16_SSCALED:
case VK_FORMAT_R16G16B16_SSCALED:
case VK_FORMAT_R16G16B16A16_SSCALED:
case VK_FORMAT_R16_USCALED:
case VK_FORMAT_R16G16_USCALED:
case VK_FORMAT_R16G16B16_USCALED:
case VK_FORMAT_R16G16B16A16_USCALED:
case VK_FORMAT_R32_SINT:
case VK_FORMAT_R32_UINT:
case VK_FORMAT_R32G32_SINT:
case VK_FORMAT_R32G32_UINT:
case VK_FORMAT_R32G32B32_SINT:
case VK_FORMAT_R32G32B32_UINT:
case VK_FORMAT_R32G32B32A32_SINT:
case VK_FORMAT_R32G32B32A32_UINT:
case VK_FORMAT_R32G32B32A32_SFLOAT:
case VK_FORMAT_R32G32B32_SFLOAT:
case VK_FORMAT_R32G32_SFLOAT:
case VK_FORMAT_R32_SFLOAT:
case VK_FORMAT_R16G16B16A16_SFLOAT:
case VK_FORMAT_R16G16B16_SFLOAT:
case VK_FORMAT_R16G16_SFLOAT:
case VK_FORMAT_R16_SFLOAT:
case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
case VK_FORMAT_A2R10G10B10_UINT_PACK32:
case VK_FORMAT_A2R10G10B10_SINT_PACK32:
case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
case VK_FORMAT_A2B10G10R10_UINT_PACK32:
case VK_FORMAT_A2B10G10R10_SINT_PACK32:
scale = sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
break;
case VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
scale = sw::vector(0x1F, 0x1F, 0x1F, 0x01);
break;
case VK_FORMAT_R5G6B5_UNORM_PACK16:
case VK_FORMAT_B5G6R5_UNORM_PACK16:
scale = sw::vector(0x1F, 0x3F, 0x1F, 1.0f);
break;
case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
scale = sw::vector(0x3FF, 0x3FF, 0x3FF, 0x03);
break;
case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
scale = sw::vector(0x1FF, 0x1FF, 0x1FF, 0x01);
break;
case VK_FORMAT_D16_UNORM:
scale = sw::vector(0xFFFF, 0.0f, 0.0f, 0.0f);
break;
case VK_FORMAT_D24_UNORM_S8_UINT:
case VK_FORMAT_X8_D24_UNORM_PACK32:
scale = sw::vector(0xFFFFFF, 0.0f, 0.0f, 0.0f);
break;
case VK_FORMAT_D32_SFLOAT:
case VK_FORMAT_D32_SFLOAT_S8_UINT:
case VK_FORMAT_S8_UINT:
scale = sw::vector(1.0f, 1.0f, 1.0f, 1.0f);
break;
default:
return false;
}
return true;
}
} // namespace vk } // namespace vk
\ No newline at end of file
src/Vulkan/VkFormat.h
...@@ -17,6 +17,11 @@ ...@@ -17,6 +17,11 @@
#include <vulkan/vulkan_core.h> #include <vulkan/vulkan_core.h>
namespace sw
{
struct float4;
}
namespace vk namespace vk
{ {
...@@ -24,17 +29,26 @@ class Format ...@@ -24,17 +29,26 @@ class Format
{ {
public: public:
Format(VkFormat format) : format(format) {} Format(VkFormat format) : format(format) {}
operator VkFormat() const { return format; } inline operator VkFormat() const { return format; }
bool isSignedNonNormalizedInteger() const; bool isSignedNonNormalizedInteger() const;
bool isUnsignedNonNormalizedInteger() const; bool isUnsignedNonNormalizedInteger() const;
bool isNonNormalizedInteger() const;
bool isStencil() const; bool isStencil() const;
bool isDepth() const; bool isDepth() const;
bool hasQuadLayout() const;
bool isSRGBformat() const;
bool isSRGBwritable() const;
bool isFloatFormat() const;
bool isUnsignedComponent(int component) const;
int bytes() const; int bytes() const;
int pitchB(int width, int border, bool target) const; int pitchB(int width, int border, bool target) const;
int sliceB(int width, int height, int border, bool target) const; int sliceB(int width, int height, int border, bool target) const;
bool getScale(sw::float4 &scale) const;
private: private:
VkFormat format; VkFormat format;
}; };
......
src/Vulkan/VkFramebuffer.cpp
...@@ -15,7 +15,6 @@ ...@@ -15,7 +15,6 @@
#include "VkFramebuffer.hpp" #include "VkFramebuffer.hpp"
#include "VkImageView.hpp" #include "VkImageView.hpp"
#include "VkRenderPass.hpp" #include "VkRenderPass.hpp"
#include "Device/Surface.hpp"
#include <algorithm> #include <algorithm>
#include <memory.h> #include <memory.h>
...@@ -46,8 +45,9 @@ void Framebuffer::clear(uint32_t clearValueCount, const VkClearValue* pClearValu ...@@ -46,8 +45,9 @@ void Framebuffer::clear(uint32_t clearValueCount, const VkClearValue* pClearValu
for(uint32_t i = 0; i < count; i++) for(uint32_t i = 0; i < count; i++)
{ {
const VkAttachmentDescription attachment = renderPass->getAttachment(i); const VkAttachmentDescription attachment = renderPass->getAttachment(i);
bool isDepth = sw::Surface::isDepth(attachment.format); const Format format(attachment.format);
bool isStencil = sw::Surface::isStencil(attachment.format); bool isDepth = format.isDepth();
bool isStencil = format.isStencil();
if(isDepth || isStencil) if(isDepth || isStencil)
{ {
......
src/Vulkan/VkImageView.hpp
...@@ -16,6 +16,7 @@ ...@@ -16,6 +16,7 @@
#define VK_IMAGE_VIEW_HPP_ #define VK_IMAGE_VIEW_HPP_
#include "VkDebug.hpp" #include "VkDebug.hpp"
#include "VkFormat.h"
#include "VkObject.hpp" #include "VkObject.hpp"
#include "VkImage.hpp" #include "VkImage.hpp"
...@@ -34,7 +35,7 @@ public: ...@@ -34,7 +35,7 @@ public:
void clear(const VkClearValue& clearValues, VkImageAspectFlags aspectMask, const VkRect2D& renderArea); void clear(const VkClearValue& clearValues, VkImageAspectFlags aspectMask, const VkRect2D& renderArea);
void clear(const VkClearValue& clearValue, VkImageAspectFlags aspectMask, const VkClearRect& renderArea); void clear(const VkClearValue& clearValue, VkImageAspectFlags aspectMask, const VkClearRect& renderArea);
VkFormat getFormat() const { return format; } Format getFormat() const { return format; }
int getSampleCount() const { return image->getSampleCountFlagBits(); } int getSampleCount() const { return image->getSampleCountFlagBits(); }
int rowPitchBytes(VkImageAspectFlagBits aspect) const { return image->rowPitchBytes(aspect, subresourceRange.baseMipLevel); } int rowPitchBytes(VkImageAspectFlagBits aspect) const { return image->rowPitchBytes(aspect, subresourceRange.baseMipLevel); }
int slicePitchBytes(VkImageAspectFlagBits aspect) const { return image->slicePitchBytes(aspect, subresourceRange.baseMipLevel); } int slicePitchBytes(VkImageAspectFlagBits aspect) const { return image->slicePitchBytes(aspect, subresourceRange.baseMipLevel); }
...@@ -48,7 +49,7 @@ private: ...@@ -48,7 +49,7 @@ private:
Image* image = nullptr; Image* image = nullptr;
VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D; VkImageViewType viewType = VK_IMAGE_VIEW_TYPE_2D;
VkFormat format = VK_FORMAT_UNDEFINED; Format format = VK_FORMAT_UNDEFINED;
VkComponentMapping components = {}; VkComponentMapping components = {};
VkImageSubresourceRange subresourceRange = {}; VkImageSubresourceRange subresourceRange = {};
}; };
......
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