diff options
Diffstat (limited to 'chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11')
53 files changed, 5347 insertions, 7547 deletions
diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp index 62636356e9b..f40a27bbfa7 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.cpp @@ -12,16 +12,29 @@ #include "libANGLE/formatutils.h" #include "libANGLE/renderer/d3d/d3d11/Renderer11.h" +#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h" #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" #include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" #include "third_party/trace_event/trace_event.h" +namespace rx +{ + +namespace +{ + +// Include inline shaders in the anonymous namespace to make sure no symbols are exported #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughdepth2d11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbapremultiply2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbaunmultiply2d11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dui11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2di11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbpremultiply2d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbunmultiply2d11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2dui11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgb2di11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrg2d11ps.h" @@ -50,6 +63,11 @@ #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlum3d11ps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughlumalpha3d11ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h" +#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h" + #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlef2dps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2dps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2dps.h" @@ -60,12 +78,6 @@ #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzlei2darrayps.h" #include "libANGLE/renderer/d3d/d3d11/shaders/compiled/swizzleui2darrayps.h" -namespace rx -{ - -namespace -{ - void StretchedBlitNearest_RowByRow(const gl::Box &sourceArea, const gl::Box &destArea, const gl::Rectangle &clippedDestArea, @@ -179,6 +191,198 @@ void StretchedBlitNearest(const gl::Box &sourceArea, } } +using DepthStencilLoader = void(const float *, uint8_t *); + +void LoadDepth16(const float *source, uint8_t *dest) +{ + uint32_t convertedDepth = gl::floatToNormalized<16, uint32_t>(source[0]); + memcpy(dest, &convertedDepth, 2u); +} + +void LoadDepth24(const float *source, uint8_t *dest) +{ + uint32_t convertedDepth = gl::floatToNormalized<24, uint32_t>(source[0]); + memcpy(dest, &convertedDepth, 3u); +} + +void LoadStencilHelper(const float *source, uint8_t *dest) +{ + uint32_t convertedStencil = gl::getShiftedData<8, 0>(static_cast<uint32_t>(source[1])); + memcpy(dest, &convertedStencil, 1u); +} + +void LoadStencil8(const float *source, uint8_t *dest) +{ + // STENCIL_INDEX8 is implemented with D24S8, with the depth bits unused. Writes zero for safety. + float zero = 0.0f; + LoadDepth24(&zero, &dest[0]); + LoadStencilHelper(source, &dest[3]); +} + +void LoadDepth24Stencil8(const float *source, uint8_t *dest) +{ + LoadDepth24(source, &dest[0]); + LoadStencilHelper(source, &dest[3]); +} + +void LoadDepth32F(const float *source, uint8_t *dest) +{ + memcpy(dest, source, sizeof(float)); +} + +void LoadDepth32FStencil8(const float *source, uint8_t *dest) +{ + LoadDepth32F(source, &dest[0]); + LoadStencilHelper(source, &dest[4]); +} + +template <DepthStencilLoader loader> +void CopyDepthStencil(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + // No stretching or subregions are supported, only full blits. + ASSERT(sourceArea == destArea); + ASSERT(sourceSize.width == sourceArea.width && sourceSize.height == sourceArea.height && + sourceSize.depth == 1); + ASSERT(clippedDestArea.width == sourceSize.width && + clippedDestArea.height == sourceSize.height); + ASSERT(readOffset == 0 && writeOffset == 0); + ASSERT(destArea.x == 0 && destArea.y == 0); + + for (int row = 0; row < destArea.height; ++row) + { + for (int column = 0; column < destArea.width; ++column) + { + ptrdiff_t offset = row * sourceRowPitch + column * srcPixelStride; + const float *sourcePixel = reinterpret_cast<const float *>(sourceData + offset); + + uint8_t *destPixel = destData + row * destRowPitch + column * destPixelStride; + + loader(sourcePixel, destPixel); + } + } +} + +void Depth32FStencil8ToDepth32F(const float *source, float *dest) +{ + *dest = *source; +} + +void Depth24Stencil8ToDepth32F(const uint32_t *source, float *dest) +{ + uint32_t normDepth = source[0] & 0x00FFFFFF; + float floatDepth = gl::normalizedToFloat<24>(normDepth); + *dest = floatDepth; +} + +void BlitD24S8ToD32F(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + // No stretching or subregions are supported, only full blits. + ASSERT(sourceArea == destArea); + ASSERT(sourceSize.width == sourceArea.width && sourceSize.height == sourceArea.height && + sourceSize.depth == 1); + ASSERT(clippedDestArea.width == sourceSize.width && + clippedDestArea.height == sourceSize.height); + ASSERT(readOffset == 0 && writeOffset == 0); + ASSERT(destArea.x == 0 && destArea.y == 0); + + for (int row = 0; row < destArea.height; ++row) + { + for (int column = 0; column < destArea.width; ++column) + { + ptrdiff_t offset = row * sourceRowPitch + column * srcPixelStride; + const uint32_t *sourcePixel = reinterpret_cast<const uint32_t *>(sourceData + offset); + + float *destPixel = + reinterpret_cast<float *>(destData + row * destRowPitch + column * destPixelStride); + + Depth24Stencil8ToDepth32F(sourcePixel, destPixel); + } + } +} + +void BlitD32FS8ToD32F(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clippedDestArea, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData) +{ + // No stretching or subregions are supported, only full blits. + ASSERT(sourceArea == destArea); + ASSERT(sourceSize.width == sourceArea.width && sourceSize.height == sourceArea.height && + sourceSize.depth == 1); + ASSERT(clippedDestArea.width == sourceSize.width && + clippedDestArea.height == sourceSize.height); + ASSERT(readOffset == 0 && writeOffset == 0); + ASSERT(destArea.x == 0 && destArea.y == 0); + + for (int row = 0; row < destArea.height; ++row) + { + for (int column = 0; column < destArea.width; ++column) + { + ptrdiff_t offset = row * sourceRowPitch + column * srcPixelStride; + const float *sourcePixel = reinterpret_cast<const float *>(sourceData + offset); + float *destPixel = + reinterpret_cast<float *>(destData + row * destRowPitch + column * destPixelStride); + + Depth32FStencil8ToDepth32F(sourcePixel, destPixel); + } + } +} + +Blit11::BlitConvertFunction *GetCopyDepthStencilFunction(GLenum internalFormat) +{ + switch (internalFormat) + { + case GL_DEPTH_COMPONENT16: + return &CopyDepthStencil<LoadDepth16>; + case GL_DEPTH_COMPONENT24: + return &CopyDepthStencil<LoadDepth24>; + case GL_DEPTH_COMPONENT32F: + return &CopyDepthStencil<LoadDepth32F>; + case GL_STENCIL_INDEX8: + return &CopyDepthStencil<LoadStencil8>; + case GL_DEPTH24_STENCIL8: + return &CopyDepthStencil<LoadDepth24Stencil8>; + case GL_DEPTH32F_STENCIL8: + return &CopyDepthStencil<LoadDepth32FStencil8>; + default: + UNREACHABLE(); + return nullptr; + } +} + inline void GenerateVertexCoords(const gl::Box &sourceArea, const gl::Extents &sourceSize, const gl::Box &destArea, @@ -265,7 +469,7 @@ void Write3DVertices(const gl::Box &sourceArea, *outTopology = D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST; } -inline unsigned int GetSwizzleIndex(GLenum swizzle) +unsigned int GetSwizzleIndex(GLenum swizzle) { unsigned int colorIndex = 0; @@ -325,6 +529,20 @@ D3D11_INPUT_ELEMENT_DESC quad3DLayout[] = { {"TEXCOORD", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0}, }; +DXGI_FORMAT GetStencilSRVFormat(const d3d11::Format &formatSet) +{ + switch (formatSet.texFormat) + { + case DXGI_FORMAT_R32G8X24_TYPELESS: + return DXGI_FORMAT_X32_TYPELESS_G8X24_UINT; + case DXGI_FORMAT_R24G8_TYPELESS: + return DXGI_FORMAT_X24_TYPELESS_G8_UINT; + default: + UNREACHABLE(); + return DXGI_FORMAT_UNKNOWN; + } +} + } // namespace Blit11::Blit11(Renderer11 *renderer) @@ -353,7 +571,19 @@ Blit11::Blit11(Renderer11 *renderer) mQuad3DVS(g_VS_Passthrough3D, ArraySize(g_VS_Passthrough3D), "Blit11 3D vertex shader"), mQuad3DGS(g_GS_Passthrough3D, ArraySize(g_GS_Passthrough3D), "Blit11 3D geometry shader"), mAlphaMaskBlendState(GetAlphaMaskBlendStateDesc(), "Blit11 Alpha Mask Blend"), - mSwizzleCB(nullptr) + mSwizzleCB(nullptr), + mResolveDepthStencilVS(g_VS_ResolveDepthStencil, + ArraySize(g_VS_ResolveDepthStencil), + "Blit11::mResolveDepthStencilVS"), + mResolveDepthPS(g_PS_ResolveDepth, ArraySize(g_PS_ResolveDepth), "Blit11::mResolveDepthPS"), + mResolveDepthStencilPS(g_PS_ResolveDepthStencil, + ArraySize(g_PS_ResolveDepthStencil), + "Blit11::mResolveDepthStencilPS"), + mResolveStencilPS(g_PS_ResolveStencil, + ArraySize(g_PS_ResolveStencil), + "Blit11::mResolveStencilPS"), + mStencilSRV(nullptr), + mResolvedDepthStencilRTView(nullptr) { } @@ -370,6 +600,7 @@ Blit11::~Blit11() mQuad3DGS.release(); clearShaderMap(); + releaseResolveDepthStencilResources(); } gl::Error Blit11::initResources() @@ -556,10 +787,14 @@ void Blit11::freeResources() // static Blit11::BlitShaderType Blit11::GetBlitShaderType(GLenum destinationFormat, bool isSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, ShaderDimension dimension) { if (dimension == SHADER_3D) { + ASSERT(!unpackPremultiplyAlpha && !unpackUnmultiplyAlpha); + if (isSigned) { switch (destinationFormat) @@ -613,6 +848,8 @@ Blit11::BlitShaderType Blit11::GetBlitShaderType(GLenum destinationFormat, } else if (isSigned) { + ASSERT(!unpackPremultiplyAlpha && !unpackUnmultiplyAlpha); + switch (destinationFormat) { case GL_RGBA_INTEGER: @@ -630,35 +867,56 @@ Blit11::BlitShaderType Blit11::GetBlitShaderType(GLenum destinationFormat, } else { - switch (destinationFormat) + if (unpackPremultiplyAlpha != unpackUnmultiplyAlpha) { - case GL_RGBA: - return BLITSHADER_2D_RGBAF; - case GL_RGBA_INTEGER: - return BLITSHADER_2D_RGBAUI; - case GL_BGRA_EXT: - return BLITSHADER_2D_BGRAF; - case GL_RGB: - return BLITSHADER_2D_RGBF; - case GL_RGB_INTEGER: - return BLITSHADER_2D_RGBUI; - case GL_RG: - return BLITSHADER_2D_RGF; - case GL_RG_INTEGER: - return BLITSHADER_2D_RGUI; - case GL_RED: - return BLITSHADER_2D_RF; - case GL_RED_INTEGER: - return BLITSHADER_2D_RUI; - case GL_ALPHA: - return BLITSHADER_2D_ALPHA; - case GL_LUMINANCE: - return BLITSHADER_2D_LUMA; - case GL_LUMINANCE_ALPHA: - return BLITSHADER_2D_LUMAALPHA; - default: - UNREACHABLE(); - return BLITSHADER_INVALID; + switch (destinationFormat) + { + case GL_RGBA: + return unpackPremultiplyAlpha ? BLITSHADER_2D_RGBAF_PREMULTIPLY + : BLITSHADER_2D_RGBAF_UNMULTIPLY; + case GL_BGRA_EXT: + return unpackPremultiplyAlpha ? BLITSHADER_2D_BGRAF_PREMULTIPLY + : BLITSHADER_2D_BGRAF_UNMULTIPLY; + case GL_RGB: + return unpackPremultiplyAlpha ? BLITSHADER_2D_RGBF_PREMULTIPLY + : BLITSHADER_2D_RGBF_UNMULTIPLY; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } + } + else + { + switch (destinationFormat) + { + case GL_RGBA: + return BLITSHADER_2D_RGBAF; + case GL_RGBA_INTEGER: + return BLITSHADER_2D_RGBAUI; + case GL_BGRA_EXT: + return BLITSHADER_2D_BGRAF; + case GL_RGB: + return BLITSHADER_2D_RGBF; + case GL_RGB_INTEGER: + return BLITSHADER_2D_RGBUI; + case GL_RG: + return BLITSHADER_2D_RGF; + case GL_RG_INTEGER: + return BLITSHADER_2D_RGUI; + case GL_RED: + return BLITSHADER_2D_RF; + case GL_RED_INTEGER: + return BLITSHADER_2D_RUI; + case GL_ALPHA: + return BLITSHADER_2D_ALPHA; + case GL_LUMINANCE: + return BLITSHADER_2D_LUMA; + case GL_LUMINANCE_ALPHA: + return BLITSHADER_2D_LUMAALPHA; + default: + UNREACHABLE(); + return BLITSHADER_INVALID; + } } } } @@ -911,7 +1169,9 @@ gl::Error Blit11::copyTexture(ID3D11ShaderResourceView *source, const gl::Rectangle *scissor, GLenum destFormat, GLenum filter, - bool maskOffAlpha) + bool maskOffAlpha, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) { ANGLE_TRY(initResources()); @@ -934,7 +1194,9 @@ gl::Error Blit11::copyTexture(ID3D11ShaderResourceView *source, (sourceSRVDesc.ViewDimension == D3D11_SRV_DIMENSION_TEXTURE3D) ? SHADER_3D : SHADER_2D; const Shader *shader = nullptr; - ANGLE_TRY(getBlitShader(destFormat, isSigned, dimension, &shader)); + ANGLE_TRY(getBlitShader(destFormat, isSigned, unpackPremultiplyAlpha, unpackUnmultiplyAlpha, + dimension, &shader)); + const ShaderSupport &support = getShaderSupport(*shader); // Set vertices @@ -1197,22 +1459,26 @@ gl::Error Blit11::copyDepthStencilImpl(const TextureHelper11 &source, const gl::Rectangle *scissor, bool stencilOnly) { - ASSERT(source.getANGLEFormat() == dest.getANGLEFormat()); + auto srcDXGIFormat = source.getFormat(); + const auto &srcSizeInfo = d3d11::GetDXGIFormatSizeInfo(srcDXGIFormat); + unsigned int srcPixelSize = srcSizeInfo.pixelBytes; + unsigned int copyOffset = 0; + unsigned int copySize = srcPixelSize; + auto destDXGIFormat = dest.getFormat(); + const auto &destSizeInfo = d3d11::GetDXGIFormatSizeInfo(destDXGIFormat); + unsigned int destPixelSize = destSizeInfo.pixelBytes; + + ASSERT(srcDXGIFormat == destDXGIFormat || destDXGIFormat == DXGI_FORMAT_R32_TYPELESS); - auto format = source.getFormat(); - const auto &sizeInfo = d3d11::GetDXGIFormatSizeInfo(format); - unsigned int pixelSize = sizeInfo.pixelBytes; - unsigned int copyOffset = 0; - unsigned int copySize = pixelSize; if (stencilOnly) { - const d3d11::DXGIFormat &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(format); + const auto &srcFormat = source.getFormatSet().format; // Stencil channel should be right after the depth channel. Some views to depth/stencil // resources have red channel for depth, in which case the depth channel bit width is in // redBits. - ASSERT((dxgiFormatInfo.redBits != 0) != (dxgiFormatInfo.depthBits != 0)); - GLuint depthBits = dxgiFormatInfo.redBits + dxgiFormatInfo.depthBits; + ASSERT((srcFormat.redBits != 0) != (srcFormat.depthBits != 0)); + GLuint depthBits = srcFormat.redBits + srcFormat.depthBits; // Known formats have either 24 or 32 bits of depth. ASSERT(depthBits == 24 || depthBits == 32); copyOffset = depthBits / 8; @@ -1221,26 +1487,41 @@ gl::Error Blit11::copyDepthStencilImpl(const TextureHelper11 &source, copySize = 1; } + if (srcDXGIFormat != destDXGIFormat) + { + if (srcDXGIFormat == DXGI_FORMAT_R24G8_TYPELESS) + { + ASSERT(sourceArea == destArea && sourceSize == destSize && scissor == nullptr); + return copyAndConvert(source, sourceSubresource, sourceArea, sourceSize, dest, + destSubresource, destArea, destSize, scissor, copyOffset, + copyOffset, copySize, srcPixelSize, destPixelSize, + BlitD24S8ToD32F); + } + ASSERT(srcDXGIFormat == DXGI_FORMAT_R32G8X24_TYPELESS); + return copyAndConvert(source, sourceSubresource, sourceArea, sourceSize, dest, + destSubresource, destArea, destSize, scissor, copyOffset, copyOffset, + copySize, srcPixelSize, destPixelSize, BlitD32FS8ToD32F); + } + return copyAndConvert(source, sourceSubresource, sourceArea, sourceSize, dest, destSubresource, - destArea, destSize, scissor, copyOffset, copyOffset, copySize, pixelSize, - pixelSize, StretchedBlitNearest); + destArea, destSize, scissor, copyOffset, copyOffset, copySize, + srcPixelSize, destPixelSize, StretchedBlitNearest); } -gl::Error Blit11::copyAndConvert(const TextureHelper11 &source, - unsigned int sourceSubresource, - const gl::Box &sourceArea, - const gl::Extents &sourceSize, - const TextureHelper11 &dest, - unsigned int destSubresource, - const gl::Box &destArea, - const gl::Extents &destSize, - const gl::Rectangle *scissor, - size_t readOffset, - size_t writeOffset, - size_t copySize, - size_t srcPixelStride, - size_t destPixelStride, - BlitConvertFunction *convertFunction) +gl::Error Blit11::copyAndConvertImpl(const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &destStaging, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + size_t readOffset, + size_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + BlitConvertFunction *convertFunction) { ANGLE_TRY(initResources()); @@ -1248,24 +1529,13 @@ gl::Error Blit11::copyAndConvert(const TextureHelper11 &source, ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); TextureHelper11 sourceStaging; - ANGLE_TRY_RESULT(CreateStagingTexture(GL_TEXTURE_2D, source.getANGLEFormat(), sourceSize, + ANGLE_TRY_RESULT(CreateStagingTexture(GL_TEXTURE_2D, source.getFormatSet(), sourceSize, StagingAccess::READ, device), sourceStaging); deviceContext->CopySubresourceRegion(sourceStaging.getResource(), 0, 0, 0, 0, source.getResource(), sourceSubresource, nullptr); - // HACK: Create the destination staging buffer as a read/write texture so - // ID3D11DevicContext::UpdateSubresource can be called - // using it's mapped data as a source - TextureHelper11 destStaging; - ANGLE_TRY_RESULT(CreateStagingTexture(GL_TEXTURE_2D, dest.getANGLEFormat(), destSize, - StagingAccess::READ_WRITE, device), - destStaging); - - deviceContext->CopySubresourceRegion(destStaging.getResource(), 0, 0, 0, 0, dest.getResource(), - destSubresource, nullptr); - D3D11_MAPPED_SUBRESOURCE sourceMapping; HRESULT result = deviceContext->Map(sourceStaging.getResource(), 0, D3D11_MAP_READ, 0, &sourceMapping); @@ -1302,21 +1572,62 @@ gl::Error Blit11::copyAndConvert(const TextureHelper11 &source, destPixelStride, static_cast<const uint8_t *>(sourceMapping.pData), static_cast<uint8_t *>(destMapping.pData)); - // HACK: Use ID3D11DevicContext::UpdateSubresource which causes an extra copy compared to - // ID3D11DevicContext::CopySubresourceRegion - // according to MSDN. - deviceContext->UpdateSubresource(dest.getResource(), destSubresource, nullptr, - destMapping.pData, destMapping.RowPitch, - destMapping.DepthPitch); - deviceContext->Unmap(sourceStaging.getResource(), 0); deviceContext->Unmap(destStaging.getResource(), 0); - // TODO: Determine why this call to ID3D11DevicContext::CopySubresourceRegion causes a TDR - // timeout on some - // systems when called repeatedly. - // deviceContext->CopySubresourceRegion(dest, destSubresource, 0, 0, 0, destStaging, 0, - // nullptr); + return gl::NoError(); +} + +gl::Error Blit11::copyAndConvert(const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &dest, + unsigned int destSubresource, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + size_t readOffset, + size_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + BlitConvertFunction *convertFunction) +{ + ANGLE_TRY(initResources()); + + ID3D11Device *device = mRenderer->getDevice(); + ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext(); + + // HACK: Create the destination staging buffer as a read/write texture so + // ID3D11DevicContext::UpdateSubresource can be called + // using it's mapped data as a source + TextureHelper11 destStaging; + ANGLE_TRY_RESULT(CreateStagingTexture(GL_TEXTURE_2D, dest.getFormatSet(), destSize, + StagingAccess::READ_WRITE, device), + destStaging); + + deviceContext->CopySubresourceRegion(destStaging.getResource(), 0, 0, 0, 0, dest.getResource(), + destSubresource, nullptr); + + copyAndConvertImpl(source, sourceSubresource, sourceArea, sourceSize, destStaging, destArea, + destSize, scissor, readOffset, writeOffset, copySize, srcPixelStride, + destPixelStride, convertFunction); + + // Work around timeouts/TDRs in older NVIDIA drivers. + if (mRenderer->getWorkarounds().depthStencilBlitExtraCopy) + { + D3D11_MAPPED_SUBRESOURCE mapped; + deviceContext->Map(destStaging.getResource(), 0, D3D11_MAP_READ, 0, &mapped); + deviceContext->UpdateSubresource(dest.getResource(), destSubresource, nullptr, mapped.pData, + mapped.RowPitch, mapped.DepthPitch); + deviceContext->Unmap(destStaging.getResource(), 0); + } + else + { + deviceContext->CopySubresourceRegion(dest.getResource(), destSubresource, 0, 0, 0, + destStaging.getResource(), 0, nullptr); + } return gl::NoError(); } @@ -1366,10 +1677,13 @@ void Blit11::clearShaderMap() gl::Error Blit11::getBlitShader(GLenum destFormat, bool isSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, ShaderDimension dimension, const Shader **shader) { - BlitShaderType blitShaderType = GetBlitShaderType(destFormat, isSigned, dimension); + BlitShaderType blitShaderType = GetBlitShaderType(destFormat, isSigned, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha, dimension); if (blitShaderType == BLITSHADER_INVALID) { @@ -1394,16 +1708,46 @@ gl::Error Blit11::getBlitShader(GLenum destFormat, blitShaderType, SHADER_2D, d3d11::CompilePS(device, g_PS_PassthroughRGBA2D, "Blit11 2D RGBA pixel shader")); break; + case BLITSHADER_2D_RGBAF_PREMULTIPLY: + addBlitShaderToMap(blitShaderType, SHADER_2D, + d3d11::CompilePS(device, g_PS_PassthroughRGBAPremultiply2D, + "Blit11 2D RGBA premultiply pixel shader")); + break; + case BLITSHADER_2D_RGBAF_UNMULTIPLY: + addBlitShaderToMap(blitShaderType, SHADER_2D, + d3d11::CompilePS(device, g_PS_PassthroughRGBAUnmultiply2D, + "Blit11 2D RGBA unmultiply pixel shader")); + break; case BLITSHADER_2D_BGRAF: addBlitShaderToMap( blitShaderType, SHADER_2D, d3d11::CompilePS(device, g_PS_PassthroughRGBA2D, "Blit11 2D BGRA pixel shader")); break; + case BLITSHADER_2D_BGRAF_PREMULTIPLY: + addBlitShaderToMap(blitShaderType, SHADER_2D, + d3d11::CompilePS(device, g_PS_PassthroughRGBAPremultiply2D, + "Blit11 2D BGRA premultiply pixel shader")); + break; + case BLITSHADER_2D_BGRAF_UNMULTIPLY: + addBlitShaderToMap(blitShaderType, SHADER_2D, + d3d11::CompilePS(device, g_PS_PassthroughRGBAUnmultiply2D, + "Blit11 2D BGRA unmultiply pixel shader")); + break; case BLITSHADER_2D_RGBF: addBlitShaderToMap( blitShaderType, SHADER_2D, d3d11::CompilePS(device, g_PS_PassthroughRGB2D, "Blit11 2D RGB pixel shader")); break; + case BLITSHADER_2D_RGBF_PREMULTIPLY: + addBlitShaderToMap(blitShaderType, SHADER_2D, + d3d11::CompilePS(device, g_PS_PassthroughRGBPremultiply2D, + "Blit11 2D RGB premultiply pixel shader")); + break; + case BLITSHADER_2D_RGBF_UNMULTIPLY: + addBlitShaderToMap(blitShaderType, SHADER_2D, + d3d11::CompilePS(device, g_PS_PassthroughRGBUnmultiply2D, + "Blit11 2D RGB unmultiply pixel shader")); + break; case BLITSHADER_2D_RGF: addBlitShaderToMap( blitShaderType, SHADER_2D, @@ -1656,13 +2000,253 @@ gl::Error Blit11::getSwizzleShader(GLenum type, return gl::NoError(); } -gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepthStencil(RenderTarget11 *dsRenderTarget, - bool resolveDepth, - bool resolveStencil) +gl::ErrorOrResult<TextureHelper11> Blit11::resolveDepth(RenderTarget11 *depth) { - ASSERT(resolveDepth || resolveStencil); - UNIMPLEMENTED(); - return gl::Error(GL_INVALID_OPERATION, - "Multisample depth stencil resolve not implemented yet."); + // Multisampled depth stencil SRVs are not available in feature level 10.0 + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_10_0) + { + return gl::Error(GL_INVALID_OPERATION, + "Resolving multisampled depth stencil textures is not supported in " + "feature level 10.0."); + } + + const auto &extents = depth->getExtents(); + ID3D11Device *device = mRenderer->getDevice(); + ID3D11DeviceContext *context = mRenderer->getDeviceContext(); + + ANGLE_TRY(initResolveDepthStencil(extents)); + + // Notify the Renderer that all state should be invalidated. + mRenderer->markAllStateDirty(); + + // Apply the necessary state changes to the D3D11 immediate device context. + context->IASetInputLayout(nullptr); + context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + context->VSSetShader(mResolveDepthStencilVS.resolve(device), nullptr, 0); + context->GSSetShader(nullptr, nullptr, 0); + context->RSSetState(nullptr); + context->OMSetDepthStencilState(nullptr, 0xFFFFFFFF); + context->OMSetRenderTargets(1, &mResolvedDepthStencilRTView, nullptr); + context->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF); + + // Set the viewport + D3D11_VIEWPORT viewport; + viewport.TopLeftX = 0; + viewport.TopLeftY = 0; + viewport.Width = static_cast<FLOAT>(extents.width); + viewport.Height = static_cast<FLOAT>(extents.height); + viewport.MinDepth = 0.0f; + viewport.MaxDepth = 1.0f; + context->RSSetViewports(1, &viewport); + + ID3D11ShaderResourceView *pixelViews[] = {depth->getShaderResourceView()}; + + context->PSSetShaderResources(0, 1, pixelViews); + + context->PSSetShader(mResolveDepthPS.resolve(device), nullptr, 0); + + // Trigger the blit on the GPU. + context->Draw(6, 0); + + gl::Box copyBox(0, 0, 0, extents.width, extents.height, 1); + + const auto ©Function = GetCopyDepthStencilFunction(depth->getInternalFormat()); + const auto &dsFormatSet = depth->getFormatSet(); + const auto &dsDxgiInfo = d3d11::GetDXGIFormatSizeInfo(dsFormatSet.texFormat); + + ID3D11Texture2D *destTex = nullptr; + + D3D11_TEXTURE2D_DESC destDesc; + destDesc.Width = extents.width; + destDesc.Height = extents.height; + destDesc.MipLevels = 1; + destDesc.ArraySize = 1; + destDesc.Format = dsFormatSet.texFormat; + destDesc.SampleDesc.Count = 1; + destDesc.SampleDesc.Quality = 0; + destDesc.Usage = D3D11_USAGE_DEFAULT; + destDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; + destDesc.CPUAccessFlags = 0; + destDesc.MiscFlags = 0; + + HRESULT hr = device->CreateTexture2D(&destDesc, nullptr, &destTex); + if (FAILED(hr)) + { + return gl::Error(GL_OUT_OF_MEMORY, "Error creating depth resolve dest texture."); + } + d3d11::SetDebugName(destTex, "resolveDepthDest"); + + TextureHelper11 dest = TextureHelper11::MakeAndPossess2D(destTex, depth->getFormatSet()); + ANGLE_TRY(copyAndConvert(mResolvedDepthStencil, 0, copyBox, extents, dest, 0, copyBox, extents, + nullptr, 0, 0, 0, 8, dsDxgiInfo.pixelBytes, copyFunction)); + return dest; +} + +gl::Error Blit11::initResolveDepthStencil(const gl::Extents &extents) +{ + // Check if we need to recreate depth stencil view + if (mResolvedDepthStencil.valid() && extents == mResolvedDepthStencil.getExtents()) + { + return gl::NoError(); + } + + if (mResolvedDepthStencil.valid()) + { + releaseResolveDepthStencilResources(); + } + + const auto &formatSet = d3d11::Format::Get(GL_RG32F, mRenderer->getRenderer11DeviceCaps()); + + D3D11_TEXTURE2D_DESC textureDesc; + textureDesc.Width = extents.width; + textureDesc.Height = extents.height; + textureDesc.MipLevels = 1; + textureDesc.ArraySize = 1; + textureDesc.Format = formatSet.texFormat; + textureDesc.SampleDesc.Count = 1; + textureDesc.SampleDesc.Quality = 0; + textureDesc.Usage = D3D11_USAGE_DEFAULT; + textureDesc.BindFlags = D3D11_BIND_RENDER_TARGET; + textureDesc.CPUAccessFlags = 0; + textureDesc.MiscFlags = 0; + + ID3D11Device *device = mRenderer->getDevice(); + + ID3D11Texture2D *resolvedDepthStencil = nullptr; + HRESULT hr = device->CreateTexture2D(&textureDesc, nullptr, &resolvedDepthStencil); + if (FAILED(hr)) + { + return gl::Error(GL_OUT_OF_MEMORY, "Failed to allocate resolved depth stencil texture"); + } + d3d11::SetDebugName(resolvedDepthStencil, "Blit11::mResolvedDepthStencil"); + + ASSERT(mResolvedDepthStencilRTView == nullptr); + hr = + device->CreateRenderTargetView(resolvedDepthStencil, nullptr, &mResolvedDepthStencilRTView); + if (FAILED(hr)) + { + return gl::Error(GL_OUT_OF_MEMORY, + "Failed to allocate Blit11::mResolvedDepthStencilRTView"); + } + d3d11::SetDebugName(mResolvedDepthStencilRTView, "Blit11::mResolvedDepthStencilRTView"); + + mResolvedDepthStencil = TextureHelper11::MakeAndPossess2D(resolvedDepthStencil, formatSet); + + return gl::NoError(); +} + +gl::ErrorOrResult<TextureHelper11> Blit11::resolveStencil(RenderTarget11 *depthStencil, + bool alsoDepth) +{ + // Multisampled depth stencil SRVs are not available in feature level 10.0 + if (mRenderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_10_0) + { + return gl::Error(GL_INVALID_OPERATION, + "Resolving multisampled depth stencil textures is not supported in " + "feature level 10.0."); + } + + const auto &extents = depthStencil->getExtents(); + + ANGLE_TRY(initResolveDepthStencil(extents)); + + ID3D11Device *device = mRenderer->getDevice(); + ID3D11DeviceContext *context = mRenderer->getDeviceContext(); + + ID3D11Resource *stencilResource = depthStencil->getTexture(); + + // Check if we need to re-create the stencil SRV. + if (mStencilSRV) + { + ID3D11Resource *priorResource = nullptr; + mStencilSRV->GetResource(&priorResource); + + if (stencilResource != priorResource) + { + SafeRelease(mStencilSRV); + } + } + + if (!mStencilSRV) + { + D3D11_SHADER_RESOURCE_VIEW_DESC srViewDesc; + srViewDesc.Format = GetStencilSRVFormat(depthStencil->getFormatSet()); + srViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS; + + HRESULT hr = device->CreateShaderResourceView(stencilResource, &srViewDesc, &mStencilSRV); + if (FAILED(hr)) + { + return gl::Error(GL_OUT_OF_MEMORY, "Error creating Blit11 stencil SRV"); + } + d3d11::SetDebugName(mStencilSRV, "Blit11::mStencilSRV"); + } + + // Notify the Renderer that all state should be invalidated. + mRenderer->markAllStateDirty(); + + // Apply the necessary state changes to the D3D11 immediate device context. + context->IASetInputLayout(nullptr); + context->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); + context->VSSetShader(mResolveDepthStencilVS.resolve(device), nullptr, 0); + context->GSSetShader(nullptr, nullptr, 0); + context->RSSetState(nullptr); + context->OMSetDepthStencilState(nullptr, 0xFFFFFFFF); + context->OMSetRenderTargets(1, &mResolvedDepthStencilRTView, nullptr); + context->OMSetBlendState(nullptr, nullptr, 0xFFFFFFF); + + // Set the viewport + D3D11_VIEWPORT viewport; + viewport.TopLeftX = 0; + viewport.TopLeftY = 0; + viewport.Width = static_cast<FLOAT>(extents.width); + viewport.Height = static_cast<FLOAT>(extents.height); + viewport.MinDepth = 0.0f; + viewport.MaxDepth = 1.0f; + context->RSSetViewports(1, &viewport); + + ID3D11ShaderResourceView *pixelViews[] = { + depthStencil->getShaderResourceView(), mStencilSRV, + }; + + context->PSSetShaderResources(0, 2, pixelViews); + + // Resolving the depth buffer works by sampling the depth in the shader using a SRV, then + // writing to the resolved depth buffer using SV_Depth. We can't use this method for stencil + // because SV_StencilRef isn't supported until HLSL 5.1/D3D11.3. + if (alsoDepth) + { + context->PSSetShader(mResolveDepthStencilPS.resolve(device), nullptr, 0); + } + else + { + context->PSSetShader(mResolveStencilPS.resolve(device), nullptr, 0); + } + + // Trigger the blit on the GPU. + context->Draw(6, 0); + + gl::Box copyBox(0, 0, 0, extents.width, extents.height, 1); + + TextureHelper11 dest; + ANGLE_TRY_RESULT(CreateStagingTexture(GL_TEXTURE_2D, depthStencil->getFormatSet(), extents, + StagingAccess::READ_WRITE, device), + dest); + + const auto ©Function = GetCopyDepthStencilFunction(depthStencil->getInternalFormat()); + const auto &dsFormatSet = depthStencil->getFormatSet(); + const auto &dsDxgiInfo = d3d11::GetDXGIFormatSizeInfo(dsFormatSet.texFormat); + + ANGLE_TRY(copyAndConvertImpl(mResolvedDepthStencil, 0, copyBox, extents, dest, copyBox, extents, + nullptr, 0, 0, 0, 8u, dsDxgiInfo.pixelBytes, copyFunction)); + + // Return the resolved depth texture, which the caller must Release. + return dest; } + +void Blit11::releaseResolveDepthStencilResources() +{ + SafeRelease(mStencilSRV); + SafeRelease(mResolvedDepthStencilRTView); +} + } // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h index ff042b8a134..e61f096c69d 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Blit11.h @@ -40,7 +40,9 @@ class Blit11 : angle::NonCopyable const gl::Rectangle *scissor, GLenum destFormat, GLenum filter, - bool maskOffAlpha); + bool maskOffAlpha, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha); gl::Error copyStencil(const TextureHelper11 &source, unsigned int sourceSubresource, @@ -70,17 +72,37 @@ class Blit11 : angle::NonCopyable const gl::Extents &destSize, const gl::Rectangle *scissor); - gl::ErrorOrResult<TextureHelper11> resolveDepthStencil(RenderTarget11 *dsRenderTarget, - bool resolveDepth, - bool resolveStencil); + gl::ErrorOrResult<TextureHelper11> resolveDepth(RenderTarget11 *depth); + + gl::ErrorOrResult<TextureHelper11> resolveStencil(RenderTarget11 *depthStencil, bool alsoDepth); + + using BlitConvertFunction = void(const gl::Box &sourceArea, + const gl::Box &destArea, + const gl::Rectangle &clipRect, + const gl::Extents &sourceSize, + unsigned int sourceRowPitch, + unsigned int destRowPitch, + ptrdiff_t readOffset, + ptrdiff_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + const uint8_t *sourceData, + uint8_t *destData); private: enum BlitShaderType { BLITSHADER_INVALID, BLITSHADER_2D_RGBAF, + BLITSHADER_2D_RGBAF_PREMULTIPLY, + BLITSHADER_2D_RGBAF_UNMULTIPLY, BLITSHADER_2D_BGRAF, + BLITSHADER_2D_BGRAF_PREMULTIPLY, + BLITSHADER_2D_BGRAF_UNMULTIPLY, BLITSHADER_2D_RGBF, + BLITSHADER_2D_RGBF_PREMULTIPLY, + BLITSHADER_2D_RGBF_UNMULTIPLY, BLITSHADER_2D_RGF, BLITSHADER_2D_RF, BLITSHADER_2D_ALPHA, @@ -165,23 +187,11 @@ class Blit11 : angle::NonCopyable static BlitShaderType GetBlitShaderType(GLenum destinationFormat, bool isSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, ShaderDimension dimension); static SwizzleShaderType GetSwizzleShaderType(GLenum type, D3D11_SRV_DIMENSION dimensionality); - typedef void BlitConvertFunction(const gl::Box &sourceArea, - const gl::Box &destArea, - const gl::Rectangle &clipRect, - const gl::Extents &sourceSize, - unsigned int sourceRowPitch, - unsigned int destRowPitch, - ptrdiff_t readOffset, - ptrdiff_t writeOffset, - size_t copySize, - size_t srcPixelStride, - size_t destPixelStride, - const uint8_t *sourceData, - uint8_t *destData); - gl::Error copyDepthStencilImpl(const TextureHelper11 &source, unsigned int sourceSubresource, const gl::Box &sourceArea, @@ -193,6 +203,21 @@ class Blit11 : angle::NonCopyable const gl::Rectangle *scissor, bool stencilOnly); + gl::Error copyAndConvertImpl(const TextureHelper11 &source, + unsigned int sourceSubresource, + const gl::Box &sourceArea, + const gl::Extents &sourceSize, + const TextureHelper11 &destStaging, + const gl::Box &destArea, + const gl::Extents &destSize, + const gl::Rectangle *scissor, + size_t readOffset, + size_t writeOffset, + size_t copySize, + size_t srcPixelStride, + size_t destPixelStride, + BlitConvertFunction *convertFunction); + gl::Error copyAndConvert(const TextureHelper11 &source, unsigned int sourceSubresource, const gl::Box &sourceArea, @@ -215,6 +240,8 @@ class Blit11 : angle::NonCopyable gl::Error getBlitShader(GLenum destFormat, bool isSigned, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha, ShaderDimension dimension, const Shader **shaderOut); gl::Error getSwizzleShader(GLenum type, @@ -226,6 +253,8 @@ class Blit11 : angle::NonCopyable ID3D11PixelShader *ps); void clearShaderMap(); + void releaseResolveDepthStencilResources(); + gl::Error initResolveDepthStencil(const gl::Extents &extents); Renderer11 *mRenderer; @@ -251,6 +280,14 @@ class Blit11 : angle::NonCopyable d3d11::LazyBlendState mAlphaMaskBlendState; ID3D11Buffer *mSwizzleCB; + + d3d11::LazyShader<ID3D11VertexShader> mResolveDepthStencilVS; + d3d11::LazyShader<ID3D11PixelShader> mResolveDepthPS; + d3d11::LazyShader<ID3D11PixelShader> mResolveDepthStencilPS; + d3d11::LazyShader<ID3D11PixelShader> mResolveStencilPS; + ID3D11ShaderResourceView *mStencilSRV; + TextureHelper11 mResolvedDepthStencil; + ID3D11RenderTargetView *mResolvedDepthStencilRTView; }; } // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp index 723eef0fad4..731680dc8e7 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp @@ -43,7 +43,7 @@ enum class CopyResult namespace gl_d3d11 { -D3D11_MAP GetD3DMapTypeFromBits(GLbitfield access) +D3D11_MAP GetD3DMapTypeFromBits(BufferUsage usage, GLbitfield access) { bool readBit = ((access & GL_MAP_READ_BIT) != 0); bool writeBit = ((access & GL_MAP_WRITE_BIT) != 0); @@ -59,7 +59,8 @@ D3D11_MAP GetD3DMapTypeFromBits(GLbitfield access) } else if (writeBit && !readBit) { - return D3D11_MAP_WRITE; + // Special case for uniform storage - we only allow full buffer updates. + return usage == BUFFER_USAGE_UNIFORM ? D3D11_MAP_WRITE_DISCARD : D3D11_MAP_WRITE; } else if (writeBit && readBit) { @@ -88,7 +89,7 @@ class Buffer11::BufferStorage : angle::NonCopyable size_t getSize() const { return mBufferSize; } void setDataRevision(DataRevision rev) { mRevision = rev; } - virtual bool isMappable() const = 0; + virtual bool isMappable(GLbitfield access) const = 0; virtual gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source, size_t sourceOffset, @@ -123,7 +124,7 @@ class Buffer11::NativeStorage : public Buffer11::BufferStorage const angle::BroadcastChannel *onStorageChanged); ~NativeStorage() override; - bool isMappable() const override { return mUsage == BUFFER_USAGE_STAGING; } + bool isMappable(GLbitfield access) const override; ID3D11Buffer *getNativeStorage() const { return mNativeStorage; } gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source, @@ -138,14 +139,18 @@ class Buffer11::NativeStorage : public Buffer11::BufferStorage uint8_t **mapPointerOut) override; void unmap() override; + gl::ErrorOrResult<ID3D11ShaderResourceView *> getSRVForFormat(DXGI_FORMAT srvFormat); + private: - static void fillBufferDesc(D3D11_BUFFER_DESC *bufferDesc, + static void FillBufferDesc(D3D11_BUFFER_DESC *bufferDesc, Renderer11 *renderer, BufferUsage usage, unsigned int bufferSize); + void clearSRVs(); ID3D11Buffer *mNativeStorage; const angle::BroadcastChannel *mOnStorageChanged; + std::map<DXGI_FORMAT, ID3D11ShaderResourceView *> mBufferResourceViews; }; // A emulated indexed buffer storage represents an underlying D3D11 buffer for data @@ -157,7 +162,7 @@ class Buffer11::EmulatedIndexedStorage : public Buffer11::BufferStorage EmulatedIndexedStorage(Renderer11 *renderer); ~EmulatedIndexedStorage() override; - bool isMappable() const override { return true; } + bool isMappable(GLbitfield access) const override { return true; } gl::ErrorOrResult<ID3D11Buffer *> getNativeStorage(SourceIndexData *indexInfo, const TranslatedAttribute &attribute, @@ -190,7 +195,7 @@ class Buffer11::PackStorage : public Buffer11::BufferStorage explicit PackStorage(Renderer11 *renderer); ~PackStorage() override; - bool isMappable() const override { return true; } + bool isMappable(GLbitfield access) const override { return true; } gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source, size_t sourceOffset, size_t size, @@ -225,7 +230,7 @@ class Buffer11::SystemMemoryStorage : public Buffer11::BufferStorage explicit SystemMemoryStorage(Renderer11 *renderer); ~SystemMemoryStorage() override {} - bool isMappable() const override { return true; } + bool isMappable(GLbitfield access) const override { return true; } gl::ErrorOrResult<CopyResult> copyFromStorage(BufferStorage *source, size_t sourceOffset, size_t size, @@ -249,11 +254,11 @@ Buffer11::Buffer11(Renderer11 *renderer) mRenderer(renderer), mSize(0), mMappedStorage(nullptr), - mBufferStorages(BUFFER_USAGE_COUNT, nullptr), + mBufferStorages({}), + mDeallocThresholds({}), + mIdleness({}), mConstantBufferStorageAdditionalSize(0), - mMaxConstantBufferLruCount(0), - mReadUsageCount(0), - mSystemMemoryDeallocThreshold(0) + mMaxConstantBufferLruCount(0) { } @@ -272,10 +277,10 @@ Buffer11::~Buffer11() mRenderer->onBufferDelete(this); } -gl::Error Buffer11::setData(const void *data, size_t size, GLenum usage) +gl::Error Buffer11::setData(GLenum target, const void *data, size_t size, GLenum usage) { updateD3DBufferUsage(usage); - ANGLE_TRY(setSubData(data, size, 0)); + ANGLE_TRY(setSubData(target, data, size, 0)); return gl::NoError(); } @@ -284,8 +289,6 @@ gl::Error Buffer11::getData(const uint8_t **outData) SystemMemoryStorage *systemMemoryStorage = nullptr; ANGLE_TRY_RESULT(getSystemMemoryStorage(), systemMemoryStorage); - mReadUsageCount = 0; - ASSERT(systemMemoryStorage->getSize() >= mSize); *outData = systemMemoryStorage->getSystemCopy()->data(); @@ -299,16 +302,20 @@ gl::ErrorOrResult<Buffer11::SystemMemoryStorage *> Buffer11::getSystemMemoryStor return GetAs<SystemMemoryStorage>(storage); } -gl::Error Buffer11::setSubData(const void *data, size_t size, size_t offset) +gl::Error Buffer11::setSubData(GLenum target, const void *data, size_t size, size_t offset) { size_t requiredSize = size + offset; if (data && size > 0) { // Use system memory storage for dynamic buffers. - + // Try using a constant storage for constant buffers BufferStorage *writeBuffer = nullptr; - if (supportsDirectBinding()) + if (target == GL_UNIFORM_BUFFER && offset == 0 && size >= mSize) + { + ANGLE_TRY_RESULT(getBufferStorage(BUFFER_USAGE_UNIFORM), writeBuffer); + } + else if (supportsDirectBinding()) { ANGLE_TRY_RESULT(getStagingStorage(), writeBuffer); } @@ -363,11 +370,12 @@ gl::Error Buffer11::copySubData(BufferImpl *source, // If copying to/from a pixel pack buffer, we must have a staging or // pack buffer partner, because other native buffers can't be mapped - if (copyDest->getUsage() == BUFFER_USAGE_PIXEL_PACK && !copySource->isMappable()) + if (copyDest->getUsage() == BUFFER_USAGE_PIXEL_PACK && !copySource->isMappable(GL_MAP_READ_BIT)) { ANGLE_TRY_RESULT(sourceBuffer->getStagingStorage(), copySource); } - else if (copySource->getUsage() == BUFFER_USAGE_PIXEL_PACK && !copyDest->isMappable()) + else if (copySource->getUsage() == BUFFER_USAGE_PIXEL_PACK && + !copyDest->isMappable(GL_MAP_WRITE_BIT)) { ANGLE_TRY_RESULT(getStagingStorage(), copyDest); } @@ -474,50 +482,65 @@ gl::Error Buffer11::markTransformFeedbackUsage() return gl::NoError(); } -void Buffer11::updateSystemMemoryDeallocThreshold() +void Buffer11::updateDeallocThreshold(BufferUsage usage) { // The following strategy was tuned on the Oort online benchmark (http://oortonline.gl/) // as well as a custom microbenchmark (IndexConversionPerfTest.Run/index_range_d3d11) - // First readback: 8 unmodified uses before we free system memory. + // First readback: 8 unmodified uses before we free buffer memory. // After that, double the threshold each time until we reach the max. - if (mSystemMemoryDeallocThreshold == 0) + if (mDeallocThresholds[usage] == 0) { - mSystemMemoryDeallocThreshold = 8; + mDeallocThresholds[usage] = 8; } - else if (mSystemMemoryDeallocThreshold < std::numeric_limits<unsigned int>::max() / 2u) + else if (mDeallocThresholds[usage] < std::numeric_limits<unsigned int>::max() / 2u) { - mSystemMemoryDeallocThreshold *= 2u; + mDeallocThresholds[usage] *= 2u; } else { - mSystemMemoryDeallocThreshold = std::numeric_limits<unsigned int>::max(); + mDeallocThresholds[usage] = std::numeric_limits<unsigned int>::max(); } } -gl::Error Buffer11::markBufferUsage() +// Free the storage if we decide it isn't being used very often. +gl::Error Buffer11::checkForDeallocation(BufferUsage usage) { - mReadUsageCount++; + mIdleness[usage]++; - // Free the system memory storage if we decide it isn't being used very often. - BufferStorage *&sysMemStorage = mBufferStorages[BUFFER_USAGE_SYSTEM_MEMORY]; - if (sysMemStorage != nullptr && mReadUsageCount > mSystemMemoryDeallocThreshold) + BufferStorage *&storage = mBufferStorages[usage]; + if (storage != nullptr && mIdleness[usage] > mDeallocThresholds[usage]) { BufferStorage *latestStorage = nullptr; ANGLE_TRY_RESULT(getLatestBufferStorage(), latestStorage); - if (latestStorage != sysMemStorage) + if (latestStorage != storage) { - SafeDelete(sysMemStorage); + SafeDelete(storage); } } return gl::NoError(); } -gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getBuffer(BufferUsage usage) +gl::Error Buffer11::markBufferUsage(BufferUsage usage) { - ANGLE_TRY(markBufferUsage()); + mIdleness[usage] = 0; + + if (usage != BUFFER_USAGE_SYSTEM_MEMORY) + { + ANGLE_TRY(checkForDeallocation(BUFFER_USAGE_SYSTEM_MEMORY)); + } + if (usage != BUFFER_USAGE_STAGING) + { + ANGLE_TRY(checkForDeallocation(BUFFER_USAGE_STAGING)); + } + + return gl::NoError(); +} + +gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getBuffer(BufferUsage usage) +{ BufferStorage *storage = nullptr; ANGLE_TRY_RESULT(getBufferStorage(usage), storage); return GetAs<NativeStorage>(storage)->getNativeStorage(); @@ -530,8 +553,6 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getEmulatedIndexedBuffer( { ASSERT(indexInfo); - ANGLE_TRY(markBufferUsage()); - BufferStorage *untypedStorage = nullptr; ANGLE_TRY_RESULT(getBufferStorage(BUFFER_USAGE_EMULATED_INDEXED_VERTEX), untypedStorage); @@ -546,11 +567,9 @@ gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getEmulatedIndexedBuffer( gl::ErrorOrResult<ID3D11Buffer *> Buffer11::getConstantBufferRange(GLintptr offset, GLsizeiptr size) { - ANGLE_TRY(markBufferUsage()); - BufferStorage *bufferStorage = nullptr; - if (offset == 0) + if (offset == 0 || mRenderer->getRenderer11DeviceCaps().supportsConstantBufferOffsets) { ANGLE_TRY_RESULT(getBufferStorage(BUFFER_USAGE_UNIFORM), bufferStorage); } @@ -566,42 +585,8 @@ gl::ErrorOrResult<ID3D11ShaderResourceView *> Buffer11::getSRV(DXGI_FORMAT srvFo { BufferStorage *storage = nullptr; ANGLE_TRY_RESULT(getBufferStorage(BUFFER_USAGE_PIXEL_UNPACK), storage); - ID3D11Buffer *buffer = GetAs<NativeStorage>(storage)->getNativeStorage(); - - auto bufferSRVIt = mBufferResourceViews.find(srvFormat); - - if (bufferSRVIt != mBufferResourceViews.end()) - { - if (bufferSRVIt->second.first == buffer) - { - return bufferSRVIt->second.second; - } - else - { - // The underlying buffer has changed since the SRV was created: recreate the SRV. - SafeRelease(bufferSRVIt->second.second); - } - } - - ID3D11Device *device = mRenderer->getDevice(); - ID3D11ShaderResourceView *bufferSRV = nullptr; - - const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(srvFormat); - - D3D11_SHADER_RESOURCE_VIEW_DESC bufferSRVDesc; - bufferSRVDesc.Buffer.ElementOffset = 0; - bufferSRVDesc.Buffer.ElementWidth = - static_cast<unsigned int>(mSize) / dxgiFormatInfo.pixelBytes; - bufferSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; - bufferSRVDesc.Format = srvFormat; - - HRESULT result = device->CreateShaderResourceView(buffer, &bufferSRVDesc, &bufferSRV); - UNUSED_ASSERTION_VARIABLE(result); - ASSERT(SUCCEEDED(result)); - - mBufferResourceViews[srvFormat] = BufferSRVPair(buffer, bufferSRV); - - return bufferSRV; + NativeStorage *nativeStorage = GetAs<NativeStorage>(storage); + return nativeStorage->getSRVForFormat(srvFormat); } gl::Error Buffer11::packPixels(const gl::FramebufferAttachment &readAttachment, @@ -650,21 +635,20 @@ gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getBufferStorage(BufferUs } ANGLE_TRY(updateBufferStorage(newStorage, 0, mSize)); + ANGLE_TRY(markBufferUsage(usage)); return newStorage; } Buffer11::BufferStorage *Buffer11::allocateStorage(BufferUsage usage) { + updateDeallocThreshold(usage); switch (usage) { case BUFFER_USAGE_PIXEL_PACK: return new PackStorage(mRenderer); case BUFFER_USAGE_SYSTEM_MEMORY: - { - updateSystemMemoryDeallocThreshold(); return new SystemMemoryStorage(mRenderer); - } case BUFFER_USAGE_EMULATED_INDEXED_VERTEX: return new EmulatedIndexedStorage(mRenderer); case BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK: @@ -729,6 +713,7 @@ gl::ErrorOrResult<Buffer11::BufferStorage *> Buffer11::getConstantBufferRangeSto } ANGLE_TRY(updateBufferStorage(newStorage, offset, size)); + ANGLE_TRY(markBufferUsage(BUFFER_USAGE_UNIFORM)); return newStorage; } @@ -746,7 +731,7 @@ gl::Error Buffer11::updateBufferStorage(BufferStorage *storage, // data directly. If we're already using a staging buffer we're fine. if (latestBuffer->getUsage() != BUFFER_USAGE_STAGING && storage->getUsage() != BUFFER_USAGE_STAGING && - (!latestBuffer->isMappable() || !storage->isMappable())) + (!latestBuffer->isMappable(GL_MAP_READ_BIT) || !storage->isMappable(GL_MAP_WRITE_BIT))) { NativeStorage *stagingBuffer = nullptr; ANGLE_TRY_RESULT(getStagingStorage(), stagingBuffer); @@ -845,6 +830,8 @@ angle::BroadcastChannel *Buffer11::getDirectBroadcastChannel() return &mDirectBroadcastChannel; } +// Buffer11::BufferStorage implementation + Buffer11::BufferStorage::BufferStorage(Renderer11 *renderer, BufferUsage usage) : mRenderer(renderer), mRevision(0), mUsage(usage), mBufferSize(0) { @@ -852,7 +839,7 @@ Buffer11::BufferStorage::BufferStorage(Renderer11 *renderer, BufferUsage usage) gl::Error Buffer11::BufferStorage::setData(const uint8_t *data, size_t offset, size_t size) { - ASSERT(isMappable()); + ASSERT(isMappable(GL_MAP_WRITE_BIT)); uint8_t *writePointer = nullptr; ANGLE_TRY(map(offset, size, GL_MAP_WRITE_BIT, &writePointer)); @@ -864,6 +851,8 @@ gl::Error Buffer11::BufferStorage::setData(const uint8_t *data, size_t offset, s return gl::NoError(); } +// Buffer11::NativeStorage implementation + Buffer11::NativeStorage::NativeStorage(Renderer11 *renderer, BufferUsage usage, const angle::BroadcastChannel *onStorageChanged) @@ -874,6 +863,18 @@ Buffer11::NativeStorage::NativeStorage(Renderer11 *renderer, Buffer11::NativeStorage::~NativeStorage() { SafeRelease(mNativeStorage); + clearSRVs(); +} + +bool Buffer11::NativeStorage::isMappable(GLbitfield access) const +{ + if ((access & GL_MAP_READ_BIT) != 0) + { + // Read is more exclusive than write mappability. + return (mUsage == BUFFER_USAGE_STAGING); + } + ASSERT((access & GL_MAP_WRITE_BIT) != 0); + return (mUsage == BUFFER_USAGE_STAGING || mUsage == BUFFER_USAGE_UNIFORM); } // Returns true if it recreates the direct buffer @@ -888,45 +889,42 @@ gl::ErrorOrResult<CopyResult> Buffer11::NativeStorage::copyFromStorage(BufferSto bool createBuffer = !mNativeStorage || mBufferSize < requiredSize; // (Re)initialize D3D buffer if needed + bool preserveData = (destOffset > 0); if (createBuffer) { - bool preserveData = (destOffset > 0); resize(requiredSize, preserveData); } + size_t clampedSize = size; + if (mUsage == BUFFER_USAGE_UNIFORM) + { + clampedSize = std::min(clampedSize, mBufferSize - destOffset); + } + if (source->getUsage() == BUFFER_USAGE_PIXEL_PACK || source->getUsage() == BUFFER_USAGE_SYSTEM_MEMORY) { - ASSERT(source->isMappable()); + ASSERT(source->isMappable(GL_MAP_READ_BIT) && isMappable(GL_MAP_WRITE_BIT)); - uint8_t *sourcePointer = nullptr; - ANGLE_TRY(source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourcePointer)); + // Uniform buffers must be mapped with write/discard. + ASSERT(!(preserveData && mUsage == BUFFER_USAGE_UNIFORM)); - D3D11_MAPPED_SUBRESOURCE mappedResource; - HRESULT hr = context->Map(mNativeStorage, 0, D3D11_MAP_WRITE, 0, &mappedResource); - ASSERT(SUCCEEDED(hr)); - if (FAILED(hr)) - { - source->unmap(); - return gl::Error( - GL_OUT_OF_MEMORY, - "Failed to map native storage in Buffer11::NativeStorage::copyFromStorage"); - } + uint8_t *sourcePointer = nullptr; + ANGLE_TRY(source->map(sourceOffset, clampedSize, GL_MAP_READ_BIT, &sourcePointer)); - uint8_t *destPointer = static_cast<uint8_t *>(mappedResource.pData) + destOffset; + uint8_t *destPointer = nullptr; + ANGLE_TRY(map(destOffset, clampedSize, GL_MAP_WRITE_BIT, &destPointer)); - // Offset bounds are validated at the API layer - ASSERT(sourceOffset + size <= destOffset + mBufferSize); - memcpy(destPointer, sourcePointer, size); + memcpy(destPointer, sourcePointer, clampedSize); - context->Unmap(mNativeStorage, 0); + unmap(); source->unmap(); } else { D3D11_BOX srcBox; srcBox.left = static_cast<unsigned int>(sourceOffset); - srcBox.right = static_cast<unsigned int>(sourceOffset + size); + srcBox.right = static_cast<unsigned int>(sourceOffset + clampedSize); srcBox.top = 0; srcBox.bottom = 1; srcBox.front = 0; @@ -947,7 +945,7 @@ gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData) ID3D11DeviceContext *context = mRenderer->getDeviceContext(); D3D11_BUFFER_DESC bufferDesc; - fillBufferDesc(&bufferDesc, mRenderer, mUsage, static_cast<unsigned int>(size)); + FillBufferDesc(&bufferDesc, mRenderer, mUsage, static_cast<unsigned int>(size)); ID3D11Buffer *newBuffer; HRESULT result = device->CreateBuffer(&bufferDesc, nullptr, &newBuffer); @@ -982,6 +980,9 @@ gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData) mBufferSize = bufferDesc.ByteWidth; + // Free the SRVs. + clearSRVs(); + // Notify that the storage has changed. if (mOnStorageChanged) { @@ -991,7 +992,8 @@ gl::Error Buffer11::NativeStorage::resize(size_t size, bool preserveData) return gl::NoError(); } -void Buffer11::NativeStorage::fillBufferDesc(D3D11_BUFFER_DESC *bufferDesc, +// static +void Buffer11::NativeStorage::FillBufferDesc(D3D11_BUFFER_DESC *bufferDesc, Renderer11 *renderer, BufferUsage usage, unsigned int bufferSize) @@ -1040,6 +1042,9 @@ void Buffer11::NativeStorage::fillBufferDesc(D3D11_BUFFER_DESC *bufferDesc, // Constant buffers must be of a limited size, and aligned to 16 byte boundaries // For our purposes we ignore any buffer data past the maximum constant buffer size bufferDesc->ByteWidth = roundUp(bufferDesc->ByteWidth, 16u); + + // Note: it seems that D3D11 allows larger buffers on some platforms, but not all. + // (Windows 10 seems to allow larger constant buffers, but not Windows 7) bufferDesc->ByteWidth = std::min<UINT>(bufferDesc->ByteWidth, static_cast<UINT>(renderer->getNativeCaps().maxUniformBlockSize)); @@ -1055,11 +1060,11 @@ gl::Error Buffer11::NativeStorage::map(size_t offset, GLbitfield access, uint8_t **mapPointerOut) { - ASSERT(mUsage == BUFFER_USAGE_STAGING); + ASSERT(isMappable(access)); D3D11_MAPPED_SUBRESOURCE mappedResource; ID3D11DeviceContext *context = mRenderer->getDeviceContext(); - D3D11_MAP d3dMapType = gl_d3d11::GetD3DMapTypeFromBits(access); + D3D11_MAP d3dMapType = gl_d3d11::GetD3DMapTypeFromBits(mUsage, access); UINT d3dMapFlag = ((access & GL_MAP_UNSYNCHRONIZED_BIT) != 0 ? D3D11_MAP_FLAG_DO_NOT_WAIT : 0); HRESULT result = context->Map(mNativeStorage, 0, d3dMapType, d3dMapFlag, &mappedResource); @@ -1076,11 +1081,56 @@ gl::Error Buffer11::NativeStorage::map(size_t offset, void Buffer11::NativeStorage::unmap() { - ASSERT(mUsage == BUFFER_USAGE_STAGING); + ASSERT(isMappable(GL_MAP_WRITE_BIT) || isMappable(GL_MAP_READ_BIT)); ID3D11DeviceContext *context = mRenderer->getDeviceContext(); context->Unmap(mNativeStorage, 0); } +gl::ErrorOrResult<ID3D11ShaderResourceView *> Buffer11::NativeStorage::getSRVForFormat( + DXGI_FORMAT srvFormat) +{ + auto bufferSRVIt = mBufferResourceViews.find(srvFormat); + + if (bufferSRVIt != mBufferResourceViews.end()) + { + return bufferSRVIt->second; + } + + ID3D11Device *device = mRenderer->getDevice(); + ID3D11ShaderResourceView *bufferSRV = nullptr; + + const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(srvFormat); + + D3D11_SHADER_RESOURCE_VIEW_DESC bufferSRVDesc; + bufferSRVDesc.Buffer.ElementOffset = 0; + bufferSRVDesc.Buffer.ElementWidth = static_cast<UINT>(mBufferSize) / dxgiFormatInfo.pixelBytes; + bufferSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER; + bufferSRVDesc.Format = srvFormat; + + HRESULT result = device->CreateShaderResourceView(mNativeStorage, &bufferSRVDesc, &bufferSRV); + ASSERT(SUCCEEDED(result)); + if (FAILED(result)) + { + return gl::Error(GL_OUT_OF_MEMORY, + "Error creating buffer SRV in Buffer11::NativeStorage::getSRVForFormat"); + } + + mBufferResourceViews[srvFormat] = bufferSRV; + + return bufferSRV; +} + +void Buffer11::NativeStorage::clearSRVs() +{ + for (auto &srv : mBufferResourceViews) + { + SafeRelease(srv.second); + } + mBufferResourceViews.clear(); +} + +// Buffer11::EmulatedIndexStorage implementation + Buffer11::EmulatedIndexedStorage::EmulatedIndexedStorage(Renderer11 *renderer) : BufferStorage(renderer, BUFFER_USAGE_EMULATED_INDEXED_VERTEX), mNativeStorage(nullptr) { @@ -1215,7 +1265,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::EmulatedIndexedStorage::copyFromStorage( size_t size, size_t destOffset) { - ASSERT(source->isMappable()); + ASSERT(source->isMappable(GL_MAP_READ_BIT)); uint8_t *sourceData = nullptr; ANGLE_TRY(source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData)); ASSERT(destOffset + size <= mMemoryBuffer.size()); @@ -1253,6 +1303,8 @@ void Buffer11::EmulatedIndexedStorage::unmap() // No-op } +// Buffer11::PackStorage implementation + Buffer11::PackStorage::PackStorage(Renderer11 *renderer) : BufferStorage(renderer, BUFFER_USAGE_PIXEL_PACK), mStagingTexture(), mDataModified(false) { @@ -1267,9 +1319,16 @@ gl::ErrorOrResult<CopyResult> Buffer11::PackStorage::copyFromStorage(BufferStora size_t size, size_t destOffset) { - // We copy through a staging buffer when drawing with a pack buffer, - // or for other cases where we access the pack buffer - UNREACHABLE(); + ANGLE_TRY(flushQueuedPackCommand()); + + // We copy through a staging buffer when drawing with a pack buffer, or for other cases where we + // access the pack buffer + ASSERT(source->isMappable(GL_MAP_READ_BIT) && source->getUsage() == BUFFER_USAGE_STAGING); + uint8_t *sourceData = nullptr; + ANGLE_TRY(source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData)); + ASSERT(destOffset + size <= mMemoryBuffer.size()); + memcpy(mMemoryBuffer.data() + destOffset, sourceData, size); + source->unmap(); return CopyResult::NOT_RECREATED; } @@ -1324,7 +1383,7 @@ gl::Error Buffer11::PackStorage::packPixels(const gl::FramebufferAttachment &rea unsigned int srcSubresource = renderTarget->getSubresourceIndex(); TextureHelper11 srcTexture = - TextureHelper11::MakeAndReference(renderTargetResource, renderTarget->getANGLEFormat()); + TextureHelper11::MakeAndReference(renderTargetResource, renderTarget->getFormatSet()); mQueuedPackCommand.reset(new PackPixelsParams(params)); @@ -1333,7 +1392,7 @@ gl::Error Buffer11::PackStorage::packPixels(const gl::FramebufferAttachment &rea mStagingTexture.getExtents() != srcTextureSize) { ANGLE_TRY_RESULT( - CreateStagingTexture(srcTexture.getTextureType(), srcTexture.getANGLEFormat(), + CreateStagingTexture(srcTexture.getTextureType(), srcTexture.getFormatSet(), srcTextureSize, StagingAccess::READ, mRenderer->getDevice()), mStagingTexture); } @@ -1377,6 +1436,8 @@ gl::Error Buffer11::PackStorage::flushQueuedPackCommand() return gl::NoError(); } +// Buffer11::SystemMemoryStorage implementation + Buffer11::SystemMemoryStorage::SystemMemoryStorage(Renderer11 *renderer) : Buffer11::BufferStorage(renderer, BUFFER_USAGE_SYSTEM_MEMORY) { @@ -1387,7 +1448,7 @@ gl::ErrorOrResult<CopyResult> Buffer11::SystemMemoryStorage::copyFromStorage(Buf size_t size, size_t destOffset) { - ASSERT(source->isMappable()); + ASSERT(source->isMappable(GL_MAP_READ_BIT)); uint8_t *sourceData = nullptr; ANGLE_TRY(source->map(sourceOffset, size, GL_MAP_READ_BIT, &sourceData)); ASSERT(destOffset + size <= mSystemCopy.size()); diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h index 6d56501d86d..dcf9a03732e 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Buffer11.h @@ -9,6 +9,7 @@ #ifndef LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_ #define LIBANGLE_RENDERER_D3D_D3D11_BUFFER11_H_ +#include <array> #include <map> #include "libANGLE/angletypes.h" @@ -68,8 +69,8 @@ class Buffer11 : public BufferD3D void invalidateStaticData() override; // BufferImpl implementation - gl::Error setData(const void *data, size_t size, GLenum usage) override; - gl::Error setSubData(const void *data, size_t size, size_t offset) override; + gl::Error setData(GLenum target, const void *data, size_t size, GLenum usage) override; + gl::Error setSubData(GLenum target, const void *data, size_t size, size_t offset) override; gl::Error copySubData(BufferImpl *source, GLintptr sourceOffset, GLintptr destOffset, @@ -100,7 +101,7 @@ class Buffer11 : public BufferD3D unsigned int lruCount; }; - gl::Error markBufferUsage(); + gl::Error markBufferUsage(BufferUsage usage); gl::ErrorOrResult<NativeStorage *> getStagingStorage(); gl::ErrorOrResult<PackStorage *> getPackStorage(); gl::ErrorOrResult<SystemMemoryStorage *> getSystemMemoryStorage(); @@ -113,14 +114,21 @@ class Buffer11 : public BufferD3D GLsizeiptr size); BufferStorage *allocateStorage(BufferUsage usage); - void updateSystemMemoryDeallocThreshold(); + void updateDeallocThreshold(BufferUsage usage); + + // Free the storage if we decide it isn't being used very often. + gl::Error checkForDeallocation(BufferUsage usage); Renderer11 *mRenderer; size_t mSize; BufferStorage *mMappedStorage; - std::vector<BufferStorage *> mBufferStorages; + std::array<BufferStorage *, BUFFER_USAGE_COUNT> mBufferStorages; + + // These two arrays are used to track when to free unused storage. + std::array<unsigned int, BUFFER_USAGE_COUNT> mDeallocThresholds; + std::array<unsigned int, BUFFER_USAGE_COUNT> mIdleness; // Cache of D3D11 constant buffer for specific ranges of buffer data. // This is used to emulate UBO ranges on 11.0 devices. @@ -130,12 +138,6 @@ class Buffer11 : public BufferD3D size_t mConstantBufferStorageAdditionalSize; unsigned int mMaxConstantBufferLruCount; - typedef std::pair<ID3D11Buffer *, ID3D11ShaderResourceView *> BufferSRVPair; - std::map<DXGI_FORMAT, BufferSRVPair> mBufferResourceViews; - - unsigned int mReadUsageCount; - unsigned int mSystemMemoryDeallocThreshold; - angle::BroadcastChannel mStaticBroadcastChannel; angle::BroadcastChannel mDirectBroadcastChannel; }; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp index 369797ac5f5..7cf003a4841 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Clear11.cpp @@ -281,17 +281,18 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, return error; } - const gl::InternalFormat &formatInfo = gl::GetInternalFormatInfo(attachment.getInternalFormat()); + const gl::InternalFormat &formatInfo = *attachment.getFormat().info; if (clearParams.colorClearType == GL_FLOAT && - !(formatInfo.componentType == GL_FLOAT || formatInfo.componentType == GL_UNSIGNED_NORMALIZED || formatInfo.componentType == GL_SIGNED_NORMALIZED)) + !(formatInfo.componentType == GL_FLOAT || + formatInfo.componentType == GL_UNSIGNED_NORMALIZED || + formatInfo.componentType == GL_SIGNED_NORMALIZED)) { - ERR( - "It is undefined behaviour to clear a render buffer which is not normalized " + ERR("It is undefined behaviour to clear a render buffer which is not normalized " "fixed point or floating-" "point to floating point values (color attachment %u has internal format " "0x%X).", - colorAttachmentIndex, attachment.getInternalFormat()); + colorAttachmentIndex, attachment.getFormat().asSized()); } if ((formatInfo.redBits == 0 || !clearParams.colorMaskRed) && @@ -302,10 +303,12 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, // Every channel either does not exist in the render target or is masked out continue; } - else if ((!(mRenderer->getRenderer11DeviceCaps().supportsClearView) && needScissoredClear) || clearParams.colorClearType != GL_FLOAT || - (formatInfo.redBits > 0 && !clearParams.colorMaskRed) || + else if ((!(mRenderer->getRenderer11DeviceCaps().supportsClearView) && + needScissoredClear) || + clearParams.colorClearType != GL_FLOAT || + (formatInfo.redBits > 0 && !clearParams.colorMaskRed) || (formatInfo.greenBits > 0 && !clearParams.colorMaskGreen) || - (formatInfo.blueBits > 0 && !clearParams.colorMaskBlue) || + (formatInfo.blueBits > 0 && !clearParams.colorMaskBlue) || (formatInfo.alphaBits > 0 && !clearParams.colorMaskAlpha)) { // A masked clear is required, or a scissored clear is required and ID3D11DeviceContext1::ClearView is unavailable @@ -328,20 +331,26 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, return gl::Error(GL_OUT_OF_MEMORY, "Internal render target view pointer unexpectedly null."); } - const auto &dxgiFormatInfo = d3d11::GetDXGIFormatInfo( - d3d11::GetANGLEFormatSet(renderTarget->getANGLEFormat()).rtvFormat); + const auto &nativeFormat = renderTarget->getFormatSet().format; // Check if the actual format has a channel that the internal format does not and set them to the // default values - float clearValues[4] = - { - ((formatInfo.redBits == 0 && dxgiFormatInfo.redBits > 0) ? 0.0f : clearParams.colorFClearValue.red), - ((formatInfo.greenBits == 0 && dxgiFormatInfo.greenBits > 0) ? 0.0f : clearParams.colorFClearValue.green), - ((formatInfo.blueBits == 0 && dxgiFormatInfo.blueBits > 0) ? 0.0f : clearParams.colorFClearValue.blue), - ((formatInfo.alphaBits == 0 && dxgiFormatInfo.alphaBits > 0) ? 1.0f : clearParams.colorFClearValue.alpha), + float clearValues[4] = { + ((formatInfo.redBits == 0 && nativeFormat.redBits > 0) + ? 0.0f + : clearParams.colorFClearValue.red), + ((formatInfo.greenBits == 0 && nativeFormat.greenBits > 0) + ? 0.0f + : clearParams.colorFClearValue.green), + ((formatInfo.blueBits == 0 && nativeFormat.blueBits > 0) + ? 0.0f + : clearParams.colorFClearValue.blue), + ((formatInfo.alphaBits == 0 && nativeFormat.alphaBits > 0) + ? 1.0f + : clearParams.colorFClearValue.alpha), }; - if (dxgiFormatInfo.alphaBits == 1) + if (formatInfo.alphaBits == 1) { // Some drivers do not correctly handle calling Clear() on a format with 1-bit alpha. // They can incorrectly round all non-zero values up to 1.0f. Note that WARP does not do this. @@ -382,10 +391,10 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, return error; } - const auto &dxgiFormatInfo = d3d11::GetDXGIFormatInfo( - d3d11::GetANGLEFormatSet(renderTarget->getANGLEFormat()).dsvFormat); + const auto &nativeFormat = renderTarget->getFormatSet().format; - unsigned int stencilUnmasked = (stencilAttachment != nullptr) ? (1 << dxgiFormatInfo.stencilBits) - 1 : 0; + unsigned int stencilUnmasked = + (stencilAttachment != nullptr) ? (1 << nativeFormat.stencilBits) - 1 : 0; bool needMaskedStencilClear = clearParams.clearStencil && (clearParams.stencilWriteMask & stencilUnmasked) != stencilUnmasked; if (needScissoredClear || needMaskedStencilClear) @@ -409,129 +418,139 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams, } } - if (maskedClearRenderTargets.size() > 0 || maskedClearDepthStencil) + if (maskedClearRenderTargets.empty() && !maskedClearDepthStencil) { - // To clear the render targets and depth stencil in one pass: - // - // Render a quad clipped to the scissor rectangle which draws the clear color and a blend - // state that will perform the required color masking. - // - // The quad's depth is equal to the depth clear value with a depth stencil state that - // will enable or disable depth test/writes if the depth buffer should be cleared or not. - // - // The rasterizer state's stencil is set to always pass or fail based on if the stencil - // should be cleared or not with a stencil write mask of the stencil clear value. - // - // ====================================================================================== - // - // Luckily, the gl spec (ES 3.0.2 pg 183) states that the results of clearing a render- - // buffer that is not normalized fixed point or floating point with floating point values - // are undefined so we can just write floats to them and D3D11 will bit cast them to - // integers. - // - // Also, we don't have to worry about attempting to clear a normalized fixed/floating point - // buffer with integer values because there is no gl API call which would allow it, - // glClearBuffer* calls only clear a single renderbuffer at a time which is verified to - // be a compatible clear type. - - // Bind all the render targets which need clearing - ASSERT(maskedClearRenderTargets.size() <= mRenderer->getNativeCaps().maxDrawBuffers); - std::vector<ID3D11RenderTargetView*> rtvs(maskedClearRenderTargets.size()); - for (unsigned int i = 0; i < maskedClearRenderTargets.size(); i++) - { - RenderTarget11 *renderTarget = maskedClearRenderTargets[i].renderTarget; - ID3D11RenderTargetView *rtv = renderTarget->getRenderTargetView(); - if (!rtv) - { - return gl::Error(GL_OUT_OF_MEMORY, "Internal render target view pointer unexpectedly null."); - } + return gl::NoError(); + } - rtvs[i] = rtv; - } - ID3D11DepthStencilView *dsv = maskedClearDepthStencil ? maskedClearDepthStencil->getDepthStencilView() : nullptr; - - ID3D11BlendState *blendState = getBlendState(maskedClearRenderTargets); - const FLOAT blendFactors[4] = { 1.0f, 1.0f, 1.0f, 1.0f }; - const UINT sampleMask = 0xFFFFFFFF; - - ID3D11DepthStencilState *dsState = getDepthStencilState(clearParams); - const UINT stencilClear = clearParams.stencilClearValue & 0xFF; - - // Set the vertices - UINT vertexStride = 0; - const UINT startIdx = 0; - ClearShader *shader = nullptr; - D3D11_MAPPED_SUBRESOURCE mappedResource; - HRESULT result = deviceContext->Map(mVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); - if (FAILED(result)) + // To clear the render targets and depth stencil in one pass: + // + // Render a quad clipped to the scissor rectangle which draws the clear color and a blend + // state that will perform the required color masking. + // + // The quad's depth is equal to the depth clear value with a depth stencil state that + // will enable or disable depth test/writes if the depth buffer should be cleared or not. + // + // The rasterizer state's stencil is set to always pass or fail based on if the stencil + // should be cleared or not with a stencil write mask of the stencil clear value. + // + // ====================================================================================== + // + // Luckily, the gl spec (ES 3.0.2 pg 183) states that the results of clearing a render- + // buffer that is not normalized fixed point or floating point with floating point values + // are undefined so we can just write floats to them and D3D11 will bit cast them to + // integers. + // + // Also, we don't have to worry about attempting to clear a normalized fixed/floating point + // buffer with integer values because there is no gl API call which would allow it, + // glClearBuffer* calls only clear a single renderbuffer at a time which is verified to + // be a compatible clear type. + + // Bind all the render targets which need clearing + ASSERT(maskedClearRenderTargets.size() <= mRenderer->getNativeCaps().maxDrawBuffers); + std::vector<ID3D11RenderTargetView *> rtvs(maskedClearRenderTargets.size()); + for (unsigned int i = 0; i < maskedClearRenderTargets.size(); i++) + { + RenderTarget11 *renderTarget = maskedClearRenderTargets[i].renderTarget; + ID3D11RenderTargetView *rtv = renderTarget->getRenderTargetView(); + if (!rtv) { - return gl::Error(GL_OUT_OF_MEMORY, "Failed to map internal masked clear vertex buffer, HRESULT: 0x%X.", result); + return gl::Error(GL_OUT_OF_MEMORY, + "Internal render target view pointer unexpectedly null."); } - const gl::Rectangle *scissorPtr = clearParams.scissorEnabled ? &clearParams.scissor : nullptr; - switch (clearParams.colorClearType) - { - case GL_FLOAT: - ApplyVertices(framebufferSize, scissorPtr, clearParams.colorFClearValue, clearParams.depthClearValue, mappedResource.pData); + rtvs[i] = rtv; + } + ID3D11DepthStencilView *dsv = + maskedClearDepthStencil ? maskedClearDepthStencil->getDepthStencilView() : nullptr; + + ID3D11BlendState *blendState = getBlendState(maskedClearRenderTargets); + const FLOAT blendFactors[4] = {1.0f, 1.0f, 1.0f, 1.0f}; + const UINT sampleMask = 0xFFFFFFFF; + + ID3D11DepthStencilState *dsState = getDepthStencilState(clearParams); + const UINT stencilClear = clearParams.stencilClearValue & 0xFF; + + // Set the vertices + UINT vertexStride = 0; + const UINT startIdx = 0; + ClearShader *shader = nullptr; + D3D11_MAPPED_SUBRESOURCE mappedResource; + HRESULT result = + deviceContext->Map(mVertexBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); + if (FAILED(result)) + { + return gl::Error(GL_OUT_OF_MEMORY, + "Failed to map internal masked clear vertex buffer, HRESULT: 0x%X.", + result); + } + + const gl::Rectangle *scissorPtr = clearParams.scissorEnabled ? &clearParams.scissor : nullptr; + switch (clearParams.colorClearType) + { + case GL_FLOAT: + ApplyVertices(framebufferSize, scissorPtr, clearParams.colorFClearValue, + clearParams.depthClearValue, mappedResource.pData); vertexStride = sizeof(d3d11::PositionDepthColorVertex<float>); - shader = mFloatClearShader; + shader = mFloatClearShader; break; - case GL_UNSIGNED_INT: - ApplyVertices(framebufferSize, scissorPtr, clearParams.colorUIClearValue, clearParams.depthClearValue, mappedResource.pData); + case GL_UNSIGNED_INT: + ApplyVertices(framebufferSize, scissorPtr, clearParams.colorUIClearValue, + clearParams.depthClearValue, mappedResource.pData); vertexStride = sizeof(d3d11::PositionDepthColorVertex<unsigned int>); - shader = mUintClearShader; + shader = mUintClearShader; break; - case GL_INT: - ApplyVertices(framebufferSize, scissorPtr, clearParams.colorIClearValue, clearParams.depthClearValue, mappedResource.pData); + case GL_INT: + ApplyVertices(framebufferSize, scissorPtr, clearParams.colorIClearValue, + clearParams.depthClearValue, mappedResource.pData); vertexStride = sizeof(d3d11::PositionDepthColorVertex<int>); - shader = mIntClearShader; + shader = mIntClearShader; break; - default: + default: UNREACHABLE(); break; - } - - deviceContext->Unmap(mVertexBuffer, 0); - - // Set the viewport to be the same size as the framebuffer - D3D11_VIEWPORT viewport; - viewport.TopLeftX = 0; - viewport.TopLeftY = 0; - viewport.Width = static_cast<FLOAT>(framebufferSize.width); - viewport.Height = static_cast<FLOAT>(framebufferSize.height); - viewport.MinDepth = 0; - viewport.MaxDepth = 1; - deviceContext->RSSetViewports(1, &viewport); - - // Apply state - deviceContext->OMSetBlendState(blendState, blendFactors, sampleMask); - deviceContext->OMSetDepthStencilState(dsState, stencilClear); - deviceContext->RSSetState(mRasterizerState); - - // Apply shaders - deviceContext->IASetInputLayout(shader->inputLayout->resolve(device)); - deviceContext->VSSetShader(shader->vertexShader.resolve(device), nullptr, 0); - deviceContext->PSSetShader(shader->pixelShader.resolve(device), nullptr, 0); - deviceContext->GSSetShader(nullptr, nullptr, 0); - - // Apply vertex buffer - deviceContext->IASetVertexBuffers(0, 1, &mVertexBuffer, &vertexStride, &startIdx); - deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); - - // Apply render targets - mRenderer->getStateManager()->setOneTimeRenderTargets(rtvs, dsv); - - // Draw the clear quad - deviceContext->Draw(4, 0); - - // Clean up - mRenderer->markAllStateDirty(); } - return gl::Error(GL_NO_ERROR); + deviceContext->Unmap(mVertexBuffer, 0); + + // Set the viewport to be the same size as the framebuffer + D3D11_VIEWPORT viewport; + viewport.TopLeftX = 0; + viewport.TopLeftY = 0; + viewport.Width = static_cast<FLOAT>(framebufferSize.width); + viewport.Height = static_cast<FLOAT>(framebufferSize.height); + viewport.MinDepth = 0; + viewport.MaxDepth = 1; + deviceContext->RSSetViewports(1, &viewport); + + // Apply state + deviceContext->OMSetBlendState(blendState, blendFactors, sampleMask); + deviceContext->OMSetDepthStencilState(dsState, stencilClear); + deviceContext->RSSetState(mRasterizerState); + + // Apply shaders + deviceContext->IASetInputLayout(shader->inputLayout->resolve(device)); + deviceContext->VSSetShader(shader->vertexShader.resolve(device), nullptr, 0); + deviceContext->PSSetShader(shader->pixelShader.resolve(device), nullptr, 0); + deviceContext->GSSetShader(nullptr, nullptr, 0); + + // Apply vertex buffer + deviceContext->IASetVertexBuffers(0, 1, &mVertexBuffer, &vertexStride, &startIdx); + deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP); + + // Apply render targets + mRenderer->getStateManager()->setOneTimeRenderTargets(rtvs, dsv); + + // Draw the clear quad + deviceContext->Draw(4, 0); + + // Clean up + mRenderer->markAllStateDirty(); + + return gl::NoError(); } ID3D11BlendState *Clear11::getBlendState(const std::vector<MaskedRenderTarget>& rts) diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp index 5eb28e73473..4ebac601667 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.cpp @@ -16,12 +16,12 @@ #include "libANGLE/renderer/d3d/RenderbufferD3D.h" #include "libANGLE/renderer/d3d/SamplerD3D.h" #include "libANGLE/renderer/d3d/TextureD3D.h" -#include "libANGLE/renderer/d3d/TransformFeedbackD3D.h" #include "libANGLE/renderer/d3d/d3d11/Buffer11.h" #include "libANGLE/renderer/d3d/d3d11/Fence11.h" #include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h" #include "libANGLE/renderer/d3d/d3d11/Renderer11.h" #include "libANGLE/renderer/d3d/d3d11/StateManager11.h" +#include "libANGLE/renderer/d3d/d3d11/TransformFeedback11.h" #include "libANGLE/renderer/d3d/d3d11/VertexArray11.h" namespace rx @@ -55,7 +55,7 @@ CompilerImpl *Context11::createCompiler() ShaderImpl *Context11::createShader(const gl::ShaderState &data) { - return new ShaderD3D(data); + return new ShaderD3D(data, mRenderer->getWorkarounds()); } ProgramImpl *Context11::createProgram(const gl::ProgramState &data) @@ -121,9 +121,9 @@ FenceSyncImpl *Context11::createFenceSync() return new FenceSync11(mRenderer); } -TransformFeedbackImpl *Context11::createTransformFeedback() +TransformFeedbackImpl *Context11::createTransformFeedback(const gl::TransformFeedbackState &state) { - return new TransformFeedbackD3D(); + return new TransformFeedback11(state, mRenderer); } SamplerImpl *Context11::createSampler() @@ -189,24 +189,9 @@ gl::Error Context11::drawRangeElements(GLenum mode, return mRenderer->genericDrawElements(this, mode, count, type, indices, 0, indexRange); } -void Context11::notifyDeviceLost() +GLenum Context11::getResetStatus() { - mRenderer->notifyDeviceLost(); -} - -bool Context11::isDeviceLost() const -{ - return mRenderer->isDeviceLost(); -} - -bool Context11::testDeviceLost() -{ - return mRenderer->testDeviceLost(); -} - -bool Context11::testDeviceResettable() -{ - return mRenderer->testDeviceResettable(); + return mRenderer->getResetStatus(); } std::string Context11::getVendorString() const diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h index 2f422601025..debf2f9be44 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Context11.h @@ -50,7 +50,8 @@ class Context11 : public ContextImpl FenceSyncImpl *createFenceSync() override; // Transform Feedback creation - TransformFeedbackImpl *createTransformFeedback() override; + TransformFeedbackImpl *createTransformFeedback( + const gl::TransformFeedbackState &state) override; // Sampler object creation SamplerImpl *createSampler() override; @@ -88,11 +89,8 @@ class Context11 : public ContextImpl const GLvoid *indices, const gl::IndexRange &indexRange) override; - // TODO(jmadill): Investigate proper impl methods for this. - void notifyDeviceLost() override; - bool isDeviceLost() const override; - bool testDeviceLost() override; - bool testDeviceResettable() override; + // Device loss + GLenum getResetStatus() override; // Vendor and description strings. std::string getVendorString() const override; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp index f9d28e84082..93343f281f3 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/DebugAnnotator11.cpp @@ -68,7 +68,7 @@ void DebugAnnotator11::setMarker(const wchar_t *markerName) bool DebugAnnotator11::getStatus() { #if defined(ANGLE_ENABLE_WINDOWS_STORE) -#if (NTDDI_VERSION == NTDDI_WIN10) + static_assert(NTDDI_VERSION >= NTDDI_WIN10, "GetStatus only works on Win10 and above"); initializeDevice(); if (mUserDefinedAnnotation != nullptr) @@ -77,38 +77,6 @@ bool DebugAnnotator11::getStatus() } return true; // Default if initializeDevice() failed -#elif defined(_DEBUG) - static bool underCapture = true; - - // ID3DUserDefinedAnnotation::GetStatus doesn't work with the Graphics Diagnostics tools in - // Windows 8.1/Visual Studio 2013. We can use IDXGraphicsAnalysis, though. - // The call to GetDebugInterface1 only succeeds if the app is under capture. - // This should only be called in DEBUG mode. - // If an app links against DXGIGetDebugInterface1 in release mode then it will fail Windows - // Store ingestion checks. - - // Cache the result to reduce the number of calls to DXGIGetDebugInterface1 - static bool triedIDXGraphicsAnalysis = false; - - if (!triedIDXGraphicsAnalysis) - { - IDXGraphicsAnalysis *graphicsAnalysis = nullptr; - - HRESULT result = DXGIGetDebugInterface1(0, IID_PPV_ARGS(&graphicsAnalysis)); - if (SUCCEEDED(result)) - { - underCapture = (graphicsAnalysis != nullptr); - } - - SafeRelease(graphicsAnalysis); - triedIDXGraphicsAnalysis = true; - } - - return underCapture; -#else - // We can't detect GetStatus() on release WinRT 8.1 builds, so always return true. - return true; -#endif // (NTDDI_VERSION == NTDDI_WIN10) or _DEBUG #else // We can't detect GetStatus() on desktop ANGLE builds so always return true. return true; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp index 53fac65f2a8..fb3a183361c 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Fence11.cpp @@ -14,6 +14,8 @@ namespace rx { +static const int kDeviceLostCheckPeriod = 64; + // // Template helpers for set and test operations. // @@ -50,10 +52,6 @@ gl::Error FenceTestHelper(FenceClass *fence, bool flushCommandBuffer, GLboolean { return gl::Error(GL_OUT_OF_MEMORY, "Failed to get query data, result: 0x%X.", result); } - else if (fence->mRenderer->isDeviceLost()) - { - return gl::Error(GL_OUT_OF_MEMORY, "Device was lost while querying result of an event query."); - } ASSERT(result == S_OK || result == S_FALSE); *outFinished = ((result == S_OK) ? GL_TRUE : GL_FALSE); @@ -89,14 +87,23 @@ gl::Error FenceNV11::test(GLboolean *outFinished) gl::Error FenceNV11::finish() { GLboolean finished = GL_FALSE; + + int loopCount = 0; while (finished != GL_TRUE) { + loopCount++; gl::Error error = FenceTestHelper(this, true, &finished); if (error.isError()) { return error; } + if (loopCount % kDeviceLostCheckPeriod == 0 && mRenderer->testDeviceLost()) + { + return gl::Error(GL_OUT_OF_MEMORY, + "Device was lost while querying result of an event query."); + } + ScheduleYield(); } @@ -176,8 +183,10 @@ gl::Error FenceSync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *ou LONGLONG timeoutInSeconds = static_cast<LONGLONG>(timeout) * static_cast<LONGLONG>(1000000ll); LONGLONG endCounter = currentCounter.QuadPart + mCounterFrequency * timeoutInSeconds; + int loopCount = 0; while (currentCounter.QuadPart < endCounter && !result) { + loopCount++; ScheduleYield(); success = QueryPerformanceCounter(¤tCounter); UNUSED_ASSERTION_VARIABLE(success); @@ -189,6 +198,13 @@ gl::Error FenceSync11::clientWait(GLbitfield flags, GLuint64 timeout, GLenum *ou *outResult = GL_WAIT_FAILED; return error; } + + if ((loopCount % kDeviceLostCheckPeriod) == 0 && mRenderer->testDeviceLost()) + { + *outResult = GL_WAIT_FAILED; + return gl::Error(GL_OUT_OF_MEMORY, + "Device was lost while querying result of an event query."); + } } if (currentCounter.QuadPart >= endCounter) diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp index dee9488f75b..a70287ccb4a 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.cpp @@ -29,7 +29,7 @@ namespace rx namespace { -gl::Error InvalidateAttachmentSwizzles(const gl::FramebufferAttachment *attachment) +gl::Error MarkAttachmentsDirty(const gl::FramebufferAttachment *attachment) { if (attachment && attachment->type() == GL_TEXTURE) { @@ -45,7 +45,7 @@ gl::Error InvalidateAttachmentSwizzles(const gl::FramebufferAttachment *attachme TextureStorage11 *texStorage11 = GetAs<TextureStorage11>(texStorage); ASSERT(texStorage11); - texStorage11->invalidateSwizzleCacheLevel(attachment->mipLevel()); + texStorage11->markLevelDirty(attachment->mipLevel()); } } @@ -89,18 +89,18 @@ Framebuffer11::~Framebuffer11() { } -gl::Error Framebuffer11::invalidateSwizzles() const +gl::Error Framebuffer11::markAttachmentsDirty() const { for (const auto &colorAttachment : mState.getColorAttachments()) { if (colorAttachment.isAttached()) { - ANGLE_TRY(InvalidateAttachmentSwizzles(&colorAttachment)); + ANGLE_TRY(MarkAttachmentsDirty(&colorAttachment)); } } - ANGLE_TRY(InvalidateAttachmentSwizzles(mState.getDepthAttachment())); - ANGLE_TRY(InvalidateAttachmentSwizzles(mState.getStencilAttachment())); + ANGLE_TRY(MarkAttachmentsDirty(mState.getDepthAttachment())); + ANGLE_TRY(MarkAttachmentsDirty(mState.getStencilAttachment())); return gl::NoError(); } @@ -128,7 +128,7 @@ gl::Error Framebuffer11::clearImpl(ContextImpl *context, const ClearParameters & ANGLE_TRY(clearer->clearFramebuffer(clearParams, mState)); } - ANGLE_TRY(invalidateSwizzles()); + ANGLE_TRY(markAttachmentsDirty()); return gl::NoError(); } @@ -262,13 +262,6 @@ gl::Error Framebuffer11::readPixelsImpl(const gl::Rectangle &area, gl::Buffer *packBuffer = pack.pixelBuffer.get(); if (packBuffer != nullptr) { - if (pack.rowLength != 0 || pack.skipRows != 0 || pack.skipPixels != 0) - { - UNIMPLEMENTED(); - return gl::Error(GL_INVALID_OPERATION, - "Unimplemented pixel store parameters in readPixelsImpl"); - } - Buffer11 *packBufferStorage = GetImplAs<Buffer11>(packBuffer); PackPixelsParams packParams(area, format, type, static_cast<GLuint>(outputPitch), pack, reinterpret_cast<ptrdiff_t>(pixels)); @@ -358,14 +351,14 @@ gl::Error Framebuffer11::blitImpl(const gl::Rectangle &sourceArea, blitDepth, blitStencil)); } - ANGLE_TRY(invalidateSwizzles()); + ANGLE_TRY(markAttachmentsDirty()); return gl::NoError(); } GLenum Framebuffer11::getRenderTargetImplementationFormat(RenderTargetD3D *renderTarget) const { RenderTarget11 *renderTarget11 = GetAs<RenderTarget11>(renderTarget); - return d3d11::GetANGLEFormatSet(renderTarget11->getANGLEFormat()).glInternalFormat; + return renderTarget11->getFormatSet().format.fboImplementationInternalFormat; } void Framebuffer11::updateColorRenderTarget(size_t colorIndex) diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h index 813e0f32f51..b1683a20607 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Framebuffer11.h @@ -28,7 +28,7 @@ class Framebuffer11 : public FramebufferD3D, public angle::SignalReceiver gl::Error invalidateSub(size_t count, const GLenum *attachments, const gl::Rectangle &area) override; // Invalidate the cached swizzles of all bound texture attachments. - gl::Error invalidateSwizzles() const; + gl::Error markAttachmentsDirty() const; void syncState(const gl::Framebuffer::DirtyBits &dirtyBits) override; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp index bc698f33ea7..c1d4d413c19 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Image11.cpp @@ -67,8 +67,8 @@ gl::Error Image11::generateMipmap(Image11 *dest, const uint8_t *sourceData = reinterpret_cast<const uint8_t*>(srcMapped.pData); uint8_t *destData = reinterpret_cast<uint8_t*>(destMapped.pData); - auto mipGenerationFunction = d3d11::GetTextureFormatInfo(src->getInternalFormat(), rendererCaps) - .formatSet->mipGenerationFunction; + auto mipGenerationFunction = + d3d11::Format::Get(src->getInternalFormat(), rendererCaps).format.mipGenerationFunction; mipGenerationFunction(src->getWidth(), src->getHeight(), src->getDepth(), sourceData, srcMapped.RowPitch, srcMapped.DepthPitch, destData, destMapped.RowPitch, destMapped.DepthPitch); @@ -90,7 +90,7 @@ bool Image11::isDirty() const if (mDirty && !mStagingTexture && !mRecoverFromStorage) { const Renderer11DeviceCaps &deviceCaps = mRenderer->getRenderer11DeviceCaps(); - const auto &formatInfo = d3d11::GetTextureFormatInfo(mInternalFormat, deviceCaps); + const auto &formatInfo = d3d11::Format::Get(mInternalFormat, deviceCaps); if (formatInfo.dataInitializerFunction == nullptr) { return false; @@ -220,10 +220,10 @@ bool Image11::redefine(GLenum target, GLenum internalformat, const gl::Extents & mTarget = target; // compute the d3d format that will be used - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalformat, mRenderer->getRenderer11DeviceCaps()); - mDXGIFormat = formatInfo.formatSet->texFormat; - mRenderable = (formatInfo.formatSet->rtvFormat != DXGI_FORMAT_UNKNOWN); + const d3d11::Format &formatInfo = + d3d11::Format::Get(internalformat, mRenderer->getRenderer11DeviceCaps()); + mDXGIFormat = formatInfo.texFormat; + mRenderable = (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN); releaseStagingTexture(); mDirty = (formatInfo.dataInitializerFunction != NULL); @@ -257,20 +257,19 @@ gl::Error Image11::loadData(const gl::Box &area, formatInfo.computeRowPitch(type, area.width, unpack.alignment, unpack.rowLength), inputRowPitch); GLuint inputDepthPitch = 0; - ANGLE_TRY_RESULT(formatInfo.computeDepthPitch(type, area.width, area.height, unpack.alignment, - unpack.rowLength, unpack.imageHeight), + ANGLE_TRY_RESULT(formatInfo.computeDepthPitch(area.height, unpack.imageHeight, inputRowPitch), inputDepthPitch); GLuint inputSkipBytes = 0; ANGLE_TRY_RESULT( - formatInfo.computeSkipBytes(inputRowPitch, inputDepthPitch, unpack.skipImages, - unpack.skipRows, unpack.skipPixels, applySkipImages), + formatInfo.computeSkipBytes(inputRowPitch, inputDepthPitch, unpack, applySkipImages), inputSkipBytes); const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat); GLuint outputPixelSize = dxgiFormatInfo.pixelBytes; - const d3d11::TextureFormat &d3dFormatInfo = d3d11::GetTextureFormatInfo(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); - LoadImageFunction loadFunction = d3dFormatInfo.loadFunctions.at(type).loadFunction; + const d3d11::Format &d3dFormatInfo = + d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); + LoadImageFunction loadFunction = d3dFormatInfo.loadFunctions(type).loadFunction; D3D11_MAPPED_SUBRESOURCE mappedImage; gl::Error error = map(D3D11_MAP_WRITE, &mappedImage); @@ -295,9 +294,7 @@ gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input) GLsizei inputRowPitch = 0; ANGLE_TRY_RESULT(formatInfo.computeRowPitch(GL_UNSIGNED_BYTE, area.width, 1, 0), inputRowPitch); GLsizei inputDepthPitch = 0; - ANGLE_TRY_RESULT( - formatInfo.computeDepthPitch(GL_UNSIGNED_BYTE, area.width, area.height, 1, 0, 0), - inputDepthPitch); + ANGLE_TRY_RESULT(formatInfo.computeDepthPitch(area.height, 0, inputRowPitch), inputDepthPitch); const d3d11::DXGIFormatSize &dxgiFormatInfo = d3d11::GetDXGIFormatSizeInfo(mDXGIFormat); GLuint outputPixelSize = dxgiFormatInfo.pixelBytes; @@ -307,8 +304,9 @@ gl::Error Image11::loadCompressedData(const gl::Box &area, const void *input) ASSERT(area.x % outputBlockWidth == 0); ASSERT(area.y % outputBlockHeight == 0); - const d3d11::TextureFormat &d3dFormatInfo = d3d11::GetTextureFormatInfo(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); - LoadImageFunction loadFunction = d3dFormatInfo.loadFunctions.at(GL_UNSIGNED_BYTE).loadFunction; + const d3d11::Format &d3dFormatInfo = + d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); + LoadImageFunction loadFunction = d3dFormatInfo.loadFunctions(GL_UNSIGNED_BYTE).loadFunction; D3D11_MAPPED_SUBRESOURCE mappedImage; gl::Error error = map(D3D11_MAP_WRITE, &mappedImage); @@ -343,7 +341,7 @@ gl::Error Image11::copyFromTexStorage(const gl::ImageIndex &imageIndex, TextureS UINT subresourceIndex = storage11->getSubresourceIndex(imageIndex); TextureHelper11 textureHelper = - TextureHelper11::MakeAndReference(resource, storage11->getANGLEFormat()); + TextureHelper11::MakeAndReference(resource, storage11->getFormatSet()); gl::Box sourceBox(0, 0, 0, mWidth, mHeight, mDepth); return copyWithoutConversion(gl::Offset(), sourceBox, textureHelper, subresourceIndex); @@ -356,11 +354,11 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset, const gl::FramebufferAttachment *srcAttachment = sourceFBO->getReadColorbuffer(); ASSERT(srcAttachment); - GLenum sourceInternalFormat = srcAttachment->getInternalFormat(); + GLenum sourceInternalFormat = srcAttachment->getFormat().asSized(); const auto &d3d11Format = - d3d11::GetTextureFormatInfo(sourceInternalFormat, mRenderer->getRenderer11DeviceCaps()); + d3d11::Format::Get(sourceInternalFormat, mRenderer->getRenderer11DeviceCaps()); - if (d3d11Format.formatSet->texFormat == mDXGIFormat && sourceInternalFormat == mInternalFormat) + if (d3d11Format.texFormat == mDXGIFormat && sourceInternalFormat == mInternalFormat) { RenderTargetD3D *renderTarget = nullptr; gl::Error error = srcAttachment->getRenderTarget(&renderTarget); @@ -373,7 +371,7 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset, ASSERT(rt11->getTexture()); TextureHelper11 textureHelper = - TextureHelper11::MakeAndReference(rt11->getTexture(), rt11->getANGLEFormat()); + TextureHelper11::MakeAndReference(rt11->getTexture(), rt11->getFormatSet()); unsigned int sourceSubResource = rt11->getSubresourceIndex(); gl::Box sourceBox(sourceArea.x, sourceArea.y, 0, sourceArea.width, sourceArea.height, 1); @@ -399,9 +397,9 @@ gl::Error Image11::copyFromFramebuffer(const gl::Offset &destOffset, const gl::InternalFormat &destFormatInfo = gl::GetInternalFormatInfo(mInternalFormat); const auto &destD3D11Format = - d3d11::GetTextureFormatInfo(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); + d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); - auto loadFunction = destD3D11Format.loadFunctions.at(destFormatInfo.type); + auto loadFunction = destD3D11Format.loadFunctions(destFormatInfo.type); if (loadFunction.requiresConversion) { size_t bufferSize = destFormatInfo.pixelBytes * sourceArea.width * sourceArea.height; @@ -564,7 +562,8 @@ gl::Error Image11::createStagingTexture() desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; desc.MiscFlags = 0; - if (d3d11::GetTextureFormatInfo(mInternalFormat, mRenderer->getRenderer11DeviceCaps()).dataInitializerFunction != NULL) + if (d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()) + .dataInitializerFunction != NULL) { std::vector<D3D11_SUBRESOURCE_DATA> initialData; std::vector<std::vector<BYTE>> textureData; @@ -604,7 +603,8 @@ gl::Error Image11::createStagingTexture() desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ | D3D11_CPU_ACCESS_WRITE; desc.MiscFlags = 0; - if (d3d11::GetTextureFormatInfo(mInternalFormat, mRenderer->getRenderer11DeviceCaps()).dataInitializerFunction != NULL) + if (d3d11::Format::Get(mInternalFormat, mRenderer->getRenderer11DeviceCaps()) + .dataInitializerFunction != NULL) { std::vector<D3D11_SUBRESOURCE_DATA> initialData; std::vector<std::vector<BYTE>> textureData; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp index f73b8aa6122..e7ca56ef2b0 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp @@ -196,8 +196,9 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac GLenum unsizedFormat = gl::GetInternalFormatInfo(destinationFormat).format; GLenum sourceFormat = gl::GetSizedInternalFormat(unsizedFormat, sourcePixelsType); - const d3d11::TextureFormat &sourceFormatInfo = d3d11::GetTextureFormatInfo(sourceFormat, mRenderer->getRenderer11DeviceCaps()); - DXGI_FORMAT srvFormat = sourceFormatInfo.formatSet->srvFormat; + const d3d11::Format &sourceFormatInfo = + d3d11::Format::Get(sourceFormat, mRenderer->getRenderer11DeviceCaps()); + DXGI_FORMAT srvFormat = sourceFormatInfo.srvFormat; ASSERT(srvFormat != DXGI_FORMAT_UNKNOWN); Buffer11 *bufferStorage11 = GetAs<Buffer11>(sourceBuffer.getImplementation()); ID3D11ShaderResourceView *bufferSRV = nullptr; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp index 171cebf202b..6449c9e6a58 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp @@ -18,7 +18,9 @@ namespace rx { -static bool getTextureProperties(ID3D11Resource *resource, unsigned int *mipLevels, unsigned int *samples) +namespace +{ +bool GetTextureProperties(ID3D11Resource *resource, unsigned int *mipLevels, unsigned int *samples) { ID3D11Texture1D *texture1D = d3d11::DynamicCastComObject<ID3D11Texture1D>(resource); if (texture1D) @@ -62,7 +64,7 @@ static bool getTextureProperties(ID3D11Resource *resource, unsigned int *mipLeve return false; } -static unsigned int getRTVSubresourceIndex(ID3D11Resource *resource, ID3D11RenderTargetView *view) +unsigned int GetRTVSubresourceIndex(ID3D11Resource *resource, ID3D11RenderTargetView *view) { D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; view->GetDesc(&rtvDesc); @@ -72,58 +74,58 @@ static unsigned int getRTVSubresourceIndex(ID3D11Resource *resource, ID3D11Rende switch (rtvDesc.ViewDimension) { - case D3D11_RTV_DIMENSION_TEXTURE1D: - mipSlice = rtvDesc.Texture1D.MipSlice; - arraySlice = 0; - break; - - case D3D11_RTV_DIMENSION_TEXTURE1DARRAY: - mipSlice = rtvDesc.Texture1DArray.MipSlice; - arraySlice = rtvDesc.Texture1DArray.FirstArraySlice; - break; - - case D3D11_RTV_DIMENSION_TEXTURE2D: - mipSlice = rtvDesc.Texture2D.MipSlice; - arraySlice = 0; - break; - - case D3D11_RTV_DIMENSION_TEXTURE2DARRAY: - mipSlice = rtvDesc.Texture2DArray.MipSlice; - arraySlice = rtvDesc.Texture2DArray.FirstArraySlice; - break; - - case D3D11_RTV_DIMENSION_TEXTURE2DMS: - mipSlice = 0; - arraySlice = 0; - break; - - case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY: - mipSlice = 0; - arraySlice = rtvDesc.Texture2DMSArray.FirstArraySlice; - break; - - case D3D11_RTV_DIMENSION_TEXTURE3D: - mipSlice = rtvDesc.Texture3D.MipSlice; - arraySlice = 0; - break; - - case D3D11_RTV_DIMENSION_UNKNOWN: - case D3D11_RTV_DIMENSION_BUFFER: - UNIMPLEMENTED(); - break; - - default: - UNREACHABLE(); - break; + case D3D11_RTV_DIMENSION_TEXTURE1D: + mipSlice = rtvDesc.Texture1D.MipSlice; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_TEXTURE1DARRAY: + mipSlice = rtvDesc.Texture1DArray.MipSlice; + arraySlice = rtvDesc.Texture1DArray.FirstArraySlice; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2D: + mipSlice = rtvDesc.Texture2D.MipSlice; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2DARRAY: + mipSlice = rtvDesc.Texture2DArray.MipSlice; + arraySlice = rtvDesc.Texture2DArray.FirstArraySlice; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2DMS: + mipSlice = 0; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_TEXTURE2DMSARRAY: + mipSlice = 0; + arraySlice = rtvDesc.Texture2DMSArray.FirstArraySlice; + break; + + case D3D11_RTV_DIMENSION_TEXTURE3D: + mipSlice = rtvDesc.Texture3D.MipSlice; + arraySlice = 0; + break; + + case D3D11_RTV_DIMENSION_UNKNOWN: + case D3D11_RTV_DIMENSION_BUFFER: + UNIMPLEMENTED(); + break; + + default: + UNREACHABLE(); + break; } unsigned int mipLevels, samples; - getTextureProperties(resource, &mipLevels, &samples); + GetTextureProperties(resource, &mipLevels, &samples); return D3D11CalcSubresource(mipSlice, arraySlice, mipLevels); } -static unsigned int getDSVSubresourceIndex(ID3D11Resource *resource, ID3D11DepthStencilView *view) +unsigned int GetDSVSubresourceIndex(ID3D11Resource *resource, ID3D11DepthStencilView *view) { D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; view->GetDesc(&dsvDesc); @@ -133,52 +135,66 @@ static unsigned int getDSVSubresourceIndex(ID3D11Resource *resource, ID3D11Depth switch (dsvDesc.ViewDimension) { - case D3D11_DSV_DIMENSION_TEXTURE1D: - mipSlice = dsvDesc.Texture1D.MipSlice; - arraySlice = 0; - break; - - case D3D11_DSV_DIMENSION_TEXTURE1DARRAY: - mipSlice = dsvDesc.Texture1DArray.MipSlice; - arraySlice = dsvDesc.Texture1DArray.FirstArraySlice; - break; - - case D3D11_DSV_DIMENSION_TEXTURE2D: - mipSlice = dsvDesc.Texture2D.MipSlice; - arraySlice = 0; - break; - - case D3D11_DSV_DIMENSION_TEXTURE2DARRAY: - mipSlice = dsvDesc.Texture2DArray.MipSlice; - arraySlice = dsvDesc.Texture2DArray.FirstArraySlice; - break; - - case D3D11_DSV_DIMENSION_TEXTURE2DMS: - mipSlice = 0; - arraySlice = 0; - break; - - case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY: - mipSlice = 0; - arraySlice = dsvDesc.Texture2DMSArray.FirstArraySlice; - break; - - case D3D11_DSV_DIMENSION_UNKNOWN: - UNIMPLEMENTED(); - break; - - default: - UNREACHABLE(); - break; + case D3D11_DSV_DIMENSION_TEXTURE1D: + mipSlice = dsvDesc.Texture1D.MipSlice; + arraySlice = 0; + break; + + case D3D11_DSV_DIMENSION_TEXTURE1DARRAY: + mipSlice = dsvDesc.Texture1DArray.MipSlice; + arraySlice = dsvDesc.Texture1DArray.FirstArraySlice; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2D: + mipSlice = dsvDesc.Texture2D.MipSlice; + arraySlice = 0; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2DARRAY: + mipSlice = dsvDesc.Texture2DArray.MipSlice; + arraySlice = dsvDesc.Texture2DArray.FirstArraySlice; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2DMS: + mipSlice = 0; + arraySlice = 0; + break; + + case D3D11_DSV_DIMENSION_TEXTURE2DMSARRAY: + mipSlice = 0; + arraySlice = dsvDesc.Texture2DMSArray.FirstArraySlice; + break; + + case D3D11_DSV_DIMENSION_UNKNOWN: + UNIMPLEMENTED(); + break; + + default: + UNREACHABLE(); + break; } unsigned int mipLevels, samples; - getTextureProperties(resource, &mipLevels, &samples); + GetTextureProperties(resource, &mipLevels, &samples); return D3D11CalcSubresource(mipSlice, arraySlice, mipLevels); } -RenderTarget11::RenderTarget11(d3d11::ANGLEFormat angleFormat) : mANGLEFormat(angleFormat) +GLenum GetSurfaceRTFormat(bool depth, SwapChain11 *swapChain) +{ + return (depth ? swapChain->getDepthBufferInternalFormat() + : swapChain->getRenderTargetInternalFormat()); +} + +const d3d11::Format &GetSurfaceFormatSet(bool depth, SwapChain11 *swapChain, Renderer11 *renderer) +{ + return d3d11::Format::Get(GetSurfaceRTFormat(depth, swapChain), + renderer->getRenderer11DeviceCaps()); +} + +} // anonymous namespace + +RenderTarget11::RenderTarget11(const d3d11::Format &formatSet) : mFormatSet(formatSet) { } @@ -200,12 +216,12 @@ TextureRenderTarget11::TextureRenderTarget11(ID3D11RenderTargetView *rtv, ID3D11ShaderResourceView *srv, ID3D11ShaderResourceView *blitSRV, GLenum internalFormat, - d3d11::ANGLEFormat angleFormat, + const d3d11::Format &formatSet, GLsizei width, GLsizei height, GLsizei depth, GLsizei samples) - : RenderTarget11(angleFormat), + : RenderTarget11(formatSet), mWidth(width), mHeight(height), mDepth(depth), @@ -240,21 +256,21 @@ TextureRenderTarget11::TextureRenderTarget11(ID3D11RenderTargetView *rtv, if (mRenderTarget && mTexture) { - mSubresourceIndex = getRTVSubresourceIndex(mTexture, mRenderTarget); + mSubresourceIndex = GetRTVSubresourceIndex(mTexture, mRenderTarget); } - ASSERT(mANGLEFormat != d3d11::ANGLE_FORMAT_NONE || mWidth == 0 || mHeight == 0); + ASSERT(mFormatSet.format.id != angle::Format::ID::NONE || mWidth == 0 || mHeight == 0); } TextureRenderTarget11::TextureRenderTarget11(ID3D11DepthStencilView *dsv, ID3D11Resource *resource, ID3D11ShaderResourceView *srv, GLenum internalFormat, - d3d11::ANGLEFormat angleFormat, + const d3d11::Format &formatSet, GLsizei width, GLsizei height, GLsizei depth, GLsizei samples) - : RenderTarget11(angleFormat), + : RenderTarget11(formatSet), mWidth(width), mHeight(height), mDepth(depth), @@ -284,9 +300,9 @@ TextureRenderTarget11::TextureRenderTarget11(ID3D11DepthStencilView *dsv, if (mDepthStencil && mTexture) { - mSubresourceIndex = getDSVSubresourceIndex(mTexture, mDepthStencil); + mSubresourceIndex = GetDSVSubresourceIndex(mTexture, mDepthStencil); } - ASSERT(mANGLEFormat != d3d11::ANGLE_FORMAT_NONE || mWidth == 0 || mHeight == 0); + ASSERT(mFormatSet.format.id != angle::Format::ID::NONE || mWidth == 0 || mHeight == 0); } TextureRenderTarget11::~TextureRenderTarget11() @@ -356,16 +372,11 @@ unsigned int TextureRenderTarget11::getSubresourceIndex() const SurfaceRenderTarget11::SurfaceRenderTarget11(SwapChain11 *swapChain, Renderer11 *renderer, bool depth) - : RenderTarget11(d3d11::ANGLE_FORMAT_NONE), // format will be determined in constructor body + : RenderTarget11(GetSurfaceFormatSet(depth, swapChain, renderer)), mSwapChain(swapChain), - mRenderer(renderer), mDepth(depth) { ASSERT(mSwapChain); - - mANGLEFormat = d3d11::GetTextureFormatInfo(getInternalFormatInternal(), - mRenderer->getRenderer11DeviceCaps()) - .formatSet->format; } SurfaceRenderTarget11::~SurfaceRenderTarget11() @@ -389,12 +400,7 @@ GLsizei SurfaceRenderTarget11::getDepth() const GLenum SurfaceRenderTarget11::getInternalFormat() const { - return getInternalFormatInternal(); -} - -GLenum SurfaceRenderTarget11::getInternalFormatInternal() const -{ - return (mDepth ? mSwapChain->GetDepthBufferInternalFormat() : mSwapChain->GetRenderTargetInternalFormat()); + return GetSurfaceRTFormat(mDepth, mSwapChain); } GLsizei SurfaceRenderTarget11::getSamples() const @@ -435,4 +441,4 @@ unsigned int SurfaceRenderTarget11::getSubresourceIndex() const return 0; } -} +} // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h index 19c824b0485..4ee0de29203 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h @@ -23,7 +23,7 @@ class Renderer11; class RenderTarget11 : public RenderTargetD3D { public: - RenderTarget11(d3d11::ANGLEFormat angleFormat); + RenderTarget11(const d3d11::Format &formatSet); virtual ~RenderTarget11(); virtual ID3D11Resource *getTexture() const = 0; @@ -37,11 +37,11 @@ class RenderTarget11 : public RenderTargetD3D void signalDirty() override; angle::BroadcastChannel *getBroadcastChannel() { return &mBroadcastChannel; } - d3d11::ANGLEFormat getANGLEFormat() const { return mANGLEFormat; } + const d3d11::Format &getFormatSet() const { return mFormatSet; } protected: angle::BroadcastChannel mBroadcastChannel; - d3d11::ANGLEFormat mANGLEFormat; + const d3d11::Format &mFormatSet; }; class TextureRenderTarget11 : public RenderTarget11 @@ -53,7 +53,7 @@ class TextureRenderTarget11 : public RenderTarget11 ID3D11ShaderResourceView *srv, ID3D11ShaderResourceView *blitSRV, GLenum internalFormat, - d3d11::ANGLEFormat angleFormat, + const d3d11::Format &formatSet, GLsizei width, GLsizei height, GLsizei depth, @@ -62,7 +62,7 @@ class TextureRenderTarget11 : public RenderTarget11 ID3D11Resource *resource, ID3D11ShaderResourceView *srv, GLenum internalFormat, - d3d11::ANGLEFormat angleFormat, + const d3d11::Format &formatSet, GLsizei width, GLsizei height, GLsizei depth, @@ -122,12 +122,7 @@ class SurfaceRenderTarget11 : public RenderTarget11 unsigned int getSubresourceIndex() const override; private: - // The internal versions of the functions are needed so that they can be safely called - // from the constructor. - GLenum getInternalFormatInternal() const; - SwapChain11 *mSwapChain; - Renderer11 *mRenderer; bool mDepth; }; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp index 360b66bfffb..5e92a25b8c3 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp @@ -9,6 +9,7 @@ #include "libANGLE/renderer/d3d/d3d11/Renderer11.h" #include <EGL/eglext.h> +#include <iomanip> #include <sstream> #include <versionhelpers.h> @@ -23,6 +24,7 @@ #include "libANGLE/Program.h" #include "libANGLE/renderer/renderer_utils.h" #include "libANGLE/renderer/d3d/CompilerD3D.h" +#include "libANGLE/renderer/d3d/DisplayD3D.h" #include "libANGLE/renderer/d3d/d3d11/Blit11.h" #include "libANGLE/renderer/d3d/d3d11/Buffer11.h" #include "libANGLE/renderer/d3d/d3d11/Clear11.h" @@ -42,6 +44,7 @@ #include "libANGLE/renderer/d3d/d3d11/SwapChain11.h" #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" #include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h" +#include "libANGLE/renderer/d3d/d3d11/TransformFeedback11.h" #include "libANGLE/renderer/d3d/d3d11/Trim11.h" #include "libANGLE/renderer/d3d/d3d11/VertexArray11.h" #include "libANGLE/renderer/d3d/d3d11/VertexBuffer11.h" @@ -54,7 +57,6 @@ #include "libANGLE/renderer/d3d/ShaderD3D.h" #include "libANGLE/renderer/d3d/SurfaceD3D.h" #include "libANGLE/renderer/d3d/TextureD3D.h" -#include "libANGLE/renderer/d3d/TransformFeedbackD3D.h" #include "libANGLE/renderer/d3d/VertexDataManager.h" #include "libANGLE/State.h" #include "libANGLE/Surface.h" @@ -444,7 +446,7 @@ Renderer11::Renderer11(egl::Display *display) mAppliedGeometryShader = NULL; mAppliedPixelShader = NULL; - mAppliedNumXFBBindings = static_cast<size_t>(-1); + mAppliedTFObject = angle::DirtyPointer; ZeroMemory(&mAdapterDescription, sizeof(mAdapterDescription)); @@ -883,6 +885,18 @@ void Renderer11::populateRenderer11DeviceCaps() { HRESULT hr = S_OK; + LARGE_INTEGER version; + hr = mDxgiAdapter->CheckInterfaceSupport(__uuidof(IDXGIDevice), &version); + if (FAILED(hr)) + { + mRenderer11DeviceCaps.driverVersion.reset(); + ERR("Error querying driver version from DXGI Adapter."); + } + else + { + mRenderer11DeviceCaps.driverVersion = version; + } + if (mDeviceContext1) { D3D11_FEATURE_DATA_D3D11_OPTIONS d3d11Options; @@ -894,11 +908,19 @@ void Renderer11::populateRenderer11DeviceCaps() } } - hr = mDevice->CheckFormatSupport(DXGI_FORMAT_B5G6R5_UNORM, &(mRenderer11DeviceCaps.B5G6R5support)); - if (FAILED(hr)) + if (getWorkarounds().disableB5G6R5Support) { mRenderer11DeviceCaps.B5G6R5support = 0; } + else + { + hr = mDevice->CheckFormatSupport(DXGI_FORMAT_B5G6R5_UNORM, + &(mRenderer11DeviceCaps.B5G6R5support)); + if (FAILED(hr)) + { + mRenderer11DeviceCaps.B5G6R5support = 0; + } + } hr = mDevice->CheckFormatSupport(DXGI_FORMAT_B4G4R4A4_UNORM, &(mRenderer11DeviceCaps.B4G4R4A4support)); if (FAILED(hr)) @@ -974,6 +996,7 @@ egl::ConfigSet Renderer11::generateConfigs() gl::GetInternalFormatInfo(colorBufferInternalFormat); const gl::InternalFormat &depthStencilBufferFormatInfo = gl::GetInternalFormatInfo(depthStencilBufferInternalFormat); + const gl::Version &maxVersion = getMaxSupportedESVersion(); egl::Config config; config.renderTargetFormat = colorBufferInternalFormat; @@ -991,15 +1014,22 @@ egl::ConfigSet Renderer11::generateConfigs() config.colorBufferType = EGL_RGB_BUFFER; config.configCaveat = EGL_NONE; config.configID = static_cast<EGLint>(configs.size() + 1); - // Can only support a conformant ES2 with feature level greater than 10.0. - config.conformant = (mRenderer11DeviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0) - ? (EGL_OPENGL_ES2_BIT | EGL_OPENGL_ES3_BIT_KHR) - : 0; // PresentPathFast may not be conformant - if (mPresentPathFastEnabled) + config.conformant = 0; + if (!mPresentPathFastEnabled) { - config.conformant = 0; + // Can only support a conformant ES2 with feature level greater than 10.0. + if (mRenderer11DeviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0) + { + config.conformant |= EGL_OPENGL_ES2_BIT; + } + + // We can only support conformant ES3 on FL 10.1+ + if (maxVersion.major >= 3) + { + config.conformant |= EGL_OPENGL_ES3_BIT_KHR; + } } config.depthSize = depthStencilBufferFormatInfo.depthBits; @@ -1013,11 +1043,14 @@ egl::ConfigSet Renderer11::generateConfigs() config.nativeRenderable = EGL_FALSE; config.nativeVisualID = 0; config.nativeVisualType = EGL_NONE; - // Can't support ES3 at all without feature level 10.0 - config.renderableType = - EGL_OPENGL_ES2_BIT | ((mRenderer11DeviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0) - ? EGL_OPENGL_ES3_BIT_KHR - : 0); + + // Can't support ES3 at all without feature level 10.1 + config.renderableType = EGL_OPENGL_ES2_BIT; + if (maxVersion.major >= 3) + { + config.renderableType |= EGL_OPENGL_ES3_BIT_KHR; + } + config.sampleBuffers = 0; // FIXME: enumerate multi-sampling config.samples = 0; config.stencilSize = depthStencilBufferFormatInfo.stencilBits; @@ -1102,11 +1135,15 @@ gl::Error Renderer11::finish() } mDeviceContext->End(mSyncQuery); - mDeviceContext->Flush(); + unsigned int attempt = 0; do { - result = mDeviceContext->GetData(mSyncQuery, NULL, 0, D3D11_ASYNC_GETDATA_DONOTFLUSH); + unsigned int flushFrequency = 100; + UINT flags = (attempt % flushFrequency == 0) ? 0 : D3D11_ASYNC_GETDATA_DONOTFLUSH; + attempt++; + + result = mDeviceContext->GetData(mSyncQuery, NULL, 0, flags); if (FAILED(result)) { return gl::Error(GL_OUT_OF_MEMORY, "Failed to get event query data, result: 0x%X.", result); @@ -1359,61 +1396,48 @@ gl::Error Renderer11::setUniformBuffers(const gl::ContextState &data, GLintptr uniformBufferOffset = uniformBuffer.getOffset(); GLsizeiptr uniformBufferSize = uniformBuffer.getSize(); - if (uniformBuffer.get() != nullptr) + if (uniformBuffer.get() == nullptr) + { + continue; + } + + Buffer11 *bufferStorage = GetImplAs<Buffer11>(uniformBuffer.get()); + ID3D11Buffer *constantBuffer = nullptr; + + ANGLE_TRY_RESULT( + bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize), + constantBuffer); + + if (!constantBuffer) { - Buffer11 *bufferStorage = GetImplAs<Buffer11>(uniformBuffer.get()); - ID3D11Buffer *constantBuffer; + return gl::Error(GL_OUT_OF_MEMORY, "Error retrieving constant buffer"); + } - if (mRenderer11DeviceCaps.supportsConstantBufferOffsets) + if (mCurrentConstantBufferVS[uniformBufferIndex] != bufferStorage->getSerial() || + mCurrentConstantBufferVSOffset[uniformBufferIndex] != uniformBufferOffset || + mCurrentConstantBufferVSSize[uniformBufferIndex] != uniformBufferSize) + { + if (mRenderer11DeviceCaps.supportsConstantBufferOffsets && uniformBufferSize != 0) { - auto bufferOrError = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM); - if (bufferOrError.isError()) - { - return bufferOrError.getError(); - } - constantBuffer = bufferOrError.getResult(); + UINT firstConstant = 0, numConstants = 0; + CalculateConstantBufferParams(uniformBufferOffset, uniformBufferSize, + &firstConstant, &numConstants); + mDeviceContext1->VSSetConstantBuffers1( + getReservedVertexUniformBuffers() + + static_cast<unsigned int>(uniformBufferIndex), + 1, &constantBuffer, &firstConstant, &numConstants); } else { - auto bufferOrError = - bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize); - if (bufferOrError.isError()) - { - return bufferOrError.getError(); - } - constantBuffer = bufferOrError.getResult(); - } - - if (!constantBuffer) - { - return gl::Error(GL_OUT_OF_MEMORY); + mDeviceContext->VSSetConstantBuffers( + getReservedVertexUniformBuffers() + + static_cast<unsigned int>(uniformBufferIndex), + 1, &constantBuffer); } - if (mCurrentConstantBufferVS[uniformBufferIndex] != bufferStorage->getSerial() || - mCurrentConstantBufferVSOffset[uniformBufferIndex] != uniformBufferOffset || - mCurrentConstantBufferVSSize[uniformBufferIndex] != uniformBufferSize) - { - if (mRenderer11DeviceCaps.supportsConstantBufferOffsets && uniformBufferSize != 0) - { - UINT firstConstant = 0, numConstants = 0; - CalculateConstantBufferParams(uniformBufferOffset, uniformBufferSize, &firstConstant, &numConstants); - mDeviceContext1->VSSetConstantBuffers1( - getReservedVertexUniformBuffers() + - static_cast<unsigned int>(uniformBufferIndex), - 1, &constantBuffer, &firstConstant, &numConstants); - } - else - { - mDeviceContext->VSSetConstantBuffers( - getReservedVertexUniformBuffers() + - static_cast<unsigned int>(uniformBufferIndex), - 1, &constantBuffer); - } - - mCurrentConstantBufferVS[uniformBufferIndex] = bufferStorage->getSerial(); - mCurrentConstantBufferVSOffset[uniformBufferIndex] = uniformBufferOffset; - mCurrentConstantBufferVSSize[uniformBufferIndex] = uniformBufferSize; - } + mCurrentConstantBufferVS[uniformBufferIndex] = bufferStorage->getSerial(); + mCurrentConstantBufferVSOffset[uniformBufferIndex] = uniformBufferOffset; + mCurrentConstantBufferVSSize[uniformBufferIndex] = uniformBufferSize; } } @@ -1431,65 +1455,52 @@ gl::Error Renderer11::setUniformBuffers(const gl::ContextState &data, GLintptr uniformBufferOffset = uniformBuffer.getOffset(); GLsizeiptr uniformBufferSize = uniformBuffer.getSize(); - if (uniformBuffer.get() != nullptr) + if (uniformBuffer.get() == nullptr) + { + continue; + } + + Buffer11 *bufferStorage = GetImplAs<Buffer11>(uniformBuffer.get()); + ID3D11Buffer *constantBuffer = nullptr; + + ANGLE_TRY_RESULT( + bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize), + constantBuffer); + + if (!constantBuffer) { - Buffer11 *bufferStorage = GetImplAs<Buffer11>(uniformBuffer.get()); - ID3D11Buffer *constantBuffer; + return gl::Error(GL_OUT_OF_MEMORY, "Error retrieving constant buffer"); + } - if (mRenderer11DeviceCaps.supportsConstantBufferOffsets) + if (mCurrentConstantBufferPS[uniformBufferIndex] != bufferStorage->getSerial() || + mCurrentConstantBufferPSOffset[uniformBufferIndex] != uniformBufferOffset || + mCurrentConstantBufferPSSize[uniformBufferIndex] != uniformBufferSize) + { + if (mRenderer11DeviceCaps.supportsConstantBufferOffsets && uniformBufferSize != 0) { - auto bufferOrError = bufferStorage->getBuffer(BUFFER_USAGE_UNIFORM); - if (bufferOrError.isError()) - { - return bufferOrError.getError(); - } - constantBuffer = bufferOrError.getResult(); + UINT firstConstant = 0, numConstants = 0; + CalculateConstantBufferParams(uniformBufferOffset, uniformBufferSize, + &firstConstant, &numConstants); + mDeviceContext1->PSSetConstantBuffers1( + getReservedFragmentUniformBuffers() + + static_cast<unsigned int>(uniformBufferIndex), + 1, &constantBuffer, &firstConstant, &numConstants); } else { - auto bufferOrError = - bufferStorage->getConstantBufferRange(uniformBufferOffset, uniformBufferSize); - if (bufferOrError.isError()) - { - return bufferOrError.getError(); - } - constantBuffer = bufferOrError.getResult(); - } - - if (!constantBuffer) - { - return gl::Error(GL_OUT_OF_MEMORY); + mDeviceContext->PSSetConstantBuffers( + getReservedFragmentUniformBuffers() + + static_cast<unsigned int>(uniformBufferIndex), + 1, &constantBuffer); } - if (mCurrentConstantBufferPS[uniformBufferIndex] != bufferStorage->getSerial() || - mCurrentConstantBufferPSOffset[uniformBufferIndex] != uniformBufferOffset || - mCurrentConstantBufferPSSize[uniformBufferIndex] != uniformBufferSize) - { - if (mRenderer11DeviceCaps.supportsConstantBufferOffsets && uniformBufferSize != 0) - { - UINT firstConstant = 0, numConstants = 0; - CalculateConstantBufferParams(uniformBufferOffset, uniformBufferSize, &firstConstant, &numConstants); - mDeviceContext1->PSSetConstantBuffers1( - getReservedFragmentUniformBuffers() + - static_cast<unsigned int>(uniformBufferIndex), - 1, &constantBuffer, &firstConstant, &numConstants); - } - else - { - mDeviceContext->PSSetConstantBuffers( - getReservedFragmentUniformBuffers() + - static_cast<unsigned int>(uniformBufferIndex), - 1, &constantBuffer); - } - - mCurrentConstantBufferPS[uniformBufferIndex] = bufferStorage->getSerial(); - mCurrentConstantBufferPSOffset[uniformBufferIndex] = uniformBufferOffset; - mCurrentConstantBufferPSSize[uniformBufferIndex] = uniformBufferSize; - } + mCurrentConstantBufferPS[uniformBufferIndex] = bufferStorage->getSerial(); + mCurrentConstantBufferPSOffset[uniformBufferIndex] = uniformBufferOffset; + mCurrentConstantBufferPSSize[uniformBufferIndex] = uniformBufferSize; } } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error Renderer11::updateState(const gl::ContextState &data, GLenum drawMode) @@ -1668,76 +1679,40 @@ gl::Error Renderer11::applyIndexBuffer(const gl::ContextState &data, return gl::NoError(); } -gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::State &state) +gl::Error Renderer11::applyTransformFeedbackBuffers(const gl::ContextState &data) { - size_t numXFBBindings = 0; - bool requiresUpdate = false; + const auto &state = data.getState(); - if (state.isTransformFeedbackActiveUnpaused()) + // If transform feedback is not active, unbind all buffers + if (!state.isTransformFeedbackActiveUnpaused()) { - const gl::TransformFeedback *transformFeedback = state.getCurrentTransformFeedback(); - numXFBBindings = transformFeedback->getIndexedBufferCount(); - ASSERT(numXFBBindings <= gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS); - - for (size_t i = 0; i < numXFBBindings; i++) + if (mAppliedTFObject != 0) { - const OffsetBindingPointer<gl::Buffer> &binding = transformFeedback->getIndexedBuffer(i); - - ID3D11Buffer *d3dBuffer = nullptr; - if (binding.get() != nullptr) - { - Buffer11 *storage = GetImplAs<Buffer11>(binding.get()); - auto bufferOrError = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK); - if (bufferOrError.isError()) - { - return bufferOrError.getError(); - } - d3dBuffer = bufferOrError.getResult(); - } - - // TODO: mAppliedTFBuffers and friends should also be kept in a vector. - if (d3dBuffer != mAppliedTFBuffers[i] || binding.getOffset() != mAppliedTFOffsets[i]) - { - requiresUpdate = true; - } + mDeviceContext->SOSetTargets(0, nullptr, nullptr); + mAppliedTFObject = 0; } + return gl::NoError(); } - if (requiresUpdate || numXFBBindings != mAppliedNumXFBBindings) + gl::TransformFeedback *transformFeedback = state.getCurrentTransformFeedback(); + TransformFeedback11 *transformFeedback11 = GetImplAs<TransformFeedback11>(transformFeedback); + uintptr_t transformFeedbackId = reinterpret_cast<uintptr_t>(transformFeedback11); + if (mAppliedTFObject == transformFeedbackId && !transformFeedback11->isDirty()) { - const gl::TransformFeedback *transformFeedback = state.getCurrentTransformFeedback(); - for (size_t i = 0; i < numXFBBindings; ++i) - { - const OffsetBindingPointer<gl::Buffer> &binding = transformFeedback->getIndexedBuffer(i); - if (binding.get() != nullptr) - { - Buffer11 *storage = GetImplAs<Buffer11>(binding.get()); - auto bufferOrError = storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK); - if (bufferOrError.isError()) - { - return bufferOrError.getError(); - } - ID3D11Buffer *d3dBuffer = bufferOrError.getResult(); + return gl::NoError(); + } - mCurrentD3DOffsets[i] = (mAppliedTFBuffers[i] != d3dBuffer || mAppliedTFOffsets[i] != binding.getOffset()) ? - static_cast<UINT>(binding.getOffset()) : -1; - mAppliedTFBuffers[i] = d3dBuffer; - } - else - { - mAppliedTFBuffers[i] = nullptr; - mCurrentD3DOffsets[i] = 0; - } - mAppliedTFOffsets[i] = binding.getOffset(); - } + const std::vector<ID3D11Buffer *> *soBuffers = nullptr; + ANGLE_TRY_RESULT(transformFeedback11->getSOBuffers(), soBuffers); + const std::vector<UINT> &soOffsets = transformFeedback11->getSOBufferOffsets(); - mAppliedNumXFBBindings = numXFBBindings; + mDeviceContext->SOSetTargets(transformFeedback11->getNumSOBuffers(), soBuffers->data(), + soOffsets.data()); - mDeviceContext->SOSetTargets(static_cast<unsigned int>(numXFBBindings), mAppliedTFBuffers, - mCurrentD3DOffsets); - } + mAppliedTFObject = transformFeedbackId; + transformFeedback11->onApply(); - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error Renderer11::drawArraysImpl(const gl::ContextState &data, @@ -2397,7 +2372,7 @@ void Renderer11::SamplerMetadataD3D11::initData(unsigned int samplerCount) void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex, const gl::Texture &texture) { unsigned int baseLevel = texture.getTextureState().getEffectiveBaseLevel(); - GLenum internalFormat = texture.getInternalFormat(texture.getTarget(), baseLevel); + GLenum sizedFormat = texture.getFormat(texture.getTarget(), baseLevel).asSized(); if (mSamplerMetadata[samplerIndex].baseLevel != static_cast<int>(baseLevel)) { mSamplerMetadata[samplerIndex].baseLevel = static_cast<int>(baseLevel); @@ -2410,7 +2385,7 @@ void Renderer11::SamplerMetadataD3D11::update(unsigned int samplerIndex, const g bool needIntegerTextureMetadata = false; // internalFormatBits == 0 means a 32-bit texture in the case of integer textures. int internalFormatBits = 0; - switch (internalFormat) + switch (sizedFormat) { case GL_RGBA32I: case GL_RGBA32UI: @@ -2549,13 +2524,7 @@ void Renderer11::markAllStateDirty() mAppliedGeometryShader = angle::DirtyPointer; mAppliedPixelShader = angle::DirtyPointer; - mAppliedNumXFBBindings = static_cast<size_t>(-1); - - for (size_t i = 0; i < gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS; i++) - { - mAppliedTFBuffers[i] = NULL; - mAppliedTFOffsets[i] = 0; - } + mAppliedTFObject = angle::DirtyPointer; memset(&mAppliedVertexConstants, 0, sizeof(dx_VertexConstants11)); memset(&mAppliedPixelConstants, 0, sizeof(dx_PixelConstants11)); @@ -2604,24 +2573,18 @@ bool Renderer11::testDeviceLost() { bool isLost = false; + if (!mDevice) + { + return true; + } + // GetRemovedReason is used to test if the device is removed HRESULT result = mDevice->GetDeviceRemovedReason(); isLost = d3d11::isDeviceLostError(result); if (isLost) { - // Log error if this is a new device lost event - if (mDeviceLost == false) - { - ERR("The D3D11 device was removed: 0x%08X", result); - } - - // ensure we note the device loss -- - // we'll probably get this done again by notifyDeviceLost - // but best to remember it! - // Note that we don't want to clear the device loss status here - // -- this needs to be done by resetDevice - mDeviceLost = true; + ERR("The D3D11 device was removed: 0x%08X", result); } return isLost; @@ -2734,8 +2697,6 @@ bool Renderer11::resetDevice() return false; } - mDeviceLost = false; - return true; } @@ -2975,7 +2936,7 @@ gl::Error Renderer11::copyImageInternal(const gl::Framebuffer *framebuffer, // Convert to the unsized format before calling copyTexture. const gl::InternalFormat &internalFormat = gl::GetInternalFormatInfo(destFormat); ANGLE_TRY(mBlit->copyTexture(source, sourceArea, sourceSize, dest, destArea, destSize, nullptr, - internalFormat.format, GL_NEAREST, false)); + internalFormat.format, GL_NEAREST, false, false, false)); return gl::NoError(); } @@ -2997,7 +2958,7 @@ gl::Error Renderer11::copyImage2D(const gl::Framebuffer *framebuffer, ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget)); - storage11->invalidateSwizzleCacheLevel(level); + storage11->markLevelDirty(level); return gl::NoError(); } @@ -3015,7 +2976,7 @@ gl::Error Renderer11::copyImageCube(const gl::Framebuffer *framebuffer, const gl ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget)); - storage11->invalidateSwizzleCacheLevel(level); + storage11->markLevelDirty(level); return gl::NoError(); } @@ -3033,7 +2994,7 @@ gl::Error Renderer11::copyImage3D(const gl::Framebuffer *framebuffer, const gl:: ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget)); - storage11->invalidateSwizzleCacheLevel(level); + storage11->markLevelDirty(level); return gl::NoError(); } @@ -3050,15 +3011,104 @@ gl::Error Renderer11::copyImage2DArray(const gl::Framebuffer *framebuffer, const ASSERT(destRenderTarget); ANGLE_TRY(copyImageInternal(framebuffer, sourceRect, destFormat, destOffset, destRenderTarget)); + storage11->markLevelDirty(level); + + return gl::NoError(); +} + +gl::Error Renderer11::copyTexture(const gl::Texture *source, + GLint sourceLevel, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint destLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) +{ + const TextureD3D *sourceD3D = GetImplAs<TextureD3D>(source); + + TextureStorage *sourceStorage = nullptr; + ANGLE_TRY(const_cast<TextureD3D *>(sourceD3D)->getNativeTexture(&sourceStorage)); + + TextureStorage11_2D *sourceStorage11 = GetAs<TextureStorage11_2D>(sourceStorage); + ASSERT(sourceStorage11); + + TextureStorage11_2D *destStorage11 = GetAs<TextureStorage11_2D>(storage); + ASSERT(destStorage11); + + // Check for fast path where a CopySubresourceRegion can be used. + if (unpackPremultiplyAlpha == unpackUnmultiplyAlpha && !unpackFlipY && + sourceStorage11->getFormatSet().texFormat == destStorage11->getFormatSet().texFormat) + { + ID3D11Resource *sourceResource = nullptr; + ANGLE_TRY(sourceStorage11->getResource(&sourceResource)); + + gl::ImageIndex sourceIndex = gl::ImageIndex::Make2D(sourceLevel); + UINT sourceSubresource = sourceStorage11->getSubresourceIndex(sourceIndex); - storage11->invalidateSwizzleCacheLevel(level); + ID3D11Resource *destResource = nullptr; + ANGLE_TRY(destStorage11->getResource(&destResource)); + + gl::ImageIndex destIndex = gl::ImageIndex::Make2D(destLevel); + UINT destSubresource = destStorage11->getSubresourceIndex(destIndex); + + D3D11_BOX sourceBox{ + static_cast<UINT>(sourceRect.x), + static_cast<UINT>(sourceRect.y), + 0u, + static_cast<UINT>(sourceRect.x + sourceRect.width), + static_cast<UINT>(sourceRect.y + sourceRect.height), + 1u, + }; + + mDeviceContext->CopySubresourceRegion(destResource, destSubresource, destOffset.x, + destOffset.y, destOffset.z, sourceResource, + sourceSubresource, &sourceBox); + } + else + { + ID3D11ShaderResourceView *sourceSRV = nullptr; + ANGLE_TRY(sourceStorage11->getSRVLevels(sourceLevel, sourceLevel, &sourceSRV)); + + gl::ImageIndex destIndex = gl::ImageIndex::Make2D(destLevel); + RenderTargetD3D *destRenderTargetD3D = nullptr; + ANGLE_TRY(destStorage11->getRenderTarget(destIndex, &destRenderTargetD3D)); + + RenderTarget11 *destRenderTarget11 = GetAs<RenderTarget11>(destRenderTargetD3D); + + ID3D11RenderTargetView *destRTV = destRenderTarget11->getRenderTargetView(); + ASSERT(destRTV); + + gl::Box sourceArea(sourceRect.x, sourceRect.y, 0, sourceRect.width, sourceRect.height, 1); + gl::Extents sourceSize( + static_cast<int>(source->getWidth(source->getTarget(), sourceLevel)), + static_cast<int>(source->getHeight(source->getTarget(), sourceLevel)), 1); + if (unpackFlipY) + { + sourceArea.y = sourceSize.height - sourceRect.y; + sourceArea.height = -sourceArea.height; + } + + gl::Box destArea(destOffset.x, destOffset.y, 0, sourceRect.width, sourceRect.height, 1); + gl::Extents destSize(destRenderTarget11->getWidth(), destRenderTarget11->getHeight(), 1); + + // Use nearest filtering because source and destination are the same size for the direct + // copy + ANGLE_TRY(mBlit->copyTexture(sourceSRV, sourceArea, sourceSize, destRTV, destArea, destSize, + nullptr, destFormat, GL_NEAREST, false, unpackPremultiplyAlpha, + unpackUnmultiplyAlpha)); + } + + destStorage11->markLevelDirty(destLevel); return gl::NoError(); } gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, GLsizei samples, RenderTargetD3D **outRT) { - const d3d11::TextureFormat &formatInfo = d3d11::GetTextureFormatInfo(format, mRenderer11DeviceCaps); + const d3d11::Format &formatInfo = d3d11::Format::Get(format, mRenderer11DeviceCaps); const gl::TextureCaps &textureCaps = getNativeTextureCaps().get(format); GLuint supportedSamples = textureCaps.getNearestSamples(samples); @@ -3071,7 +3121,7 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G desc.Height = height; desc.MipLevels = 1; desc.ArraySize = 1; - desc.Format = formatInfo.formatSet->texFormat; + desc.Format = formatInfo.texFormat; desc.SampleDesc.Count = (supportedSamples == 0) ? 1 : supportedSamples; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -3082,19 +3132,22 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G // we'll flag it to allow binding that way. Shader resource views are a little // more complicated. bool bindRTV = false, bindDSV = false, bindSRV = false; - bindRTV = (formatInfo.formatSet->rtvFormat != DXGI_FORMAT_UNKNOWN); - bindDSV = (formatInfo.formatSet->dsvFormat != DXGI_FORMAT_UNKNOWN); - if (formatInfo.formatSet->srvFormat != DXGI_FORMAT_UNKNOWN) + bindRTV = (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN); + bindDSV = (formatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN); + bindSRV = (formatInfo.srvFormat != DXGI_FORMAT_UNKNOWN); + + // D3D feature level 10.0 no longer allows creation of textures with both the bind SRV and + // DSV flags when multisampled. crbug.com/656989 + bool supportsMultisampledDepthStencilSRVs = + mRenderer11DeviceCaps.featureLevel > D3D_FEATURE_LEVEL_10_0; + bool isMultisampledDepthStencil = bindDSV && desc.SampleDesc.Count > 1; + if (isMultisampledDepthStencil && !supportsMultisampledDepthStencilSRVs) { - // Multisample targets flagged for binding as depth stencil cannot also be - // flagged for binding as SRV, so make certain not to add the SRV flag for - // these targets. - bindSRV = !(formatInfo.formatSet->dsvFormat != DXGI_FORMAT_UNKNOWN && - desc.SampleDesc.Count > 1); + bindSRV = false; } - desc.BindFlags = (bindRTV ? D3D11_BIND_RENDER_TARGET : 0) | - (bindDSV ? D3D11_BIND_DEPTH_STENCIL : 0) | + desc.BindFlags = (bindRTV ? D3D11_BIND_RENDER_TARGET : 0) | + (bindDSV ? D3D11_BIND_DEPTH_STENCIL : 0) | (bindSRV ? D3D11_BIND_SHADER_RESOURCE : 0); // The format must be either an RTV or a DSV @@ -3113,7 +3166,7 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G if (bindSRV) { D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; - srvDesc.Format = formatInfo.formatSet->srvFormat; + srvDesc.Format = formatInfo.srvFormat; srvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_SRV_DIMENSION_TEXTURE2D : D3D11_SRV_DIMENSION_TEXTURE2DMS; srvDesc.Texture2D.MostDetailedMip = 0; srvDesc.Texture2D.MipLevels = 1; @@ -3126,10 +3179,10 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G return gl::Error(GL_OUT_OF_MEMORY, "Failed to create render target shader resource view, result: 0x%X.", result); } - if (formatInfo.formatSet->blitSRVFormat != formatInfo.formatSet->srvFormat) + if (formatInfo.blitSRVFormat != formatInfo.srvFormat) { D3D11_SHADER_RESOURCE_VIEW_DESC blitSRVDesc; - blitSRVDesc.Format = formatInfo.formatSet->blitSRVFormat; + blitSRVDesc.Format = formatInfo.blitSRVFormat; blitSRVDesc.ViewDimension = (supportedSamples == 0) ? D3D11_SRV_DIMENSION_TEXTURE2D : D3D11_SRV_DIMENSION_TEXTURE2DMS; @@ -3158,7 +3211,7 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G if (bindDSV) { D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; - dsvDesc.Format = formatInfo.formatSet->dsvFormat; + dsvDesc.Format = formatInfo.dsvFormat; dsvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_DSV_DIMENSION_TEXTURE2D : D3D11_DSV_DIMENSION_TEXTURE2DMS; dsvDesc.Texture2D.MipSlice = 0; dsvDesc.Flags = 0; @@ -3174,16 +3227,15 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G return gl::Error(GL_OUT_OF_MEMORY, "Failed to create render target depth stencil view, result: 0x%X.", result); } - *outRT = - new TextureRenderTarget11(dsv, texture, srv, format, formatInfo.formatSet->format, - width, height, 1, supportedSamples); + *outRT = new TextureRenderTarget11(dsv, texture, srv, format, formatInfo, width, height, + 1, supportedSamples); SafeRelease(dsv); } else if (bindRTV) { D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = formatInfo.formatSet->rtvFormat; + rtvDesc.Format = formatInfo.rtvFormat; rtvDesc.ViewDimension = (supportedSamples == 0) ? D3D11_RTV_DIMENSION_TEXTURE2D : D3D11_RTV_DIMENSION_TEXTURE2DMS; rtvDesc.Texture2D.MipSlice = 0; @@ -3204,9 +3256,8 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G mDeviceContext->ClearRenderTargetView(rtv, clearValues); } - *outRT = new TextureRenderTarget11(rtv, texture, srv, blitSRV, format, - formatInfo.formatSet->format, width, height, 1, - supportedSamples); + *outRT = new TextureRenderTarget11(rtv, texture, srv, blitSRV, format, formatInfo, + width, height, 1, supportedSamples); SafeRelease(rtv); } @@ -3221,9 +3272,9 @@ gl::Error Renderer11::createRenderTarget(int width, int height, GLenum format, G } else { - *outRT = new TextureRenderTarget11(static_cast<ID3D11RenderTargetView *>(nullptr), nullptr, - nullptr, nullptr, format, d3d11::ANGLE_FORMAT_NONE, - width, height, 1, supportedSamples); + *outRT = new TextureRenderTarget11( + static_cast<ID3D11RenderTargetView *>(nullptr), nullptr, nullptr, nullptr, format, + d3d11::Format::Get(GL_NONE, mRenderer11DeviceCaps), width, height, 1, supportedSamples); } return gl::Error(GL_NO_ERROR); @@ -3459,7 +3510,8 @@ bool Renderer11::supportsFastCopyBufferToTexture(GLenum internalFormat) const ASSERT(getNativeExtensions().pixelBufferObject); const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat); - const d3d11::TextureFormat &d3d11FormatInfo = d3d11::GetTextureFormatInfo(internalFormat, mRenderer11DeviceCaps); + const d3d11::Format &d3d11FormatInfo = + d3d11::Format::Get(internalFormat, mRenderer11DeviceCaps); // sRGB formats do not work with D3D11 buffer SRVs if (internalFormatInfo.colorEncoding == GL_SRGB) @@ -3468,7 +3520,7 @@ bool Renderer11::supportsFastCopyBufferToTexture(GLenum internalFormat) const } // We cannot support direct copies to non-color-renderable formats - if (d3d11FormatInfo.formatSet->rtvFormat == DXGI_FORMAT_UNKNOWN) + if (d3d11FormatInfo.rtvFormat == DXGI_FORMAT_UNKNOWN) { return false; } @@ -3480,14 +3532,19 @@ bool Renderer11::supportsFastCopyBufferToTexture(GLenum internalFormat) const } // We don't support formats which we can't represent without conversion - if (d3d11FormatInfo.formatSet->glInternalFormat != internalFormat) + if (d3d11FormatInfo.format.glInternalFormat != internalFormat) + { + return false; + } + + // Buffer SRV creation for this format was not working on Windows 10. + if (d3d11FormatInfo.texFormat == DXGI_FORMAT_B5G5R5A1_UNORM) { return false; } - // Buffer SRV creation in this format was not working on Windows 10, repro at least on Intel - // and NVIDIA. - if (internalFormat == GL_RGB5_A1) + // This format is not supported as a buffer SRV. + if (d3d11FormatInfo.texFormat == DXGI_FORMAT_A8_UNORM) { return false; } @@ -3523,16 +3580,12 @@ gl::Error Renderer11::generateMipmapUsingD3D(TextureStorage *storage, ASSERT(storage11->supportsNativeMipmapFunction()); ID3D11ShaderResourceView *srv; - gl::Error error = storage11->getSRVLevels(textureState.getEffectiveBaseLevel(), - textureState.getEffectiveMaxLevel(), &srv); - if (error.isError()) - { - return error; - } + ANGLE_TRY(storage11->getSRVLevels(textureState.getEffectiveBaseLevel(), + textureState.getEffectiveMaxLevel(), &srv)); mDeviceContext->GenerateMips(srv); - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } TextureStorage *Renderer11::createTextureStorage2D(SwapChainD3D *swapChain) @@ -3541,9 +3594,10 @@ TextureStorage *Renderer11::createTextureStorage2D(SwapChainD3D *swapChain) return new TextureStorage11_2D(this, swapChain11); } -TextureStorage *Renderer11::createTextureStorageEGLImage(EGLImageD3D *eglImage) +TextureStorage *Renderer11::createTextureStorageEGLImage(EGLImageD3D *eglImage, + RenderTargetD3D *renderTargetD3D) { - return new TextureStorage11_EGLImage(this, eglImage); + return new TextureStorage11_EGLImage(this, eglImage, GetAs<RenderTarget11>(renderTargetD3D)); } TextureStorage *Renderer11::createTextureStorageExternal( @@ -3593,7 +3647,7 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt ASSERT(rt11->getTexture()); TextureHelper11 textureHelper = - TextureHelper11::MakeAndReference(rt11->getTexture(), rt11->getANGLEFormat()); + TextureHelper11::MakeAndReference(rt11->getTexture(), rt11->getFormatSet()); unsigned int sourceSubResource = rt11->getSubresourceIndex(); const gl::Extents &texSize = textureHelper.getExtents(); @@ -3627,8 +3681,8 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt gl::Extents safeSize(safeArea.width, safeArea.height, 1); TextureHelper11 stagingHelper; ANGLE_TRY_RESULT( - CreateStagingTexture(textureHelper.getTextureType(), textureHelper.getANGLEFormat(), - safeSize, StagingAccess::READ, mDevice), + CreateStagingTexture(textureHelper.getTextureType(), textureHelper.getFormatSet(), safeSize, + StagingAccess::READ, mDevice), stagingHelper); TextureHelper11 resolvedTextureHelper; @@ -3665,7 +3719,7 @@ gl::Error Renderer11::readFromAttachment(const gl::FramebufferAttachment &srcAtt mDeviceContext->ResolveSubresource(resolveTex2D, 0, textureHelper.getTexture2D(), sourceSubResource, textureHelper.getFormat()); resolvedTextureHelper = - TextureHelper11::MakeAndReference(resolveTex2D, textureHelper.getANGLEFormat()); + TextureHelper11::MakeAndReference(resolveTex2D, textureHelper.getFormatSet()); sourceSubResource = 0; srcTexture = &resolvedTextureHelper; @@ -3728,14 +3782,10 @@ gl::Error Renderer11::packPixels(const TextureHelper11 &textureHelper, uint8_t *source = static_cast<uint8_t *>(mapping.pData); int inputPitch = static_cast<int>(mapping.RowPitch); - const auto &angleFormatInfo = d3d11::GetANGLEFormatSet(textureHelper.getANGLEFormat()); - const gl::InternalFormat &sourceFormatInfo = - gl::GetInternalFormatInfo(angleFormatInfo.glInternalFormat); - const auto &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(textureHelper.getFormat()); - ColorReadFunction colorReadFunction = angleFormatInfo.colorReadFunction; + const auto &formatInfo = textureHelper.getFormatSet(); + ASSERT(formatInfo.format.glInternalFormat != GL_NONE); - PackPixels(params, sourceFormatInfo, dxgiFormatInfo.fastCopyFunctions, colorReadFunction, - inputPitch, source, pixelsOut); + PackPixels(params, formatInfo.format, inputPitch, source, pixelsOut); mDeviceContext->Unmap(readResource, 0); @@ -3764,7 +3814,7 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn, } TextureHelper11 drawTexture = TextureHelper11::MakeAndReference( - drawRenderTarget11->getTexture(), drawRenderTarget11->getANGLEFormat()); + drawRenderTarget11->getTexture(), drawRenderTarget11->getFormatSet()); unsigned int drawSubresource = drawRenderTarget11->getSubresourceIndex(); ID3D11RenderTargetView *drawRTV = drawRenderTarget11->getRenderTargetView(); ID3D11DepthStencilView *drawDSV = drawRenderTarget11->getDepthStencilView(); @@ -3784,27 +3834,31 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn, auto readRT11 = GetAs<RenderTarget11>(readRenderTarget); ANGLE_TRY_RESULT(resolveMultisampledTexture(readRT11, depthBlit, stencilBlit), readTexture); - const auto &formatSet = d3d11::GetANGLEFormatSet(readTexture.getANGLEFormat()); + if (!stencilBlit) + { + const auto &readFormatSet = readTexture.getFormatSet(); - D3D11_SHADER_RESOURCE_VIEW_DESC srViewDesc; - srViewDesc.Format = formatSet.srvFormat; - srViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; - srViewDesc.Texture2D.MipLevels = 1; - srViewDesc.Texture2D.MostDetailedMip = 0; + D3D11_SHADER_RESOURCE_VIEW_DESC viewDesc; + viewDesc.Format = readFormatSet.srvFormat; + viewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; + viewDesc.Texture2D.MipLevels = 1; + viewDesc.Texture2D.MostDetailedMip = 0; - HRESULT hresult = - mDevice->CreateShaderResourceView(readTexture.getResource(), &srViewDesc, &readSRV); - if (FAILED(hresult)) - { - return gl::Error(GL_OUT_OF_MEMORY, - "Renderer11::blitRenderbufferRect: Failed to create temporary SRV."); + HRESULT hresult = + mDevice->CreateShaderResourceView(readTexture.getResource(), &viewDesc, &readSRV); + if (FAILED(hresult)) + { + return gl::Error( + GL_OUT_OF_MEMORY, + "Renderer11::blitRenderbufferRect: Failed to create temporary SRV."); + } } } else { ASSERT(readRenderTarget11); readTexture = TextureHelper11::MakeAndReference(readRenderTarget11->getTexture(), - readRenderTarget11->getANGLEFormat()); + readRenderTarget11->getFormatSet()); readSubresource = readRenderTarget11->getSubresourceIndex(); readSRV = readRenderTarget11->getBlitShaderResourceView(); if (readSRV == nullptr) @@ -3816,10 +3870,8 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn, readSRV->AddRef(); } - if (!readSRV) - { - return gl::Error(GL_OUT_OF_MEMORY, "Failed to retrieve the internal read render target view from the read render target."); - } + // Stencil blits don't use shaders. + ASSERT(readSRV || stencilBlit); const gl::Extents readSize(readRenderTarget->getWidth(), readRenderTarget->getHeight(), 1); const gl::Extents drawSize(drawRenderTarget->getWidth(), drawRenderTarget->getHeight(), 1); @@ -3888,22 +3940,21 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn, const auto &destFormatInfo = gl::GetInternalFormatInfo(drawRenderTarget->getInternalFormat()); const auto &srcFormatInfo = gl::GetInternalFormatInfo(readRenderTarget->getInternalFormat()); - const auto &formatSet = d3d11::GetANGLEFormatSet(drawRenderTarget11->getANGLEFormat()); - const DXGI_FORMAT drawDXGIFormat = colorBlit ? formatSet.rtvFormat : formatSet.dsvFormat; - const auto &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(drawDXGIFormat); + const auto &formatSet = drawRenderTarget11->getFormatSet(); + const auto &nativeFormat = formatSet.format; // Some blits require masking off emulated texture channels. eg: from RGBA8 to RGB8, we // emulate RGB8 with RGBA8, so we need to mask off the alpha channel when we copy. gl::Color<bool> colorMask; - colorMask.red = (srcFormatInfo.redBits > 0) && (destFormatInfo.redBits == 0) && - (dxgiFormatInfo.redBits > 0); + colorMask.red = + (srcFormatInfo.redBits > 0) && (destFormatInfo.redBits == 0) && (nativeFormat.redBits > 0); colorMask.green = (srcFormatInfo.greenBits > 0) && (destFormatInfo.greenBits == 0) && - (dxgiFormatInfo.greenBits > 0); + (nativeFormat.greenBits > 0); colorMask.blue = (srcFormatInfo.blueBits > 0) && (destFormatInfo.blueBits == 0) && - (dxgiFormatInfo.blueBits > 0); + (nativeFormat.blueBits > 0); colorMask.alpha = (srcFormatInfo.alphaBits > 0) && (destFormatInfo.alphaBits == 0) && - (dxgiFormatInfo.alphaBits > 0); + (nativeFormat.alphaBits > 0); // We only currently support masking off the alpha channel. bool colorMaskingNeeded = colorMask.alpha; @@ -3924,9 +3975,11 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn, drawRect.x < 0 || drawRect.x + drawRect.width > drawSize.width || drawRect.y < 0 || drawRect.y + drawRect.height > drawSize.height; - bool partialDSBlit = (dxgiFormatInfo.depthBits > 0 && depthBlit) != (dxgiFormatInfo.stencilBits > 0 && stencilBlit); + bool partialDSBlit = + (nativeFormat.depthBits > 0 && depthBlit) != (nativeFormat.stencilBits > 0 && stencilBlit); - if (readRenderTarget11->getANGLEFormat() == drawRenderTarget11->getANGLEFormat() && + if (readRenderTarget11->getFormatSet().format.id == + drawRenderTarget11->getFormatSet().format.id && !stretchRequired && !outOfBounds && !flipRequired && !partialDSBlit && !colorMaskingNeeded && (!(depthBlit || stencilBlit) || wholeBufferCopy)) { @@ -3987,6 +4040,7 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn, } else if (depthBlit) { + ASSERT(readSRV); ANGLE_TRY(mBlit->copyDepth(readSRV, readArea, readSize, drawDSV, drawArea, drawSize, scissor)); } @@ -4000,8 +4054,10 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Rectangle &readRectIn, { // We don't currently support masking off any other channel than alpha bool maskOffAlpha = colorMaskingNeeded && colorMask.alpha; + ASSERT(readSRV); ANGLE_TRY(mBlit->copyTexture(readSRV, readArea, readSize, drawRTV, drawArea, drawSize, - scissor, destFormatInfo.format, filter, maskOffAlpha)); + scissor, destFormatInfo.format, filter, maskOffAlpha, + false, false)); } } @@ -4058,12 +4114,17 @@ void Renderer11::onBufferDelete(const Buffer11 *deleted) gl::ErrorOrResult<TextureHelper11> Renderer11::resolveMultisampledTexture(RenderTarget11 *renderTarget, bool depth, bool stencil) { - if (depth || stencil) + if (depth && !stencil) { - return mBlit->resolveDepthStencil(renderTarget, depth, stencil); + return mBlit->resolveDepth(renderTarget); } - const auto &formatSet = d3d11::GetANGLEFormatSet(renderTarget->getANGLEFormat()); + if (stencil) + { + return mBlit->resolveStencil(renderTarget, depth); + } + + const auto &formatSet = renderTarget->getFormatSet(); ASSERT(renderTarget->getSamples() > 1); @@ -4090,7 +4151,7 @@ Renderer11::resolveMultisampledTexture(RenderTarget11 *renderTarget, bool depth, mDeviceContext->ResolveSubresource(resolveTexture, 0, renderTarget->getTexture(), renderTarget->getSubresourceIndex(), formatSet.texFormat); - return TextureHelper11::MakeAndPossess2D(resolveTexture, renderTarget->getANGLEFormat()); + return TextureHelper11::MakeAndPossess2D(resolveTexture, renderTarget->getFormatSet()); } bool Renderer11::getLUID(LUID *adapterLuid) const @@ -4168,7 +4229,7 @@ void Renderer11::generateCaps(gl::Caps *outCaps, gl::TextureCapsMap *outTextureC WorkaroundsD3D Renderer11::generateWorkarounds() const { - return d3d11::GenerateWorkarounds(mRenderer11DeviceCaps.featureLevel); + return d3d11::GenerateWorkarounds(mRenderer11DeviceCaps, mAdapterDescription); } gl::Error Renderer11::clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) @@ -4232,7 +4293,7 @@ gl::Error Renderer11::genericDrawElements(Context11 *context, ANGLE_TRY(applyIndexBuffer(data, indices, count, mode, type, &indexInfo)); - applyTransformFeedbackBuffers(glState); + applyTransformFeedbackBuffers(data); // Transform feedback is not allowed for DrawElements, this error should have been caught at the // API validation layer. ASSERT(!glState.isTransformFeedbackActiveUnpaused()); @@ -4274,7 +4335,7 @@ gl::Error Renderer11::genericDrawArrays(Context11 *context, } ANGLE_TRY(updateState(data, mode)); - ANGLE_TRY(applyTransformFeedbackBuffers(glState)); + ANGLE_TRY(applyTransformFeedbackBuffers(data)); ANGLE_TRY(applyVertexBuffer(glState, mode, first, count, instances, nullptr)); ANGLE_TRY(applyTextures(context, data)); ANGLE_TRY(applyShaders(data, mode)); @@ -4328,6 +4389,11 @@ gl::Error Renderer11::getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer return gl::NoError(); } +gl::Version Renderer11::getMaxSupportedESVersion() const +{ + return gl::Version(d3d11_gl::GetMaximumClientVersion(mRenderer11DeviceCaps.featureLevel), 0); +} + gl::DebugAnnotator *Renderer11::getAnnotator() { return mAnnotator; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h index f86ae6e2c5a..b19c5dc09d6 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Renderer11.h @@ -52,6 +52,7 @@ struct Renderer11DeviceCaps UINT B5G6R5support; // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B5G6R5_UNORM UINT B4G4R4A4support; // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B4G4R4A4_UNORM UINT B5G5R5A1support; // Bitfield of D3D11_FORMAT_SUPPORT values for DXGI_FORMAT_B5G5R5A1_UNORM + Optional<LARGE_INTEGER> driverVersion; // Four-part driver version number. }; enum @@ -105,7 +106,7 @@ class Renderer11 : public RendererD3D virtual ~Renderer11(); egl::Error initialize() override; - virtual bool resetDevice(); + bool resetDevice() override; egl::ConfigSet generateConfigs() override; void generateDisplayExtensions(egl::DisplayExtensions *outExtensions) const override; @@ -126,8 +127,11 @@ class Renderer11 : public RendererD3D GLenum depthBufferFormat, EGLint orientation) override; - virtual gl::Error setSamplerState(gl::SamplerType type, int index, gl::Texture *texture, const gl::SamplerState &sampler); - virtual gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture); + gl::Error setSamplerState(gl::SamplerType type, + int index, + gl::Texture *texture, + const gl::SamplerState &sampler) override; + gl::Error setTexture(gl::SamplerType type, int index, gl::Texture *texture) override; gl::Error setUniformBuffers(const gl::ContextState &data, const std::vector<GLint> &vertexUniformBuffers, @@ -152,11 +156,11 @@ class Renderer11 : public RendererD3D GLenum mode, GLenum type, TranslatedIndexData *indexInfo); - gl::Error applyTransformFeedbackBuffers(const gl::State &state); + gl::Error applyTransformFeedbackBuffers(const gl::ContextState &data); // lost device bool testDeviceLost() override; - bool testDeviceResettable(); + bool testDeviceResettable() override; std::string getRendererDescription() const; DeviceIdentifier getAdapterIdentifier() const override; @@ -170,7 +174,7 @@ class Renderer11 : public RendererD3D bool getNV12TextureSupport() const; - virtual int getMajorShaderModel() const; + int getMajorShaderModel() const override; int getMinorShaderModel() const override; std::string getShaderModelSuffix() const override; @@ -201,6 +205,17 @@ class Renderer11 : public RendererD3D TextureStorage *storage, GLint level) override; + gl::Error copyTexture(const gl::Texture *source, + GLint sourceLevel, + const gl::Rectangle &sourceRect, + GLenum destFormat, + const gl::Offset &destOffset, + TextureStorage *storage, + GLint destLevel, + bool unpackFlipY, + bool unpackPremultiplyAlpha, + bool unpackUnmultiplyAlpha) override; + // RenderTarget creation gl::Error createRenderTarget(int width, int height, @@ -231,7 +246,8 @@ class Renderer11 : public RendererD3D gl::Error generateMipmapUsingD3D(TextureStorage *storage, const gl::TextureState &textureState) override; TextureStorage *createTextureStorage2D(SwapChainD3D *swapChain) override; - TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage) override; + TextureStorage *createTextureStorageEGLImage(EGLImageD3D *eglImage, + RenderTargetD3D *renderTargetD3D) override; TextureStorage *createTextureStorageExternal( egl::Stream *stream, const egl::Stream::GLTextureDescription &desc) override; @@ -281,9 +297,13 @@ class Renderer11 : public RendererD3D gl::DebugAnnotator *getAnnotator(); // Buffer-to-texture and Texture-to-buffer copies - virtual bool supportsFastCopyBufferToTexture(GLenum internalFormat) const; - virtual gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, unsigned int offset, RenderTargetD3D *destRenderTarget, - GLenum destinationFormat, GLenum sourcePixelsType, const gl::Box &destArea); + bool supportsFastCopyBufferToTexture(GLenum internalFormat) const override; + gl::Error fastCopyBufferToTexture(const gl::PixelUnpackState &unpack, + unsigned int offset, + RenderTargetD3D *destRenderTarget, + GLenum destinationFormat, + GLenum sourcePixelsType, + const gl::Box &destArea) override; void markAllStateDirty(); gl::Error packPixels(const TextureHelper11 &textureHelper, @@ -341,6 +361,8 @@ class Renderer11 : public RendererD3D gl::Error getScratchMemoryBuffer(size_t requestedSize, MemoryBuffer **bufferOut); + gl::Version getMaxSupportedESVersion() const override; + protected: gl::Error clearTextures(gl::SamplerType samplerType, size_t rangeStart, size_t rangeEnd) override; @@ -470,15 +492,7 @@ class Renderer11 : public RendererD3D bool mAppliedIBChanged; // Currently applied transform feedback buffers - size_t mAppliedNumXFBBindings; - ID3D11Buffer *mAppliedTFBuffers[gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS]; // Tracks the current D3D buffers - // in use for streamout - GLintptr mAppliedTFOffsets[gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS]; // Tracks the current GL-specified - // buffer offsets to transform feedback - // buffers - UINT mCurrentD3DOffsets[gl::IMPLEMENTATION_MAX_TRANSFORM_FEEDBACK_BUFFERS]; // Tracks the D3D buffer offsets, - // which may differ from GLs, due - // to different append behavior + uintptr_t mAppliedTFObject; // Currently applied shaders uintptr_t mAppliedVertexShader; @@ -549,5 +563,5 @@ class Renderer11 : public RendererD3D mutable Optional<bool> mSupportsShareHandles; }; -} +} // namespace rx #endif // LIBANGLE_RENDERER_D3D_D3D11_RENDERER11_H_ diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp index d00d831c737..0e28c8c18a0 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp @@ -24,15 +24,16 @@ namespace bool ImageIndexConflictsWithSRV(const gl::ImageIndex &index, D3D11_SHADER_RESOURCE_VIEW_DESC desc) { unsigned mipLevel = index.mipIndex; - unsigned layerIndex = index.layerIndex; + GLint layerIndex = index.layerIndex; GLenum type = index.type; switch (desc.ViewDimension) { case D3D11_SRV_DIMENSION_TEXTURE2D: { - unsigned maxSrvMip = desc.Texture2D.MipLevels + desc.Texture2D.MostDetailedMip; - maxSrvMip = (desc.Texture2D.MipLevels == -1) ? INT_MAX : maxSrvMip; + bool allLevels = (desc.Texture2D.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = desc.Texture2D.MipLevels + desc.Texture2D.MostDetailedMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; unsigned mipMin = index.mipIndex; unsigned mipMax = (layerIndex == -1) ? INT_MAX : layerIndex; @@ -44,22 +45,25 @@ bool ImageIndexConflictsWithSRV(const gl::ImageIndex &index, D3D11_SHADER_RESOUR case D3D11_SRV_DIMENSION_TEXTURE2DARRAY: { - unsigned maxSrvMip = + bool allLevels = (desc.Texture2DArray.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = desc.Texture2DArray.MipLevels + desc.Texture2DArray.MostDetailedMip; - maxSrvMip = (desc.Texture2DArray.MipLevels == -1) ? INT_MAX : maxSrvMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; unsigned maxSlice = desc.Texture2DArray.FirstArraySlice + desc.Texture2DArray.ArraySize; // Cube maps can be mapped to Texture2DArray SRVs return (type == GL_TEXTURE_2D_ARRAY || gl::IsCubeMapTextureTarget(type)) && desc.Texture2DArray.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip && - desc.Texture2DArray.FirstArraySlice <= layerIndex && layerIndex < maxSlice; + desc.Texture2DArray.FirstArraySlice <= static_cast<UINT>(layerIndex) && + static_cast<UINT>(layerIndex) < maxSlice; } case D3D11_SRV_DIMENSION_TEXTURECUBE: { - unsigned maxSrvMip = desc.TextureCube.MipLevels + desc.TextureCube.MostDetailedMip; - maxSrvMip = (desc.TextureCube.MipLevels == -1) ? INT_MAX : maxSrvMip; + bool allLevels = (desc.TextureCube.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = desc.TextureCube.MipLevels + desc.TextureCube.MostDetailedMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; return gl::IsCubeMapTextureTarget(type) && desc.TextureCube.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip; @@ -67,8 +71,9 @@ bool ImageIndexConflictsWithSRV(const gl::ImageIndex &index, D3D11_SHADER_RESOUR case D3D11_SRV_DIMENSION_TEXTURE3D: { - unsigned maxSrvMip = desc.Texture3D.MipLevels + desc.Texture3D.MostDetailedMip; - maxSrvMip = (desc.Texture3D.MipLevels == -1) ? INT_MAX : maxSrvMip; + bool allLevels = (desc.Texture3D.MipLevels == std::numeric_limits<UINT>::max()); + unsigned int maxSrvMip = desc.Texture3D.MipLevels + desc.Texture3D.MostDetailedMip; + maxSrvMip = allLevels ? INT_MAX : maxSrvMip; return type == GL_TEXTURE_3D && desc.Texture3D.MostDetailedMip <= mipLevel && mipLevel < maxSrvMip; @@ -487,16 +492,11 @@ gl::Error StateManager11::setBlendState(const gl::Framebuffer *framebuffer, { if (!mBlendStateIsDirty && sampleMask == mCurSampleMask) { - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } ID3D11BlendState *dxBlendState = nullptr; - gl::Error error = - mRenderer->getStateCache().getBlendState(framebuffer, blendState, &dxBlendState); - if (error.isError()) - { - return error; - } + ANGLE_TRY(mRenderer->getStateCache().getBlendState(framebuffer, blendState, &dxBlendState)); ASSERT(dxBlendState != nullptr); @@ -527,7 +527,7 @@ gl::Error StateManager11::setBlendState(const gl::Framebuffer *framebuffer, mBlendStateIsDirty = false; - return error; + return gl::NoError(); } gl::Error StateManager11::setDepthStencilState(const gl::State &glState) @@ -547,7 +547,7 @@ gl::Error StateManager11::setDepthStencilState(const gl::State &glState) disableDepth == mCurDisableDepth.value() && mCurDisableStencil.valid() && disableStencil == mCurDisableStencil.value()) { - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } const auto &depthStencilState = glState.getDepthStencilState(); @@ -567,12 +567,8 @@ gl::Error StateManager11::setDepthStencilState(const gl::State &glState) (depthStencilState.stencilBackMask & maxStencil)); ID3D11DepthStencilState *dxDepthStencilState = NULL; - gl::Error error = mRenderer->getStateCache().getDepthStencilState( - depthStencilState, disableDepth, disableStencil, &dxDepthStencilState); - if (error.isError()) - { - return error; - } + ANGLE_TRY(mRenderer->getStateCache().getDepthStencilState( + depthStencilState, disableDepth, disableStencil, &dxDepthStencilState)); ASSERT(dxDepthStencilState); @@ -596,7 +592,7 @@ gl::Error StateManager11::setDepthStencilState(const gl::State &glState) mDepthStencilStateIsDirty = false; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterState) @@ -605,11 +601,10 @@ gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterSt if (!mRasterizerStateIsDirty && rasterState.pointDrawMode == mCurRasterState.pointDrawMode && rasterState.multiSample == mCurRasterState.multiSample) { - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } ID3D11RasterizerState *dxRasterState = nullptr; - gl::Error error(GL_NO_ERROR); if (mCurPresentPathFastEnabled) { @@ -628,18 +623,13 @@ gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterSt modifiedRasterState.frontFace = GL_CCW; } - error = mRenderer->getStateCache().getRasterizerState(modifiedRasterState, - mCurScissorEnabled, &dxRasterState); + ANGLE_TRY(mRenderer->getStateCache().getRasterizerState( + modifiedRasterState, mCurScissorEnabled, &dxRasterState)); } else { - error = mRenderer->getStateCache().getRasterizerState(rasterState, mCurScissorEnabled, - &dxRasterState); - } - - if (error.isError()) - { - return error; + ANGLE_TRY(mRenderer->getStateCache().getRasterizerState(rasterState, mCurScissorEnabled, + &dxRasterState)); } mRenderer->getDeviceContext()->RSSetState(dxRasterState); @@ -647,7 +637,7 @@ gl::Error StateManager11::setRasterizerState(const gl::RasterizerState &rasterSt mCurRasterState = rasterState; mRasterizerStateIsDirty = false; - return error; + return gl::NoError(); } void StateManager11::setScissorRectangle(const gl::Rectangle &scissor, bool enabled) @@ -862,7 +852,7 @@ gl::Error StateManager11::onMakeCurrent(const gl::ContextState &data) } } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } void StateManager11::setShaderResource(gl::SamplerType shaderType, @@ -896,7 +886,7 @@ gl::Error StateManager11::clearTextures(gl::SamplerType samplerType, { if (rangeStart == rangeEnd) { - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } auto ¤tSRVs = (samplerType == gl::SAMPLER_VERTEX ? mCurVertexSRVs : mCurPixelSRVs); @@ -906,7 +896,7 @@ gl::Error StateManager11::clearTextures(gl::SamplerType samplerType, if (clearRange.empty()) { - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } auto deviceContext = mRenderer->getDeviceContext(); @@ -928,7 +918,7 @@ gl::Error StateManager11::clearTextures(gl::SamplerType samplerType, currentSRVs.update(samplerIndex, nullptr); } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } void StateManager11::unsetConflictingSRVs(gl::SamplerType samplerType, @@ -984,11 +974,7 @@ void StateManager11::deinitialize() gl::Error StateManager11::syncFramebuffer(gl::Framebuffer *framebuffer) { Framebuffer11 *framebuffer11 = GetImplAs<Framebuffer11>(framebuffer); - gl::Error error = framebuffer11->invalidateSwizzles(); - if (error.isError()) - { - return error; - } + ANGLE_TRY(framebuffer11->markAttachmentsDirty()); if (framebuffer11->hasAnyInternalDirtyBit()) { @@ -998,7 +984,7 @@ gl::Error StateManager11::syncFramebuffer(gl::Framebuffer *framebuffer) if (!mRenderTargetIsDirty) { - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } mRenderTargetIsDirty = false; @@ -1012,7 +998,7 @@ gl::Error StateManager11::syncFramebuffer(gl::Framebuffer *framebuffer) const gl::Extents &size = framebuffer->getFirstColorbuffer()->getSize(); if (size.width == 0 || size.height == 0) { - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } } @@ -1096,7 +1082,7 @@ gl::Error StateManager11::syncFramebuffer(gl::Framebuffer *framebuffer) setViewportBounds(renderTargetWidth, renderTargetHeight); - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error StateManager11::updateCurrentValueAttribs(const gl::State &state, @@ -1119,15 +1105,11 @@ gl::Error StateManager11::updateCurrentValueAttribs(const gl::State &state, currentValueAttrib->currentValueType = currentValue.Type; currentValueAttrib->attribute = &vertexAttributes[attribIndex]; - gl::Error error = vertexDataManager->storeCurrentValue(currentValue, currentValueAttrib, - static_cast<size_t>(attribIndex)); - if (error.isError()) - { - return error; - } + ANGLE_TRY(vertexDataManager->storeCurrentValue(currentValue, currentValueAttrib, + static_cast<size_t>(attribIndex))); } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } const std::vector<TranslatedAttribute> &StateManager11::getCurrentValueAttribs() const diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp index e934aa888f8..b12fd80d2c6 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp @@ -177,7 +177,8 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe releaseOffscreenColorBuffer(); - const d3d11::TextureFormat &backbufferFormatInfo = d3d11::GetTextureFormatInfo(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps()); + const d3d11::Format &backbufferFormatInfo = + d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps()); // If the app passed in a share handle, open the resource // See EGL_ANGLE_d3d_share_handle_client_buffer @@ -209,7 +210,7 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe if (offscreenTextureDesc.Width != (UINT)backbufferWidth || offscreenTextureDesc.Height != (UINT)backbufferHeight || - offscreenTextureDesc.Format != backbufferFormatInfo.formatSet->texFormat || + offscreenTextureDesc.Format != backbufferFormatInfo.texFormat || offscreenTextureDesc.MipLevels != 1 || offscreenTextureDesc.ArraySize != 1) { ERR("Invalid texture parameters in the shared offscreen texture pbuffer"); @@ -225,7 +226,7 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe D3D11_TEXTURE2D_DESC offscreenTextureDesc = {0}; offscreenTextureDesc.Width = backbufferWidth; offscreenTextureDesc.Height = backbufferHeight; - offscreenTextureDesc.Format = backbufferFormatInfo.formatSet->texFormat; + offscreenTextureDesc.Format = backbufferFormatInfo.texFormat; offscreenTextureDesc.MipLevels = 1; offscreenTextureDesc.ArraySize = 1; offscreenTextureDesc.SampleDesc.Count = 1; @@ -283,7 +284,7 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe mKeyedMutex = d3d11::DynamicCastComObject<IDXGIKeyedMutex>(mOffscreenTexture); D3D11_RENDER_TARGET_VIEW_DESC offscreenRTVDesc; - offscreenRTVDesc.Format = backbufferFormatInfo.formatSet->rtvFormat; + offscreenRTVDesc.Format = backbufferFormatInfo.rtvFormat; offscreenRTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; offscreenRTVDesc.Texture2D.MipSlice = 0; @@ -292,7 +293,7 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe d3d11::SetDebugName(mOffscreenRTView, "Offscreen back buffer render target"); D3D11_SHADER_RESOURCE_VIEW_DESC offscreenSRVDesc; - offscreenSRVDesc.Format = backbufferFormatInfo.formatSet->srvFormat; + offscreenSRVDesc.Format = backbufferFormatInfo.srvFormat; offscreenSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; offscreenSRVDesc.Texture2D.MostDetailedMip = 0; offscreenSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1); @@ -333,13 +334,13 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe if (mDepthBufferFormat != GL_NONE) { - const d3d11::TextureFormat &depthBufferFormatInfo = - d3d11::GetTextureFormatInfo(mDepthBufferFormat, mRenderer->getRenderer11DeviceCaps()); + const d3d11::Format &depthBufferFormatInfo = + d3d11::Format::Get(mDepthBufferFormat, mRenderer->getRenderer11DeviceCaps()); D3D11_TEXTURE2D_DESC depthStencilTextureDesc; depthStencilTextureDesc.Width = backbufferWidth; depthStencilTextureDesc.Height = backbufferHeight; - depthStencilTextureDesc.Format = depthBufferFormatInfo.formatSet->texFormat; + depthStencilTextureDesc.Format = depthBufferFormatInfo.texFormat; depthStencilTextureDesc.MipLevels = 1; depthStencilTextureDesc.ArraySize = 1; depthStencilTextureDesc.SampleDesc.Count = 1; @@ -347,7 +348,7 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe depthStencilTextureDesc.Usage = D3D11_USAGE_DEFAULT; depthStencilTextureDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; - if (depthBufferFormatInfo.formatSet->srvFormat != DXGI_FORMAT_UNKNOWN) + if (depthBufferFormatInfo.srvFormat != DXGI_FORMAT_UNKNOWN) { depthStencilTextureDesc.BindFlags |= D3D11_BIND_SHADER_RESOURCE; } @@ -375,7 +376,7 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe d3d11::SetDebugName(mDepthStencilTexture, "Offscreen depth stencil texture"); D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilDesc; - depthStencilDesc.Format = depthBufferFormatInfo.formatSet->dsvFormat; + depthStencilDesc.Format = depthBufferFormatInfo.dsvFormat; depthStencilDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; depthStencilDesc.Flags = 0; depthStencilDesc.Texture2D.MipSlice = 0; @@ -384,10 +385,10 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe ASSERT(SUCCEEDED(result)); d3d11::SetDebugName(mDepthStencilDSView, "Offscreen depth stencil view"); - if (depthBufferFormatInfo.formatSet->srvFormat != DXGI_FORMAT_UNKNOWN) + if (depthBufferFormatInfo.srvFormat != DXGI_FORMAT_UNKNOWN) { D3D11_SHADER_RESOURCE_VIEW_DESC depthStencilSRVDesc; - depthStencilSRVDesc.Format = depthBufferFormatInfo.formatSet->srvFormat; + depthStencilSRVDesc.Format = depthBufferFormatInfo.srvFormat; depthStencilSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; depthStencilSRVDesc.Texture2D.MostDetailedMip = 0; depthStencilSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1); @@ -489,7 +490,7 @@ DXGI_FORMAT SwapChain11::getSwapChainNativeFormat() const return (mOffscreenRenderTargetFormat == GL_BGRA8_EXT) ? DXGI_FORMAT_B8G8R8A8_UNORM : DXGI_FORMAT_R8G8B8A8_UNORM; } -EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swapInterval) +EGLint SwapChain11::reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval) { mSwapInterval = static_cast<unsigned int>(swapInterval); if (mSwapInterval > 4) @@ -876,4 +877,4 @@ void SwapChain11::recreate() // possibly should use this method instead of reset } -} +} // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h index 23f2fd37b12..1ea608054b0 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.h @@ -18,7 +18,7 @@ namespace rx class Renderer11; class NativeWindow11; -class SwapChain11 : public SwapChainD3D +class SwapChain11 final : public SwapChainD3D { public: SwapChain11(Renderer11 *renderer, @@ -30,20 +30,20 @@ class SwapChain11 : public SwapChainD3D virtual ~SwapChain11(); EGLint resize(EGLint backbufferWidth, EGLint backbufferHeight); - virtual EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval); - virtual EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height); - virtual void recreate(); + EGLint reset(EGLint backbufferWidth, EGLint backbufferHeight, EGLint swapInterval) override; + EGLint swapRect(EGLint x, EGLint y, EGLint width, EGLint height) override; + void recreate() override; RenderTargetD3D *getColorRenderTarget() override { return &mColorRenderTarget; } RenderTargetD3D *getDepthStencilRenderTarget() override { return &mDepthStencilRenderTarget; } - virtual ID3D11Texture2D *getOffscreenTexture(); - virtual ID3D11RenderTargetView *getRenderTarget(); - virtual ID3D11ShaderResourceView *getRenderTargetShaderResource(); + ID3D11Texture2D *getOffscreenTexture(); + ID3D11RenderTargetView *getRenderTarget(); + ID3D11ShaderResourceView *getRenderTargetShaderResource(); - virtual ID3D11Texture2D *getDepthStencilTexture(); - virtual ID3D11DepthStencilView *getDepthStencil(); - virtual ID3D11ShaderResourceView *getDepthStencilShaderResource(); + ID3D11Texture2D *getDepthStencilTexture(); + ID3D11DepthStencilView *getDepthStencil(); + ID3D11ShaderResourceView *getDepthStencilShaderResource(); EGLint getWidth() const { return mWidth; } EGLint getHeight() const { return mHeight; } @@ -103,5 +103,5 @@ class SwapChain11 : public SwapChainD3D SurfaceRenderTarget11 mDepthStencilRenderTarget; }; -} +} // namespace rx #endif // LIBANGLE_RENDERER_D3D_D3D11_SWAPCHAIN11_H_ diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp index 81c6f39b471..e84aca677ea 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp @@ -31,27 +31,29 @@ namespace rx { -TextureStorage11::SRVKey::SRVKey(int baseLevel, int mipLevels, bool swizzle) - : baseLevel(baseLevel), mipLevels(mipLevels), swizzle(swizzle) +TextureStorage11::SRVKey::SRVKey(int baseLevel, int mipLevels, bool swizzle, bool dropStencil) + : baseLevel(baseLevel), mipLevels(mipLevels), swizzle(swizzle), dropStencil(dropStencil) { } bool TextureStorage11::SRVKey::operator<(const SRVKey &rhs) const { - return std::tie(baseLevel, mipLevels, swizzle) < - std::tie(rhs.baseLevel, rhs.mipLevels, rhs.swizzle); + return std::tie(baseLevel, mipLevels, swizzle, dropStencil) < + std::tie(rhs.baseLevel, rhs.mipLevels, rhs.swizzle, rhs.dropStencil); } -TextureStorage11::TextureStorage11(Renderer11 *renderer, UINT bindFlags, UINT miscFlags) +TextureStorage11::TextureStorage11(Renderer11 *renderer, + UINT bindFlags, + UINT miscFlags, + GLenum internalFormat) : mRenderer(renderer), mTopLevel(0), mMipLevels(0), - mInternalFormat(GL_NONE), - mTextureFormatSet(nullptr), - mSwizzleFormatSet(nullptr), + mFormatInfo(d3d11::Format::Get(internalFormat, mRenderer->getRenderer11DeviceCaps())), mTextureWidth(0), mTextureHeight(0), mTextureDepth(0), + mDropStencilTexture(nullptr), mBindFlags(bindFlags), mMiscFlags(miscFlags) { @@ -72,6 +74,7 @@ TextureStorage11::~TextureStorage11() SafeRelease(i->second); } mSrvCache.clear(); + SafeRelease(mDropStencilTexture); } DWORD TextureStorage11::GetTextureBindFlags(GLenum internalFormat, @@ -80,17 +83,16 @@ DWORD TextureStorage11::GetTextureBindFlags(GLenum internalFormat, { UINT bindFlags = 0; - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalFormat, renderer11DeviceCaps); - if (formatInfo.formatSet->srvFormat != DXGI_FORMAT_UNKNOWN) + const d3d11::Format &formatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); + if (formatInfo.srvFormat != DXGI_FORMAT_UNKNOWN) { bindFlags |= D3D11_BIND_SHADER_RESOURCE; } - if (formatInfo.formatSet->dsvFormat != DXGI_FORMAT_UNKNOWN) + if (formatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) { bindFlags |= D3D11_BIND_DEPTH_STENCIL; } - if (formatInfo.formatSet->rtvFormat != DXGI_FORMAT_UNKNOWN && renderTarget) + if (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN && renderTarget) { bindFlags |= D3D11_BIND_RENDER_TARGET; } @@ -105,12 +107,10 @@ DWORD TextureStorage11::GetTextureMiscFlags(GLenum internalFormat, { UINT miscFlags = 0; - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalFormat, renderer11DeviceCaps); + const d3d11::Format &formatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); if (renderTarget && levels > 1) { - const d3d11::DXGIFormat &dxgiFormatInfo = - d3d11::GetDXGIFormatInfo(formatInfo.formatSet->texFormat); + const d3d11::DXGIFormat &dxgiFormatInfo = d3d11::GetDXGIFormatInfo(formatInfo.texFormat); if (dxgiFormatInfo.nativeMipmapSupport(renderer11DeviceCaps.featureLevel)) { @@ -205,11 +205,7 @@ gl::Error TextureStorage11::getSRV(const gl::TextureState &textureState, if (mRenderer->getWorkarounds().zeroMaxLodWorkaround) { // We must ensure that the level zero texture is in sync with mipped texture. - gl::Error error = useLevelZeroWorkaroundTexture(mipLevels == 1); - if (error.isError()) - { - return error; - } + ANGLE_TRY(useLevelZeroWorkaroundTexture(mipLevels == 1)); } if (swizzleRequired) @@ -217,7 +213,22 @@ gl::Error TextureStorage11::getSRV(const gl::TextureState &textureState, verifySwizzleExists(textureState.getSwizzleState()); } - SRVKey key(effectiveBaseLevel, mipLevels, swizzleRequired); + // We drop the stencil when sampling from the SRV if three conditions hold: + // 1. the drop stencil workaround is enabled. + bool workaround = mRenderer->getWorkarounds().emulateTinyStencilTextures; + // 2. this is a stencil texture. + bool hasStencil = (mFormatInfo.format.stencilBits > 0); + // 3. the texture has a 1x1 or 2x2 mip. + bool hasSmallMips = (getLevelWidth(mMipLevels - 1) <= 2 || getLevelHeight(mMipLevels - 1) <= 2); + + bool useDropStencil = (workaround && hasStencil && hasSmallMips); + if (useDropStencil) + { + // Ensure drop texture gets re-created, if SRV is cached. + ANGLE_TRY(createDropStencilTexture()); + } + + SRVKey key(effectiveBaseLevel, mipLevels, swizzleRequired, useDropStencil); ANGLE_TRY(getCachedOrCreateSRV(key, outSRV)); return gl::NoError(); @@ -234,18 +245,28 @@ gl::Error TextureStorage11::getCachedOrCreateSRV(const SRVKey &key, } ID3D11Resource *texture = nullptr; + DXGI_FORMAT format = DXGI_FORMAT_UNKNOWN; + if (key.swizzle) { + ASSERT(!key.dropStencil || mFormatInfo.swizzle.format.stencilBits == 0); ANGLE_TRY(getSwizzleTexture(&texture)); + format = mFormatInfo.swizzle.srvFormat; + } + else if (key.dropStencil) + { + ASSERT(mDropStencilTexture); + texture = mDropStencilTexture; + format = DXGI_FORMAT_R32_FLOAT; } else { ANGLE_TRY(getResource(&texture)); + format = mFormatInfo.srvFormat; } ID3D11ShaderResourceView *srv = nullptr; - DXGI_FORMAT format = - (key.swizzle ? mSwizzleFormatSet->srvFormat : mTextureFormatSet->srvFormat); + ANGLE_TRY(createSRV(key.baseLevel, key.mipLevels, format, texture, &srv)); mSrvCache.insert(std::make_pair(key, srv)); @@ -266,8 +287,7 @@ gl::Error TextureStorage11::getSRVLevel(int mipLevel, if (!levelSRVs[mipLevel]) { // Only create a different SRV for blit if blit format is different from regular srv format - if (otherLevelSRVs[mipLevel] && - mTextureFormatSet->srvFormat == mTextureFormatSet->blitSRVFormat) + if (otherLevelSRVs[mipLevel] && mFormatInfo.srvFormat == mFormatInfo.blitSRVFormat) { levelSRVs[mipLevel] = otherLevelSRVs[mipLevel]; levelSRVs[mipLevel]->AddRef(); @@ -275,25 +295,17 @@ gl::Error TextureStorage11::getSRVLevel(int mipLevel, else { ID3D11Resource *resource = nullptr; - gl::Error error = getResource(&resource); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getResource(&resource)); DXGI_FORMAT resourceFormat = - blitSRV ? mTextureFormatSet->blitSRVFormat : mTextureFormatSet->srvFormat; - error = createSRV(mipLevel, 1, resourceFormat, resource, &levelSRVs[mipLevel]); - if (error.isError()) - { - return error; - } + blitSRV ? mFormatInfo.blitSRVFormat : mFormatInfo.srvFormat; + ANGLE_TRY(createSRV(mipLevel, 1, resourceFormat, resource, &levelSRVs[mipLevel])); } } *outSRV = levelSRVs[mipLevel]; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11::getSRVLevels(GLint baseLevel, @@ -314,22 +326,20 @@ gl::Error TextureStorage11::getSRVLevels(GLint baseLevel, if (mRenderer->getWorkarounds().zeroMaxLodWorkaround) { // We must ensure that the level zero texture is in sync with mipped texture. - gl::Error error = useLevelZeroWorkaroundTexture(mipLevels == 1); - if (error.isError()) - { - return error; - } + ANGLE_TRY(useLevelZeroWorkaroundTexture(mipLevels == 1)); } - SRVKey key(baseLevel, mipLevels, false); + // TODO(jmadill): Assert we don't need to drop stencil. + + SRVKey key(baseLevel, mipLevels, false, false); ANGLE_TRY(getCachedOrCreateSRV(key, outSRV)); return gl::NoError(); } -d3d11::ANGLEFormat TextureStorage11::getANGLEFormat() const +const d3d11::Format &TextureStorage11::getFormatSet() const { - return mTextureFormatSet->format; + return mFormatInfo; } gl::Error TextureStorage11::generateSwizzles(const gl::SwizzleState &swizzleTarget) @@ -341,38 +351,25 @@ gl::Error TextureStorage11::generateSwizzles(const gl::SwizzleState &swizzleTarg { // Need to re-render the swizzle for this level ID3D11ShaderResourceView *sourceSRV = nullptr; - gl::Error error = getSRVLevel(level, true, &sourceSRV); - - if (error.isError()) - { - return error; - } + ANGLE_TRY(getSRVLevel(level, true, &sourceSRV)); ID3D11RenderTargetView *destRTV = nullptr; - error = getSwizzleRenderTarget(level, &destRTV); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getSwizzleRenderTarget(level, &destRTV)); gl::Extents size(getLevelWidth(level), getLevelHeight(level), getLevelDepth(level)); Blit11 *blitter = mRenderer->getBlitter(); - error = blitter->swizzleTexture(sourceSRV, destRTV, size, swizzleTarget); - if (error.isError()) - { - return error; - } + ANGLE_TRY(blitter->swizzleTexture(sourceSRV, destRTV, size, swizzleTarget)); mSwizzleCache[level] = swizzleTarget; } } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } -void TextureStorage11::invalidateSwizzleCacheLevel(int mipLevel) +void TextureStorage11::markLevelDirty(int mipLevel) { if (mipLevel >= 0 && static_cast<unsigned int>(mipLevel) < ArraySize(mSwizzleCache)) { @@ -380,13 +377,15 @@ void TextureStorage11::invalidateSwizzleCacheLevel(int mipLevel) // not a valid swizzle combination mSwizzleCache[mipLevel] = gl::SwizzleState(); } + + SafeRelease(mDropStencilTexture); } -void TextureStorage11::invalidateSwizzleCache() +void TextureStorage11::markDirty() { for (unsigned int mipLevel = 0; mipLevel < ArraySize(mSwizzleCache); mipLevel++) { - invalidateSwizzleCacheLevel(mipLevel); + markLevelDirty(mipLevel); } } @@ -399,7 +398,7 @@ gl::Error TextureStorage11::updateSubresourceLevel(ID3D11Resource *srcTexture, const GLint level = index.mipIndex; - invalidateSwizzleCacheLevel(level); + markLevelDirty(level); gl::Extents texSize(getLevelWidth(level), getLevelHeight(level), getLevelDepth(level)); @@ -425,13 +424,13 @@ gl::Error TextureStorage11::updateSubresourceLevel(ID3D11Resource *srcTexture, ASSERT(dstTexture); const d3d11::DXGIFormatSize &dxgiFormatSizeInfo = - d3d11::GetDXGIFormatSizeInfo(mTextureFormatSet->texFormat); - if (!fullCopy && mTextureFormatSet->dsvFormat != DXGI_FORMAT_UNKNOWN) + d3d11::GetDXGIFormatSizeInfo(mFormatInfo.texFormat); + if (!fullCopy && mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) { // CopySubresourceRegion cannot copy partial depth stencils, use the blitter instead Blit11 *blitter = mRenderer->getBlitter(); - TextureHelper11 source = TextureHelper11::MakeAndReference(srcTexture, getANGLEFormat()); - TextureHelper11 dest = TextureHelper11::MakeAndReference(dstTexture, getANGLEFormat()); + TextureHelper11 source = TextureHelper11::MakeAndReference(srcTexture, getFormatSet()); + TextureHelper11 dest = TextureHelper11::MakeAndReference(dstTexture, getFormatSet()); return blitter->copyDepthStencil(source, sourceSubresource, copyArea, texSize, dest, dstSubresource, copyArea, texSize, nullptr); } @@ -461,22 +460,16 @@ gl::Error TextureStorage11::copySubresourceLevel(ID3D11Resource *dstTexture, ASSERT(dstTexture); ID3D11Resource *srcTexture = nullptr; - gl::Error error(GL_NO_ERROR); // If the zero-LOD workaround is active and we want to update a level greater than zero, then we // should update the mipmapped texture, even if mapmaps are currently disabled. if (index.mipIndex > 0 && mRenderer->getWorkarounds().zeroMaxLodWorkaround) { - error = getMippedResource(&srcTexture); + ANGLE_TRY(getMippedResource(&srcTexture)); } else { - error = getResource(&srcTexture); - } - - if (error.isError()) - { - return error; + ANGLE_TRY(getResource(&srcTexture)); } ASSERT(srcTexture); @@ -494,7 +487,7 @@ gl::Error TextureStorage11::copySubresourceLevel(ID3D11Resource *dstTexture, // However, D3D10Level9 doesn't always perform CopySubresourceRegion correctly unless the // source box is specified. This is okay, since we don't perform CopySubresourceRegion on // depth/stencil textures on 9_3. - ASSERT(mTextureFormatSet->dsvFormat == DXGI_FORMAT_UNKNOWN); + ASSERT(mFormatInfo.dsvFormat == DXGI_FORMAT_UNKNOWN); srcBox.left = region.x; srcBox.right = region.x + region.width; srcBox.top = region.y; @@ -515,21 +508,13 @@ gl::Error TextureStorage11::generateMipmap(const gl::ImageIndex &sourceIndex, { ASSERT(sourceIndex.layerIndex == destIndex.layerIndex); - invalidateSwizzleCacheLevel(destIndex.mipIndex); + markLevelDirty(destIndex.mipIndex); RenderTargetD3D *source = nullptr; - gl::Error error = getRenderTarget(sourceIndex, &source); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getRenderTarget(sourceIndex, &source)); RenderTargetD3D *dest = nullptr; - error = getRenderTarget(destIndex, &dest); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getRenderTarget(destIndex, &dest)); ID3D11ShaderResourceView *sourceSRV = GetAs<RenderTarget11>(source)->getBlitShaderResourceView(); @@ -542,9 +527,10 @@ gl::Error TextureStorage11::generateMipmap(const gl::ImageIndex &sourceIndex, gl::Extents destSize(dest->getWidth(), dest->getHeight(), dest->getDepth()); Blit11 *blitter = mRenderer->getBlitter(); - return blitter->copyTexture( - sourceSRV, sourceArea, sourceSize, destRTV, destArea, destSize, nullptr, - gl::GetInternalFormatInfo(source->getInternalFormat()).format, GL_LINEAR, false); + return blitter->copyTexture(sourceSRV, sourceArea, sourceSize, destRTV, destArea, destSize, + nullptr, + gl::GetInternalFormatInfo(source->getInternalFormat()).format, + GL_LINEAR, false, false, false); } void TextureStorage11::verifySwizzleExists(const gl::SwizzleState &swizzleState) @@ -557,7 +543,7 @@ void TextureStorage11::verifySwizzleExists(const gl::SwizzleState &swizzleState) void TextureStorage11::clearSRVCache() { - invalidateSwizzleCache(); + markDirty(); auto iter = mSrvCache.begin(); while (iter != mSrvCache.end()) @@ -585,26 +571,18 @@ gl::Error TextureStorage11::copyToStorage(TextureStorage *destStorage) ASSERT(destStorage); ID3D11Resource *sourceResouce = nullptr; - gl::Error error = getResource(&sourceResouce); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getResource(&sourceResouce)); TextureStorage11 *dest11 = GetAs<TextureStorage11>(destStorage); ID3D11Resource *destResource = nullptr; - error = dest11->getResource(&destResource); - if (error.isError()) - { - return error; - } + ANGLE_TRY(dest11->getResource(&destResource)); ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); immediateContext->CopyResource(destResource, sourceResouce); - dest11->invalidateSwizzleCache(); + dest11->markDirty(); - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11::setData(const gl::ImageIndex &index, @@ -616,6 +594,8 @@ gl::Error TextureStorage11::setData(const gl::ImageIndex &index, { ASSERT(!image->isDirty()); + markLevelDirty(index.mipIndex); + ID3D11Resource *resource = nullptr; ANGLE_TRY(getResource(&resource)); ASSERT(resource); @@ -644,19 +624,17 @@ gl::Error TextureStorage11::setData(const gl::ImageIndex &index, internalFormatInfo.computeRowPitch(type, width, unpack.alignment, unpack.rowLength), srcRowPitch); GLuint srcDepthPitch = 0; - ANGLE_TRY_RESULT(internalFormatInfo.computeDepthPitch(type, width, height, unpack.alignment, - unpack.rowLength, unpack.imageHeight), + ANGLE_TRY_RESULT(internalFormatInfo.computeDepthPitch(height, unpack.imageHeight, srcRowPitch), srcDepthPitch); GLuint srcSkipBytes = 0; ANGLE_TRY_RESULT( - internalFormatInfo.computeSkipBytes(srcRowPitch, srcDepthPitch, unpack.skipImages, - unpack.skipRows, unpack.skipPixels, index.is3D()), + internalFormatInfo.computeSkipBytes(srcRowPitch, srcDepthPitch, unpack, index.is3D()), srcSkipBytes); - const d3d11::TextureFormat &d3d11Format = d3d11::GetTextureFormatInfo( - image->getInternalFormat(), mRenderer->getRenderer11DeviceCaps()); + const d3d11::Format &d3d11Format = + d3d11::Format::Get(image->getInternalFormat(), mRenderer->getRenderer11DeviceCaps()); const d3d11::DXGIFormatSize &dxgiFormatInfo = - d3d11::GetDXGIFormatSizeInfo(d3d11Format.formatSet->texFormat); + d3d11::GetDXGIFormatSizeInfo(d3d11Format.texFormat); const size_t outputPixelSize = dxgiFormatInfo.pixelBytes; @@ -667,7 +645,7 @@ gl::Error TextureStorage11::setData(const gl::ImageIndex &index, MemoryBuffer *conversionBuffer = nullptr; const uint8_t *data = nullptr; - d3d11::LoadImageFunctionInfo loadFunctionInfo = d3d11Format.loadFunctions.at(type); + LoadImageFunctionInfo loadFunctionInfo = d3d11Format.loadFunctions(type); if (loadFunctionInfo.requiresConversion) { ANGLE_TRY(mRenderer->getScratchMemoryBuffer(neededSize, &conversionBuffer)); @@ -709,8 +687,17 @@ gl::Error TextureStorage11::setData(const gl::ImageIndex &index, return gl::NoError(); } +gl::Error TextureStorage11::createDropStencilTexture() +{ + UNIMPLEMENTED(); + return gl::Error(GL_INVALID_OPERATION, "Drop stencil texture not implemented."); +} + TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swapchain) - : TextureStorage11(renderer, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, 0), + : TextureStorage11(renderer, + D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, + 0, + swapchain->getRenderTargetInternalFormat()), mTexture(swapchain->getOffscreenTexture()), mLevelZeroTexture(nullptr), mLevelZeroRenderTarget(nullptr), @@ -733,13 +720,6 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swap mTextureHeight = texDesc.Height; mTextureDepth = 1; mHasKeyedMutex = (texDesc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0; - - mInternalFormat = swapchain->GetRenderTargetInternalFormat(); - - const auto &formatInfo = - d3d11::GetTextureFormatInfo(mInternalFormat, mRenderer->getRenderer11DeviceCaps()); - mTextureFormatSet = formatInfo.formatSet; - mSwizzleFormatSet = formatInfo.swizzleFormatSet; } TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, @@ -755,7 +735,8 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, GetTextureMiscFlags(internalformat, renderer->getRenderer11DeviceCaps(), renderTarget, - levels)), + levels), + internalformat), mTexture(nullptr), mHasKeyedMutex(false), mLevelZeroTexture(nullptr), @@ -770,14 +751,7 @@ TextureStorage11_2D::TextureStorage11_2D(Renderer11 *renderer, mSwizzleRenderTargets[i] = nullptr; } - mInternalFormat = internalformat; - - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalformat, renderer->getRenderer11DeviceCaps()); - mTextureFormatSet = formatInfo.formatSet; - mSwizzleFormatSet = formatInfo.swizzleFormatSet; - - d3d11::MakeValidSize(false, mTextureFormatSet->texFormat, &width, &height, &mTopLevel); + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel); mMipLevels = mTopLevel + levels; mTextureWidth = width; mTextureHeight = height; @@ -842,63 +816,37 @@ gl::Error TextureStorage11_2D::copyToStorage(TextureStorage *destStorage) // corresponding textures in destStorage. if (mTexture) { - gl::Error error = dest11->useLevelZeroWorkaroundTexture(false); - if (error.isError()) - { - return error; - } + ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(false)); ID3D11Resource *destResource = nullptr; - error = dest11->getResource(&destResource); - if (error.isError()) - { - return error; - } + ANGLE_TRY(dest11->getResource(&destResource)); immediateContext->CopyResource(destResource, mTexture); } if (mLevelZeroTexture) { - gl::Error error = dest11->useLevelZeroWorkaroundTexture(true); - if (error.isError()) - { - return error; - } + ANGLE_TRY(dest11->useLevelZeroWorkaroundTexture(true)); ID3D11Resource *destResource = nullptr; - error = dest11->getResource(&destResource); - if (error.isError()) - { - return error; - } + ANGLE_TRY(dest11->getResource(&destResource)); immediateContext->CopyResource(destResource, mLevelZeroTexture); } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } - else - { - ID3D11Resource *sourceResouce = nullptr; - gl::Error error = getResource(&sourceResouce); - if (error.isError()) - { - return error; - } - ID3D11Resource *destResource = nullptr; - error = dest11->getResource(&destResource); - if (error.isError()) - { - return error; - } + ID3D11Resource *sourceResouce = nullptr; + ANGLE_TRY(getResource(&sourceResouce)); - immediateContext->CopyResource(destResource, sourceResouce); - dest11->invalidateSwizzleCache(); - } + ID3D11Resource *destResource = nullptr; + ANGLE_TRY(dest11->getResource(&destResource)); - return gl::Error(GL_NO_ERROR); + immediateContext->CopyResource(destResource, sourceResouce); + dest11->markDirty(); + + return gl::NoError(); } gl::Error TextureStorage11_2D::useLevelZeroWorkaroundTexture(bool useLevelZeroTexture) @@ -909,11 +857,7 @@ gl::Error TextureStorage11_2D::useLevelZeroWorkaroundTexture(bool useLevelZeroTe { if (!mUseLevelZeroTexture && mTexture) { - gl::Error error = ensureTextureExists(1); - if (error.isError()) - { - return error; - } + ANGLE_TRY(ensureTextureExists(1)); // Pull data back from the mipped texture if necessary. ASSERT(mLevelZeroTexture); @@ -927,11 +871,7 @@ gl::Error TextureStorage11_2D::useLevelZeroWorkaroundTexture(bool useLevelZeroTe { if (mUseLevelZeroTexture && mLevelZeroTexture) { - gl::Error error = ensureTextureExists(mMipLevels); - if (error.isError()) - { - return error; - } + ANGLE_TRY(ensureTextureExists(mMipLevels)); // Pull data back from the level zero texture if necessary. ASSERT(mTexture); @@ -958,7 +898,7 @@ gl::Error TextureStorage11_2D::useLevelZeroWorkaroundTexture(bool useLevelZeroTe } } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } void TextureStorage11_2D::associateImage(Image11 *image, const gl::ImageIndex &index) @@ -1040,33 +980,23 @@ gl::Error TextureStorage11_2D::releaseAssociatedImage(const gl::ImageIndex &inde } } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11_2D::getResource(ID3D11Resource **outResource) { if (mUseLevelZeroTexture && mMipLevels > 1) { - gl::Error error = ensureTextureExists(1); - if (error.isError()) - { - return error; - } + ANGLE_TRY(ensureTextureExists(1)); *outResource = mLevelZeroTexture; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } - else - { - gl::Error error = ensureTextureExists(mMipLevels); - if (error.isError()) - { - return error; - } - *outResource = mTexture; - return gl::Error(GL_NO_ERROR); - } + ANGLE_TRY(ensureTextureExists(mMipLevels)); + + *outResource = mTexture; + return gl::NoError(); } gl::Error TextureStorage11_2D::getMippedResource(ID3D11Resource **outResource) @@ -1074,14 +1004,10 @@ gl::Error TextureStorage11_2D::getMippedResource(ID3D11Resource **outResource) // This shouldn't be called unless the zero max LOD workaround is active. ASSERT(mRenderer->getWorkarounds().zeroMaxLodWorkaround); - gl::Error error = ensureTextureExists(mMipLevels); - if (error.isError()) - { - return error; - } + ANGLE_TRY(ensureTextureExists(mMipLevels)); *outResource = mTexture; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11_2D::ensureTextureExists(int mipLevels) @@ -1105,7 +1031,7 @@ gl::Error TextureStorage11_2D::ensureTextureExists(int mipLevels) desc.Height = mTextureHeight; desc.MipLevels = mipLevels; desc.ArraySize = 1; - desc.Format = mTextureFormatSet->texFormat; + desc.Format = mFormatInfo.texFormat; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -1155,29 +1081,17 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend if (mRenderTarget[level]) { *outRT = mRenderTarget[level]; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } ID3D11Resource *texture = nullptr; - gl::Error error = getResource(&texture); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getResource(&texture)); ID3D11ShaderResourceView *srv = nullptr; - error = getSRVLevel(level, false, &srv); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getSRVLevel(level, false, &srv)); ID3D11ShaderResourceView *blitSRV = nullptr; - error = getSRVLevel(level, true, &blitSRV); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getSRVLevel(level, true, &blitSRV)); ID3D11Device *device = mRenderer->getDevice(); @@ -1186,7 +1100,7 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend if (!mLevelZeroRenderTarget) { D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mTextureFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; rtvDesc.Texture2D.MipSlice = mTopLevel + level; @@ -1203,21 +1117,21 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend ASSERT(SUCCEEDED(result)); mLevelZeroRenderTarget = new TextureRenderTarget11( - rtv, mLevelZeroTexture, nullptr, nullptr, mInternalFormat, - mTextureFormatSet->format, getLevelWidth(level), getLevelHeight(level), 1, 0); + rtv, mLevelZeroTexture, nullptr, nullptr, mFormatInfo.internalFormat, + getFormatSet(), getLevelWidth(level), getLevelHeight(level), 1, 0); // RenderTarget will take ownership of these resources SafeRelease(rtv); } *outRT = mLevelZeroRenderTarget; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } - if (mTextureFormatSet->rtvFormat != DXGI_FORMAT_UNKNOWN) + if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) { D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mTextureFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; rtvDesc.Texture2D.MipSlice = mTopLevel + level; @@ -1234,7 +1148,7 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend } mRenderTarget[level] = new TextureRenderTarget11( - rtv, texture, srv, blitSRV, mInternalFormat, mTextureFormatSet->format, + rtv, texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(level), getLevelHeight(level), 1, 0); // RenderTarget will take ownership of these resources @@ -1244,10 +1158,10 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend return gl::Error(GL_NO_ERROR); } - ASSERT(mTextureFormatSet->dsvFormat != DXGI_FORMAT_UNKNOWN); + ASSERT(mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN); D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; - dsvDesc.Format = mTextureFormatSet->dsvFormat; + dsvDesc.Format = mFormatInfo.dsvFormat; dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; dsvDesc.Texture2D.MipSlice = mTopLevel + level; dsvDesc.Flags = 0; @@ -1265,14 +1179,14 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::ImageIndex &index, Rend } mRenderTarget[level] = - new TextureRenderTarget11(dsv, texture, srv, mInternalFormat, mTextureFormatSet->format, + new TextureRenderTarget11(dsv, texture, srv, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(level), getLevelHeight(level), 1, 0); // RenderTarget will take ownership of these resources SafeRelease(dsv); *outRT = mRenderTarget[level]; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11_2D::createSRV(int baseLevel, @@ -1340,7 +1254,7 @@ gl::Error TextureStorage11_2D::getSwizzleTexture(ID3D11Resource **outTexture) desc.Height = mTextureHeight; desc.MipLevels = mMipLevels; desc.ArraySize = 1; - desc.Format = mSwizzleFormatSet->texFormat; + desc.Format = mFormatInfo.swizzle.texFormat; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -1381,7 +1295,7 @@ gl::Error TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel, ID3D11Render ID3D11Device *device = mRenderer->getDevice(); D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mSwizzleFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.swizzle.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel; @@ -1398,14 +1312,48 @@ gl::Error TextureStorage11_2D::getSwizzleRenderTarget(int mipLevel, ID3D11Render } *outRTV = mSwizzleRenderTargets[mipLevel]; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); +} + +gl::Error TextureStorage11_2D::createDropStencilTexture() +{ + if (mDropStencilTexture) + { + return gl::NoError(); + } + + D3D11_TEXTURE2D_DESC dropDesc = {}; + dropDesc.ArraySize = 1; + dropDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DEPTH_STENCIL; + dropDesc.CPUAccessFlags = 0; + dropDesc.Format = DXGI_FORMAT_R32_TYPELESS; + dropDesc.Height = mTextureHeight; + dropDesc.MipLevels = mMipLevels; + dropDesc.MiscFlags = 0; + dropDesc.SampleDesc.Count = 1; + dropDesc.SampleDesc.Quality = 0; + dropDesc.Usage = D3D11_USAGE_DEFAULT; + dropDesc.Width = mTextureWidth; + + ID3D11Device *device = mRenderer->getDevice(); + + HRESULT hr = device->CreateTexture2D(&dropDesc, nullptr, &mDropStencilTexture); + if (FAILED(hr)) + { + return gl::Error(GL_INVALID_OPERATION, "Error creating drop stencil texture."); + } + d3d11::SetDebugName(mDropStencilTexture, "TexStorage2D.DropStencil"); + + ANGLE_TRY(initDropStencilTexture(gl::ImageIndexIterator::Make2D(0, mMipLevels))); + + return gl::NoError(); } TextureStorage11_External::TextureStorage11_External( Renderer11 *renderer, egl::Stream *stream, const egl::Stream::GLTextureDescription &glDesc) - : TextureStorage11(renderer, D3D11_BIND_SHADER_RESOURCE, 0) + : TextureStorage11(renderer, D3D11_BIND_SHADER_RESOURCE, 0, glDesc.internalFormat) { ASSERT(stream->getProducerType() == egl::Stream::ProducerType::D3D11TextureNV12); StreamProducerNV12 *producer = static_cast<StreamProducerNV12 *>(stream->getImplementation()); @@ -1419,13 +1367,7 @@ TextureStorage11_External::TextureStorage11_External( mTextureWidth = desc.Width; mTextureHeight = desc.Height; mTextureDepth = 1; - mInternalFormat = glDesc.internalFormat; mHasKeyedMutex = (desc.MiscFlags & D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX) != 0; - - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(mInternalFormat, renderer->getRenderer11DeviceCaps()); - mTextureFormatSet = formatInfo.formatSet; - mSwizzleFormatSet = formatInfo.swizzleFormatSet; } TextureStorage11_External::~TextureStorage11_External() @@ -1554,25 +1496,24 @@ gl::Error TextureStorage11_External::getSwizzleRenderTarget(int mipLevel, return gl::Error(GL_INVALID_OPERATION); } -TextureStorage11_EGLImage::TextureStorage11_EGLImage(Renderer11 *renderer, EGLImageD3D *eglImage) - : TextureStorage11(renderer, D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, 0), +TextureStorage11_EGLImage::TextureStorage11_EGLImage(Renderer11 *renderer, + EGLImageD3D *eglImage, + RenderTarget11 *renderTarget11) + : TextureStorage11(renderer, + D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE, + 0, + renderTarget11->getInternalFormat()), mImage(eglImage), mCurrentRenderTarget(0), mSwizzleTexture(nullptr), mSwizzleRenderTargets(gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS, nullptr) { - RenderTargetD3D *renderTargetD3D = nullptr; - mImage->getRenderTarget(&renderTargetD3D); - RenderTarget11 *renderTarget11 = GetAs<RenderTarget11>(renderTargetD3D); - mCurrentRenderTarget = reinterpret_cast<uintptr_t>(renderTarget11); + mCurrentRenderTarget = reinterpret_cast<uintptr_t>(renderTarget11); mMipLevels = 1; - mTextureFormatSet = &d3d11::GetANGLEFormatSet(renderTarget11->getANGLEFormat()); - mSwizzleFormatSet = &d3d11::GetANGLEFormatSet(mTextureFormatSet->swizzleFormat); mTextureWidth = renderTarget11->getWidth(); mTextureHeight = renderTarget11->getHeight(); mTextureDepth = 1; - mInternalFormat = renderTarget11->getInternalFormat(); } TextureStorage11_EGLImage::~TextureStorage11_EGLImage() @@ -1586,32 +1527,18 @@ TextureStorage11_EGLImage::~TextureStorage11_EGLImage() gl::Error TextureStorage11_EGLImage::getResource(ID3D11Resource **outResource) { - gl::Error error = checkForUpdatedRenderTarget(); - if (error.isError()) - { - return error; - } + ANGLE_TRY(checkForUpdatedRenderTarget()); RenderTarget11 *renderTarget11 = nullptr; - error = getImageRenderTarget(&renderTarget11); - if (error.isError()) - { - return error; - } - + ANGLE_TRY(getImageRenderTarget(&renderTarget11)); *outResource = renderTarget11->getTexture(); - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11_EGLImage::getSRV(const gl::TextureState &textureState, ID3D11ShaderResourceView **outSRV) { - gl::Error error = checkForUpdatedRenderTarget(); - if (error.isError()) - { - return error; - } - + ANGLE_TRY(checkForUpdatedRenderTarget()); return TextureStorage11::getSRV(textureState, outSRV); } @@ -1660,7 +1587,7 @@ gl::Error TextureStorage11_EGLImage::copyToStorage(TextureStorage *destStorage) ID3D11DeviceContext *immediateContext = mRenderer->getDeviceContext(); immediateContext->CopyResource(destResource, sourceResouce); - dest11->invalidateSwizzleCache(); + dest11->markDirty(); return gl::Error(GL_NO_ERROR); } @@ -1702,7 +1629,7 @@ gl::Error TextureStorage11_EGLImage::getSwizzleTexture(ID3D11Resource **outTextu desc.Height = mTextureHeight; desc.MipLevels = mMipLevels; desc.ArraySize = 1; - desc.Format = mSwizzleFormatSet->texFormat; + desc.Format = mFormatInfo.swizzle.texFormat; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -1744,7 +1671,7 @@ gl::Error TextureStorage11_EGLImage::getSwizzleRenderTarget(int mipLevel, ID3D11Device *device = mRenderer->getDevice(); D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mSwizzleFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.swizzle.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D; rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel; @@ -1767,11 +1694,7 @@ gl::Error TextureStorage11_EGLImage::getSwizzleRenderTarget(int mipLevel, gl::Error TextureStorage11_EGLImage::checkForUpdatedRenderTarget() { RenderTarget11 *renderTarget11 = nullptr; - gl::Error error = getImageRenderTarget(&renderTarget11); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getImageRenderTarget(&renderTarget11)); if (mCurrentRenderTarget != reinterpret_cast<uintptr_t>(renderTarget11)) { @@ -1779,7 +1702,7 @@ gl::Error TextureStorage11_EGLImage::checkForUpdatedRenderTarget() mCurrentRenderTarget = reinterpret_cast<uintptr_t>(renderTarget11); } - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11_EGLImage::createSRV(int baseLevel, @@ -1836,14 +1759,9 @@ gl::Error TextureStorage11_EGLImage::createSRV(int baseLevel, gl::Error TextureStorage11_EGLImage::getImageRenderTarget(RenderTarget11 **outRT) const { RenderTargetD3D *renderTargetD3D = nullptr; - gl::Error error = mImage->getRenderTarget(&renderTargetD3D); - if (error.isError()) - { - return error; - } - + ANGLE_TRY(mImage->getRenderTarget(&renderTargetD3D)); *outRT = GetAs<RenderTarget11>(renderTargetD3D); - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer, @@ -1858,7 +1776,8 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer, GetTextureMiscFlags(internalformat, renderer->getRenderer11DeviceCaps(), renderTarget, - levels)), + levels), + internalformat), mTexture(nullptr), mLevelZeroTexture(nullptr), mUseLevelZeroTexture(hintLevelZeroOnly && levels > 1), @@ -1879,16 +1798,9 @@ TextureStorage11_Cube::TextureStorage11_Cube(Renderer11 *renderer, mLevelZeroRenderTarget[face] = nullptr; } - mInternalFormat = internalformat; - - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalformat, renderer->getRenderer11DeviceCaps()); - mTextureFormatSet = formatInfo.formatSet; - mSwizzleFormatSet = formatInfo.swizzleFormatSet; - // adjust size if needed for compressed textures int height = size; - d3d11::MakeValidSize(false, mTextureFormatSet->texFormat, &size, &height, &mTopLevel); + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &size, &height, &mTopLevel); mMipLevels = mTopLevel + levels; mTextureWidth = size; @@ -2028,7 +1940,7 @@ gl::Error TextureStorage11_Cube::copyToStorage(TextureStorage *destStorage) immediateContext->CopyResource(destResource, sourceResouce); } - dest11->invalidateSwizzleCache(); + dest11->markDirty(); return gl::Error(GL_NO_ERROR); } @@ -2091,11 +2003,11 @@ void TextureStorage11_Cube::associateImage(Image11 *image, const gl::ImageIndex const GLint layerTarget = index.layerIndex; ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); - ASSERT(0 <= layerTarget && layerTarget < CUBE_FACE_COUNT); + ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(CUBE_FACE_COUNT)); if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) { - if (0 <= layerTarget && layerTarget < CUBE_FACE_COUNT) + if (0 <= layerTarget && layerTarget < static_cast<GLint>(CUBE_FACE_COUNT)) { mAssociatedImages[layerTarget][level] = image; } @@ -2110,7 +2022,7 @@ bool TextureStorage11_Cube::isAssociatedImageValid(const gl::ImageIndex &index, if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) { - if (0 <= layerTarget && layerTarget < CUBE_FACE_COUNT) + if (0 <= layerTarget && layerTarget < static_cast<GLint>(CUBE_FACE_COUNT)) { // This validation check should never return false. It means the Image/TextureStorage // association is broken. @@ -2130,11 +2042,11 @@ void TextureStorage11_Cube::disassociateImage(const gl::ImageIndex &index, Image const GLint layerTarget = index.layerIndex; ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); - ASSERT(0 <= layerTarget && layerTarget < CUBE_FACE_COUNT); + ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(CUBE_FACE_COUNT)); if (0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS) { - if (0 <= layerTarget && layerTarget < CUBE_FACE_COUNT) + if (0 <= layerTarget && layerTarget < static_cast<GLint>(CUBE_FACE_COUNT)) { ASSERT(mAssociatedImages[layerTarget][level] == expectedImage); @@ -2155,11 +2067,11 @@ gl::Error TextureStorage11_Cube::releaseAssociatedImage(const gl::ImageIndex &in const GLint layerTarget = index.layerIndex; ASSERT(0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS); - ASSERT(0 <= layerTarget && layerTarget < CUBE_FACE_COUNT); + ASSERT(0 <= layerTarget && layerTarget < static_cast<GLint>(CUBE_FACE_COUNT)); if ((0 <= level && level < gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS)) { - if (0 <= layerTarget && layerTarget < CUBE_FACE_COUNT) + if (0 <= layerTarget && layerTarget < static_cast<GLint>(CUBE_FACE_COUNT)) { // No need to let the old Image recover its data, if it is also the incoming Image. if (mAssociatedImages[layerTarget][level] != nullptr && @@ -2251,7 +2163,7 @@ gl::Error TextureStorage11_Cube::ensureTextureExists(int mipLevels) desc.Height = mTextureHeight; desc.MipLevels = mipLevels; desc.ArraySize = CUBE_FACE_COUNT; - desc.Format = mTextureFormatSet->texFormat; + desc.Format = mFormatInfo.texFormat; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -2324,7 +2236,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, const int level = index.mipIndex; ASSERT(level >= 0 && level < getLevelCount()); - ASSERT(faceIndex >= 0 && faceIndex < CUBE_FACE_COUNT); + ASSERT(faceIndex >= 0 && faceIndex < static_cast<GLint>(CUBE_FACE_COUNT)); if (!mRenderTarget[faceIndex][level]) { @@ -2343,7 +2255,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, if (!mLevelZeroRenderTarget[faceIndex]) { D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mTextureFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; rtvDesc.Texture2DArray.MipSlice = mTopLevel + level; rtvDesc.Texture2DArray.FirstArraySlice = faceIndex; @@ -2362,8 +2274,8 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, ASSERT(SUCCEEDED(result)); mLevelZeroRenderTarget[faceIndex] = new TextureRenderTarget11( - rtv, mLevelZeroTexture, nullptr, nullptr, mInternalFormat, - mTextureFormatSet->format, getLevelWidth(level), getLevelHeight(level), 1, 0); + rtv, mLevelZeroTexture, nullptr, nullptr, mFormatInfo.internalFormat, + getFormatSet(), getLevelWidth(level), getLevelHeight(level), 1, 0); // RenderTarget will take ownership of these resources SafeRelease(rtv); @@ -2375,16 +2287,15 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, } ID3D11ShaderResourceView *srv = nullptr; - error = createRenderTargetSRV(texture, index, mTextureFormatSet->srvFormat, &srv); + error = createRenderTargetSRV(texture, index, mFormatInfo.srvFormat, &srv); if (error.isError()) { return error; } ID3D11ShaderResourceView *blitSRV = nullptr; - if (mTextureFormatSet->blitSRVFormat != mTextureFormatSet->srvFormat) + if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat) { - error = - createRenderTargetSRV(texture, index, mTextureFormatSet->blitSRVFormat, &blitSRV); + error = createRenderTargetSRV(texture, index, mFormatInfo.blitSRVFormat, &blitSRV); if (error.isError()) { SafeRelease(srv); @@ -2399,10 +2310,10 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, d3d11::SetDebugName(srv, "TexStorageCube.RenderTargetSRV"); - if (mTextureFormatSet->rtvFormat != DXGI_FORMAT_UNKNOWN) + if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) { D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mTextureFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; rtvDesc.Texture2DArray.MipSlice = mTopLevel + level; rtvDesc.Texture2DArray.FirstArraySlice = faceIndex; @@ -2425,7 +2336,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, d3d11::SetDebugName(rtv, "TexStorageCube.RenderTargetRTV"); mRenderTarget[faceIndex][level] = new TextureRenderTarget11( - rtv, texture, srv, blitSRV, mInternalFormat, mTextureFormatSet->format, + rtv, texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(level), getLevelHeight(level), 1, 0); // RenderTarget will take ownership of these resources @@ -2433,10 +2344,10 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, SafeRelease(srv); SafeRelease(blitSRV); } - else if (mTextureFormatSet->dsvFormat != DXGI_FORMAT_UNKNOWN) + else if (mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) { D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; - dsvDesc.Format = mTextureFormatSet->dsvFormat; + dsvDesc.Format = mFormatInfo.dsvFormat; dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; dsvDesc.Flags = 0; dsvDesc.Texture2DArray.MipSlice = mTopLevel + level; @@ -2460,7 +2371,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::ImageIndex &index, d3d11::SetDebugName(dsv, "TexStorageCube.RenderTargetDSV"); mRenderTarget[faceIndex][level] = new TextureRenderTarget11( - dsv, texture, srv, mInternalFormat, mTextureFormatSet->format, getLevelWidth(level), + dsv, texture, srv, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(level), getLevelHeight(level), 1, 0); // RenderTarget will take ownership of these resources @@ -2559,7 +2470,7 @@ gl::Error TextureStorage11_Cube::getSwizzleTexture(ID3D11Resource **outTexture) desc.Height = mTextureHeight; desc.MipLevels = mMipLevels; desc.ArraySize = CUBE_FACE_COUNT; - desc.Format = mSwizzleFormatSet->texFormat; + desc.Format = mFormatInfo.swizzle.texFormat; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -2601,7 +2512,7 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel, ID3D11Device *device = mRenderer->getDevice(); D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mSwizzleFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.swizzle.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; rtvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; rtvDesc.Texture2DArray.FirstArraySlice = 0; @@ -2623,6 +2534,66 @@ gl::Error TextureStorage11_Cube::getSwizzleRenderTarget(int mipLevel, return gl::Error(GL_NO_ERROR); } +gl::Error TextureStorage11::initDropStencilTexture(const gl::ImageIndexIterator &it) +{ + ID3D11Resource *resource = nullptr; + ANGLE_TRY(getResource(&resource)); + TextureHelper11 sourceTexture = TextureHelper11::MakeAndReference(resource, mFormatInfo); + TextureHelper11 destTexture = TextureHelper11::MakeAndReference( + mDropStencilTexture, + d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps())); + + gl::ImageIndexIterator itCopy = it; + + while (itCopy.hasNext()) + { + gl::ImageIndex index = itCopy.next(); + gl::Box wholeArea(0, 0, 0, getLevelWidth(index.mipIndex), getLevelHeight(index.mipIndex), + 1); + gl::Extents wholeSize(wholeArea.width, wholeArea.height, 1); + UINT subresource = getSubresourceIndex(index); + ANGLE_TRY(mRenderer->getBlitter()->copyDepthStencil(sourceTexture, subresource, wholeArea, + wholeSize, destTexture, subresource, + wholeArea, wholeSize, nullptr)); + } + + return gl::NoError(); +} + +gl::Error TextureStorage11_Cube::createDropStencilTexture() +{ + if (mDropStencilTexture) + { + return gl::NoError(); + } + + D3D11_TEXTURE2D_DESC dropDesc = {}; + dropDesc.ArraySize = 6; + dropDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DEPTH_STENCIL; + dropDesc.CPUAccessFlags = 0; + dropDesc.Format = DXGI_FORMAT_R32_TYPELESS; + dropDesc.Height = mTextureHeight; + dropDesc.MipLevels = mMipLevels; + dropDesc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE; + dropDesc.SampleDesc.Count = 1; + dropDesc.SampleDesc.Quality = 0; + dropDesc.Usage = D3D11_USAGE_DEFAULT; + dropDesc.Width = mTextureWidth; + + ID3D11Device *device = mRenderer->getDevice(); + + HRESULT hr = device->CreateTexture2D(&dropDesc, nullptr, &mDropStencilTexture); + if (FAILED(hr)) + { + return gl::Error(GL_INVALID_OPERATION, "Error creating drop stencil texture."); + } + d3d11::SetDebugName(mDropStencilTexture, "TexStorageCube.DropStencil"); + + ANGLE_TRY(initDropStencilTexture(gl::ImageIndexIterator::MakeCube(0, mMipLevels))); + + return gl::NoError(); +} + TextureStorage11_3D::TextureStorage11_3D(Renderer11 *renderer, GLenum internalformat, bool renderTarget, @@ -2636,7 +2607,8 @@ TextureStorage11_3D::TextureStorage11_3D(Renderer11 *renderer, GetTextureMiscFlags(internalformat, renderer->getRenderer11DeviceCaps(), renderTarget, - levels)) + levels), + internalformat) { mTexture = nullptr; mSwizzleTexture = nullptr; @@ -2648,15 +2620,8 @@ TextureStorage11_3D::TextureStorage11_3D(Renderer11 *renderer, mSwizzleRenderTargets[i] = nullptr; } - mInternalFormat = internalformat; - - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalformat, renderer->getRenderer11DeviceCaps()); - mTextureFormatSet = formatInfo.formatSet; - mSwizzleFormatSet = formatInfo.swizzleFormatSet; - // adjust size if needed for compressed textures - d3d11::MakeValidSize(false, mTextureFormatSet->texFormat, &width, &height, &mTopLevel); + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel); mMipLevels = mTopLevel + levels; mTextureWidth = width; @@ -2796,7 +2761,7 @@ gl::Error TextureStorage11_3D::getResource(ID3D11Resource **outResource) desc.Height = mTextureHeight; desc.Depth = mTextureDepth; desc.MipLevels = mMipLevels; - desc.Format = mTextureFormatSet->texFormat; + desc.Format = mFormatInfo.texFormat; desc.Usage = D3D11_USAGE_DEFAULT; desc.BindFlags = getBindFlags(); desc.CPUAccessFlags = 0; @@ -2859,37 +2824,25 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend const int mipLevel = index.mipIndex; ASSERT(mipLevel >= 0 && mipLevel < getLevelCount()); - ASSERT(mTextureFormatSet->rtvFormat != DXGI_FORMAT_UNKNOWN); + ASSERT(mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN); if (!index.hasLayer()) { if (!mLevelRenderTargets[mipLevel]) { ID3D11Resource *texture = nullptr; - gl::Error error = getResource(&texture); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getResource(&texture)); ID3D11ShaderResourceView *srv = nullptr; - error = getSRVLevel(mipLevel, false, &srv); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getSRVLevel(mipLevel, false, &srv)); ID3D11ShaderResourceView *blitSRV = nullptr; - error = getSRVLevel(mipLevel, true, &blitSRV); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getSRVLevel(mipLevel, true, &blitSRV)); ID3D11Device *device = mRenderer->getDevice(); D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mTextureFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; rtvDesc.Texture3D.MipSlice = mTopLevel + mipLevel; rtvDesc.Texture3D.FirstWSlice = 0; @@ -2912,7 +2865,7 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend d3d11::SetDebugName(rtv, "TexStorage3D.RTV"); mLevelRenderTargets[mipLevel] = new TextureRenderTarget11( - rtv, texture, srv, blitSRV, mInternalFormat, mTextureFormatSet->format, + rtv, texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(mipLevel), getLevelHeight(mipLevel), getLevelDepth(mipLevel), 0); // RenderTarget will take ownership of these resources @@ -2945,7 +2898,7 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend ID3D11ShaderResourceView *blitSRV = nullptr; D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mTextureFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; rtvDesc.Texture3D.MipSlice = mTopLevel + mipLevel; rtvDesc.Texture3D.FirstWSlice = layer; @@ -2969,7 +2922,7 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::ImageIndex &index, Rend d3d11::SetDebugName(rtv, "TexStorage3D.LayerRTV"); mLevelLayerRenderTargets[key] = new TextureRenderTarget11( - rtv, texture, srv, blitSRV, mInternalFormat, mTextureFormatSet->format, + rtv, texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0); // RenderTarget will take ownership of these resources @@ -2995,7 +2948,7 @@ gl::Error TextureStorage11_3D::getSwizzleTexture(ID3D11Resource **outTexture) desc.Height = mTextureHeight; desc.Depth = mTextureDepth; desc.MipLevels = mMipLevels; - desc.Format = mSwizzleFormatSet->texFormat; + desc.Format = mFormatInfo.swizzle.texFormat; desc.Usage = D3D11_USAGE_DEFAULT; desc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; desc.CPUAccessFlags = 0; @@ -3025,16 +2978,12 @@ gl::Error TextureStorage11_3D::getSwizzleRenderTarget(int mipLevel, ID3D11Render if (!mSwizzleRenderTargets[mipLevel]) { ID3D11Resource *swizzleTexture = nullptr; - gl::Error error = getSwizzleTexture(&swizzleTexture); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getSwizzleTexture(&swizzleTexture)); ID3D11Device *device = mRenderer->getDevice(); D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mSwizzleFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.swizzle.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE3D; rtvDesc.Texture3D.MipSlice = mTopLevel + mipLevel; rtvDesc.Texture3D.FirstWSlice = 0; @@ -3071,7 +3020,8 @@ TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer11 *renderer, GetTextureMiscFlags(internalformat, renderer->getRenderer11DeviceCaps(), renderTarget, - levels)) + levels), + internalformat) { mTexture = nullptr; mSwizzleTexture = nullptr; @@ -3081,15 +3031,8 @@ TextureStorage11_2DArray::TextureStorage11_2DArray(Renderer11 *renderer, mSwizzleRenderTargets[level] = nullptr; } - mInternalFormat = internalformat; - - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalformat, renderer->getRenderer11DeviceCaps()); - mTextureFormatSet = formatInfo.formatSet; - mSwizzleFormatSet = formatInfo.swizzleFormatSet; - // adjust size if needed for compressed textures - d3d11::MakeValidSize(false, mTextureFormatSet->texFormat, &width, &height, &mTopLevel); + d3d11::MakeValidSize(false, mFormatInfo.texFormat, &width, &height, &mTopLevel); mMipLevels = mTopLevel + levels; mTextureWidth = width; @@ -3230,7 +3173,7 @@ gl::Error TextureStorage11_2DArray::getResource(ID3D11Resource **outResource) desc.Height = mTextureHeight; desc.MipLevels = mMipLevels; desc.ArraySize = mTextureDepth; - desc.Format = mTextureFormatSet->texFormat; + desc.Format = mFormatInfo.texFormat; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -3335,22 +3278,14 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index, HRESULT result; ID3D11Resource *texture = nullptr; - gl::Error error = getResource(&texture); - if (error.isError()) - { - return error; - } + ANGLE_TRY(getResource(&texture)); ID3D11ShaderResourceView *srv; - error = createRenderTargetSRV(texture, index, mTextureFormatSet->srvFormat, &srv); - if (error.isError()) - { - return error; - } + ANGLE_TRY(createRenderTargetSRV(texture, index, mFormatInfo.srvFormat, &srv)); ID3D11ShaderResourceView *blitSRV; - if (mTextureFormatSet->blitSRVFormat != mTextureFormatSet->srvFormat) + if (mFormatInfo.blitSRVFormat != mFormatInfo.srvFormat) { - error = - createRenderTargetSRV(texture, index, mTextureFormatSet->blitSRVFormat, &blitSRV); + gl::Error error = + createRenderTargetSRV(texture, index, mFormatInfo.blitSRVFormat, &blitSRV); if (error.isError()) { SafeRelease(srv); @@ -3365,10 +3300,10 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index, d3d11::SetDebugName(srv, "TexStorage2DArray.RenderTargetSRV"); - if (mTextureFormatSet->rtvFormat != DXGI_FORMAT_UNKNOWN) + if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) { D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mTextureFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; rtvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; rtvDesc.Texture2DArray.FirstArraySlice = layer; @@ -3391,7 +3326,7 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index, d3d11::SetDebugName(rtv, "TexStorage2DArray.RenderTargetRTV"); mRenderTargets[key] = new TextureRenderTarget11( - rtv, texture, srv, blitSRV, mInternalFormat, mTextureFormatSet->format, + rtv, texture, srv, blitSRV, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0); // RenderTarget will take ownership of these resources @@ -3401,10 +3336,10 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index, } else { - ASSERT(mTextureFormatSet->dsvFormat != DXGI_FORMAT_UNKNOWN); + ASSERT(mFormatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN); D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; - dsvDesc.Format = mTextureFormatSet->dsvFormat; + dsvDesc.Format = mFormatInfo.dsvFormat; dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2DARRAY; dsvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; dsvDesc.Texture2DArray.FirstArraySlice = layer; @@ -3426,7 +3361,7 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index, d3d11::SetDebugName(dsv, "TexStorage2DArray.RenderTargetDSV"); mRenderTargets[key] = new TextureRenderTarget11( - dsv, texture, srv, mInternalFormat, mTextureFormatSet->format, + dsv, texture, srv, mFormatInfo.internalFormat, getFormatSet(), getLevelWidth(mipLevel), getLevelHeight(mipLevel), 1, 0); // RenderTarget will take ownership of these resources @@ -3438,7 +3373,7 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::ImageIndex &index, ASSERT(outRT); *outRT = mRenderTargets[key]; - return gl::Error(GL_NO_ERROR); + return gl::NoError(); } gl::Error TextureStorage11_2DArray::getSwizzleTexture(ID3D11Resource **outTexture) @@ -3452,7 +3387,7 @@ gl::Error TextureStorage11_2DArray::getSwizzleTexture(ID3D11Resource **outTextur desc.Height = mTextureHeight; desc.MipLevels = mMipLevels; desc.ArraySize = mTextureDepth; - desc.Format = mSwizzleFormatSet->texFormat; + desc.Format = mFormatInfo.swizzle.texFormat; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; desc.Usage = D3D11_USAGE_DEFAULT; @@ -3494,7 +3429,7 @@ gl::Error TextureStorage11_2DArray::getSwizzleRenderTarget(int mipLevel, ID3D11Device *device = mRenderer->getDevice(); D3D11_RENDER_TARGET_VIEW_DESC rtvDesc; - rtvDesc.Format = mSwizzleFormatSet->rtvFormat; + rtvDesc.Format = mFormatInfo.swizzle.rtvFormat; rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DARRAY; rtvDesc.Texture2DArray.MipSlice = mTopLevel + mipLevel; rtvDesc.Texture2DArray.FirstArraySlice = 0; @@ -3515,4 +3450,42 @@ gl::Error TextureStorage11_2DArray::getSwizzleRenderTarget(int mipLevel, *outRTV = mSwizzleRenderTargets[mipLevel]; return gl::Error(GL_NO_ERROR); } + +gl::Error TextureStorage11_2DArray::createDropStencilTexture() +{ + if (mDropStencilTexture) + { + return gl::NoError(); + } + + D3D11_TEXTURE2D_DESC dropDesc = {}; + dropDesc.ArraySize = mTextureDepth; + dropDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_DEPTH_STENCIL; + dropDesc.CPUAccessFlags = 0; + dropDesc.Format = DXGI_FORMAT_R32_TYPELESS; + dropDesc.Height = mTextureHeight; + dropDesc.MipLevels = mMipLevels; + dropDesc.MiscFlags = 0; + dropDesc.SampleDesc.Count = 1; + dropDesc.SampleDesc.Quality = 0; + dropDesc.Usage = D3D11_USAGE_DEFAULT; + dropDesc.Width = mTextureWidth; + + ID3D11Device *device = mRenderer->getDevice(); + + HRESULT hr = device->CreateTexture2D(&dropDesc, nullptr, &mDropStencilTexture); + if (FAILED(hr)) + { + return gl::Error(GL_INVALID_OPERATION, "Error creating drop stencil texture."); + } + d3d11::SetDebugName(mDropStencilTexture, "TexStorage2DArray.DropStencil"); + + std::vector<GLsizei> layerCounts(mMipLevels, mTextureDepth); + + ANGLE_TRY(initDropStencilTexture( + gl::ImageIndexIterator::Make2DArray(0, mMipLevels, layerCounts.data()))); + + return gl::NoError(); +} + } // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h index 222894dc3e6..46eb8458bef 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TextureStorage11.h @@ -59,8 +59,8 @@ class TextureStorage11 : public TextureStorage virtual UINT getSubresourceIndex(const gl::ImageIndex &index) const; gl::Error generateSwizzles(const gl::SwizzleState &swizzleTarget); - void invalidateSwizzleCacheLevel(int mipLevel); - void invalidateSwizzleCache(); + void markLevelDirty(int mipLevel); + void markDirty(); gl::Error updateSubresourceLevel(ID3D11Resource *texture, unsigned int sourceSubresource, const gl::ImageIndex &index, const gl::Box ©Area); @@ -79,10 +79,10 @@ class TextureStorage11 : public TextureStorage gl::Error getSRVLevels(GLint baseLevel, GLint maxLevel, ID3D11ShaderResourceView **outSRV); - d3d11::ANGLEFormat getANGLEFormat() const; + const d3d11::Format &getFormatSet() const; protected: - TextureStorage11(Renderer11 *renderer, UINT bindFlags, UINT miscFlags); + TextureStorage11(Renderer11 *renderer, UINT bindFlags, UINT miscFlags, GLenum internalFormat); int getLevelWidth(int mipLevel) const; int getLevelHeight(int mipLevel) const; int getLevelDepth(int mipLevel) const; @@ -94,6 +94,10 @@ class TextureStorage11 : public TextureStorage virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV) = 0; gl::Error getSRVLevel(int mipLevel, bool blitSRV, ID3D11ShaderResourceView **outSRV); + // Get a version of a depth texture with only depth information, not stencil. + virtual gl::Error createDropStencilTexture(); + gl::Error initDropStencilTexture(const gl::ImageIndexIterator &it); + // The baseLevel parameter should *not* have mTopLevel applied. virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture, ID3D11ShaderResourceView **outSRV) const = 0; @@ -107,14 +111,13 @@ class TextureStorage11 : public TextureStorage int mTopLevel; unsigned int mMipLevels; - GLenum mInternalFormat; - const d3d11::ANGLEFormatSet *mTextureFormatSet; - const d3d11::ANGLEFormatSet *mSwizzleFormatSet; + const d3d11::Format &mFormatInfo; unsigned int mTextureWidth; unsigned int mTextureHeight; unsigned int mTextureDepth; gl::SwizzleState mSwizzleCache[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS]; + ID3D11Texture2D *mDropStencilTexture; private: const UINT mBindFlags; @@ -122,13 +125,14 @@ class TextureStorage11 : public TextureStorage struct SRVKey { - SRVKey(int baseLevel = 0, int mipLevels = 0, bool swizzle = false); + SRVKey(int baseLevel, int mipLevels, bool swizzle, bool dropStencil); bool operator<(const SRVKey &rhs) const; - int baseLevel; // Without mTopLevel applied. - int mipLevels; - bool swizzle; + int baseLevel = 0; // Without mTopLevel applied. + int mipLevels = 0; + bool swizzle = false; + bool dropStencil = false; }; typedef std::map<SRVKey, ID3D11ShaderResourceView *> SRVCache; @@ -144,30 +148,35 @@ class TextureStorage11_2D : public TextureStorage11 public: TextureStorage11_2D(Renderer11 *renderer, SwapChain11 *swapchain); TextureStorage11_2D(Renderer11 *renderer, GLenum internalformat, bool renderTarget, GLsizei width, GLsizei height, int levels, bool hintLevelZeroOnly = false); - virtual ~TextureStorage11_2D(); + ~TextureStorage11_2D() override; - virtual gl::Error getResource(ID3D11Resource **outResource); - virtual gl::Error getMippedResource(ID3D11Resource **outResource); - virtual gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT); + gl::Error getResource(ID3D11Resource **outResource) override; + gl::Error getMippedResource(ID3D11Resource **outResource) override; + gl::Error getRenderTarget(const gl::ImageIndex &index, RenderTargetD3D **outRT) override; - virtual gl::Error copyToStorage(TextureStorage *destStorage); + gl::Error copyToStorage(TextureStorage *destStorage) override; - virtual void associateImage(Image11* image, const gl::ImageIndex &index); - virtual void disassociateImage(const gl::ImageIndex &index, Image11* expectedImage); - virtual bool isAssociatedImageValid(const gl::ImageIndex &index, Image11* expectedImage); - virtual gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11* incomingImage); + void associateImage(Image11 *image, const gl::ImageIndex &index) override; + void disassociateImage(const gl::ImageIndex &index, Image11 *expectedImage) override; + bool isAssociatedImageValid(const gl::ImageIndex &index, Image11 *expectedImage) override; + gl::Error releaseAssociatedImage(const gl::ImageIndex &index, Image11 *incomingImage) override; - virtual gl::Error useLevelZeroWorkaroundTexture(bool useLevelZeroTexture); + gl::Error useLevelZeroWorkaroundTexture(bool useLevelZeroTexture) override; protected: - virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture); - virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV); + gl::Error getSwizzleTexture(ID3D11Resource **outTexture) override; + gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV) override; + + gl::Error createDropStencilTexture() override; gl::Error ensureTextureExists(int mipLevels); private: - virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture, - ID3D11ShaderResourceView **outSRV) const; + gl::Error createSRV(int baseLevel, + int mipLevels, + DXGI_FORMAT format, + ID3D11Resource *texture, + ID3D11ShaderResourceView **outSRV) const override; ID3D11Texture2D *mTexture; RenderTarget11 *mRenderTarget[gl::IMPLEMENTATION_MAX_TEXTURE_LEVELS]; @@ -233,7 +242,9 @@ class TextureStorage11_External : public TextureStorage11 class TextureStorage11_EGLImage final : public TextureStorage11 { public: - TextureStorage11_EGLImage(Renderer11 *renderer, EGLImageD3D *eglImage); + TextureStorage11_EGLImage(Renderer11 *renderer, + EGLImageD3D *eglImage, + RenderTarget11 *renderTarget11); ~TextureStorage11_EGLImage() override; gl::Error getResource(ID3D11Resource **outResource) override; @@ -301,6 +312,8 @@ class TextureStorage11_Cube : public TextureStorage11 virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture); virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV); + gl::Error createDropStencilTexture() override; + gl::Error ensureTextureExists(int mipLevels); private: @@ -384,6 +397,8 @@ class TextureStorage11_2DArray : public TextureStorage11 virtual gl::Error getSwizzleTexture(ID3D11Resource **outTexture); virtual gl::Error getSwizzleRenderTarget(int mipLevel, ID3D11RenderTargetView **outRTV); + gl::Error createDropStencilTexture() override; + private: virtual gl::Error createSRV(int baseLevel, int mipLevels, DXGI_FORMAT format, ID3D11Resource *texture, ID3D11ShaderResourceView **outSRV) const; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp new file mode 100644 index 00000000000..39b293f9b09 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.cpp @@ -0,0 +1,102 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TransformFeedbackD3D.cpp is a no-op implementation for both the D3D9 and D3D11 renderers. + +#include "libANGLE/renderer/d3d/d3d11/TransformFeedback11.h" + +#include "libANGLE/Buffer.h" +#include "libANGLE/renderer/d3d/d3d11/Buffer11.h" +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" + +namespace rx +{ + +TransformFeedback11::TransformFeedback11(const gl::TransformFeedbackState &state, + Renderer11 *renderer) + : TransformFeedbackImpl(state), + mRenderer(renderer), + mIsDirty(true), + mBuffers(state.getIndexedBuffers().size(), nullptr), + mBufferOffsets(state.getIndexedBuffers().size(), 0) +{ +} + +TransformFeedback11::~TransformFeedback11() +{ +} + +void TransformFeedback11::begin(GLenum primitiveMode) +{ +} + +void TransformFeedback11::end() +{ + if (mRenderer->getWorkarounds().flushAfterEndingTransformFeedback) + { + mRenderer->getDeviceContext()->Flush(); + } +} + +void TransformFeedback11::pause() +{ +} + +void TransformFeedback11::resume() +{ +} + +void TransformFeedback11::bindGenericBuffer(const BindingPointer<gl::Buffer> &binding) +{ +} + +void TransformFeedback11::bindIndexedBuffer(size_t index, + const OffsetBindingPointer<gl::Buffer> &binding) +{ + mIsDirty = true; + mBufferOffsets[index] = static_cast<UINT>(binding.getOffset()); +} + +void TransformFeedback11::onApply() +{ + mIsDirty = false; + + // Change all buffer offsets to -1 so that if any of them need to be re-applied, the are set to + // append + std::fill(mBufferOffsets.begin(), mBufferOffsets.end(), -1); +} + +bool TransformFeedback11::isDirty() const +{ + return mIsDirty; +} + +UINT TransformFeedback11::getNumSOBuffers() const +{ + return static_cast<UINT>(mBuffers.size()); +} + +gl::ErrorOrResult<const std::vector<ID3D11Buffer *> *> TransformFeedback11::getSOBuffers() +{ + for (size_t bindingIdx = 0; bindingIdx < mBuffers.size(); bindingIdx++) + { + const auto &binding = mState.getIndexedBuffer(bindingIdx); + if (binding.get() != nullptr) + { + Buffer11 *storage = GetImplAs<Buffer11>(binding.get()); + ANGLE_TRY_RESULT(storage->getBuffer(BUFFER_USAGE_VERTEX_OR_TRANSFORM_FEEDBACK), + mBuffers[bindingIdx]); + } + } + + return &mBuffers; +} + +const std::vector<UINT> &TransformFeedback11::getSOBufferOffsets() const +{ + return mBufferOffsets; +} +} // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h new file mode 100644 index 00000000000..01879d6f3af --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/TransformFeedback11.h @@ -0,0 +1,54 @@ +// +// Copyright 2014 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// + +// TransformFeedback11.h: Implements the abstract rx::TransformFeedbackImpl class. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_TRANSFORMFEEDBACK11_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_TRANSFORMFEEDBACK11_H_ + +#include "common/platform.h" + +#include "libANGLE/angletypes.h" +#include "libANGLE/Error.h" +#include "libANGLE/renderer/TransformFeedbackImpl.h" + +namespace rx +{ + +class Renderer11; + +class TransformFeedback11 : public TransformFeedbackImpl +{ + public: + TransformFeedback11(const gl::TransformFeedbackState &state, Renderer11 *renderer); + ~TransformFeedback11() override; + + void begin(GLenum primitiveMode) override; + void end() override; + void pause() override; + void resume() override; + + void bindGenericBuffer(const BindingPointer<gl::Buffer> &binding) override; + void bindIndexedBuffer(size_t index, const OffsetBindingPointer<gl::Buffer> &binding) override; + + void onApply(); + + bool isDirty() const; + + UINT getNumSOBuffers() const; + gl::ErrorOrResult<const std::vector<ID3D11Buffer *> *> getSOBuffers(); + const std::vector<UINT> &getSOBufferOffsets() const; + + private: + Renderer11 *mRenderer; + + bool mIsDirty; + std::vector<ID3D11Buffer *> mBuffers; + std::vector<UINT> mBufferOffsets; +}; +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_TRANSFORMFEEDBACK11_H_ diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Trim11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Trim11.cpp index ca48b1872c4..29185a9d934 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Trim11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/Trim11.cpp @@ -47,7 +47,6 @@ void Trim11::trim() #if defined (ANGLE_ENABLE_WINDOWS_STORE) ID3D11Device* device = mRenderer->getDevice(); - // IDXGIDevice3 is only supported on Windows 8.1 and Windows Phone 8.1 and above. IDXGIDevice3 *dxgiDevice3 = d3d11::DynamicCastComObject<IDXGIDevice3>(device); if (dxgiDevice3) { diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp index 8a0153c988d..7895bf18f47 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.cpp @@ -9,13 +9,14 @@ #include "libANGLE/renderer/d3d/d3d11/formatutils11.h" +#include "image_util/copyimage.h" +#include "image_util/generatemip.h" +#include "image_util/loadimage.h" + #include "libANGLE/formatutils.h" -#include "libANGLE/renderer/copyimage.h" #include "libANGLE/renderer/d3d/d3d11/copyvertex.h" #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" #include "libANGLE/renderer/d3d/d3d11/Renderer11.h" -#include "libANGLE/renderer/d3d/generatemip.h" -#include "libANGLE/renderer/d3d/loadimage.h" namespace rx { @@ -23,204 +24,9 @@ namespace rx namespace d3d11 { -struct D3D11FastCopyFormat -{ - GLenum destFormat; - GLenum destType; - ColorCopyFunction copyFunction; - - D3D11FastCopyFormat(GLenum destFormat, GLenum destType, ColorCopyFunction copyFunction) - : destFormat(destFormat), destType(destType), copyFunction(copyFunction) - { } - - bool operator<(const D3D11FastCopyFormat& other) const - { - return memcmp(this, &other, sizeof(D3D11FastCopyFormat)) < 0; - } -}; - -static const FastCopyFunctionMap &GetFastCopyFunctionMap(DXGI_FORMAT dxgiFormat) -{ - switch (dxgiFormat) - { - case DXGI_FORMAT_B8G8R8A8_UNORM: - { - static FastCopyFunctionMap fastCopyMap; - if (fastCopyMap.empty()) - { - fastCopyMap[gl::FormatType(GL_RGBA, GL_UNSIGNED_BYTE)] = CopyBGRA8ToRGBA8; - } - return fastCopyMap; - } - default: - { - static FastCopyFunctionMap emptyMap; - return emptyMap; - } - } -} - -struct DXGIColorFormatInfo -{ - size_t redBits; - size_t greenBits; - size_t blueBits; - - size_t luminanceBits; - - size_t alphaBits; - size_t sharedBits; -}; - -typedef std::map<DXGI_FORMAT, DXGIColorFormatInfo> ColorFormatInfoMap; -typedef std::pair<DXGI_FORMAT, DXGIColorFormatInfo> ColorFormatInfoPair; - -static inline void InsertDXGIColorFormatInfo(ColorFormatInfoMap *map, DXGI_FORMAT format, size_t redBits, size_t greenBits, - size_t blueBits, size_t alphaBits, size_t sharedBits) -{ - DXGIColorFormatInfo info; - info.redBits = redBits; - info.greenBits = greenBits; - info.blueBits = blueBits; - info.alphaBits = alphaBits; - info.sharedBits = sharedBits; - - map->insert(std::make_pair(format, info)); -} - -static ColorFormatInfoMap BuildColorFormatInfoMap() -{ - ColorFormatInfoMap map; - - // clang-format off - // | DXGI format | R | G | B | A | S | - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_A8_UNORM, 0, 0, 0, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8_UNORM, 8, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8_UNORM, 8, 8, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8B8A8_UNORM, 8, 8, 8, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, 8, 8, 8, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_B8G8R8A8_UNORM, 8, 8, 8, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16_UNORM, 16, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16_UNORM, 16, 16, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16B16A16_UNORM, 16, 16, 16, 16, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8_SNORM, 8, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8_SNORM, 8, 8, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8B8A8_SNORM, 8, 8, 8, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16_SNORM, 16, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16_SNORM, 16, 16, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16B16A16_SNORM, 16, 16, 16, 16, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8_UINT, 8, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16_UINT, 16, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32_UINT, 32, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8_UINT, 8, 8, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16_UINT, 16, 16, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32_UINT, 32, 32, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32_UINT, 32, 32, 32, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8B8A8_UINT, 8, 8, 8, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16B16A16_UINT, 16, 16, 16, 16, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32A32_UINT, 32, 32, 32, 32, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8_SINT, 8, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16_SINT, 16, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32_SINT, 32, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8_SINT, 8, 8, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16_SINT, 16, 16, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32_SINT, 32, 32, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32_SINT, 32, 32, 32, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8B8A8_SINT, 8, 8, 8, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16B16A16_SINT, 16, 16, 16, 16, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32A32_SINT, 32, 32, 32, 32, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R10G10B10A2_TYPELESS, 10, 10, 10, 2, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R10G10B10A2_UNORM, 10, 10, 10, 2, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R10G10B10A2_UINT, 10, 10, 10, 2, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16_FLOAT, 16, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16_FLOAT, 16, 16, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16B16A16_FLOAT, 16, 16, 16, 16, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32_FLOAT, 32, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32_FLOAT, 32, 32, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32_FLOAT, 32, 32, 32, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32A32_FLOAT, 32, 32, 32, 32, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R9G9B9E5_SHAREDEXP, 9, 9, 9, 0, 5); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R11G11B10_FLOAT, 11, 11, 10, 0, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_B5G6R5_UNORM, 5, 6, 5, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_B4G4R4A4_UNORM, 4, 4, 4, 4, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_B5G5R5A1_UNORM, 5, 5, 5, 1, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8_TYPELESS, 8, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16_TYPELESS, 16, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32_TYPELESS, 32, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8_TYPELESS, 8, 8, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16_TYPELESS, 16, 16, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32_TYPELESS, 32, 32, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32_TYPELESS, 32, 32, 32, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R8G8B8A8_TYPELESS, 8, 8, 8, 8, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R16G16B16A16_TYPELESS, 16, 16, 16, 16, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G32B32A32_TYPELESS, 32, 32, 32, 32, 0); - - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R24G8_TYPELESS, 24, 8, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R24_UNORM_X8_TYPELESS, 24, 0, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32G8X24_TYPELESS, 32, 8, 0, 0, 0); - InsertDXGIColorFormatInfo(&map, DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, 32, 0, 0, 0, 0); - // clang-format on - - return map; -} - -struct DXGIDepthStencilInfo -{ - unsigned int depthBits; - unsigned int stencilBits; -}; - -typedef std::map<DXGI_FORMAT, DXGIDepthStencilInfo> DepthStencilInfoMap; -typedef std::pair<DXGI_FORMAT, DXGIDepthStencilInfo> DepthStencilInfoPair; - -static inline void InsertDXGIDepthStencilInfo(DepthStencilInfoMap *map, - DXGI_FORMAT format, - unsigned int depthBits, - unsigned int stencilBits) -{ - DXGIDepthStencilInfo info; - info.depthBits = depthBits; - info.stencilBits = stencilBits; - - map->insert(std::make_pair(format, info)); -} - -static DepthStencilInfoMap BuildDepthStencilInfoMap() -{ - DepthStencilInfoMap map; - - // clang-format off - InsertDXGIDepthStencilInfo(&map, DXGI_FORMAT_D16_UNORM, 16, 0); - InsertDXGIDepthStencilInfo(&map, DXGI_FORMAT_D24_UNORM_S8_UINT, 24, 8); - InsertDXGIDepthStencilInfo(&map, DXGI_FORMAT_D32_FLOAT, 32, 0); - InsertDXGIDepthStencilInfo(&map, DXGI_FORMAT_D32_FLOAT_S8X24_UINT, 32, 8); - // clang-format on - - return map; -} - typedef std::map<DXGI_FORMAT, DXGIFormat> DXGIFormatInfoMap; -DXGIFormat::DXGIFormat() - : redBits(0), - greenBits(0), - blueBits(0), - alphaBits(0), - sharedBits(0), - depthBits(0), - stencilBits(0), - componentType(GL_NONE), - fastCopyFunctions(), - nativeMipmapSupport(NULL) +DXGIFormat::DXGIFormat() : componentType(GL_NONE), nativeMipmapSupport(NULL) { } @@ -242,29 +48,7 @@ void AddDXGIFormat(DXGIFormatInfoMap *map, { DXGIFormat info; - static const ColorFormatInfoMap colorInfoMap = BuildColorFormatInfoMap(); - ColorFormatInfoMap::const_iterator colorInfoIter = colorInfoMap.find(dxgiFormat); - if (colorInfoIter != colorInfoMap.end()) - { - const DXGIColorFormatInfo &colorInfo = colorInfoIter->second; - info.redBits = static_cast<GLuint>(colorInfo.redBits); - info.greenBits = static_cast<GLuint>(colorInfo.greenBits); - info.blueBits = static_cast<GLuint>(colorInfo.blueBits); - info.alphaBits = static_cast<GLuint>(colorInfo.alphaBits); - info.sharedBits = static_cast<GLuint>(colorInfo.sharedBits); - } - - static const DepthStencilInfoMap dsInfoMap = BuildDepthStencilInfoMap(); - DepthStencilInfoMap::const_iterator dsInfoIter = dsInfoMap.find(dxgiFormat); - if (dsInfoIter != dsInfoMap.end()) - { - const DXGIDepthStencilInfo &dsInfo = dsInfoIter->second; - info.depthBits = dsInfo.depthBits; - info.stencilBits = dsInfo.stencilBits; - } - info.componentType = componentType; - info.fastCopyFunctions = GetFastCopyFunctionMap(dxgiFormat); info.nativeMipmapSupport = nativeMipmapSupport; map->insert(std::make_pair(dxgiFormat, info)); @@ -1189,6 +973,6 @@ const VertexFormat &GetVertexFormatInfo(gl::VertexFormatType vertexFormatType, D } } -} +} // namespace d3d11 -} +} // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.h index 8d719d37418..14bde45e487 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/formatutils11.h @@ -31,19 +31,8 @@ struct DXGIFormat { DXGIFormat(); - GLuint redBits; - GLuint greenBits; - GLuint blueBits; - GLuint alphaBits; - GLuint sharedBits; - - GLuint depthBits; - GLuint stencilBits; - GLenum componentType; - FastCopyFunctionMap fastCopyFunctions; - NativeMipmapGenerationSupportFunction nativeMipmapSupport; }; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/gen_load_functions_table.py b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/gen_load_functions_table.py deleted file mode 100644 index 33240cedd87..00000000000 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/gen_load_functions_table.py +++ /dev/null @@ -1,197 +0,0 @@ -#!/usr/bin/python -# Copyright 2015 The ANGLE Project Authors. All rights reserved. -# Use of this source code is governed by a BSD-style license that can be -# found in the LICENSE file. -# -# gen_load_functions_table.py: -# Code generation for the load function tables used for texture formats -# - -import json - -template = """// GENERATED FILE - DO NOT EDIT. -// Generated by gen_load_functions_table.py using data from load_functions_data.json -// -// Copyright 2015 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// -// load_functions_table: -// Contains the GetLoadFunctionsMap for texture_format_util.h -// - -#include "libANGLE/renderer/d3d/d3d11/load_functions_table.h" -#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" -#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" -#include "libANGLE/renderer/d3d/loadimage.h" -#include "libANGLE/renderer/d3d/loadimage_etc.h" - -namespace rx -{{ - -namespace d3d11 -{{ - -namespace -{{ - -// ES3 image loading functions vary based on: -// - the GL internal format (supplied to glTex*Image*D) -// - the GL data type given (supplied to glTex*Image*D) -// - the target DXGI_FORMAT that the image will be loaded into (which is chosen based on the D3D -// device's capabilities) -// This map type determines which loading function to use, based on these three parameters. -// Source formats and types are taken from Tables 3.2 and 3.3 of the ES 3 spec. -void UnimplementedLoadFunction(size_t width, - size_t height, - size_t depth, - const uint8_t *input, - size_t inputRowPitch, - size_t inputDepthPitch, - uint8_t *output, - size_t outputRowPitch, - size_t outputDepthPitch) -{{ - UNIMPLEMENTED(); -}} - -void UnreachableLoadFunction(size_t width, - size_t height, - size_t depth, - const uint8_t *input, - size_t inputRowPitch, - size_t inputDepthPitch, - uint8_t *output, - size_t outputRowPitch, - size_t outputDepthPitch) -{{ - UNREACHABLE(); -}} - -}} // namespace - -// TODO we can replace these maps with more generated code -const std::map<GLenum, LoadImageFunctionInfo> &GetLoadFunctionsMap(GLenum {internal_format}, - DXGI_FORMAT {dxgi_format}) -{{ - // clang-format off - switch ({internal_format}) - {{ -{data} - default: - {{ - static std::map<GLenum, LoadImageFunctionInfo> emptyLoadFunctionsMap; - return emptyLoadFunctionsMap; - }} - }} - // clang-format on - -}} // GetLoadFunctionsMap - -}} // namespace d3d11 - -}} // namespace rx -""" - -internal_format_param = 'internalFormat' -dxgi_format_param = 'dxgiFormat' -dxgi_format_unknown = "DXGI_FORMAT_UNKNOWN" - -def get_function_maps_string(typestr, function, requiresConversion): - return ' { ' + typestr + ', LoadImageFunctionInfo(' + function + ', ' + requiresConversion + ') },\n' - -def get_unknown_format_string(dxgi_to_type_map, dxgi_unknown_string): - if dxgi_unknown_string not in dxgi_to_type_map: - return '' - - table_data = '' - - for unknown_type_function in dxgi_to_type_map[dxgi_unknown_string]: - table_data += get_function_maps_string(unknown_type_function['type'], unknown_type_function['loadFunction'], 'true') - - return table_data - -# Making map from dxgi to type map for a particular internalFormat -def create_dxgi_to_type_map(dst, json_data, internal_format_str): - for type_item in sorted(json_data[internal_format_str].iteritems()): - for entry_in_type_item in type_item[1]: - dxgi_format_str = entry_in_type_item['dxgiFormat'] - - if dxgi_format_str not in dst: - dst[dxgi_format_str] = [] - - type_dxgi_load_function = entry_in_type_item.copy(); - type_dxgi_load_function['type'] = type_item[0] - dst[dxgi_format_str].append(type_dxgi_load_function) - -def get_load_function_map_snippet(insert_map_string): - load_function_map_snippet = '' - load_function_map_snippet += ' static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = {\n' - load_function_map_snippet += insert_map_string - load_function_map_snippet += ' };\n\n' - load_function_map_snippet += ' return loadFunctionsMap;\n' - - return load_function_map_snippet - -def parse_json_into_switch_string(json_data): - table_data = '' - for internal_format_item in sorted(json_data.iteritems()): - internal_format_str = internal_format_item[0] - table_data += ' case ' + internal_format_str + ':\n' - table_data += ' {\n' - table_data += ' switch (' + dxgi_format_param + ')\n' - table_data += ' {\n' - - dxgi_to_type_map = {}; - create_dxgi_to_type_map(dxgi_to_type_map, json_data, internal_format_str) - - dxgi_unknown_str = get_unknown_format_string(dxgi_to_type_map, dxgi_format_unknown); - - for dxgi_format_item in sorted(dxgi_to_type_map.iteritems()): - dxgi_format_str = dxgi_format_item[0] - - # Main case statements - table_data += ' case ' + dxgi_format_str + ':\n' - table_data += ' {\n' - insert_map_string = '' - types_already_in_loadmap = set() - for type_function in sorted(dxgi_format_item[1]): - insert_map_string += get_function_maps_string(type_function['type'], type_function['loadFunction'], type_function['requiresConversion']) - types_already_in_loadmap.add(type_function['type']) - - # DXGI_FORMAT_UNKNOWN add ons - if dxgi_format_unknown in dxgi_to_type_map: - for unknown_type_function in dxgi_to_type_map[dxgi_format_unknown]: - # Check that it's not already in the loadmap so it doesn't override the value - if unknown_type_function['type'] not in types_already_in_loadmap: - insert_map_string += get_function_maps_string(unknown_type_function['type'], unknown_type_function['loadFunction'], 'true') - - table_data += get_load_function_map_snippet(insert_map_string) - table_data += ' }\n' - - table_data += ' default:\n' - - if dxgi_unknown_str: - table_data += ' {\n' - table_data += get_load_function_map_snippet(dxgi_unknown_str) - table_data += ' }\n' - else: - table_data += ' break;\n' - table_data += ' }\n' - table_data += ' }\n' - - return table_data - -with open('load_functions_data.json') as functions_json_file: - functions_data = functions_json_file.read(); - functions_json_file.close() - json_data = json.loads(functions_data) - - table_data = parse_json_into_switch_string(json_data) - output = template.format(internal_format = internal_format_param, - dxgi_format = dxgi_format_param, - data=table_data) - - with open('load_functions_table_autogen.cpp', 'wt') as out_file: - out_file.write(output) - out_file.close() diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py index b28a9ea8ac5..981a77f51ab 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/gen_texture_format_table.py @@ -11,31 +11,12 @@ from datetime import date import json import math import pprint +import os import re +import sys -template_texture_format_table_autogen_h = """// GENERATED FILE - DO NOT EDIT. -// Generated by gen_texture_format_table.py using data from texture_format_data.json -// -// Copyright 2016 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// - -namespace rx -{{ - -namespace d3d11 -{{ - -enum ANGLEFormat -{{ -{angle_format_enum} -}}; - -}} // namespace d3d11 - -}} // namespace rx -""" +sys.path.append('../..') +import angle_format template_texture_format_table_autogen_cpp = """// GENERATED FILE - DO NOT EDIT. // Generated by gen_texture_format_table.py using data from texture_format_data.json @@ -50,12 +31,15 @@ template_texture_format_table_autogen_cpp = """// GENERATED FILE - DO NOT EDIT. #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" -#include "libANGLE/renderer/copyimage.h" +#include "image_util/copyimage.h" +#include "image_util/generatemip.h" +#include "image_util/loadimage.h" + #include "libANGLE/renderer/d3d/d3d11/formatutils11.h" -#include "libANGLE/renderer/d3d/d3d11/load_functions_table.h" #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" -#include "libANGLE/renderer/d3d/generatemip.h" -#include "libANGLE/renderer/d3d/loadimage.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h" + +using namespace angle; namespace rx {{ @@ -63,140 +47,11 @@ namespace rx namespace d3d11 {{ -namespace -{{ - -typedef bool (*FormatSupportFunction)(const Renderer11DeviceCaps &); - -bool OnlyFL10Plus(const Renderer11DeviceCaps &deviceCaps) -{{ - return (deviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0); -}} - -bool OnlyFL9_3(const Renderer11DeviceCaps &deviceCaps) -{{ - return (deviceCaps.featureLevel == D3D_FEATURE_LEVEL_9_3); -}} - -template <DXGI_FORMAT format, bool requireSupport> -bool SupportsFormat(const Renderer11DeviceCaps &deviceCaps) -{{ - // Must support texture, SRV and RTV support - UINT mustSupport = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURECUBE | - D3D11_FORMAT_SUPPORT_SHADER_SAMPLE | D3D11_FORMAT_SUPPORT_MIP | - D3D11_FORMAT_SUPPORT_RENDER_TARGET; - - if (d3d11_gl::GetMaximumClientVersion(deviceCaps.featureLevel) > 2) - {{ - mustSupport |= D3D11_FORMAT_SUPPORT_TEXTURE3D; - }} - - bool fullSupport = false; - if (format == DXGI_FORMAT_B5G6R5_UNORM) - {{ - // All hardware that supports DXGI_FORMAT_B5G6R5_UNORM should support autogen mipmaps, but - // check anyway. - mustSupport |= D3D11_FORMAT_SUPPORT_MIP_AUTOGEN; - fullSupport = ((deviceCaps.B5G6R5support & mustSupport) == mustSupport); - }} - else if (format == DXGI_FORMAT_B4G4R4A4_UNORM) - {{ - fullSupport = ((deviceCaps.B4G4R4A4support & mustSupport) == mustSupport); - }} - else if (format == DXGI_FORMAT_B5G5R5A1_UNORM) - {{ - fullSupport = ((deviceCaps.B5G5R5A1support & mustSupport) == mustSupport); - }} - else - {{ - UNREACHABLE(); - return false; - }} - - // This 'SupportsFormat' function is used by individual entries in the D3D11 Format Map below, - // which maps GL formats to DXGI formats. - if (requireSupport) - {{ - // This means that ANGLE would like to use the entry in the map if the inputted DXGI format - // *IS* supported. - // e.g. the entry might map GL_RGB5_A1 to DXGI_FORMAT_B5G5R5A1, which should only be used if - // DXGI_FORMAT_B5G5R5A1 is supported. - // In this case, we should only return 'true' if the format *IS* supported. - return fullSupport; - }} - else - {{ - // This means that ANGLE would like to use the entry in the map if the inputted DXGI format - // *ISN'T* supported. - // This might be a fallback entry. e.g. for ANGLE to use DXGI_FORMAT_R8G8B8A8_UNORM if - // DXGI_FORMAT_B5G5R5A1 isn't supported. - // In this case, we should only return 'true' if the format *ISN'T* supported. - return !fullSupport; - }} -}} - -// End Format Support Functions -}} // namespace - -ANGLEFormatSet::ANGLEFormatSet() - : format(ANGLE_FORMAT_NONE), - glInternalFormat(GL_NONE), - texFormat(DXGI_FORMAT_UNKNOWN), - srvFormat(DXGI_FORMAT_UNKNOWN), - rtvFormat(DXGI_FORMAT_UNKNOWN), - dsvFormat(DXGI_FORMAT_UNKNOWN), - blitSRVFormat(DXGI_FORMAT_UNKNOWN), - swizzleFormat(ANGLE_FORMAT_NONE), - mipGenerationFunction(nullptr), - colorReadFunction(nullptr) -{{ -}} - -// For sized GL internal formats, there are several possible corresponding D3D11 formats depending -// on device capabilities. -// This function allows querying for the DXGI texture formats to use for textures, SRVs, RTVs and -// DSVs given a GL internal format. -TextureFormat::TextureFormat(GLenum internalFormat, - const ANGLEFormat angleFormat, - InitializeTextureDataFunction internalFormatInitializer) - : dataInitializerFunction(internalFormatInitializer) -{{ - formatSet = &GetANGLEFormatSet(angleFormat); - swizzleFormatSet = &GetANGLEFormatSet(formatSet->swizzleFormat); - - // Gather all the load functions for this internal format - loadFunctions = GetLoadFunctionsMap(internalFormat, formatSet->texFormat); - - ASSERT(loadFunctions.size() != 0 || internalFormat == GL_NONE); -}} - -ANGLEFormatSet::ANGLEFormatSet(ANGLEFormat format, - GLenum glInternalFormat, - DXGI_FORMAT texFormat, - DXGI_FORMAT srvFormat, - DXGI_FORMAT rtvFormat, - DXGI_FORMAT dsvFormat, - DXGI_FORMAT blitSRVFormat, - ANGLEFormat swizzleFormat, - MipGenerationFunction mipGenerationFunction, - ColorReadFunction colorReadFunction) - : format(format), - glInternalFormat(glInternalFormat), - texFormat(texFormat), - srvFormat(srvFormat), - rtvFormat(rtvFormat), - dsvFormat(dsvFormat), - blitSRVFormat(blitSRVFormat), - swizzleFormat(swizzleFormat), - mipGenerationFunction(mipGenerationFunction), - colorReadFunction(colorReadFunction) -{{ -}} - -const ANGLEFormatSet &GetANGLEFormatSet(ANGLEFormat angleFormat) +// static +const Format &Format::Get(GLenum internalFormat, const Renderer11DeviceCaps &deviceCaps) {{ // clang-format off - switch (angleFormat) + switch (internalFormat) {{ {angle_format_info_cases} default: @@ -205,26 +60,10 @@ const ANGLEFormatSet &GetANGLEFormatSet(ANGLEFormat angleFormat) // clang-format on UNREACHABLE(); - static const ANGLEFormatSet defaultInfo; + static const Format defaultInfo; return defaultInfo; }} -const TextureFormat &GetTextureFormatInfo(GLenum internalFormat, - const Renderer11DeviceCaps &renderer11DeviceCaps) -{{ - // clang-format off - switch (internalFormat) - {{ -{texture_format_info_cases} - default: - break; - }} - // clang-format on - - static const TextureFormat defaultInfo(GL_NONE, ANGLE_FORMAT_NONE, nullptr); - return defaultInfo; -}} // GetTextureFormatInfo - }} // namespace d3d11 }} // namespace rx @@ -305,16 +144,18 @@ def get_internal_format_initializer(internal_format, angle_format): return internal_format_initializer -def get_swizzle_format_id(angle_format_id, angle_format): - if angle_format_id == 'ANGLE_FORMAT_NONE': - return 'ANGLE_FORMAT_NONE' +def get_swizzle_format_id(internal_format, angle_format): + angle_format_id = angle_format["formatName"] + if (internal_format == 'GL_NONE') or (angle_format_id == 'NONE'): + return 'GL_NONE' + elif 'swizzleFormat' in angle_format: # For some special formats like compressed formats that don't have a clearly defined number # of bits per channel, swizzle format needs to be specified manually. return angle_format['swizzleFormat'] if 'bits' not in angle_format: - raise ValueError('no bits information for determining swizzleformat for format: ' + angle_format_id) + raise ValueError('no bits information for determining swizzleformat for format: ' + internal_format) bits = angle_format['bits'] max_component_bits = max(bits.itervalues()) @@ -323,7 +164,7 @@ def get_swizzle_format_id(angle_format_id, angle_format): # The format itself can be used for swizzles if it can be accessed as a render target and # sampled and the bit count for all 4 channels is the same. if "rtvFormat" in angle_format and "srvFormat" in angle_format and not channels_different and len(angle_format['channels']) == 4: - return angle_format_id + return angle_format["glInternalFormat"] if "glInternalFormat" in angle_format else internal_format b = int(math.ceil(float(max_component_bits) / 8) * 8) @@ -331,170 +172,167 @@ def get_swizzle_format_id(angle_format_id, angle_format): # defined component type. if angle_format['channels'].find('d') >= 0: if b == 24 or b == 32: - return 'ANGLE_FORMAT_R32G32B32A32_FLOAT' + return 'GL_RGBA32F' if b == 16: - return 'ANGLE_FORMAT_R16G16B16A16_UNORM' + return 'GL_RGBA16_EXT' if b == 24: - raise ValueError('unexpected 24-bit format when determining swizzleformat for format: ' + angle_format_id) + raise ValueError('unexpected 24-bit format when determining swizzleformat for format: ' + internal_format) if 'componentType' not in angle_format: - raise ValueError('no component type information for determining swizzleformat for format: ' + angle_format_id) + raise ValueError('no component type information for determining swizzleformat for format: ' + internal_format) component_type = angle_format['componentType'] + + swizzle = "GL_RGBA" + str(b) + if component_type == 'uint': - return 'ANGLE_FORMAT_R{}G{}B{}A{}_UINT'.format(b, b, b, b) + swizzle += "I" elif component_type == 'int': - return 'ANGLE_FORMAT_R{}G{}B{}A{}_SINT'.format(b, b, b, b) + swizzle += "I" elif component_type == 'unorm': - return 'ANGLE_FORMAT_R{}G{}B{}A{}_UNORM'.format(b, b, b, b) + if (b == 16): + swizzle += "_EXT" elif component_type == 'snorm': - return 'ANGLE_FORMAT_R{}G{}B{}A{}_SNORM'.format(b, b, b, b) + swizzle += "_SNORM" + if (b == 16): + swizzle += "_EXT" elif component_type == 'float': - return 'ANGLE_FORMAT_R{}G{}B{}A{}_FLOAT'.format(b, b, b, b) + swizzle += "F" + if (b == 16): + swizzle += "_EXT" else: - raise ValueError('could not determine swizzleformat based on componentType for format: ' + angle_format_id) + raise ValueError('could not determine swizzleformat based on componentType for format: ' + internal_format) -def get_texture_format_item(idx, internal_format, requirements_fn, angle_format_id, angle_format): - table_data = ''; + return swizzle - internal_format_initializer = get_internal_format_initializer(internal_format, angle_format) +def get_blit_srv_format(angle_format): + if 'channels' not in angle_format: + return 'DXGI_FORMAT_UNKNOWN' + if 'r' in angle_format['channels'] and angle_format['componentType'] in ['int', 'uint']: + return angle_format['rtvFormat'] - indent = ' ' - if requirements_fn != None: - if idx == 0: - table_data += ' if (' + requirements_fn + '(renderer11DeviceCaps))\n' - else: - table_data += ' else if (' + requirements_fn + '(renderer11DeviceCaps))\n' - table_data += ' {\n' - indent += ' ' + return angle_format["srvFormat"] if "srvFormat" in angle_format else "DXGI_FORMAT_UNKNOWN" - table_data += indent + 'static const TextureFormat textureFormat(internalFormat,\n' - table_data += indent + ' ' + angle_format_id + ',\n' - table_data += indent + ' ' + internal_format_initializer + ');\n' - table_data += indent + 'return textureFormat;\n' - if requirements_fn != None: - table_data += ' }\n' +format_entry_template = """{space}{{ +{space} static const Format info({internalFormat}, +{space} angle::Format::ID::{formatName}, +{space} {texFormat}, +{space} {srvFormat}, +{space} {rtvFormat}, +{space} {dsvFormat}, +{space} {blitSRVFormat}, +{space} {swizzleFormat}, +{space} {initializer}, +{space} deviceCaps); +{space} return info; +{space}}} +""" - return table_data +split_format_entry_template = """{space} {condition} +{space} {{ +{space} static const Format info({internalFormat}, +{space} angle::Format::ID::{formatName}, +{space} {texFormat}, +{space} {srvFormat}, +{space} {rtvFormat}, +{space} {dsvFormat}, +{space} {blitSRVFormat}, +{space} {swizzleFormat}, +{space} {initializer}, +{space} deviceCaps); +{space} return info; +{space} }} +""" -def parse_json_into_switch_texture_format_string(json_map, json_data): - table_data = '' - angle_format_map = {} +def json_to_table_data(internal_format, format_name, prefix, json): - for internal_format_item in sorted(json_map.iteritems()): - internal_format = internal_format_item[0] - table_data += ' case ' + internal_format + ':\n' - table_data += ' {\n' + table_data = "" - if isinstance(json_map[internal_format], basestring): - angle_format_id = json_map[internal_format] - table_data += get_texture_format_item(0, internal_format, None, angle_format_id, json_data[angle_format_id]) - else: - for idx, requirements_map in enumerate(sorted(json_map[internal_format].iteritems())): - angle_format_id = requirements_map[1] - table_data += get_texture_format_item(idx, internal_format, requirements_map[0], angle_format_id, json_data[angle_format_id]) - table_data += ' else\n' - table_data += ' {\n' - table_data += ' break;\n' - table_data += ' }\n' + parsed = { + "space": " ", + "internalFormat": internal_format, + "formatName": format_name, + "texFormat": "DXGI_FORMAT_UNKNOWN", + "srvFormat": "DXGI_FORMAT_UNKNOWN", + "rtvFormat": "DXGI_FORMAT_UNKNOWN", + "dsvFormat": "DXGI_FORMAT_UNKNOWN", + "condition": prefix, + } - table_data += ' }\n' + for k, v in json.iteritems(): + parsed[k] = v - return table_data + # Derived values. + parsed["blitSRVFormat"] = get_blit_srv_format(parsed) + parsed["swizzleFormat"] = get_swizzle_format_id(internal_format, parsed) + parsed["initializer"] = get_internal_format_initializer(internal_format, json) -def get_channel_struct(angle_format): - if 'bits' not in angle_format: - return None - bits = angle_format['bits'] - if 'depth' in bits or 'stencil' in bits: - return None - - if 'channelStruct' in angle_format: - return angle_format['channelStruct'] - - struct_name = '' - for channel in angle_format['channels']: - if channel == 'r': - struct_name += 'R{}'.format(bits['red']) - if channel == 'g': - struct_name += 'G{}'.format(bits['green']) - if channel == 'b': - struct_name += 'B{}'.format(bits['blue']) - if channel == 'a': - struct_name += 'A{}'.format(bits['alpha']) - if angle_format['componentType'] == 'float': - struct_name += 'F' - if angle_format['componentType'] == 'int' or angle_format['componentType'] == 'snorm': - struct_name += 'S' - return struct_name - -def get_mip_generation_function(angle_format): - channel_struct = get_channel_struct(angle_format) - if channel_struct == None: - return 'nullptr' - return 'GenerateMip<' + channel_struct + '>' - -def get_color_read_function(angle_format): - channel_struct = get_channel_struct(angle_format) - if channel_struct == None: - return 'nullptr' - component_type_map = { - 'uint': 'GLuint', - 'int': 'GLint', - 'unorm': 'GLfloat', - 'snorm': 'GLfloat', - 'float': 'GLfloat' - } - return 'ReadColor<' + channel_struct + ', '+ component_type_map[angle_format['componentType']] + '>' + if len(prefix) > 0: + return split_format_entry_template.format(**parsed) + else: + return format_entry_template.format(**parsed) + +def parse_json_angle_format_case(format_name, angle_format, json_data): + supported_case = {} + unsupported_case = {} + support_test = None + fallback = None + + for k, v in angle_format.iteritems(): + if k == "FL10Plus": + assert support_test is None + support_test = "OnlyFL10Plus(deviceCaps)" + for k2, v2 in v.iteritems(): + supported_case[k2] = v2 + elif k == "FL9_3": + split = True + for k2, v2 in v.iteritems(): + unsupported_case[k2] = v2 + elif k == "supportTest": + assert support_test is None + support_test = v + elif k == "fallbackFormat": + fallback = v + else: + supported_case[k] = v + unsupported_case[k] = v -def get_blit_srv_format(angle_format): - if 'channels' not in angle_format: - return 'DXGI_FORMAT_UNKNOWN' - if 'r' in angle_format['channels'] and angle_format['componentType'] in ['int', 'uint']: - return angle_format['rtvFormat'] + if fallback != None: + unsupported_case, _, _ = parse_json_angle_format_case( + fallback, json_data[fallback], json_data) + unsupported_case["formatName"] = fallback - return angle_format["srvFormat"] if "srvFormat" in angle_format else "DXGI_FORMAT_UNKNOWN" + if support_test != None: + return supported_case, unsupported_case, support_test + else: + return supported_case, None, None -def parse_json_into_switch_angle_format_string(json_data): +def parse_json_into_switch_angle_format_string(json_map, json_data): table_data = '' - for angle_format_item in sorted(json_data.iteritems()): - table_data += ' case ' + angle_format_item[0] + ':\n' - angle_format = angle_format_item[1] - gl_internal_format = angle_format["glInternalFormat"] if "glInternalFormat" in angle_format else "GL_NONE" - tex_format = angle_format["texFormat"] if "texFormat" in angle_format else "DXGI_FORMAT_UNKNOWN" - srv_format = angle_format["srvFormat"] if "srvFormat" in angle_format else "DXGI_FORMAT_UNKNOWN" - rtv_format = angle_format["rtvFormat"] if "rtvFormat" in angle_format else "DXGI_FORMAT_UNKNOWN" - dsv_format = angle_format["dsvFormat"] if "dsvFormat" in angle_format else "DXGI_FORMAT_UNKNOWN" - blit_srv_format = get_blit_srv_format(angle_format) - swizzle_format = get_swizzle_format_id(angle_format_item[0], angle_format) - mip_generation_function = get_mip_generation_function(angle_format) - color_read_function = get_color_read_function(angle_format) - table_data += ' {\n' - table_data += ' static const ANGLEFormatSet formatInfo(' + angle_format_item[0] + ',\n' - table_data += ' ' + gl_internal_format + ',\n' - table_data += ' ' + tex_format + ',\n' - table_data += ' ' + srv_format + ',\n' - table_data += ' ' + rtv_format + ',\n' - table_data += ' ' + dsv_format + ',\n' - table_data += ' ' + blit_srv_format + ',\n' - table_data += ' ' + swizzle_format + ',\n' - table_data += ' ' + mip_generation_function + ',\n' - table_data += ' ' + color_read_function + ');\n' - table_data += ' return formatInfo;\n' - table_data += ' }\n' - return table_data -def parse_json_into_angle_format_enum_string(json_data): - enum_data = '' - index = 0 - for angle_format_item in sorted(json_data.iteritems()): - if index > 0: - enum_data += ',\n' - enum_data += ' ' + angle_format_item[0] - index += 1 - return enum_data + for internal_format, format_name in sorted(json_map.iteritems()): + + if format_name not in json_data: + continue + + angle_format = json_data[format_name] + + supported_case, unsupported_case, support_test = parse_json_angle_format_case( + format_name, angle_format, json_data) + + table_data += ' case ' + internal_format + ':\n' + + if support_test != None: + table_data += " {\n" + table_data += json_to_table_data(internal_format, format_name, "if (" + support_test + ")", supported_case) + table_data += json_to_table_data(internal_format, format_name, "else", unsupported_case) + table_data += " }\n" + else: + table_data += json_to_table_data(internal_format, format_name, "", supported_case) + + return table_data def reject_duplicate_keys(pairs): found_keys = {} @@ -505,27 +343,17 @@ def reject_duplicate_keys(pairs): found_keys[key] = value return found_keys -with open('texture_format_map.json') as texture_format_map_file: - with open('texture_format_data.json') as texture_format_json_file: - texture_format_map = texture_format_map_file.read() - texture_format_data = texture_format_json_file.read() - texture_format_map_file.close() - texture_format_json_file.close() - json_map = json.loads(texture_format_map, object_pairs_hook=reject_duplicate_keys) - json_data = json.loads(texture_format_data, object_pairs_hook=reject_duplicate_keys) - - texture_format_cases = parse_json_into_switch_texture_format_string(json_map, json_data) - angle_format_cases = parse_json_into_switch_angle_format_string(json_data) - output_cpp = template_texture_format_table_autogen_cpp.format( - copyright_year=date.today().year, - texture_format_info_cases=texture_format_cases, - angle_format_info_cases=angle_format_cases) - with open('texture_format_table_autogen.cpp', 'wt') as out_file: - out_file.write(output_cpp) - out_file.close() - - enum_data = parse_json_into_angle_format_enum_string(json_data) - output_h = template_texture_format_table_autogen_h.format(angle_format_enum=enum_data) - with open('texture_format_table_autogen.h', 'wt') as out_file: - out_file.write(output_h) - out_file.close() +json_map = angle_format.load_with_override(os.path.abspath('texture_format_map.json')) + +with open('texture_format_data.json') as texture_format_json_file: + texture_format_data = texture_format_json_file.read() + texture_format_json_file.close() + json_data = json.loads(texture_format_data, object_pairs_hook=angle_format.reject_duplicate_keys) + + angle_format_cases = parse_json_into_switch_angle_format_string(json_map, json_data) + output_cpp = template_texture_format_table_autogen_cpp.format( + copyright_year=date.today().year, + angle_format_info_cases=angle_format_cases) + with open('texture_format_table_autogen.cpp', 'wt') as out_file: + out_file.write(output_cpp) + out_file.close() diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_data.json b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_data.json deleted file mode 100644 index bef8980906e..00000000000 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_data.json +++ /dev/null @@ -1,1208 +0,0 @@ -{ - "GL_RG8_SNORM": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative<GLbyte,2>", - "dxgiFormat": "DXGI_FORMAT_R8G8_SNORM", - "requiresConversion": "false" - } - ] - }, - "GL_SRGB8": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative3To4<GLubyte,0xFF>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA8I": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative<GLbyte,4>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_R8_SNORM": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative<GLbyte,1>", - "dxgiFormat": "DXGI_FORMAT_R8_SNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RGBA8_SNORM": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative<GLbyte,4>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SNORM", - "requiresConversion": "false" - } - ] - }, - "GL_R16I": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative<GLshort,1>", - "dxgiFormat": "DXGI_FORMAT_R16_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC2SRGBA8ToSRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC2RGB8A1ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGB32UI": { - "GL_UNSIGNED_INT": [ - { - "loadFunction": "LoadToNative3To4<GLuint,0x00000001>", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_UINT", - "requiresConversion": "true" - } - ] - }, - "GL_ALPHA32F_EXT": { - "GL_FLOAT": [ - { - "loadFunction": "LoadA32FToRGBA32F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_R16UI": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,1>", - "dxgiFormat": "DXGI_FORMAT_R16_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_RGB9_E5": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadRGB16FToRGB9E5", - "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_INT_5_9_9_9_REV": [ - { - "loadFunction": "LoadToNative<GLuint,1>", - "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP", - "requiresConversion": "false" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "LoadRGB32FToRGB9E5", - "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadRGB16FToRGB9E5", - "dxgiFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_R11_EAC": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadEACR11ToR8", - "dxgiFormat": "DXGI_FORMAT_R8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA32UI": { - "GL_UNSIGNED_INT": [ - { - "loadFunction": "LoadToNative<GLuint,4>", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_RG8UI": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,2>", - "dxgiFormat": "DXGI_FORMAT_R8G8_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_LUMINANCE32F_EXT": { - "GL_FLOAT": [ - { - "loadFunction": "LoadL32FToRGBA32F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC2SRGB8A1ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", - "requiresConversion": "true" - } - ] - }, - "GL_R16F": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadToNative<GLhalf,1>", - "dxgiFormat": "DXGI_FORMAT_R16_FLOAT", - "requiresConversion": "false" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "Load32FTo16F<1>", - "dxgiFormat": "DXGI_FORMAT_R16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadToNative<GLhalf,1>", - "dxgiFormat": "DXGI_FORMAT_R16_FLOAT", - "requiresConversion": "false" - } - ] - }, - "GL_RGBA8UI": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_BGRA4_ANGLEX": { - "GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT": [ - { - "loadFunction": "LoadRGBA4ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "false" - } - ] - }, - "GL_RGBA16F": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadToNative<GLhalf,4>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "false" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "Load32FTo16F<4>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadToNative<GLhalf,4>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "false" - } - ] - }, - "GL_LUMINANCE8_EXT": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadL8ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadCompressedToNative<4,4,16>", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RGB": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_SHORT_5_6_5": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RGB5_A1": { - "GL_UNSIGNED_INT_2_10_10_10_REV": [ - { - "loadFunction": "LoadRGB10A2ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - }, - { - "loadFunction": "LoadRGB10A2ToBGR5A1", - "dxgiFormat": "DXGI_FORMAT_B5G5R5A1_UNORM", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "false" - }, - { - "loadFunction": "LoadRGBA8ToBGR5A1", - "dxgiFormat": "DXGI_FORMAT_B5G5R5A1_UNORM", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_SHORT_5_5_5_1": [ - { - "loadFunction": "LoadRGB5A1ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - }, - { - "loadFunction": "LoadRGB5A1ToA1RGB5", - "dxgiFormat": "DXGI_FORMAT_B5G5R5A1_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGB16UI": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative3To4<GLushort,0x0001>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_UINT", - "requiresConversion": "true" - } - ] - }, - "GL_BGRA_EXT": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_RGB8_ETC2": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC2RGB8ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA32F": { - "GL_FLOAT": [ - { - "loadFunction": "LoadToNative<GLfloat,4>", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", - "requiresConversion": "false" - } - ] - }, - "GL_RGBA32I": { - "GL_INT": [ - { - "loadFunction": "LoadToNative<GLint,4>", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_LUMINANCE8_ALPHA8_EXT": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadLA8ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RG8": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,2>", - "dxgiFormat": "DXGI_FORMAT_R8G8_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RGB10_A2": { - "GL_UNSIGNED_INT_2_10_10_10_REV": [ - { - "loadFunction": "LoadToNative<GLuint,1>", - "dxgiFormat": "DXGI_FORMAT_R10G10B10A2_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_COMPRESSED_SIGNED_RG11_EAC": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadEACRG11SToRG8", - "dxgiFormat": "DXGI_FORMAT_R8G8_SNORM", - "requiresConversion": "true" - } - ] - }, - "GL_DEPTH_COMPONENT16": { - "GL_UNSIGNED_INT": [ - { - "loadFunction": "LoadR32ToR16", - "dxgiFormat": "DXGI_FORMAT_R16_TYPELESS", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,1>", - "dxgiFormat": "DXGI_FORMAT_R16_TYPELESS", - "requiresConversion": "false" - }, - { - "loadFunction": "LoadToNative<GLushort,1>", - "dxgiFormat": "DXGI_FORMAT_D16_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RGB32I": { - "GL_INT": [ - { - "loadFunction": "LoadToNative3To4<GLint,0x00000001>", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_SINT", - "requiresConversion": "true" - } - ] - }, - "GL_R8": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,1>", - "dxgiFormat": "DXGI_FORMAT_R8_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RGB32F": { - "GL_FLOAT": [ - { - "loadFunction": "LoadToNative3To4<GLfloat,gl::Float32One>", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", - "requiresConversion": "true" - } - ] - }, - "GL_R11F_G11F_B10F": { - "GL_UNSIGNED_INT_10F_11F_11F_REV": [ - { - "loadFunction": "LoadToNative<GLuint,1>", - "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT", - "requiresConversion": "false" - } - ], - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadRGB16FToRG11B10F", - "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT", - "requiresConversion": "true" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "LoadRGB32FToRG11B10F", - "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadRGB16FToRG11B10F", - "dxgiFormat": "DXGI_FORMAT_R11G11B10_FLOAT", - "requiresConversion": "true" - } - ] - }, - "GL_RGB8": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative3To4<GLubyte,0xFF>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_LUMINANCE_ALPHA": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadLA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "LoadLA32FToRGBA32F", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadLA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA16I": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative<GLshort,4>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_R8I": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative<GLbyte,1>", - "dxgiFormat": "DXGI_FORMAT_R8_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_RGB8_SNORM": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative3To4<GLbyte,0x7F>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RG32F": { - "GL_FLOAT": [ - { - "loadFunction": "LoadToNative<GLfloat,2>", - "dxgiFormat": "DXGI_FORMAT_R32G32_FLOAT", - "requiresConversion": "false" - } - ] - }, - "GL_DEPTH_COMPONENT32F": { - "GL_FLOAT": [ - { - "loadFunction": "LoadToNative<GLfloat,1>", - "dxgiFormat": "DXGI_FORMAT_R32_TYPELESS", - "requiresConversion": "false" - }, - { - "loadFunction": "UnimplementedLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RG32I": { - "GL_INT": [ - { - "loadFunction": "LoadToNative<GLint,2>", - "dxgiFormat": "DXGI_FORMAT_R32G32_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_ALPHA8_EXT": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,1>", - "dxgiFormat": "DXGI_FORMAT_A8_UNORM", - "requiresConversion": "false" - }, - { - "loadFunction": "LoadA8ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RG32UI": { - "GL_UNSIGNED_INT": [ - { - "loadFunction": "LoadToNative<GLuint,2>", - "dxgiFormat": "DXGI_FORMAT_R32G32_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_RGBA16UI": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,4>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_COMPRESSED_RGBA8_ETC2_EAC": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC2RGBA8ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGB8I": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative3To4<GLbyte,0x01>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_SINT", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_SRGB8_ETC2": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC2SRGB8ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", - "requiresConversion": "true" - } - ] - }, - "GL_DEPTH32F_STENCIL8": { - "GL_FLOAT_32_UNSIGNED_INT_24_8_REV": [ - { - "loadFunction": "LoadToNative<GLuint,2>", - "dxgiFormat": "DXGI_FORMAT_R32G8X24_TYPELESS", - "requiresConversion": "false" - }, - { - "loadFunction": "UnimplementedLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RG8I": { - "GL_BYTE": [ - { - "loadFunction": "LoadToNative<GLbyte,2>", - "dxgiFormat": "DXGI_FORMAT_R8G8_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_R32UI": { - "GL_UNSIGNED_INT": [ - { - "loadFunction": "LoadToNative<GLuint,1>", - "dxgiFormat": "DXGI_FORMAT_R32_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_BGR5_A1_ANGLEX": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "false" - } - ], - "GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT": [ - { - "loadFunction": "LoadRGB5A1ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_RG11_EAC": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadEACRG11ToRG8", - "dxgiFormat": "DXGI_FORMAT_R8G8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_SRGB8_ALPHA8": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", - "requiresConversion": "false" - } - ] - }, - "GL_LUMINANCE_ALPHA16F_EXT": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadLA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadLA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_SHORT_4_4_4_4": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_SHORT_5_5_5_1": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_DEPTH24_STENCIL8": { - "GL_UNSIGNED_INT_24_8": [ - { - "loadFunction": "LoadR32ToR24G8", - "dxgiFormat": "DXGI_FORMAT_R24G8_TYPELESS", - "requiresConversion": "true" - }, - { - "loadFunction": "LoadR32ToR24G8", - "dxgiFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT", - "requiresConversion": "true" - } - ] - }, - "GL_RGB16I": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative3To4<GLshort,0x0001>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_SINT", - "requiresConversion": "true" - } - ] - }, - "GL_R8UI": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,1>", - "dxgiFormat": "DXGI_FORMAT_R8_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_ALPHA": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "LoadA32FToRGBA32F", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ] - }, - "GL_RGB16F": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadToNative3To4<GLhalf,gl::Float16One>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "LoadRGB32FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadToNative3To4<GLhalf,gl::Float16One>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_SIGNED_R11_EAC": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadEACR11SToR8", - "dxgiFormat": "DXGI_FORMAT_R8_SNORM", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_RGB_S3TC_DXT1_EXT": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadCompressedToNative<4,4,8>", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadCompressedToNative<4,4,8>", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_STENCIL_INDEX8": { - "DXGI_FORMAT_R24G8_TYPELESS": [ - { - "loadFunction": "UnimplementedLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "DXGI_FORMAT_D24_UNORM_S8_UINT": [ - { - "loadFunction": "UnimplementedLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_LUMINANCE_ALPHA32F_EXT": { - "GL_FLOAT": [ - { - "loadFunction": "LoadLA32FToRGBA32F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RGB8UI": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative3To4<GLubyte,0x01>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UINT", - "requiresConversion": "true" - } - ] - }, - "GL_DEPTH_COMPONENT24": { - "GL_UNSIGNED_INT": [ - { - "loadFunction": "LoadR32ToR24G8", - "dxgiFormat": "DXGI_FORMAT_R24G8_TYPELESS", - "requiresConversion": "true" - }, - { - "loadFunction": "LoadR32ToR24G8", - "dxgiFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT", - "requiresConversion": "true" - } - ] - }, - "GL_R32I": { - "GL_INT": [ - { - "loadFunction": "LoadToNative<GLint,1>", - "dxgiFormat": "DXGI_FORMAT_R32_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_DEPTH_COMPONENT32_OES": { - "GL_UNSIGNED_INT": [ - { - "loadFunction": "LoadR32ToR24G8", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_R32F": { - "GL_FLOAT": [ - { - "loadFunction": "LoadToNative<GLfloat,1>", - "dxgiFormat": "DXGI_FORMAT_R32_FLOAT", - "requiresConversion": "false" - } - ] - }, - "GL_RG16F": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadToNative<GLhalf,2>", - "dxgiFormat": "DXGI_FORMAT_R16G16_FLOAT", - "requiresConversion": "false" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "Load32FTo16F<2>", - "dxgiFormat": "DXGI_FORMAT_R16G16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadToNative<GLhalf,2>", - "dxgiFormat": "DXGI_FORMAT_R16G16_FLOAT", - "requiresConversion": "false" - } - ] - }, - "GL_RGB565": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative3To4<GLubyte,0xFF>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - }, - { - "loadFunction": "LoadRGB8ToBGR565", - "dxgiFormat": "DXGI_FORMAT_B5G6R5_UNORM", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_SHORT_5_6_5": [ - { - "loadFunction": "LoadR5G6B5ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - }, - { - "loadFunction": "LoadToNative<GLushort,1>", - "dxgiFormat": "DXGI_FORMAT_B5G6R5_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_LUMINANCE16F_EXT": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadL16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadL16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RG16UI": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,2>", - "dxgiFormat": "DXGI_FORMAT_R16G16_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadCompressedToNative<4,4,16>", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RG16I": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative<GLshort,2>", - "dxgiFormat": "DXGI_FORMAT_R16G16_SINT", - "requiresConversion": "false" - } - ] - }, - "GL_BGRA8_EXT": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "false" - } - ] - }, - "GL_ALPHA16F_EXT": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadA16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA4": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "false" - }, - { - "loadFunction": "LoadRGBA8ToBGRA4", - "dxgiFormat": "DXGI_FORMAT_B4G4R4A4_UNORM", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_SHORT_4_4_4_4": [ - { - "loadFunction": "LoadRGBA4ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - }, - { - "loadFunction": "LoadRGBA4ToARGB4", - "dxgiFormat": "DXGI_FORMAT_B4G4R4A4_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA8": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadToNative<GLubyte,4>", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_LUMINANCE": { - "GL_HALF_FLOAT": [ - { - "loadFunction": "LoadL16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ], - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "UnreachableLoadFunction", - "dxgiFormat": "DXGI_FORMAT_UNKNOWN", - "requiresConversion": "true" - } - ], - "GL_FLOAT": [ - { - "loadFunction": "LoadL32FToRGBA32F", - "dxgiFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", - "requiresConversion": "true" - } - ], - "GL_HALF_FLOAT_OES": [ - { - "loadFunction": "LoadL16FToRGBA16F", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", - "requiresConversion": "true" - } - ] - }, - "GL_RGB10_A2UI": { - "GL_UNSIGNED_INT_2_10_10_10_REV": [ - { - "loadFunction": "LoadToNative<GLuint,1>", - "dxgiFormat": "DXGI_FORMAT_R10G10B10A2_UINT", - "requiresConversion": "false" - } - ] - }, - "GL_ETC1_RGB8_OES": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC1RGB8ToRGBA8", - "dxgiFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_ETC1_RGB8_LOSSY_DECODE_ANGLE": { - "GL_UNSIGNED_BYTE": [ - { - "loadFunction": "LoadETC1RGB8ToBC1", - "dxgiFormat": "DXGI_FORMAT_BC1_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_R16_EXT": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,1>", - "dxgiFormat": "DXGI_FORMAT_R16_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RG16_EXT": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,2>", - "dxgiFormat": "DXGI_FORMAT_R16G16_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RGB16_EXT": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative3To4<GLushort,0xFFFF>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_UNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA16_EXT": { - "GL_UNSIGNED_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,4>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_UNORM", - "requiresConversion": "false" - } - ] - }, - "GL_R16_SNORM_EXT": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,1>", - "dxgiFormat": "DXGI_FORMAT_R16_SNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RG16_SNORM_EXT": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,2>", - "dxgiFormat": "DXGI_FORMAT_R16G16_SNORM", - "requiresConversion": "false" - } - ] - }, - "GL_RGB16_SNORM_EXT": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative3To4<GLushort,0x7FFF>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_SNORM", - "requiresConversion": "true" - } - ] - }, - "GL_RGBA16_SNORM_EXT": { - "GL_SHORT": [ - { - "loadFunction": "LoadToNative<GLushort,4>", - "dxgiFormat": "DXGI_FORMAT_R16G16B16A16_SNORM", - "requiresConversion": "false" - } - ] - } -}
\ No newline at end of file diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_table.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_table.h deleted file mode 100644 index b17062f68dd..00000000000 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_table.h +++ /dev/null @@ -1,31 +0,0 @@ -// -// Copyright 2015 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// -// load_functions_table: -// Contains load functions table depending on internal format and dxgi format -// - -#ifndef LIBANGLE_RENDERER_D3D_D3D11_LOADFUNCTIONSTABLE_H_ -#define LIBANGLE_RENDERER_D3D_D3D11_LOADFUNCTIONSTABLE_H_ - -#include <map> - -#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" -#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" - -namespace rx -{ - -namespace d3d11 -{ - -const std::map<GLenum, LoadImageFunctionInfo> &GetLoadFunctionsMap(GLenum internalFormat, - DXGI_FORMAT dxgiFormat); - -} // namespace d3d11 - -} // namespace rx - -#endif // LIBANGLE_RENDERER_D3D_D3D11_LOADFUNCTIONSTABLE_H_ diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_table_autogen.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_table_autogen.cpp deleted file mode 100644 index 9b03083a926..00000000000 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/load_functions_table_autogen.cpp +++ /dev/null @@ -1,1970 +0,0 @@ -// GENERATED FILE - DO NOT EDIT. -// Generated by gen_load_functions_table.py using data from load_functions_data.json -// -// Copyright 2015 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// -// load_functions_table: -// Contains the GetLoadFunctionsMap for texture_format_util.h -// - -#include "libANGLE/renderer/d3d/d3d11/load_functions_table.h" -#include "libANGLE/renderer/d3d/d3d11/formatutils11.h" -#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" -#include "libANGLE/renderer/d3d/loadimage.h" -#include "libANGLE/renderer/d3d/loadimage_etc.h" - -namespace rx -{ - -namespace d3d11 -{ - -namespace -{ - -// ES3 image loading functions vary based on: -// - the GL internal format (supplied to glTex*Image*D) -// - the GL data type given (supplied to glTex*Image*D) -// - the target DXGI_FORMAT that the image will be loaded into (which is chosen based on the D3D -// device's capabilities) -// This map type determines which loading function to use, based on these three parameters. -// Source formats and types are taken from Tables 3.2 and 3.3 of the ES 3 spec. -void UnimplementedLoadFunction(size_t width, - size_t height, - size_t depth, - const uint8_t *input, - size_t inputRowPitch, - size_t inputDepthPitch, - uint8_t *output, - size_t outputRowPitch, - size_t outputDepthPitch) -{ - UNIMPLEMENTED(); -} - -void UnreachableLoadFunction(size_t width, - size_t height, - size_t depth, - const uint8_t *input, - size_t inputRowPitch, - size_t inputDepthPitch, - uint8_t *output, - size_t outputRowPitch, - size_t outputDepthPitch) -{ - UNREACHABLE(); -} - -} // namespace - -// TODO we can replace these maps with more generated code -const std::map<GLenum, LoadImageFunctionInfo> &GetLoadFunctionsMap(GLenum internalFormat, - DXGI_FORMAT dxgiFormat) -{ - // clang-format off - switch (internalFormat) - { - case GL_ALPHA: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadA16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadA16FToRGBA16F, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R32G32B32A32_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadA32FToRGBA32F, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_ALPHA16F_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadA16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadA16FToRGBA16F, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadA16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadA16FToRGBA16F, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_ALPHA32F_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadA32FToRGBA32F, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadA32FToRGBA32F, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_ALPHA8_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,1>, false) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadA8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_BGR5_A1_ANGLEX: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT, LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, true) }, - { GL_UNSIGNED_SHORT_1_5_5_5_REV_EXT, LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_BGRA4_ANGLEX: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT, LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, true) }, - { GL_UNSIGNED_SHORT_4_4_4_4_REV_EXT, LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_BGRA8_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_BGRA_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_COMPRESSED_R11_EAC: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadEACR11ToR8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_RG11_EAC: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadEACRG11ToRG8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_RGB8_ETC2: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC2RGB8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC2RGB8A1ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_RGBA8_ETC2_EAC: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC2RGBA8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,16>, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadCompressedToNative<4,4,8>, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_COMPRESSED_SIGNED_R11_EAC: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadEACR11SToR8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_SIGNED_RG11_EAC: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadEACRG11SToRG8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC2SRGBA8ToSRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_SRGB8_ETC2: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC2SRGB8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC2SRGB8A1ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_DEPTH24_STENCIL8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_D24_UNORM_S8_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT_24_8, LoadImageFunctionInfo(LoadR32ToR24G8, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R24G8_TYPELESS: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT_24_8, LoadImageFunctionInfo(LoadR32ToR24G8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_DEPTH32F_STENCIL8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G8X24_TYPELESS: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT_32_UNSIGNED_INT_24_8_REV, LoadImageFunctionInfo(LoadToNative<GLuint,2>, false) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT_32_UNSIGNED_INT_24_8_REV, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT_32_UNSIGNED_INT_24_8_REV, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_DEPTH_COMPONENT16: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_D16_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,1>, false) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R16_TYPELESS: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadR32ToR16, true) }, - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_DEPTH_COMPONENT24: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_D24_UNORM_S8_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadR32ToR24G8, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R24G8_TYPELESS: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadR32ToR24G8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_DEPTH_COMPONENT32F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32_TYPELESS: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadToNative<GLfloat,1>, false) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_DEPTH_COMPONENT32_OES: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadR32ToR24G8, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadR32ToR24G8, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_BC1_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC1RGB8ToBC1, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_ETC1_RGB8_OES: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadETC1RGB8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_LUMINANCE: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadL16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadL16FToRGBA16F, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R32G32B32A32_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadL32FToRGBA32F, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_LUMINANCE16F_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadL16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadL16FToRGBA16F, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadL16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadL16FToRGBA16F, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_LUMINANCE32F_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadL32FToRGBA32F, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadL32FToRGBA32F, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_LUMINANCE8_ALPHA8_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadLA8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadLA8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_LUMINANCE8_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadL8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadL8ToRGBA8, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_LUMINANCE_ALPHA: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadLA16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadLA16FToRGBA16F, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R32G32B32A32_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadLA32FToRGBA32F, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_LUMINANCE_ALPHA16F_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadLA16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadLA16FToRGBA16F, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadLA16FToRGBA16F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadLA16FToRGBA16F, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_LUMINANCE_ALPHA32F_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadLA32FToRGBA32F, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadLA32FToRGBA32F, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_R11F_G11F_B10F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R11G11B10_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadRGB16FToRG11B10F, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadRGB16FToRG11B10F, true) }, - { GL_FLOAT, LoadImageFunctionInfo(LoadRGB32FToRG11B10F, true) }, - { GL_UNSIGNED_INT_10F_11F_11F_REV, LoadImageFunctionInfo(LoadToNative<GLuint,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R16F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(Load32FTo16F<1>, true) }, - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadToNative<GLhalf,1>, false) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadToNative<GLhalf,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R16I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative<GLshort,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R16UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R16_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R16_SNORM_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R32F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadToNative<GLfloat,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R32I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_INT, LoadImageFunctionInfo(LoadToNative<GLint,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R32UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadToNative<GLuint,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R8I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative<GLbyte,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R8UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_R8_SNORM: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative<GLbyte,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG16F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(Load32FTo16F<2>, true) }, - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadToNative<GLhalf,2>, false) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadToNative<GLhalf,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG16I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative<GLshort,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG16UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG16_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG16_SNORM_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG32F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadToNative<GLfloat,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG32I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_INT, LoadImageFunctionInfo(LoadToNative<GLint,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG32UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadToNative<GLuint,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG8I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative<GLbyte,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG8UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RG8_SNORM: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative<GLbyte,2>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - { GL_UNSIGNED_SHORT_5_6_5, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - { GL_UNSIGNED_SHORT_5_6_5, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_RGB10_A2: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R10G10B10A2_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT_2_10_10_10_REV, LoadImageFunctionInfo(LoadToNative<GLuint,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB10_A2UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R10G10B10A2_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT_2_10_10_10_REV, LoadImageFunctionInfo(LoadToNative<GLuint,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB16F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadRGB32FToRGBA16F, true) }, - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadToNative3To4<GLhalf,gl::Float16One>, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadToNative3To4<GLhalf,gl::Float16One>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB16I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative3To4<GLshort,0x0001>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB16UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative3To4<GLushort,0x0001>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB16_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative3To4<GLushort,0xFFFF>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB16_SNORM_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative3To4<GLushort,0x7FFF>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB32F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32B32A32_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadToNative3To4<GLfloat,gl::Float32One>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB32I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32B32A32_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_INT, LoadImageFunctionInfo(LoadToNative3To4<GLint,0x00000001>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB32UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32B32A32_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadToNative3To4<GLuint,0x00000001>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB565: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_B5G6R5_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadRGB8ToBGR565, true) }, - { GL_UNSIGNED_SHORT_5_6_5, LoadImageFunctionInfo(LoadToNative<GLushort,1>, false) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT_5_6_5, LoadImageFunctionInfo(LoadR5G6B5ToRGBA8, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0xFF>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB5_A1: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_B5G5R5A1_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT_2_10_10_10_REV, LoadImageFunctionInfo(LoadRGB10A2ToBGR5A1, true) }, - { GL_UNSIGNED_SHORT_5_5_5_1, LoadImageFunctionInfo(LoadRGB5A1ToA1RGB5, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadRGBA8ToBGR5A1, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT_2_10_10_10_REV, LoadImageFunctionInfo(LoadRGB10A2ToRGBA8, true) }, - { GL_UNSIGNED_SHORT_5_5_5_1, LoadImageFunctionInfo(LoadRGB5A1ToRGBA8, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0xFF>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB8I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative3To4<GLbyte,0x01>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB8UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0x01>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB8_SNORM: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative3To4<GLbyte,0x7F>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGB9_E5: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R9G9B9E5_SHAREDEXP: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadRGB16FToRGB9E5, true) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadRGB16FToRGB9E5, true) }, - { GL_FLOAT, LoadImageFunctionInfo(LoadRGB32FToRGB9E5, true) }, - { GL_UNSIGNED_INT_5_9_9_9_REV, LoadImageFunctionInfo(LoadToNative<GLuint,1>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - { GL_UNSIGNED_SHORT_4_4_4_4, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - { GL_UNSIGNED_SHORT_5_5_5_1, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - { GL_UNSIGNED_SHORT_4_4_4_4, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - { GL_UNSIGNED_SHORT_5_5_5_1, LoadImageFunctionInfo(UnreachableLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - case GL_RGBA16F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(Load32FTo16F<4>, true) }, - { GL_HALF_FLOAT, LoadImageFunctionInfo(LoadToNative<GLhalf,4>, false) }, - { GL_HALF_FLOAT_OES, LoadImageFunctionInfo(LoadToNative<GLhalf,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA16I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative<GLshort,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA16UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA16_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA16_SNORM_EXT: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R16G16B16A16_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_SHORT, LoadImageFunctionInfo(LoadToNative<GLushort,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA32F: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32B32A32_FLOAT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_FLOAT, LoadImageFunctionInfo(LoadToNative<GLfloat,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA32I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32B32A32_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_INT, LoadImageFunctionInfo(LoadToNative<GLint,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA32UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R32G32B32A32_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_INT, LoadImageFunctionInfo(LoadToNative<GLuint,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA4: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_B4G4R4A4_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT_4_4_4_4, LoadImageFunctionInfo(LoadRGBA4ToARGB4, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadRGBA8ToBGRA4, true) }, - }; - - return loadFunctionsMap; - } - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_SHORT_4_4_4_4, LoadImageFunctionInfo(LoadRGBA4ToRGBA8, true) }, - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA8I: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_SINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative<GLbyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA8UI: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UINT: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_RGBA8_SNORM: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_SNORM: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_BYTE, LoadImageFunctionInfo(LoadToNative<GLbyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_SRGB8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative3To4<GLubyte,0xFF>, true) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_SRGB8_ALPHA8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_R8G8B8A8_UNORM_SRGB: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { GL_UNSIGNED_BYTE, LoadImageFunctionInfo(LoadToNative<GLubyte,4>, false) }, - }; - - return loadFunctionsMap; - } - default: - break; - } - } - case GL_STENCIL_INDEX8: - { - switch (dxgiFormat) - { - case DXGI_FORMAT_UNKNOWN: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { DXGI_FORMAT_D24_UNORM_S8_UINT, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - { DXGI_FORMAT_R24G8_TYPELESS, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - default: - { - static const std::map<GLenum, LoadImageFunctionInfo> loadFunctionsMap = { - { DXGI_FORMAT_D24_UNORM_S8_UINT, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - { DXGI_FORMAT_R24G8_TYPELESS, LoadImageFunctionInfo(UnimplementedLoadFunction, true) }, - }; - - return loadFunctionsMap; - } - } - } - - default: - { - static std::map<GLenum, LoadImageFunctionInfo> emptyLoadFunctionsMap; - return emptyLoadFunctionsMap; - } - } - // clang-format on - -} // GetLoadFunctionsMap - -} // namespace d3d11 - -} // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp index 1c5e9651d12..ad0e1085d71 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp @@ -349,8 +349,7 @@ static gl::TextureCaps GenerateTextureFormatCaps(GLint maxClientVersion, GLenum gl::TextureCaps textureCaps; DXGISupportHelper support(device, renderer11DeviceCaps.featureLevel); - const d3d11::TextureFormat &formatInfo = - d3d11::GetTextureFormatInfo(internalFormat, renderer11DeviceCaps); + const d3d11::Format &formatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); const gl::InternalFormat &internalFormatInfo = gl::GetInternalFormatInfo(internalFormat); @@ -364,21 +363,21 @@ static gl::TextureCaps GenerateTextureFormatCaps(GLint maxClientVersion, GLenum } } - textureCaps.texturable = support.query(formatInfo.formatSet->texFormat, texSupportMask); + textureCaps.texturable = support.query(formatInfo.texFormat, texSupportMask); textureCaps.filterable = - support.query(formatInfo.formatSet->srvFormat, D3D11_FORMAT_SUPPORT_SHADER_SAMPLE); + support.query(formatInfo.srvFormat, D3D11_FORMAT_SUPPORT_SHADER_SAMPLE); textureCaps.renderable = - (support.query(formatInfo.formatSet->rtvFormat, D3D11_FORMAT_SUPPORT_RENDER_TARGET)) || - (support.query(formatInfo.formatSet->dsvFormat, D3D11_FORMAT_SUPPORT_DEPTH_STENCIL)); + (support.query(formatInfo.rtvFormat, D3D11_FORMAT_SUPPORT_RENDER_TARGET)) || + (support.query(formatInfo.dsvFormat, D3D11_FORMAT_SUPPORT_DEPTH_STENCIL)); DXGI_FORMAT renderFormat = DXGI_FORMAT_UNKNOWN; - if (formatInfo.formatSet->dsvFormat != DXGI_FORMAT_UNKNOWN) + if (formatInfo.dsvFormat != DXGI_FORMAT_UNKNOWN) { - renderFormat = formatInfo.formatSet->dsvFormat; + renderFormat = formatInfo.dsvFormat; } - else if (formatInfo.formatSet->rtvFormat != DXGI_FORMAT_UNKNOWN) + else if (formatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN) { - renderFormat = formatInfo.formatSet->rtvFormat; + renderFormat = formatInfo.rtvFormat; } if (renderFormat != DXGI_FORMAT_UNKNOWN && support.query(renderFormat, D3D11_FORMAT_SUPPORT_MULTISAMPLE_RENDERTARGET)) @@ -754,14 +753,13 @@ static size_t GetMaximumVertexInputSlots(D3D_FEATURE_LEVEL featureLevel) static size_t GetMaximumVertexUniformVectors(D3D_FEATURE_LEVEL featureLevel) { - // TODO(geofflang): Remove hard-coded limit once the gl-uniform-arrays test can pass switch (featureLevel) { case D3D_FEATURE_LEVEL_11_1: - case D3D_FEATURE_LEVEL_11_0: return 1024; // D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; + case D3D_FEATURE_LEVEL_11_0: return D3D11_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; case D3D_FEATURE_LEVEL_10_1: - case D3D_FEATURE_LEVEL_10_0: return 1024; // D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; + case D3D_FEATURE_LEVEL_10_0: return D3D10_REQ_CONSTANT_BUFFER_ELEMENT_COUNT; // From http://msdn.microsoft.com/en-us/library/windows/desktop/ff476149.aspx ID3D11DeviceContext::VSSetConstantBuffers case D3D_FEATURE_LEVEL_9_3: @@ -798,7 +796,7 @@ static size_t GetMaximumVertexUniformBlocks(D3D_FEATURE_LEVEL featureLevel) static size_t GetReservedVertexOutputVectors(D3D_FEATURE_LEVEL featureLevel) { - // According to The OpenGL ES Shading Language specifications + // According to The OpenGL ES Shading Language specifications // (Language Version 1.00 section 10.16, Language Version 3.10 section 12.21) // built-in special variables (e.g. gl_FragCoord, or gl_PointCoord) // which are statically used in the shader should be included in the variable packing algorithm. @@ -821,8 +819,6 @@ static size_t GetReservedVertexOutputVectors(D3D_FEATURE_LEVEL featureLevel) default: UNREACHABLE(); return 0; } - - return 1; } static size_t GetMaximumVertexOutputVectors(D3D_FEATURE_LEVEL featureLevel) @@ -1242,6 +1238,7 @@ void GenerateCaps(ID3D11Device *device, ID3D11DeviceContext *deviceContext, cons extensions->packSubimage = true; extensions->lossyETCDecode = true; extensions->syncQuery = GetEventQuerySupport(featureLevel); + extensions->copyTexture = true; // D3D11 Feature Level 10_0+ uses SV_IsFrontFace in HLSL to emulate gl_FrontFacing. // D3D11 Feature Level 9_3 doesn't support SV_IsFrontFace, and has no equivalent, so can't support gl_FrontFacing. @@ -1370,11 +1367,11 @@ void GenerateInitialTextureData(GLint internalFormat, std::vector<D3D11_SUBRESOURCE_DATA> *outSubresourceData, std::vector<std::vector<BYTE>> *outData) { - const d3d11::TextureFormat &d3dFormatInfo = d3d11::GetTextureFormatInfo(internalFormat, renderer11DeviceCaps); + const d3d11::Format &d3dFormatInfo = d3d11::Format::Get(internalFormat, renderer11DeviceCaps); ASSERT(d3dFormatInfo.dataInitializerFunction != NULL); const d3d11::DXGIFormatSize &dxgiFormatInfo = - d3d11::GetDXGIFormatSizeInfo(d3dFormatInfo.formatSet->texFormat); + d3d11::GetDXGIFormatSizeInfo(d3dFormatInfo.texFormat); outSubresourceData->resize(mipLevels); outData->resize(mipLevels); @@ -1509,13 +1506,48 @@ ID3D11BlendState *LazyBlendState::resolve(ID3D11Device *device) return mResource; } -WorkaroundsD3D GenerateWorkarounds(D3D_FEATURE_LEVEL featureLevel) +WorkaroundsD3D GenerateWorkarounds(const Renderer11DeviceCaps &deviceCaps, + const DXGI_ADAPTER_DESC &adapterDesc) { + bool is9_3 = (deviceCaps.featureLevel <= D3D_FEATURE_LEVEL_9_3); + WorkaroundsD3D workarounds; workarounds.mrtPerfWorkaround = true; workarounds.setDataFasterThanImageUpload = true; - workarounds.zeroMaxLodWorkaround = (featureLevel <= D3D_FEATURE_LEVEL_9_3); - workarounds.useInstancedPointSpriteEmulation = (featureLevel <= D3D_FEATURE_LEVEL_9_3); + workarounds.zeroMaxLodWorkaround = is9_3; + workarounds.useInstancedPointSpriteEmulation = is9_3; + + // TODO(jmadill): Narrow problematic driver range. + if (adapterDesc.VendorId == VENDOR_ID_NVIDIA) + { + if (deviceCaps.driverVersion.valid()) + { + WORD part1 = HIWORD(deviceCaps.driverVersion.value().LowPart); + WORD part2 = LOWORD(deviceCaps.driverVersion.value().LowPart); + + // Disable the workaround to fix a second driver bug on newer NVIDIA. + workarounds.depthStencilBlitExtraCopy = (part1 <= 13u && part2 < 6881); + } + else + { + workarounds.depthStencilBlitExtraCopy = true; + } + } + + // TODO(jmadill): Disable workaround when we have a fixed compiler DLL. + workarounds.expandIntegerPowExpressions = true; + + workarounds.flushAfterEndingTransformFeedback = (adapterDesc.VendorId == VENDOR_ID_NVIDIA); + workarounds.getDimensionsIgnoresBaseLevel = (adapterDesc.VendorId == VENDOR_ID_NVIDIA); + + workarounds.preAddTexelFetchOffsets = (adapterDesc.VendorId == VENDOR_ID_INTEL); + workarounds.disableB5G6R5Support = (adapterDesc.VendorId == VENDOR_ID_INTEL); + workarounds.rewriteUnaryMinusOperator = (adapterDesc.VendorId == VENDOR_ID_INTEL); + workarounds.emulateIsnanFloat = (adapterDesc.VendorId == VENDOR_ID_INTEL); + + // TODO(jmadill): Disable when we have a fixed driver version. + workarounds.emulateTinyStencilTextures = (adapterDesc.VendorId == VENDOR_ID_AMD); + return workarounds; } @@ -1534,7 +1566,7 @@ void InitConstantBufferDesc(D3D11_BUFFER_DESC *constantBufferDescription, size_t TextureHelper11::TextureHelper11() : mTextureType(GL_NONE), mFormat(DXGI_FORMAT_UNKNOWN), - mANGLEFormat(d3d11::ANGLE_FORMAT_NONE), + mFormatSet(nullptr), mSampleCount(0), mTexture2D(nullptr), mTexture3D(nullptr) @@ -1545,7 +1577,7 @@ TextureHelper11::TextureHelper11(TextureHelper11 &&toCopy) : mTextureType(toCopy.mTextureType), mExtents(toCopy.mExtents), mFormat(toCopy.mFormat), - mANGLEFormat(toCopy.mANGLEFormat), + mFormatSet(toCopy.mFormatSet), mSampleCount(toCopy.mSampleCount), mTexture2D(toCopy.mTexture2D), mTexture3D(toCopy.mTexture3D) @@ -1555,10 +1587,10 @@ TextureHelper11::TextureHelper11(TextureHelper11 &&toCopy) // static TextureHelper11 TextureHelper11::MakeAndReference(ID3D11Resource *genericResource, - d3d11::ANGLEFormat angleFormat) + const d3d11::Format &formatSet) { TextureHelper11 newHelper; - newHelper.mANGLEFormat = angleFormat; + newHelper.mFormatSet = &formatSet; newHelper.mTexture2D = d3d11::DynamicCastComObject<ID3D11Texture2D>(genericResource); newHelper.mTexture3D = d3d11::DynamicCastComObject<ID3D11Texture3D>(genericResource); newHelper.mTextureType = newHelper.mTexture2D ? GL_TEXTURE_2D : GL_TEXTURE_3D; @@ -1568,10 +1600,10 @@ TextureHelper11 TextureHelper11::MakeAndReference(ID3D11Resource *genericResourc // static TextureHelper11 TextureHelper11::MakeAndPossess2D(ID3D11Texture2D *texToOwn, - d3d11::ANGLEFormat angleFormat) + const d3d11::Format &formatSet) { TextureHelper11 newHelper; - newHelper.mANGLEFormat = angleFormat; + newHelper.mFormatSet = &formatSet; newHelper.mTexture2D = texToOwn; newHelper.mTextureType = GL_TEXTURE_2D; newHelper.initDesc(); @@ -1580,10 +1612,10 @@ TextureHelper11 TextureHelper11::MakeAndPossess2D(ID3D11Texture2D *texToOwn, // static TextureHelper11 TextureHelper11::MakeAndPossess3D(ID3D11Texture3D *texToOwn, - d3d11::ANGLEFormat angleFormat) + const d3d11::Format &formatSet) { TextureHelper11 newHelper; - newHelper.mANGLEFormat = angleFormat; + newHelper.mFormatSet = &formatSet; newHelper.mTexture3D = texToOwn; newHelper.mTextureType = GL_TEXTURE_3D; newHelper.initDesc(); @@ -1616,7 +1648,7 @@ void TextureHelper11::initDesc() mFormat = desc3D.Format; mSampleCount = 1; } - ASSERT(mFormat == d3d11::GetANGLEFormatSet(mANGLEFormat).texFormat); + ASSERT(mFormatSet && mFormat == mFormatSet->texFormat); } TextureHelper11::~TextureHelper11() @@ -1639,10 +1671,10 @@ TextureHelper11 &TextureHelper11::operator=(TextureHelper11 &&texture) mTextureType = texture.mTextureType; mExtents = texture.mExtents; mFormat = texture.mFormat; - mANGLEFormat = texture.mANGLEFormat; + mFormatSet = texture.mFormatSet; mSampleCount = texture.mSampleCount; mTexture2D = texture.mTexture2D; - mTexture3D = texture.mTexture3D; + mTexture3D = texture.mTexture3D; texture.reset(); return *this; } @@ -1652,19 +1684,23 @@ void TextureHelper11::reset() mTextureType = GL_NONE; mExtents = gl::Extents(); mFormat = DXGI_FORMAT_UNKNOWN; + mFormatSet = nullptr; mSampleCount = 0; mTexture2D = nullptr; mTexture3D = nullptr; } +bool TextureHelper11::valid() const +{ + return (mTextureType != GL_NONE); +} + gl::ErrorOrResult<TextureHelper11> CreateStagingTexture(GLenum textureType, - d3d11::ANGLEFormat angleFormat, + const d3d11::Format &formatSet, const gl::Extents &size, StagingAccess readAndWriteAccess, ID3D11Device *device) { - const auto &formatSet = d3d11::GetANGLEFormatSet(angleFormat); - if (textureType == GL_TEXTURE_2D) { D3D11_TEXTURE2D_DESC stagingDesc; @@ -1693,7 +1729,7 @@ gl::ErrorOrResult<TextureHelper11> CreateStagingTexture(GLenum textureType, result); } - return TextureHelper11::MakeAndPossess2D(stagingTex, angleFormat); + return TextureHelper11::MakeAndPossess2D(stagingTex, formatSet); } ASSERT(textureType == GL_TEXTURE_3D); @@ -1716,7 +1752,7 @@ gl::ErrorOrResult<TextureHelper11> CreateStagingTexture(GLenum textureType, result); } - return TextureHelper11::MakeAndPossess3D(stagingTex, angleFormat); + return TextureHelper11::MakeAndPossess3D(stagingTex, formatSet); } bool UsePresentPathFast(const Renderer11 *renderer, diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h index de01dbe30c7..2690fc6f52d 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h @@ -14,7 +14,8 @@ #include <functional> #include <vector> -#include "libANGLE/angletypes.h" +#include "common/Color.h" + #include "libANGLE/Caps.h" #include "libANGLE/Error.h" #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" @@ -345,7 +346,8 @@ void SetBufferData(ID3D11DeviceContext *context, ID3D11Buffer *constantBuffer, c } } -WorkaroundsD3D GenerateWorkarounds(D3D_FEATURE_LEVEL featureLevel); +WorkaroundsD3D GenerateWorkarounds(const Renderer11DeviceCaps &deviceCaps, + const DXGI_ADAPTER_DESC &adapterDesc); enum ReservedConstantBufferSlot { @@ -368,20 +370,21 @@ class TextureHelper11 : angle::NonCopyable TextureHelper11 &operator=(TextureHelper11 &&texture); static TextureHelper11 MakeAndReference(ID3D11Resource *genericResource, - d3d11::ANGLEFormat angleFormat); + const d3d11::Format &formatSet); static TextureHelper11 MakeAndPossess2D(ID3D11Texture2D *texToOwn, - d3d11::ANGLEFormat angleFormat); + const d3d11::Format &formatSet); static TextureHelper11 MakeAndPossess3D(ID3D11Texture3D *texToOwn, - d3d11::ANGLEFormat angleFormat); + const d3d11::Format &formatSet); GLenum getTextureType() const { return mTextureType; } gl::Extents getExtents() const { return mExtents; } DXGI_FORMAT getFormat() const { return mFormat; } - d3d11::ANGLEFormat getANGLEFormat() const { return mANGLEFormat; } + const d3d11::Format &getFormatSet() const { return *mFormatSet; } int getSampleCount() const { return mSampleCount; } ID3D11Texture2D *getTexture2D() const { return mTexture2D; } ID3D11Texture3D *getTexture3D() const { return mTexture3D; } ID3D11Resource *getResource() const; + bool valid() const; private: void reset(); @@ -390,7 +393,7 @@ class TextureHelper11 : angle::NonCopyable GLenum mTextureType; gl::Extents mExtents; DXGI_FORMAT mFormat; - d3d11::ANGLEFormat mANGLEFormat; + const d3d11::Format *mFormatSet; int mSampleCount; ID3D11Texture2D *mTexture2D; ID3D11Texture3D *mTexture3D; @@ -403,7 +406,7 @@ enum class StagingAccess }; gl::ErrorOrResult<TextureHelper11> CreateStagingTexture(GLenum textureType, - d3d11::ANGLEFormat angleFormat, + const d3d11::Format &formatSet, const gl::Extents &size, StagingAccess readAndWriteAccess, ID3D11Device *device); diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/Passthrough2D11.hlsl b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/Passthrough2D11.hlsl index 8671c39fb7a..21024e3b77d 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/Passthrough2D11.hlsl +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/Passthrough2D11.hlsl @@ -21,6 +21,23 @@ float4 PS_PassthroughRGBA2D(in float4 inPosition : SV_POSITION, in float2 inTexC return TextureF.Sample(Sampler, inTexCoord).rgba; } +float4 PS_PassthroughRGBAPremultiply2D(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0 +{ + float4 color = TextureF.Sample(Sampler, inTexCoord).rgba; + color.rgb *= color.a; + return color; +} + +float4 PS_PassthroughRGBAUnmultiply2D(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0 +{ + float4 color = TextureF.Sample(Sampler, inTexCoord).rgba; + if (color.a > 0.0f) + { + color.rgb /= color.a; + } + return color; +} + uint4 PS_PassthroughRGBA2DUI(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0 { uint2 size; @@ -42,6 +59,23 @@ float4 PS_PassthroughRGB2D(in float4 inPosition : SV_POSITION, in float2 inTexCo return float4(TextureF.Sample(Sampler, inTexCoord).rgb, 1.0f); } +float4 PS_PassthroughRGBPremultiply2D(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0 +{ + float4 color = TextureF.Sample(Sampler, inTexCoord).rgba; + color.rgb *= color.a; + return color; +} + +float4 PS_PassthroughRGBUnmultiply2D(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0 +{ + float4 color = TextureF.Sample(Sampler, inTexCoord).rgba; + if (color.a > 0.0f) + { + color.rgb /= color.a; + } + return color; +} + uint4 PS_PassthroughRGB2DUI(in float4 inPosition : SV_POSITION, in float2 inTexCoord : TEXCOORD0) : SV_TARGET0 { uint2 size; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/ResolveDepthStencil.hlsl b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/ResolveDepthStencil.hlsl new file mode 100644 index 00000000000..70df1d1b6e0 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/ResolveDepthStencil.hlsl @@ -0,0 +1,56 @@ +static const float2 g_Corners[6] = +{ + float2(-1.0f, 1.0f), + float2( 1.0f, -1.0f), + float2(-1.0f, -1.0f), + float2(-1.0f, 1.0f), + float2( 1.0f, 1.0f), + float2( 1.0f, -1.0f), +}; + +void VS_ResolveDepthStencil(in uint id : SV_VertexID, + out float4 position : SV_Position, + out float2 texCoord : TEXCOORD0) +{ + float2 corner = g_Corners[id]; + position = float4(corner.x, corner.y, 0.0f, 1.0f); + texCoord = float2((corner.x + 1.0f) * 0.5f, (-corner.y + 1.0f) * 0.5f); +} + +Texture2DMS<float> Depth : register(t0); +Texture2DMS<uint2> Stencil : register(t1); + +void PS_ResolveDepth(in float4 position : SV_Position, + in float2 texCoord : TEXCOORD0, + out float depth : SV_Target0) +{ + // MS samplers must use Load + uint width, height, samples; + Depth.GetDimensions(width, height, samples); + uint2 coord = uint2(texCoord.x * float(width), texCoord.y * float(height)); + depth = Depth.Load(coord, 0).r; +} + +void PS_ResolveDepthStencil(in float4 position : SV_Position, + in float2 texCoord : TEXCOORD0, + out float2 depthStencil : SV_Target0) +{ + // MS samplers must use Load + uint width, height, samples; + Depth.GetDimensions(width, height, samples); + uint2 coord = uint2(texCoord.x * float(width), texCoord.y * float(height)); + depthStencil.r = Depth.Load(coord, 0).r; + depthStencil.g = float(Stencil.Load(coord, 0).g); +} + +void PS_ResolveStencil(in float4 position : SV_Position, + in float2 texCoord : TEXCOORD0, + out float2 stencil : SV_Target0) +{ + // MS samplers must use Load + uint width, height, samples; + Stencil.GetDimensions(width, height, samples); + uint2 coord = uint2(texCoord.x * float(width), texCoord.y * float(height)); + stencil.r = 0.0f; + stencil.g = float(Stencil.Load(coord, 0).g); +} diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbapremultiply2d11ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbapremultiply2d11ps.h new file mode 100644 index 00000000000..e7285a6bca6 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbapremultiply2d11ps.h @@ -0,0 +1,101 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// Sampler sampler NA NA 0 1 +// TextureF texture float4 2d 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mul r0.xyz, r0.w, r0 + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBAPremultiply2D[] = { + 68, 88, 66, 67, 139, 254, 84, 241, 202, 33, 132, 221, 123, 19, 241, 182, 75, 155, 177, + 115, 1, 0, 0, 0, 8, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 180, 0, + 0, 0, 88, 1, 0, 0, 212, 1, 0, 0, 124, 2, 0, 0, 212, 2, 0, 0, 65, + 111, 110, 57, 116, 0, 0, 0, 116, 0, 0, 0, 0, 2, 255, 255, 76, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 31, 0, 0, 2, 0, 0, + 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, 0, 8, 15, 160, 66, + 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, 160, 5, 0, 0, 3, + 0, 0, 7, 128, 0, 0, 255, 128, 0, 0, 228, 128, 1, 0, 0, 2, 0, 8, 15, + 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, 72, 68, 82, 156, 0, 0, 0, 64, 0, + 0, 0, 39, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, + 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, + 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, + 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, + 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, + 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 160, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, 4, + 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, + 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, 97, + 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, 48, + 48, 46, 49, 54, 51, 56, 52, 0, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, + 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, + 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, + 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbaunmultiply2d11ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbaunmultiply2d11ps.h new file mode 100644 index 00000000000..d3b8b6a8424 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbaunmultiply2d11ps.h @@ -0,0 +1,110 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// Sampler sampler NA NA 0 1 +// TextureF texture float4 2d 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + rcp r1.w, r0.w + mul r1.xyz, r0, r1.w + cmp r0.xyz, -r0.w, r0, r1 + mov oC0, r0 + +// approximately 5 instruction slots used (1 texture, 4 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBAUnmultiply2D[] = { + 68, 88, 66, 67, 180, 87, 43, 111, 255, 135, 28, 224, 42, 85, 197, 16, 17, 172, 176, + 70, 1, 0, 0, 0, 104, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 212, 0, + 0, 0, 184, 1, 0, 0, 52, 2, 0, 0, 220, 2, 0, 0, 52, 3, 0, 0, 65, + 111, 110, 57, 148, 0, 0, 0, 148, 0, 0, 0, 0, 2, 255, 255, 108, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 31, 0, 0, 2, 0, 0, + 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, 0, 8, 15, 160, 66, + 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, 160, 6, 0, 0, 2, + 1, 0, 8, 128, 0, 0, 255, 128, 5, 0, 0, 3, 1, 0, 7, 128, 0, 0, 228, + 128, 1, 0, 255, 128, 88, 0, 0, 4, 0, 0, 7, 128, 0, 0, 255, 129, 0, 0, + 228, 128, 1, 0, 228, 128, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, + 255, 0, 0, 83, 72, 68, 82, 220, 0, 0, 0, 64, 0, 0, 0, 55, 0, 0, 0, + 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, + 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, + 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, + 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, + 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, + 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, + 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, + 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 160, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, + 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, + 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, + 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, + 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, + 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, + 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, + 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbpremultiply2d11ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbpremultiply2d11ps.h new file mode 100644 index 00000000000..9af002d4465 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbpremultiply2d11ps.h @@ -0,0 +1,101 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// Sampler sampler NA NA 0 1 +// TextureF texture float4 2d 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + mul r0.xyz, r0.w, r0 + mov oC0, r0 + +// approximately 3 instruction slots used (1 texture, 2 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 1 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +mul o0.xyz, r0.wwww, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 4 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBPremultiply2D[] = { + 68, 88, 66, 67, 139, 254, 84, 241, 202, 33, 132, 221, 123, 19, 241, 182, 75, 155, 177, + 115, 1, 0, 0, 0, 8, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 180, 0, + 0, 0, 88, 1, 0, 0, 212, 1, 0, 0, 124, 2, 0, 0, 212, 2, 0, 0, 65, + 111, 110, 57, 116, 0, 0, 0, 116, 0, 0, 0, 0, 2, 255, 255, 76, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 31, 0, 0, 2, 0, 0, + 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, 0, 8, 15, 160, 66, + 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, 160, 5, 0, 0, 3, + 0, 0, 7, 128, 0, 0, 255, 128, 0, 0, 228, 128, 1, 0, 0, 2, 0, 8, 15, + 128, 0, 0, 228, 128, 255, 255, 0, 0, 83, 72, 68, 82, 156, 0, 0, 0, 64, 0, + 0, 0, 39, 0, 0, 0, 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, + 24, 0, 4, 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, + 50, 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, + 0, 104, 0, 0, 2, 1, 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, + 0, 0, 70, 16, 16, 0, 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, + 96, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 114, 32, 16, 0, 0, 0, 0, 0, + 246, 15, 16, 0, 0, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 160, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, 4, + 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, + 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, 97, + 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, 114, + 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, + 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, 48, + 48, 46, 49, 54, 51, 56, 52, 0, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, + 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, + 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, + 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbunmultiply2d11ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbunmultiply2d11ps.h new file mode 100644 index 00000000000..2cde26481c1 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgbunmultiply2d11ps.h @@ -0,0 +1,110 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// Sampler sampler NA NA 0 1 +// TextureF texture float4 2d 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_POSITION 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_TARGET 0 xyzw 0 TARGET float xyzw +// +// +// Sampler/Resource to DX9 shader sampler mappings: +// +// Target Sampler Source Sampler Source Resource +// -------------- --------------- ---------------- +// s0 s0 t0 +// +// +// Level9 shader bytecode: +// + ps_2_x + dcl t0.xy + dcl_2d s0 + texld r0, t0, s0 + rcp r1.w, r0.w + mul r1.xyz, r0, r1.w + cmp r0.xyz, -r0.w, r0, r1 + mov oC0, r0 + +// approximately 5 instruction slots used (1 texture, 4 arithmetic) +ps_4_0 +dcl_sampler s0, mode_default +dcl_resource_texture2d (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.xyzw +dcl_temps 2 +sample r0.xyzw, v1.xyxx, t0.xyzw, s0 +lt r1.x, l(0.000000), r0.w +div r1.yzw, r0.xxyz, r0.wwww +movc o0.xyz, r1.xxxx, r1.yzwy, r0.xyzx +mov o0.w, r0.w +ret +// Approximately 6 instruction slots used +#endif + +const BYTE g_PS_PassthroughRGBUnmultiply2D[] = { + 68, 88, 66, 67, 180, 87, 43, 111, 255, 135, 28, 224, 42, 85, 197, 16, 17, 172, 176, + 70, 1, 0, 0, 0, 104, 3, 0, 0, 6, 0, 0, 0, 56, 0, 0, 0, 212, 0, + 0, 0, 184, 1, 0, 0, 52, 2, 0, 0, 220, 2, 0, 0, 52, 3, 0, 0, 65, + 111, 110, 57, 148, 0, 0, 0, 148, 0, 0, 0, 0, 2, 255, 255, 108, 0, 0, 0, + 40, 0, 0, 0, 0, 0, 40, 0, 0, 0, 40, 0, 0, 0, 40, 0, 1, 0, 36, + 0, 0, 0, 40, 0, 0, 0, 0, 0, 1, 2, 255, 255, 31, 0, 0, 2, 0, 0, + 0, 128, 0, 0, 3, 176, 31, 0, 0, 2, 0, 0, 0, 144, 0, 8, 15, 160, 66, + 0, 0, 3, 0, 0, 15, 128, 0, 0, 228, 176, 0, 8, 228, 160, 6, 0, 0, 2, + 1, 0, 8, 128, 0, 0, 255, 128, 5, 0, 0, 3, 1, 0, 7, 128, 0, 0, 228, + 128, 1, 0, 255, 128, 88, 0, 0, 4, 0, 0, 7, 128, 0, 0, 255, 129, 0, 0, + 228, 128, 1, 0, 228, 128, 1, 0, 0, 2, 0, 8, 15, 128, 0, 0, 228, 128, 255, + 255, 0, 0, 83, 72, 68, 82, 220, 0, 0, 0, 64, 0, 0, 0, 55, 0, 0, 0, + 90, 0, 0, 3, 0, 96, 16, 0, 0, 0, 0, 0, 88, 24, 0, 4, 0, 112, 16, + 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, + 0, 0, 101, 0, 0, 3, 242, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 2, + 0, 0, 0, 69, 0, 0, 9, 242, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, + 1, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 0, 96, 16, 0, 0, 0, 0, + 0, 49, 0, 0, 7, 18, 0, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, + 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 14, 0, 0, 7, 226, 0, 16, 0, 1, + 0, 0, 0, 6, 9, 16, 0, 0, 0, 0, 0, 246, 15, 16, 0, 0, 0, 0, 0, + 55, 0, 0, 9, 114, 32, 16, 0, 0, 0, 0, 0, 6, 0, 16, 0, 1, 0, 0, + 0, 150, 7, 16, 0, 1, 0, 0, 0, 70, 2, 16, 0, 0, 0, 0, 0, 54, 0, + 0, 5, 130, 32, 16, 0, 0, 0, 0, 0, 58, 0, 16, 0, 0, 0, 0, 0, 62, + 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 6, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 82, 68, 69, 70, 160, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, 0, + 4, 255, 255, 0, 1, 0, 0, 109, 0, 0, 0, 92, 0, 0, 0, 3, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, + 0, 1, 0, 0, 0, 100, 0, 0, 0, 2, 0, 0, 0, 5, 0, 0, 0, 4, 0, + 0, 0, 255, 255, 255, 255, 0, 0, 0, 0, 1, 0, 0, 0, 13, 0, 0, 0, 83, + 97, 109, 112, 108, 101, 114, 0, 84, 101, 120, 116, 117, 114, 101, 70, 0, 77, 105, 99, + 114, 111, 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, + 100, 101, 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, + 48, 48, 46, 49, 54, 51, 56, 52, 0, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, + 0, 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 3, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, + 95, 80, 79, 83, 73, 84, 73, 79, 78, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, + 171, 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, + 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, + 0, 15, 0, 0, 0, 83, 86, 95, 84, 65, 82, 71, 69, 84, 0, 171, 171}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h new file mode 100644 index 00000000000..f173cff07d1 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepth11_ps.h @@ -0,0 +1,82 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// Depth texture float 2dMS 0 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 x 0 TARGET float x +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (float,float,float,float) t0 +dcl_input_ps linear v1.xy +dcl_output o0.x +dcl_temps 1 +resinfo_uint r0.xy, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftou r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ldms r0.x, r0.xyzw, t0.xyzw, l(0) +mov o0.x, r0.x +ret +// Approximately 8 instruction slots used +#endif + +const BYTE g_PS_ResolveDepth[] = { + 68, 88, 66, 67, 205, 219, 191, 201, 103, 134, 243, 76, 11, 91, 23, 182, 42, 8, 17, + 173, 1, 0, 0, 0, 184, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 176, 0, + 0, 0, 8, 1, 0, 0, 60, 1, 0, 0, 60, 2, 0, 0, 82, 68, 69, 70, 116, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 66, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 68, 101, 112, 116, 104, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, + 54, 51, 56, 52, 0, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, + 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, + 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 111, 115, 105, + 116, 105, 111, 110, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 79, 83, + 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 1, 14, 0, 0, + 83, 86, 95, 84, 97, 114, 103, 101, 116, 0, 171, 171, 83, 72, 68, 82, 248, 0, 0, + 0, 65, 0, 0, 0, 62, 0, 0, 0, 106, 8, 0, 1, 88, 32, 0, 4, 0, 112, + 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, + 0, 0, 0, 101, 0, 0, 3, 18, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, + 1, 0, 0, 0, 61, 16, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, + 0, 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, + 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, + 1, 0, 0, 0, 28, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, + 0, 0, 0, 0, 0, 54, 0, 0, 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, + 0, 0, 9, 18, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, + 70, 126, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, 0, 0, + 5, 18, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 62, 0, + 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 8, 0, 0, 0, 1, 0, 0, 0, 0, + 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h new file mode 100644 index 00000000000..b2c0b62f006 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_ps.h @@ -0,0 +1,92 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// Depth texture float 2dMS 0 1 +// Stencil texture uint2 2dMS 1 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 xy 0 TARGET float xy +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (float,float,float,float) t0 +dcl_resource_texture2dms(0) (uint,uint,uint,uint) t1 +dcl_input_ps linear v1.xy +dcl_output o0.xy +dcl_temps 1 +resinfo_uint r0.xy, l(0), t0.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftou r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ldms r0.z, r0.xyzw, t1.xzyw, l(0) +ldms r0.x, r0.xyww, t0.xyzw, l(0) +mov o0.x, r0.x +utof o0.y, r0.z +ret +// Approximately 10 instruction slots used +#endif + +const BYTE g_PS_ResolveDepthStencil[] = { + 68, 88, 66, 67, 229, 191, 254, 12, 10, 19, 181, 162, 222, 203, 244, 146, 104, 226, 195, + 177, 1, 0, 0, 0, 40, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 216, 0, + 0, 0, 48, 1, 0, 0, 100, 1, 0, 0, 172, 2, 0, 0, 82, 68, 69, 70, 156, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 106, 0, 0, 0, 92, 0, 0, 0, 2, 0, 0, + 0, 5, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 1, 0, 0, 0, 98, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 6, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 5, 0, 0, 0, + 68, 101, 112, 116, 104, 0, 83, 116, 101, 110, 99, 105, 108, 0, 77, 105, 99, 114, 111, + 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, + 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, 48, 48, + 46, 49, 54, 51, 56, 52, 0, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, + 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, 80, 111, + 115, 105, 116, 105, 111, 110, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, + 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 12, + 0, 0, 83, 86, 95, 84, 97, 114, 103, 101, 116, 0, 171, 171, 83, 72, 68, 82, 64, + 1, 0, 0, 65, 0, 0, 0, 80, 0, 0, 0, 106, 8, 0, 1, 88, 32, 0, 4, + 0, 112, 16, 0, 0, 0, 0, 0, 85, 85, 0, 0, 88, 32, 0, 4, 0, 112, 16, + 0, 1, 0, 0, 0, 68, 68, 0, 0, 98, 16, 0, 3, 50, 16, 16, 0, 1, 0, + 0, 0, 101, 0, 0, 3, 50, 32, 16, 0, 0, 0, 0, 0, 104, 0, 0, 2, 1, + 0, 0, 0, 61, 16, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, + 0, 0, 0, 0, 70, 126, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 50, 0, 16, + 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 7, 50, 0, + 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 70, 16, 16, 0, 1, + 0, 0, 0, 28, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, + 0, 0, 0, 0, 54, 0, 0, 8, 194, 0, 16, 0, 0, 0, 0, 0, 2, 64, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 46, 0, + 0, 9, 66, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, 0, 0, 0, 0, 134, + 125, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 46, 0, 0, 9, + 18, 0, 16, 0, 0, 0, 0, 0, 70, 15, 16, 0, 0, 0, 0, 0, 70, 126, 16, + 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, 0, 54, 0, 0, 5, 18, 32, + 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 86, 0, 0, 5, 34, + 32, 16, 0, 0, 0, 0, 0, 42, 0, 16, 0, 0, 0, 0, 0, 62, 0, 0, 1, + 83, 84, 65, 84, 116, 0, 0, 0, 10, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h new file mode 100644 index 00000000000..1e907956ce0 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvedepthstencil11_vs.h @@ -0,0 +1,84 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_VertexID 0 x 0 VERTID uint x +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float xyzw +// TEXCOORD 0 xy 1 NONE float xy +// +vs_4_1 +dcl_globalFlags refactoringAllowed +dcl_immediateConstantBuffer { { -1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0}, + { -1.000000, -1.000000, 0, 0}, + { -1.000000, 1.000000, 0, 0}, + { 1.000000, 1.000000, 0, 0}, + { 1.000000, -1.000000, 0, 0} } +dcl_input_sgv v0.x, vertex_id +dcl_output_siv o0.xyzw, position +dcl_output o1.xy +dcl_temps 1 +mov o0.zw, l(0,0,0,1.000000) +mov r0.x, v0.x +mov o0.xy, icb[r0.x + 0].xyxx +add r0.y, l(1.000000), icb[r0.x + 0].x +add r0.x, l(1.000000), -icb[r0.x + 0].y +mul o1.xy, r0.yxyy, l(0.500000, 0.500000, 0.000000, 0.000000) +ret +// Approximately 7 instruction slots used +#endif + +const BYTE g_VS_ResolveDepthStencil[] = { + 68, 88, 66, 67, 205, 15, 103, 70, 202, 235, 195, 98, 255, 82, 84, 239, 130, 6, 12, + 104, 1, 0, 0, 0, 0, 3, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 140, 0, + 0, 0, 192, 0, 0, 0, 24, 1, 0, 0, 132, 2, 0, 0, 82, 68, 69, 70, 80, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 254, 255, 0, 1, 0, 0, 28, 0, 0, 0, 77, 105, 99, 114, 111, 115, 111, + 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, 114, 32, + 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, 48, 48, 46, 49, + 54, 51, 56, 52, 0, 171, 171, 73, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, + 8, 0, 0, 0, 32, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 1, 0, 0, + 0, 0, 0, 0, 0, 1, 1, 0, 0, 83, 86, 95, 86, 101, 114, 116, 101, 120, 73, + 68, 0, 79, 83, 71, 78, 80, 0, 0, 0, 2, 0, 0, 0, 8, 0, 0, 0, 56, + 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, + 0, 1, 0, 0, 0, 3, 12, 0, 0, 83, 86, 95, 80, 111, 115, 105, 116, 105, 111, + 110, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, 171, 171, 83, 72, 68, 82, 100, + 1, 0, 0, 65, 0, 1, 0, 89, 0, 0, 0, 106, 8, 0, 1, 53, 24, 0, 0, + 26, 0, 0, 0, 0, 0, 128, 191, 0, 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 128, 63, 0, 0, 128, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 128, 191, 0, 0, 128, 191, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 191, 0, + 0, 128, 63, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 128, 63, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 0, 0, 128, 191, 0, 0, 0, + 0, 0, 0, 0, 0, 96, 0, 0, 4, 18, 16, 16, 0, 0, 0, 0, 0, 6, 0, + 0, 0, 103, 0, 0, 4, 242, 32, 16, 0, 0, 0, 0, 0, 1, 0, 0, 0, 101, + 0, 0, 3, 50, 32, 16, 0, 1, 0, 0, 0, 104, 0, 0, 2, 1, 0, 0, 0, + 54, 0, 0, 8, 194, 32, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 63, 54, 0, 0, 5, 18, 0, + 16, 0, 0, 0, 0, 0, 10, 16, 16, 0, 0, 0, 0, 0, 54, 0, 0, 6, 50, + 32, 16, 0, 0, 0, 0, 0, 70, 144, 144, 0, 10, 0, 16, 0, 0, 0, 0, 0, + 0, 0, 0, 8, 34, 0, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, + 63, 10, 144, 144, 0, 10, 0, 16, 0, 0, 0, 0, 0, 0, 0, 0, 9, 18, 0, + 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, 0, 128, 63, 26, 144, 144, 128, 65, + 0, 0, 0, 10, 0, 16, 0, 0, 0, 0, 0, 56, 0, 0, 10, 50, 32, 16, 0, + 1, 0, 0, 0, 22, 5, 16, 0, 0, 0, 0, 0, 2, 64, 0, 0, 0, 0, 0, + 63, 0, 0, 0, 63, 0, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 1, 83, 84, + 65, 84, 116, 0, 0, 0, 7, 0, 0, 0, 1, 0, 0, 0, 6, 0, 0, 0, 3, + 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h new file mode 100644 index 00000000000..ea43731b5fa --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/compiled/resolvestencil11_ps.h @@ -0,0 +1,84 @@ +#if 0 +// +// Generated by Microsoft (R) HLSL Shader Compiler 6.3.9600.16384 +// +// +// Resource Bindings: +// +// Name Type Format Dim Slot Elements +// ------------------------------ ---------- ------- ----------- ---- -------- +// Stencil texture uint2 2dMS 1 1 +// +// +// +// Input signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Position 0 xyzw 0 POS float +// TEXCOORD 0 xy 1 NONE float xy +// +// +// Output signature: +// +// Name Index Mask Register SysValue Format Used +// -------------------- ----- ------ -------- -------- ------- ------ +// SV_Target 0 xy 0 TARGET float xy +// +ps_4_1 +dcl_globalFlags refactoringAllowed +dcl_resource_texture2dms(0) (uint,uint,uint,uint) t1 +dcl_input_ps linear v1.xy +dcl_output o0.xy +dcl_temps 1 +resinfo_uint r0.xy, l(0), t1.xyzw +utof r0.xy, r0.xyxx +mul r0.xy, r0.xyxx, v1.xyxx +ftou r0.xy, r0.xyxx +mov r0.zw, l(0,0,0,0) +ldms r0.x, r0.xyzw, t1.yxzw, l(0) +utof o0.y, r0.x +mov o0.x, l(0) +ret +// Approximately 9 instruction slots used +#endif + +const BYTE g_PS_ResolveStencil[] = { + 68, 88, 66, 67, 122, 29, 34, 146, 254, 203, 175, 97, 151, 254, 255, 190, 91, 40, 55, + 118, 1, 0, 0, 0, 208, 2, 0, 0, 5, 0, 0, 0, 52, 0, 0, 0, 180, 0, + 0, 0, 12, 1, 0, 0, 64, 1, 0, 0, 84, 2, 0, 0, 82, 68, 69, 70, 120, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 28, 0, 0, 0, + 1, 4, 255, 255, 0, 1, 0, 0, 68, 0, 0, 0, 60, 0, 0, 0, 2, 0, 0, + 0, 4, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, + 0, 0, 5, 0, 0, 0, 83, 116, 101, 110, 99, 105, 108, 0, 77, 105, 99, 114, 111, + 115, 111, 102, 116, 32, 40, 82, 41, 32, 72, 76, 83, 76, 32, 83, 104, 97, 100, 101, + 114, 32, 67, 111, 109, 112, 105, 108, 101, 114, 32, 54, 46, 51, 46, 57, 54, 48, 48, + 46, 49, 54, 51, 56, 52, 0, 171, 171, 73, 83, 71, 78, 80, 0, 0, 0, 2, 0, + 0, 0, 8, 0, 0, 0, 56, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 3, + 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 1, 0, 0, 0, 3, 3, 0, 0, 83, 86, 95, + 80, 111, 115, 105, 116, 105, 111, 110, 0, 84, 69, 88, 67, 79, 79, 82, 68, 0, 171, + 171, 171, 79, 83, 71, 78, 44, 0, 0, 0, 1, 0, 0, 0, 8, 0, 0, 0, 32, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, + 3, 12, 0, 0, 83, 86, 95, 84, 97, 114, 103, 101, 116, 0, 171, 171, 83, 72, 68, + 82, 12, 1, 0, 0, 65, 0, 0, 0, 67, 0, 0, 0, 106, 8, 0, 1, 88, 32, + 0, 4, 0, 112, 16, 0, 1, 0, 0, 0, 68, 68, 0, 0, 98, 16, 0, 3, 50, + 16, 16, 0, 1, 0, 0, 0, 101, 0, 0, 3, 50, 32, 16, 0, 0, 0, 0, 0, + 104, 0, 0, 2, 1, 0, 0, 0, 61, 16, 0, 7, 50, 0, 16, 0, 0, 0, 0, + 0, 1, 64, 0, 0, 0, 0, 0, 0, 70, 126, 16, 0, 1, 0, 0, 0, 86, 0, + 0, 5, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, 56, + 0, 0, 7, 50, 0, 16, 0, 0, 0, 0, 0, 70, 0, 16, 0, 0, 0, 0, 0, + 70, 16, 16, 0, 1, 0, 0, 0, 28, 0, 0, 5, 50, 0, 16, 0, 0, 0, 0, + 0, 70, 0, 16, 0, 0, 0, 0, 0, 54, 0, 0, 8, 194, 0, 16, 0, 0, 0, + 0, 0, 2, 64, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 46, 0, 0, 9, 18, 0, 16, 0, 0, 0, 0, 0, 70, 14, 16, 0, + 0, 0, 0, 0, 22, 126, 16, 0, 1, 0, 0, 0, 1, 64, 0, 0, 0, 0, 0, + 0, 86, 0, 0, 5, 34, 32, 16, 0, 0, 0, 0, 0, 10, 0, 16, 0, 0, 0, + 0, 0, 54, 0, 0, 5, 18, 32, 16, 0, 0, 0, 0, 0, 1, 64, 0, 0, 0, + 0, 0, 0, 62, 0, 0, 1, 83, 84, 65, 84, 116, 0, 0, 0, 9, 0, 0, 0, + 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, + 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat index 652c5eae90c..657a1c02480 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/shaders/generate_shaders.bat @@ -20,7 +20,7 @@ if "%1" == "release" ( ) :: Shaders for OpenGL ES 2.0 and OpenGL ES 3.0+ -:: | Input file | Entry point | Type | Output file | Debug | +:: | Input file | Entry point | Type | Output file | Debug | call:BuildShader Passthrough2D11.hlsl VS_Passthrough2D vs_4_0_level_9_3 compiled\passthrough2d11vs.h %debug% call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBA2D ps_4_0_level_9_3 compiled\passthroughrgba2d11ps.h %debug% call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGB2D ps_4_0_level_9_3 compiled\passthroughrgb2d11ps.h %debug% @@ -29,64 +29,73 @@ call:BuildShader Passthrough2D11.hlsl PS_PassthroughR2D ps_4_0_level_9_3 call:BuildShader Passthrough2D11.hlsl PS_PassthroughLum2D ps_4_0_level_9_3 compiled\passthroughlum2d11ps.h %debug% call:BuildShader Passthrough2D11.hlsl PS_PassthroughLumAlpha2D ps_4_0_level_9_3 compiled\passthroughlumalpha2d11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBAPremultiply2D ps_4_0_level_9_3 compiled\passthroughrgbapremultiply2d11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBAUnmultiply2D ps_4_0_level_9_3 compiled\passthroughrgbaunmultiply2d11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBPremultiply2D ps_4_0_level_9_3 compiled\passthroughrgbpremultiply2d11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBUnmultiply2D ps_4_0_level_9_3 compiled\passthroughrgbunmultiply2d11ps.h %debug% + call:BuildShader Clear11.hlsl VS_ClearFloat vs_4_0_level_9_3 compiled\clearfloat11vs.h %debug% call:BuildShader Clear11.hlsl PS_ClearFloat_FL9 ps_4_0_level_9_3 compiled\clearfloat11_fl9ps.h %debug% call:BuildShader Clear11.hlsl PS_ClearFloat ps_4_0 compiled\clearfloat11ps.h %debug% :: Shaders for OpenGL ES 3.0+ only -:: | Input file | Entry point | Type | Output file | Debug | -call:BuildShader Passthrough2D11.hlsl PS_PassthroughDepth2D ps_4_0 compiled\passthroughdepth2d11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBA2DUI ps_4_0 compiled\passthroughrgba2dui11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBA2DI ps_4_0 compiled\passthroughrgba2di11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGB2DUI ps_4_0 compiled\passthroughrgb2dui11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGB2DI ps_4_0 compiled\passthroughrgb2di11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughRG2DUI ps_4_0 compiled\passthroughrg2dui11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughRG2DI ps_4_0 compiled\passthroughrg2di11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughR2DUI ps_4_0 compiled\passthroughr2dui11ps.h %debug% -call:BuildShader Passthrough2D11.hlsl PS_PassthroughR2DI ps_4_0 compiled\passthroughr2di11ps.h %debug% - - -call:BuildShader Passthrough3D11.hlsl VS_Passthrough3D vs_4_0 compiled\passthrough3d11vs.h %debug% -call:BuildShader Passthrough3D11.hlsl GS_Passthrough3D gs_4_0 compiled\passthrough3d11gs.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGBA3D ps_4_0 compiled\passthroughrgba3d11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGBA3DUI ps_4_0 compiled\passthroughrgba3dui11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGBA3DI ps_4_0 compiled\passthroughrgba3di11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGB3D ps_4_0 compiled\passthroughrgb3d11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGB3DUI ps_4_0 compiled\passthroughrgb3dui11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGB3DI ps_4_0 compiled\passthroughrgb3di11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRG3D ps_4_0 compiled\passthroughrg3d11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRG3DUI ps_4_0 compiled\passthroughrg3dui11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughRG3DI ps_4_0 compiled\passthroughrg3di11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughR3D ps_4_0 compiled\passthroughr3d11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughR3DUI ps_4_0 compiled\passthroughr3dui11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughR3DI ps_4_0 compiled\passthroughr3di11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughLum3D ps_4_0 compiled\passthroughlum3d11ps.h %debug% -call:BuildShader Passthrough3D11.hlsl PS_PassthroughLumAlpha3D ps_4_0 compiled\passthroughlumalpha3d11ps.h %debug% - -call:BuildShader Swizzle11.hlsl PS_SwizzleF2D ps_4_0 compiled\swizzlef2dps.h %debug% -call:BuildShader Swizzle11.hlsl PS_SwizzleI2D ps_4_0 compiled\swizzlei2dps.h %debug% -call:BuildShader Swizzle11.hlsl PS_SwizzleUI2D ps_4_0 compiled\swizzleui2dps.h %debug% - -call:BuildShader Swizzle11.hlsl PS_SwizzleF3D ps_4_0 compiled\swizzlef3dps.h %debug% -call:BuildShader Swizzle11.hlsl PS_SwizzleI3D ps_4_0 compiled\swizzlei3dps.h %debug% -call:BuildShader Swizzle11.hlsl PS_SwizzleUI3D ps_4_0 compiled\swizzleui3dps.h %debug% - -call:BuildShader Swizzle11.hlsl PS_SwizzleF2DArray ps_4_0 compiled\swizzlef2darrayps.h %debug% -call:BuildShader Swizzle11.hlsl PS_SwizzleI2DArray ps_4_0 compiled\swizzlei2darrayps.h %debug% -call:BuildShader Swizzle11.hlsl PS_SwizzleUI2DArray ps_4_0 compiled\swizzleui2darrayps.h %debug% - -call:BuildShader Clear11.hlsl VS_ClearUint vs_4_0 compiled\clearuint11vs.h %debug% -call:BuildShader Clear11.hlsl PS_ClearUint ps_4_0 compiled\clearuint11ps.h %debug% - -call:BuildShader Clear11.hlsl VS_ClearSint vs_4_0 compiled\clearsint11vs.h %debug% -call:BuildShader Clear11.hlsl PS_ClearSint ps_4_0 compiled\clearsint11ps.h %debug% - -call:BuildShader BufferToTexture11.hlsl VS_BufferToTexture vs_4_0 compiled/buffertotexture11_vs.h %debug% -call:BuildShader BufferToTexture11.hlsl GS_BufferToTexture gs_4_0 compiled/buffertotexture11_gs.h %debug% -call:BuildShader BufferToTexture11.hlsl PS_BufferToTexture_4F ps_4_0 compiled/buffertotexture11_ps_4f.h %debug% -call:BuildShader BufferToTexture11.hlsl PS_BufferToTexture_4I ps_4_0 compiled/buffertotexture11_ps_4i.h %debug% -call:BuildShader BufferToTexture11.hlsl PS_BufferToTexture_4UI ps_4_0 compiled/buffertotexture11_ps_4ui.h %debug% +:: | Input file | Entry point | Type | Output file | Debug | +call:BuildShader Passthrough2D11.hlsl PS_PassthroughDepth2D ps_4_0 compiled\passthroughdepth2d11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBA2DUI ps_4_0 compiled\passthroughrgba2dui11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGBA2DI ps_4_0 compiled\passthroughrgba2di11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGB2DUI ps_4_0 compiled\passthroughrgb2dui11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRGB2DI ps_4_0 compiled\passthroughrgb2di11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRG2DUI ps_4_0 compiled\passthroughrg2dui11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughRG2DI ps_4_0 compiled\passthroughrg2di11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughR2DUI ps_4_0 compiled\passthroughr2dui11ps.h %debug% +call:BuildShader Passthrough2D11.hlsl PS_PassthroughR2DI ps_4_0 compiled\passthroughr2di11ps.h %debug% + +call:BuildShader Passthrough3D11.hlsl VS_Passthrough3D vs_4_0 compiled\passthrough3d11vs.h %debug% +call:BuildShader Passthrough3D11.hlsl GS_Passthrough3D gs_4_0 compiled\passthrough3d11gs.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGBA3D ps_4_0 compiled\passthroughrgba3d11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGBA3DUI ps_4_0 compiled\passthroughrgba3dui11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGBA3DI ps_4_0 compiled\passthroughrgba3di11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGB3D ps_4_0 compiled\passthroughrgb3d11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGB3DUI ps_4_0 compiled\passthroughrgb3dui11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRGB3DI ps_4_0 compiled\passthroughrgb3di11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRG3D ps_4_0 compiled\passthroughrg3d11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRG3DUI ps_4_0 compiled\passthroughrg3dui11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughRG3DI ps_4_0 compiled\passthroughrg3di11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughR3D ps_4_0 compiled\passthroughr3d11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughR3DUI ps_4_0 compiled\passthroughr3dui11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughR3DI ps_4_0 compiled\passthroughr3di11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughLum3D ps_4_0 compiled\passthroughlum3d11ps.h %debug% +call:BuildShader Passthrough3D11.hlsl PS_PassthroughLumAlpha3D ps_4_0 compiled\passthroughlumalpha3d11ps.h %debug% + +call:BuildShader Swizzle11.hlsl PS_SwizzleF2D ps_4_0 compiled\swizzlef2dps.h %debug% +call:BuildShader Swizzle11.hlsl PS_SwizzleI2D ps_4_0 compiled\swizzlei2dps.h %debug% +call:BuildShader Swizzle11.hlsl PS_SwizzleUI2D ps_4_0 compiled\swizzleui2dps.h %debug% + +call:BuildShader Swizzle11.hlsl PS_SwizzleF3D ps_4_0 compiled\swizzlef3dps.h %debug% +call:BuildShader Swizzle11.hlsl PS_SwizzleI3D ps_4_0 compiled\swizzlei3dps.h %debug% +call:BuildShader Swizzle11.hlsl PS_SwizzleUI3D ps_4_0 compiled\swizzleui3dps.h %debug% + +call:BuildShader Swizzle11.hlsl PS_SwizzleF2DArray ps_4_0 compiled\swizzlef2darrayps.h %debug% +call:BuildShader Swizzle11.hlsl PS_SwizzleI2DArray ps_4_0 compiled\swizzlei2darrayps.h %debug% +call:BuildShader Swizzle11.hlsl PS_SwizzleUI2DArray ps_4_0 compiled\swizzleui2darrayps.h %debug% + +call:BuildShader Clear11.hlsl VS_ClearUint vs_4_0 compiled\clearuint11vs.h %debug% +call:BuildShader Clear11.hlsl PS_ClearUint ps_4_0 compiled\clearuint11ps.h %debug% + +call:BuildShader Clear11.hlsl VS_ClearSint vs_4_0 compiled\clearsint11vs.h %debug% +call:BuildShader Clear11.hlsl PS_ClearSint ps_4_0 compiled\clearsint11ps.h %debug% + +call:BuildShader BufferToTexture11.hlsl VS_BufferToTexture vs_4_0 compiled/buffertotexture11_vs.h %debug% +call:BuildShader BufferToTexture11.hlsl GS_BufferToTexture gs_4_0 compiled/buffertotexture11_gs.h %debug% +call:BuildShader BufferToTexture11.hlsl PS_BufferToTexture_4F ps_4_0 compiled/buffertotexture11_ps_4f.h %debug% +call:BuildShader BufferToTexture11.hlsl PS_BufferToTexture_4I ps_4_0 compiled/buffertotexture11_ps_4i.h %debug% +call:BuildShader BufferToTexture11.hlsl PS_BufferToTexture_4UI ps_4_0 compiled/buffertotexture11_ps_4ui.h %debug% + +call:BuildShader ResolveDepthStencil.hlsl VS_ResolveDepthStencil vs_4_1 compiled/resolvedepthstencil11_vs.h %debug% +call:BuildShader ResolveDepthStencil.hlsl PS_ResolveDepth ps_4_1 compiled/resolvedepth11_ps.h %debug% +call:BuildShader ResolveDepthStencil.hlsl PS_ResolveDepthStencil ps_4_1 compiled/resolvedepthstencil11_ps.h %debug% +call:BuildShader ResolveDepthStencil.hlsl PS_ResolveStencil ps_4_1 compiled/resolvestencil11_ps.h %debug% echo. diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_data.json b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_data.json index 9deb4777f98..06f7e2afd9e 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_data.json +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_data.json @@ -1,17 +1,17 @@ { - "ANGLE_FORMAT_NONE": { - + "NONE": { }, - "ANGLE_FORMAT_A8_UNORM": { + "A8_UNORM": { "texFormat": "DXGI_FORMAT_A8_UNORM", "srvFormat": "DXGI_FORMAT_A8_UNORM", "rtvFormat": "DXGI_FORMAT_A8_UNORM", "channels": "a", "componentType": "unorm", "bits": { "alpha": 8 }, - "glInternalFormat": "GL_ALPHA8_EXT" + "supportTest": "OnlyFL10Plus(deviceCaps)", + "fallbackFormat": "R8G8B8A8_UNORM" }, - "ANGLE_FORMAT_R8G8B8A8_UNORM": { + "R8G8B8A8_UNORM": { "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", @@ -20,15 +20,16 @@ "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, "glInternalFormat": "GL_RGBA8" }, - "ANGLE_FORMAT_R16G16B16A16_UNORM": { + "R16G16B16A16_UNORM": { "texFormat": "DXGI_FORMAT_R16G16B16A16_UNORM", "srvFormat": "DXGI_FORMAT_R16G16B16A16_UNORM", "rtvFormat": "DXGI_FORMAT_R16G16B16A16_UNORM", "channels": "rgba", "componentType": "unorm", - "bits": { "red": 16, "green": 16, "blue": 16, "alpha": 16 } + "bits": { "red": 16, "green": 16, "blue": 16, "alpha": 16 }, + "glInternalFormat": "GL_RGBA16_EXT" }, - "ANGLE_FORMAT_R16G16B16A16_FLOAT": { + "R16G16B16A16_FLOAT": { "texFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", "srvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", "rtvFormat": "DXGI_FORMAT_R16G16B16A16_FLOAT", @@ -37,7 +38,7 @@ "bits": { "red": 16, "green": 16, "blue": 16, "alpha": 16 }, "glInternalFormat": "GL_RGBA16F" }, - "ANGLE_FORMAT_R32G32B32A32_FLOAT": { + "R32G32B32A32_FLOAT": { "texFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", "srvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", "rtvFormat": "DXGI_FORMAT_R32G32B32A32_FLOAT", @@ -46,7 +47,7 @@ "bits": { "red": 32, "green": 32, "blue": 32, "alpha": 32 }, "glInternalFormat": "GL_RGBA32F" }, - "ANGLE_FORMAT_B8G8R8A8_UNORM": { + "B8G8R8A8_UNORM": { "texFormat": "DXGI_FORMAT_B8G8R8A8_UNORM", "srvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM", "rtvFormat": "DXGI_FORMAT_B8G8R8A8_UNORM", @@ -55,78 +56,52 @@ "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, "glInternalFormat": "GL_BGRA8_EXT" }, - "ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE": { - "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", - "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM", + "BC1_RGBA_UNORM_BLOCK": { + "texFormat": "DXGI_FORMAT_BC1_UNORM", + "srvFormat": "DXGI_FORMAT_BC1_UNORM", "channels": "rgba", "componentType": "unorm", - "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, - "glInternalFormat": "GL_RGBA8" + "swizzleFormat": "GL_RGBA8", + "glInternalFormat": "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT" }, - "ANGLE_FORMAT_BC1_UNORM": { + "BC1_RGB_UNORM_BLOCK": { "texFormat": "DXGI_FORMAT_BC1_UNORM", "srvFormat": "DXGI_FORMAT_BC1_UNORM", "channels": "rgba", "componentType": "unorm", - "swizzleFormat": "ANGLE_FORMAT_R8G8B8A8_UNORM", + "swizzleFormat": "GL_RGBA8", "glInternalFormat": "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT" }, - "ANGLE_FORMAT_BC2_UNORM": { + "BC2_RGBA_UNORM_BLOCK": { "texFormat": "DXGI_FORMAT_BC2_UNORM", "srvFormat": "DXGI_FORMAT_BC2_UNORM", "channels": "rgba", "componentType": "unorm", - "swizzleFormat": "ANGLE_FORMAT_R8G8B8A8_UNORM", + "swizzleFormat": "GL_RGBA8", "glInternalFormat": "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE" }, - "ANGLE_FORMAT_BC3_UNORM": { + "BC3_RGBA_UNORM_BLOCK": { "texFormat": "DXGI_FORMAT_BC3_UNORM", "srvFormat": "DXGI_FORMAT_BC3_UNORM", "channels": "rgba", "componentType": "unorm", - "swizzleFormat": "ANGLE_FORMAT_R8G8B8A8_UNORM", + "swizzleFormat": "GL_RGBA8", "glInternalFormat": "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE" }, - "ANGLE_FORMAT_R8_SNORM_NONRENDERABLE": { - "texFormat": "DXGI_FORMAT_R8_SNORM", - "srvFormat": "DXGI_FORMAT_R8_SNORM", - "channels": "r", - "componentType": "snorm", - "bits": { "red": 8 }, - "glInternalFormat": "GL_R8_SNORM" - }, - "ANGLE_FORMAT_R8G8_SNORM_NONRENDERABLE": { - "texFormat": "DXGI_FORMAT_R8G8_SNORM", - "srvFormat": "DXGI_FORMAT_R8G8_SNORM", - "channels": "rg", - "componentType": "snorm", - "bits": { "red": 8, "green": 8 }, - "glInternalFormat": "GL_RG8_SNORM" - }, - "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE": { - "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", - "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", - "channels": "rgba", - "componentType": "unorm", - "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, - "glInternalFormat": "GL_SRGB8_ALPHA8" - }, - "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10": { - "texFormat": "DXGI_FORMAT_R24G8_TYPELESS", - "srvFormat": "DXGI_FORMAT_R24_UNORM_X8_TYPELESS", - "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT", - "channels": "ds", - "bits": { "depth": 24, "stencil": 8 }, - "glInternalFormat": "GL_DEPTH24_STENCIL8_OES" - }, - "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3": { - "texFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT", + "D24_UNORM_S8_UINT": { + "FL10Plus": { + "texFormat": "DXGI_FORMAT_R24G8_TYPELESS", + "srvFormat": "DXGI_FORMAT_R24_UNORM_X8_TYPELESS" + }, + "FL9_3": { + "texFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT" + }, "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT", "channels": "ds", "bits": { "depth": 24, "stencil": 8 }, "glInternalFormat": "GL_DEPTH24_STENCIL8_OES" }, - "ANGLE_FORMAT_D32_FLOAT_S8X24_UINT_FL10": { + "D32_FLOAT_S8X24_UINT": { "texFormat": "DXGI_FORMAT_R32G8X24_TYPELESS", "srvFormat": "DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS", "dsvFormat": "DXGI_FORMAT_D32_FLOAT_S8X24_UINT", @@ -134,24 +109,21 @@ "bits": { "depth": 32, "stencil": 8 }, "glInternalFormat": "GL_DEPTH32F_STENCIL8" }, - "ANGLE_FORMAT_D16_UNORM_FL10": { - "texFormat": "DXGI_FORMAT_R16_TYPELESS", - "srvFormat": "DXGI_FORMAT_R16_UNORM", - "dsvFormat": "DXGI_FORMAT_D16_UNORM", - "channels": "d", - "componentType": "unorm", - "bits": { "depth": 16 }, - "glInternalFormat": "GL_DEPTH_COMPONENT16" - }, - "ANGLE_FORMAT_D16_UNORM_FL9_3": { - "texFormat": "DXGI_FORMAT_D16_UNORM", + "D16_UNORM": { + "FL10Plus": { + "texFormat": "DXGI_FORMAT_R16_TYPELESS", + "srvFormat": "DXGI_FORMAT_R16_UNORM" + }, + "FL9_3": { + "texFormat": "DXGI_FORMAT_D16_UNORM" + }, "dsvFormat": "DXGI_FORMAT_D16_UNORM", "channels": "d", "componentType": "unorm", "bits": { "depth": 16 }, "glInternalFormat": "GL_DEPTH_COMPONENT16" }, - "ANGLE_FORMAT_D32_FLOAT": { + "D32_FLOAT": { "texFormat": "DXGI_FORMAT_R32_TYPELESS", "srvFormat": "DXGI_FORMAT_R32_FLOAT", "dsvFormat": "DXGI_FORMAT_D32_FLOAT", @@ -160,7 +132,7 @@ "bits": { "depth": 32 }, "glInternalFormat": "GL_DEPTH_COMPONENT32F" }, - "ANGLE_FORMAT_R11G11B10_FLOAT": { + "R11G11B10_FLOAT": { "texFormat": "DXGI_FORMAT_R11G11B10_FLOAT", "srvFormat": "DXGI_FORMAT_R11G11B10_FLOAT", "rtvFormat": "DXGI_FORMAT_R11G11B10_FLOAT", @@ -169,7 +141,7 @@ "bits": { "red": 11, "green": 11, "blue": 10 }, "glInternalFormat": "GL_R11F_G11F_B10F" }, - "ANGLE_FORMAT_R16_FLOAT": { + "R16_FLOAT": { "texFormat": "DXGI_FORMAT_R16_FLOAT", "srvFormat": "DXGI_FORMAT_R16_FLOAT", "rtvFormat": "DXGI_FORMAT_R16_FLOAT", @@ -178,7 +150,7 @@ "bits": { "red": 16 }, "glInternalFormat": "GL_R16F" }, - "ANGLE_FORMAT_R16_SINT": { + "R16_SINT": { "texFormat": "DXGI_FORMAT_R16_SINT", "srvFormat": "DXGI_FORMAT_R16_SINT", "rtvFormat": "DXGI_FORMAT_R16_SINT", @@ -187,7 +159,7 @@ "bits": { "red": 16 }, "glInternalFormat": "GL_R16I" }, - "ANGLE_FORMAT_R16_UINT": { + "R16_UINT": { "texFormat": "DXGI_FORMAT_R16_UINT", "srvFormat": "DXGI_FORMAT_R16_UINT", "rtvFormat": "DXGI_FORMAT_R16_UINT", @@ -196,7 +168,7 @@ "bits": { "red": 16 }, "glInternalFormat": "GL_R16UI" }, - "ANGLE_FORMAT_R32_FLOAT": { + "R32_FLOAT": { "texFormat": "DXGI_FORMAT_R32_FLOAT", "srvFormat": "DXGI_FORMAT_R32_FLOAT", "rtvFormat": "DXGI_FORMAT_R32_FLOAT", @@ -205,7 +177,7 @@ "bits": { "red": 32 }, "glInternalFormat": "GL_R32F" }, - "ANGLE_FORMAT_R32_SINT": { + "R32_SINT": { "texFormat": "DXGI_FORMAT_R32_SINT", "srvFormat": "DXGI_FORMAT_R32_SINT", "rtvFormat": "DXGI_FORMAT_R32_SINT", @@ -214,7 +186,7 @@ "bits": { "red": 32 }, "glInternalFormat": "GL_R32I" }, - "ANGLE_FORMAT_R32_UINT": { + "R32_UINT": { "texFormat": "DXGI_FORMAT_R32_UINT", "srvFormat": "DXGI_FORMAT_R32_UINT", "rtvFormat": "DXGI_FORMAT_R32_UINT", @@ -223,15 +195,7 @@ "bits": { "red": 32 }, "glInternalFormat": "GL_R32UI" }, - "ANGLE_FORMAT_R8_UNORM_NONRENDERABLE": { - "texFormat": "DXGI_FORMAT_R8_UNORM", - "srvFormat": "DXGI_FORMAT_R8_UNORM", - "channels": "r", - "componentType": "unorm", - "bits": { "red": 8 }, - "glInternalFormat": "GL_R8" - }, - "ANGLE_FORMAT_R8_UNORM": { + "R8_UNORM": { "texFormat": "DXGI_FORMAT_R8_UNORM", "srvFormat": "DXGI_FORMAT_R8_UNORM", "rtvFormat": "DXGI_FORMAT_R8_UNORM", @@ -240,7 +204,7 @@ "bits": { "red": 8 }, "glInternalFormat": "GL_R8" }, - "ANGLE_FORMAT_R8_SINT": { + "R8_SINT": { "texFormat": "DXGI_FORMAT_R8_SINT", "srvFormat": "DXGI_FORMAT_R8_SINT", "rtvFormat": "DXGI_FORMAT_R8_SINT", @@ -249,7 +213,7 @@ "bits": { "red": 8 }, "glInternalFormat": "GL_R8I" }, - "ANGLE_FORMAT_R8_UINT": { + "R8_UINT": { "texFormat": "DXGI_FORMAT_R8_UINT", "srvFormat": "DXGI_FORMAT_R8_UINT", "rtvFormat": "DXGI_FORMAT_R8_UINT", @@ -258,7 +222,7 @@ "bits": { "red": 8 }, "glInternalFormat": "GL_R8UI" }, - "ANGLE_FORMAT_R8_SNORM": { + "R8_SNORM": { "texFormat": "DXGI_FORMAT_R8_SNORM", "srvFormat": "DXGI_FORMAT_R8_SNORM", "channels": "r", @@ -266,7 +230,7 @@ "bits": { "red": 8 }, "glInternalFormat": "GL_R8_SNORM" }, - "ANGLE_FORMAT_R16G16_FLOAT": { + "R16G16_FLOAT": { "texFormat": "DXGI_FORMAT_R16G16_FLOAT", "srvFormat": "DXGI_FORMAT_R16G16_FLOAT", "rtvFormat": "DXGI_FORMAT_R16G16_FLOAT", @@ -275,7 +239,7 @@ "bits": { "red": 16, "green": 16 }, "glInternalFormat": "GL_RG16F" }, - "ANGLE_FORMAT_R16G16_SINT": { + "R16G16_SINT": { "texFormat": "DXGI_FORMAT_R16G16_SINT", "srvFormat": "DXGI_FORMAT_R16G16_SINT", "rtvFormat": "DXGI_FORMAT_R16G16_SINT", @@ -284,7 +248,7 @@ "bits": { "red": 16, "green": 16 }, "glInternalFormat": "GL_RG16I" }, - "ANGLE_FORMAT_R16G16_UINT": { + "R16G16_UINT": { "texFormat": "DXGI_FORMAT_R16G16_UINT", "srvFormat": "DXGI_FORMAT_R16G16_UINT", "rtvFormat": "DXGI_FORMAT_R16G16_UINT", @@ -293,7 +257,7 @@ "bits": { "red": 16, "green": 16 }, "glInternalFormat": "GL_RG16UI" }, - "ANGLE_FORMAT_R32G32_FLOAT": { + "R32G32_FLOAT": { "texFormat": "DXGI_FORMAT_R32G32_FLOAT", "srvFormat": "DXGI_FORMAT_R32G32_FLOAT", "rtvFormat": "DXGI_FORMAT_R32G32_FLOAT", @@ -302,7 +266,7 @@ "bits": { "red": 32, "green": 32 }, "glInternalFormat": "GL_RG32F" }, - "ANGLE_FORMAT_R32G32_SINT": { + "R32G32_SINT": { "texFormat": "DXGI_FORMAT_R32G32_SINT", "srvFormat": "DXGI_FORMAT_R32G32_SINT", "rtvFormat": "DXGI_FORMAT_R32G32_SINT", @@ -311,7 +275,7 @@ "bits": { "red": 32, "green": 32 }, "glInternalFormat": "GL_RG32I" }, - "ANGLE_FORMAT_R32G32_UINT": { + "R32G32_UINT": { "texFormat": "DXGI_FORMAT_R32G32_UINT", "srvFormat": "DXGI_FORMAT_R32G32_UINT", "rtvFormat": "DXGI_FORMAT_R32G32_UINT", @@ -320,7 +284,7 @@ "bits": { "red": 32, "green": 32 }, "glInternalFormat": "GL_RG32UI" }, - "ANGLE_FORMAT_R8G8_UNORM": { + "R8G8_UNORM": { "texFormat": "DXGI_FORMAT_R8G8_UNORM", "srvFormat": "DXGI_FORMAT_R8G8_UNORM", "rtvFormat": "DXGI_FORMAT_R8G8_UNORM", @@ -329,15 +293,7 @@ "bits": { "red": 8, "green": 8 }, "glInternalFormat": "GL_RG8" }, - "ANGLE_FORMAT_R8G8_UNORM_NONRENDERABLE": { - "texFormat": "DXGI_FORMAT_R8G8_UNORM", - "srvFormat": "DXGI_FORMAT_R8G8_UNORM", - "channels": "rg", - "componentType": "unorm", - "bits": { "red": 8, "green": 8 }, - "glInternalFormat": "GL_RG8" - }, - "ANGLE_FORMAT_R8G8_SINT": { + "R8G8_SINT": { "texFormat": "DXGI_FORMAT_R8G8_SINT", "srvFormat": "DXGI_FORMAT_R8G8_SINT", "rtvFormat": "DXGI_FORMAT_R8G8_SINT", @@ -346,7 +302,7 @@ "bits": { "red": 8, "green": 8 }, "glInternalFormat": "GL_RG8I" }, - "ANGLE_FORMAT_R8G8_UINT": { + "R8G8_UINT": { "texFormat": "DXGI_FORMAT_R8G8_UINT", "srvFormat": "DXGI_FORMAT_R8G8_UINT", "rtvFormat": "DXGI_FORMAT_R8G8_UINT", @@ -355,7 +311,7 @@ "bits": { "red": 8, "green": 8 }, "glInternalFormat": "GL_RG8UI" }, - "ANGLE_FORMAT_R8G8_SNORM": { + "R8G8_SNORM": { "texFormat": "DXGI_FORMAT_R8G8_SNORM", "srvFormat": "DXGI_FORMAT_R8G8_SNORM", "channels": "rg", @@ -363,7 +319,7 @@ "bits": { "red": 8, "green": 8 }, "glInternalFormat": "GL_RG8_SNORM" }, - "ANGLE_FORMAT_R10G10B10A2_UNORM": { + "R10G10B10A2_UNORM": { "texFormat": "DXGI_FORMAT_R10G10B10A2_UNORM", "srvFormat": "DXGI_FORMAT_R10G10B10A2_UNORM", "rtvFormat": "DXGI_FORMAT_R10G10B10A2_UNORM", @@ -372,7 +328,7 @@ "bits": { "red": 10, "green": 10, "blue": 10, "alpha": 2 }, "glInternalFormat": "GL_RGB10_A2" }, - "ANGLE_FORMAT_R10G10B10A2_UINT": { + "R10G10B10A2_UINT": { "texFormat": "DXGI_FORMAT_R10G10B10A2_UINT", "srvFormat": "DXGI_FORMAT_R10G10B10A2_UINT", "rtvFormat": "DXGI_FORMAT_R10G10B10A2_UINT", @@ -381,7 +337,7 @@ "bits": { "red": 10, "green": 10, "blue": 10, "alpha": 2 }, "glInternalFormat": "GL_RGB10_A2UI" }, - "ANGLE_FORMAT_R16G16B16A16_SINT": { + "R16G16B16A16_SINT": { "texFormat": "DXGI_FORMAT_R16G16B16A16_SINT", "srvFormat": "DXGI_FORMAT_R16G16B16A16_SINT", "rtvFormat": "DXGI_FORMAT_R16G16B16A16_SINT", @@ -390,7 +346,7 @@ "bits": { "red": 16, "green": 16, "blue": 16, "alpha": 16 }, "glInternalFormat": "GL_RGBA16I" }, - "ANGLE_FORMAT_R16G16B16A16_UINT": { + "R16G16B16A16_UINT": { "texFormat": "DXGI_FORMAT_R16G16B16A16_UINT", "srvFormat": "DXGI_FORMAT_R16G16B16A16_UINT", "rtvFormat": "DXGI_FORMAT_R16G16B16A16_UINT", @@ -399,7 +355,7 @@ "bits": { "red": 16, "green": 16, "blue": 16, "alpha": 16 }, "glInternalFormat": "GL_RGBA16UI" }, - "ANGLE_FORMAT_R32G32B32A32_SINT": { + "R32G32B32A32_SINT": { "texFormat": "DXGI_FORMAT_R32G32B32A32_SINT", "srvFormat": "DXGI_FORMAT_R32G32B32A32_SINT", "rtvFormat": "DXGI_FORMAT_R32G32B32A32_SINT", @@ -408,7 +364,7 @@ "bits": { "red": 32, "green": 32, "blue": 32, "alpha": 32 }, "glInternalFormat": "GL_RGBA32I" }, - "ANGLE_FORMAT_R32G32B32A32_UINT": { + "R32G32B32A32_UINT": { "texFormat": "DXGI_FORMAT_R32G32B32A32_UINT", "srvFormat": "DXGI_FORMAT_R32G32B32A32_UINT", "rtvFormat": "DXGI_FORMAT_R32G32B32A32_UINT", @@ -417,27 +373,27 @@ "bits": { "red": 32, "green": 32, "blue": 32, "alpha": 32 }, "glInternalFormat": "GL_RGBA32UI" }, - "ANGLE_FORMAT_B5G6R5_UNORM": { + "B5G6R5_UNORM": { "texFormat": "DXGI_FORMAT_B5G6R5_UNORM", "srvFormat": "DXGI_FORMAT_B5G6R5_UNORM", "rtvFormat": "DXGI_FORMAT_B5G6R5_UNORM", "channels": "bgr", "componentType": "unorm", "bits": { "red": 5, "green": 6, "blue": 5 }, - "glInternalFormat": "GL_RGB565", - "channelStruct": "R5G6B5" + "supportTest": "SupportsFormat(DXGI_FORMAT_B5G6R5_UNORM, deviceCaps)", + "fallbackFormat": "R8G8B8A8_UNORM" }, - "ANGLE_FORMAT_B5G5R5A1_UNORM": { + "B5G5R5A1_UNORM": { "texFormat": "DXGI_FORMAT_B5G5R5A1_UNORM", "srvFormat": "DXGI_FORMAT_B5G5R5A1_UNORM", "rtvFormat": "DXGI_FORMAT_B5G5R5A1_UNORM", "channels": "bgra", "componentType": "unorm", "bits": { "red": 5, "green": 5, "blue": 5, "alpha": 1 }, - "glInternalFormat": "GL_RGB5_A1", - "channelStruct": "A1R5G5B5" + "supportTest": "SupportsFormat(DXGI_FORMAT_B5G5R5A1_UNORM, deviceCaps)", + "fallbackFormat": "R8G8B8A8_UNORM" }, - "ANGLE_FORMAT_R8G8B8A8_SINT": { + "R8G8B8A8_SINT": { "texFormat": "DXGI_FORMAT_R8G8B8A8_SINT", "srvFormat": "DXGI_FORMAT_R8G8B8A8_SINT", "rtvFormat": "DXGI_FORMAT_R8G8B8A8_SINT", @@ -446,7 +402,7 @@ "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, "glInternalFormat": "GL_RGBA8I" }, - "ANGLE_FORMAT_R8G8B8A8_UINT": { + "R8G8B8A8_UINT": { "texFormat": "DXGI_FORMAT_R8G8B8A8_UINT", "srvFormat": "DXGI_FORMAT_R8G8B8A8_UINT", "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UINT", @@ -455,7 +411,7 @@ "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, "glInternalFormat": "GL_RGBA8UI" }, - "ANGLE_FORMAT_R8G8B8A8_SNORM": { + "R8G8B8A8_SNORM": { "texFormat": "DXGI_FORMAT_R8G8B8A8_SNORM", "srvFormat": "DXGI_FORMAT_R8G8B8A8_SNORM", "channels": "rgba", @@ -463,26 +419,24 @@ "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, "glInternalFormat": "GL_RGBA8_SNORM" }, - "ANGLE_FORMAT_R9G9B9E5_SHAREDEXP": { + "R9G9B9E5_SHAREDEXP": { "texFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP", "srvFormat": "DXGI_FORMAT_R9G9B9E5_SHAREDEXP", "channels": "rgb", "componentType": "float", - "bits": { "red": 9, "green": 9, "blue": 9, "shared": 5 }, - "glInternalFormat": "GL_RGB9_E5", - "channelStruct": "R9G9B9E5" + "bits": { "red": 9, "green": 9, "blue": 9, "shared": 5 } }, - "ANGLE_FORMAT_B4G4R4A4_UNORM": { + "B4G4R4A4_UNORM": { "texFormat": "DXGI_FORMAT_B4G4R4A4_UNORM", "srvFormat": "DXGI_FORMAT_B4G4R4A4_UNORM", "rtvFormat": "DXGI_FORMAT_B4G4R4A4_UNORM", "channels": "bgra", "componentType": "unorm", "bits": { "red": 4, "green": 4, "blue": 4, "alpha": 4 }, - "glInternalFormat": "GL_RGBA4", - "channelStruct": "A4R4G4B4" + "supportTest": "SupportsFormat(DXGI_FORMAT_B4G4R4A4_UNORM, deviceCaps)", + "fallbackFormat": "R8G8B8A8_UNORM" }, - "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB": { + "R8G8B8A8_UNORM_SRGB": { "texFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", "srvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", "rtvFormat": "DXGI_FORMAT_R8G8B8A8_UNORM_SRGB", @@ -491,31 +445,25 @@ "bits": { "red": 8, "green": 8, "blue": 8, "alpha": 8 }, "glInternalFormat": "GL_SRGB8_ALPHA8" }, - "ANGLE_FORMAT_X24_TYPELESS_G8_UINT": { - "texFormat": "DXGI_FORMAT_R24G8_TYPELESS", - "srvFormat": "DXGI_FORMAT_X24_TYPELESS_G8_UINT", - "dsvFormat": "DXGI_FORMAT_D24_UNORM_S8_UINT", - "channels": "ds", - "bits": { "depth": 24, "stencil": 8 }, - "glInternalFormat": "GL_DEPTH24_STENCIL8_OES" - }, - "ANGLE_FORMAT_R16_UNORM": { + "R16_UNORM": { "texFormat": "DXGI_FORMAT_R16_UNORM", "srvFormat": "DXGI_FORMAT_R16_UNORM", "rtvFormat": "DXGI_FORMAT_R16_UNORM", "channels": "r", "componentType": "unorm", - "bits": { "red": 16 } + "bits": { "red": 16 }, + "glInternalFormat": "GL_R16_EXT" }, - "ANGLE_FORMAT_R16G16_UNORM": { + "R16G16_UNORM": { "texFormat": "DXGI_FORMAT_R16G16_UNORM", "srvFormat": "DXGI_FORMAT_R16G16_UNORM", "rtvFormat": "DXGI_FORMAT_R16G16_UNORM", "channels": "rg", "componentType": "unorm", - "bits": { "red": 16, "green": 16 } + "bits": { "red": 16, "green": 16 }, + "glInternalFormat": "GL_RG16_EXT" }, - "ANGLE_FORMAT_R16_SNORM": { + "R16_SNORM": { "texFormat": "DXGI_FORMAT_R16_SNORM", "srvFormat": "DXGI_FORMAT_R16_SNORM", "channels": "r", @@ -523,7 +471,7 @@ "bits": { "red": 16 }, "glInternalFormat": "GL_R16_SNORM_EXT" }, - "ANGLE_FORMAT_R16G16_SNORM": { + "R16G16_SNORM": { "texFormat": "DXGI_FORMAT_R16G16_SNORM", "srvFormat": "DXGI_FORMAT_R16G16_SNORM", "channels": "rg", @@ -531,7 +479,7 @@ "bits": { "red": 16, "green": 16 }, "glInternalFormat": "GL_RG16_SNORM_EXT" }, - "ANGLE_FORMAT_R16G16B16A16_SNORM": { + "R16G16B16A16_SNORM": { "texFormat": "DXGI_FORMAT_R16G16B16A16_SNORM", "srvFormat": "DXGI_FORMAT_R16G16B16A16_SNORM", "channels": "rgba", diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_map.json b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_map.json index 5ef0787ce80..9b2e8d9db66 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_map.json +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_map.json @@ -1,156 +1,74 @@ { - "GL_ALPHA": { - "OnlyFL10Plus": "ANGLE_FORMAT_A8_UNORM", - "OnlyFL9_3": "ANGLE_FORMAT_R8G8B8A8_UNORM" - }, - "GL_ALPHA16F_EXT": "ANGLE_FORMAT_R16G16B16A16_FLOAT", - "GL_ALPHA32F_EXT": "ANGLE_FORMAT_R32G32B32A32_FLOAT", - "GL_ALPHA8_EXT": { - "OnlyFL10Plus": "ANGLE_FORMAT_A8_UNORM", - "OnlyFL9_3": "ANGLE_FORMAT_R8G8B8A8_UNORM" - }, - "GL_BGR5_A1_ANGLEX": "ANGLE_FORMAT_B8G8R8A8_UNORM", - "GL_BGRA4_ANGLEX": "ANGLE_FORMAT_B8G8R8A8_UNORM", - "GL_BGRA8_EXT": "ANGLE_FORMAT_B8G8R8A8_UNORM", - "GL_BGRA_EXT": "ANGLE_FORMAT_B8G8R8A8_UNORM", - "GL_COMPRESSED_R11_EAC": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8_UNORM_NONRENDERABLE" - }, - "GL_COMPRESSED_RG11_EAC": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8_UNORM_NONRENDERABLE" - }, - "GL_COMPRESSED_RGB8_ETC2": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE" - }, - "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE" - }, - "GL_COMPRESSED_RGBA8_ETC2_EAC": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE" - }, - "GL_COMPRESSED_RGBA_S3TC_DXT1_EXT": "ANGLE_FORMAT_BC1_UNORM", - "GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE": "ANGLE_FORMAT_BC2_UNORM", - "GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE": "ANGLE_FORMAT_BC3_UNORM", - "GL_COMPRESSED_RGB_S3TC_DXT1_EXT": "ANGLE_FORMAT_BC1_UNORM", - "GL_COMPRESSED_SIGNED_R11_EAC": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8_SNORM_NONRENDERABLE" - }, - "GL_COMPRESSED_SIGNED_RG11_EAC": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8_SNORM_NONRENDERABLE" - }, - "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE" - }, - "GL_COMPRESSED_SRGB8_ETC2": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE" - }, - "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2": { - "OnlyFL10Plus": "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE" - }, - "GL_DEPTH24_STENCIL8": { - "OnlyFL10Plus": "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10", - "OnlyFL9_3": "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3" - }, - "GL_DEPTH32F_STENCIL8": { - "OnlyFL10Plus": "ANGLE_FORMAT_D32_FLOAT_S8X24_UINT_FL10", - "OnlyFL9_3": "ANGLE_FORMAT_NONE" - }, - "GL_DEPTH_COMPONENT16": { - "OnlyFL10Plus": "ANGLE_FORMAT_D16_UNORM_FL10", - "OnlyFL9_3": "ANGLE_FORMAT_D16_UNORM_FL9_3" - }, - "GL_DEPTH_COMPONENT24": { - "OnlyFL10Plus": "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10", - "OnlyFL9_3": "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3" - }, - "GL_DEPTH_COMPONENT32F": { - "OnlyFL10Plus": "ANGLE_FORMAT_D32_FLOAT", - "OnlyFL9_3": "ANGLE_FORMAT_NONE" - }, - "GL_DEPTH_COMPONENT32_OES": { - "OnlyFL10Plus": "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10" - }, - "GL_ETC1_RGB8_OES": "ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE", - "GL_ETC1_RGB8_LOSSY_DECODE_ANGLE": "ANGLE_FORMAT_BC1_UNORM", - "GL_LUMINANCE": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_LUMINANCE16F_EXT": "ANGLE_FORMAT_R16G16B16A16_FLOAT", - "GL_LUMINANCE32F_EXT": "ANGLE_FORMAT_R32G32B32A32_FLOAT", - "GL_LUMINANCE8_ALPHA8_EXT": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_LUMINANCE8_EXT": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_LUMINANCE_ALPHA": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_LUMINANCE_ALPHA16F_EXT": "ANGLE_FORMAT_R16G16B16A16_FLOAT", - "GL_LUMINANCE_ALPHA32F_EXT": "ANGLE_FORMAT_R32G32B32A32_FLOAT", - "GL_NONE": "ANGLE_FORMAT_NONE", - "GL_R11F_G11F_B10F": "ANGLE_FORMAT_R11G11B10_FLOAT", - "GL_R16F": "ANGLE_FORMAT_R16_FLOAT", - "GL_R16I": "ANGLE_FORMAT_R16_SINT", - "GL_R16UI": "ANGLE_FORMAT_R16_UINT", - "GL_R32F": "ANGLE_FORMAT_R32_FLOAT", - "GL_R32I": "ANGLE_FORMAT_R32_SINT", - "GL_R32UI": "ANGLE_FORMAT_R32_UINT", - "GL_R8": "ANGLE_FORMAT_R8_UNORM", - "GL_R8I": "ANGLE_FORMAT_R8_SINT", - "GL_R8UI": "ANGLE_FORMAT_R8_UINT", - "GL_R8_SNORM": "ANGLE_FORMAT_R8_SNORM", - "GL_RG16F": "ANGLE_FORMAT_R16G16_FLOAT", - "GL_RG16I": "ANGLE_FORMAT_R16G16_SINT", - "GL_RG16UI": "ANGLE_FORMAT_R16G16_UINT", - "GL_RG32F": "ANGLE_FORMAT_R32G32_FLOAT", - "GL_RG32I": "ANGLE_FORMAT_R32G32_SINT", - "GL_RG32UI": "ANGLE_FORMAT_R32G32_UINT", - "GL_RG8": "ANGLE_FORMAT_R8G8_UNORM", - "GL_RG8I": "ANGLE_FORMAT_R8G8_SINT", - "GL_RG8UI": "ANGLE_FORMAT_R8G8_UINT", - "GL_RG8_SNORM": "ANGLE_FORMAT_R8G8_SNORM", - "GL_RGB": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_RGB10_A2": "ANGLE_FORMAT_R10G10B10A2_UNORM", - "GL_RGB10_A2UI": "ANGLE_FORMAT_R10G10B10A2_UINT", - "GL_RGB16F": "ANGLE_FORMAT_R16G16B16A16_FLOAT", - "GL_RGB16I": "ANGLE_FORMAT_R16G16B16A16_SINT", - "GL_RGB16UI": "ANGLE_FORMAT_R16G16B16A16_UINT", - "GL_RGB32F": "ANGLE_FORMAT_R32G32B32A32_FLOAT", - "GL_RGB32I": "ANGLE_FORMAT_R32G32B32A32_SINT", - "GL_RGB32UI": "ANGLE_FORMAT_R32G32B32A32_UINT", - "GL_RGB565": { - "SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,false>": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,true>": "ANGLE_FORMAT_B5G6R5_UNORM" - }, - "GL_RGB5_A1": { - "SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,false>": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,true>": "ANGLE_FORMAT_B5G5R5A1_UNORM" - }, - "GL_RGB8": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_RGB8I": "ANGLE_FORMAT_R8G8B8A8_SINT", - "GL_RGB8UI": "ANGLE_FORMAT_R8G8B8A8_UINT", - "GL_RGB8_SNORM": "ANGLE_FORMAT_R8G8B8A8_SNORM", - "GL_RGB9_E5": "ANGLE_FORMAT_R9G9B9E5_SHAREDEXP", - "GL_RGBA": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_RGBA16F": "ANGLE_FORMAT_R16G16B16A16_FLOAT", - "GL_RGBA16I": "ANGLE_FORMAT_R16G16B16A16_SINT", - "GL_RGBA16UI": "ANGLE_FORMAT_R16G16B16A16_UINT", - "GL_RGBA32F": "ANGLE_FORMAT_R32G32B32A32_FLOAT", - "GL_RGBA32I": "ANGLE_FORMAT_R32G32B32A32_SINT", - "GL_RGBA32UI": "ANGLE_FORMAT_R32G32B32A32_UINT", - "GL_RGBA4": { - "SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,false>": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,true>": "ANGLE_FORMAT_B4G4R4A4_UNORM" - }, - "GL_RGBA8": "ANGLE_FORMAT_R8G8B8A8_UNORM", - "GL_RGBA8I": "ANGLE_FORMAT_R8G8B8A8_SINT", - "GL_RGBA8UI": "ANGLE_FORMAT_R8G8B8A8_UINT", - "GL_RGBA8_SNORM": "ANGLE_FORMAT_R8G8B8A8_SNORM", - "GL_SRGB8": "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE", - "GL_SRGB8_ALPHA8": "ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB", - "GL_STENCIL_INDEX8": { - "OnlyFL10Plus": "ANGLE_FORMAT_X24_TYPELESS_G8_UINT", - "OnlyFL9_3": "ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3" - }, - "GL_R16_EXT": "ANGLE_FORMAT_R16_UNORM", - "GL_RG16_EXT": "ANGLE_FORMAT_R16G16_UNORM", - "GL_RGB16_EXT": "ANGLE_FORMAT_R16G16B16A16_UNORM", - "GL_RGBA16_EXT": "ANGLE_FORMAT_R16G16B16A16_UNORM", - "GL_R16_SNORM_EXT": "ANGLE_FORMAT_R16_SNORM", - "GL_RG16_SNORM_EXT": "ANGLE_FORMAT_R16G16_SNORM", - "GL_RGB16_SNORM_EXT": "ANGLE_FORMAT_R16G16B16A16_SNORM", - "GL_RGBA16_SNORM_EXT": "ANGLE_FORMAT_R16G16B16A16_SNORM" + "GL_ALPHA16F_EXT": "R16G16B16A16_FLOAT", + "GL_ALPHA32F_EXT": "R32G32B32A32_FLOAT", + "GL_BGR5_A1_ANGLEX": "B8G8R8A8_UNORM", + "GL_BGRA4_ANGLEX": "B8G8R8A8_UNORM", + "GL_COMPRESSED_R11_EAC": "R8_UNORM", + "GL_COMPRESSED_RG11_EAC": "R8G8_UNORM", + "GL_COMPRESSED_RGB8_ETC2": "R8G8B8A8_UNORM", + "GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2": "R8G8B8A8_UNORM", + "GL_COMPRESSED_RGBA8_ETC2_EAC": "R8G8B8A8_UNORM", + "GL_COMPRESSED_RGBA_ASTC_4x4_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_5x4_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_5x5_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_6x5_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_6x6_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_8x5_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_8x6_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_8x8_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_10x5_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_10x6_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_10x8_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_10x10_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_12x10_KHR": "NONE", + "GL_COMPRESSED_RGBA_ASTC_12x12_KHR": "NONE", + "GL_COMPRESSED_RGB_S3TC_DXT1_EXT": "BC1_RGB_UNORM_BLOCK", + "GL_COMPRESSED_SIGNED_R11_EAC": "R8_SNORM", + "GL_COMPRESSED_SIGNED_RG11_EAC": "R8G8_SNORM", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR": "NONE", + "GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC": "R8G8B8A8_UNORM_SRGB", + "GL_COMPRESSED_SRGB8_ETC2": "R8G8B8A8_UNORM_SRGB", + "GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2": "R8G8B8A8_UNORM_SRGB", + "GL_DEPTH_COMPONENT24": "D24_UNORM_S8_UINT", + "GL_DEPTH_COMPONENT32_OES": "D24_UNORM_S8_UINT", + "GL_ETC1_RGB8_OES": "R8G8B8A8_UNORM", + "GL_ETC1_RGB8_LOSSY_DECODE_ANGLE": "BC1_RGB_UNORM_BLOCK", + "GL_LUMINANCE16F_EXT": "R16G16B16A16_FLOAT", + "GL_LUMINANCE32F_EXT": "R32G32B32A32_FLOAT", + "GL_LUMINANCE8_ALPHA8_EXT": "R8G8B8A8_UNORM", + "GL_LUMINANCE8_EXT": "R8G8B8A8_UNORM", + "GL_LUMINANCE_ALPHA16F_EXT": "R16G16B16A16_FLOAT", + "GL_LUMINANCE_ALPHA32F_EXT": "R32G32B32A32_FLOAT", + "GL_RGB": "R8G8B8A8_UNORM", + "GL_RGB16F": "R16G16B16A16_FLOAT", + "GL_RGB16I": "R16G16B16A16_SINT", + "GL_RGB16UI": "R16G16B16A16_UINT", + "GL_RGB565": "B5G6R5_UNORM", + "GL_RGB5_A1": "B5G5R5A1_UNORM", + "GL_RGB8": "R8G8B8A8_UNORM", + "GL_RGB8I": "R8G8B8A8_SINT", + "GL_RGB8UI": "R8G8B8A8_UINT", + "GL_RGB8_SNORM": "R8G8B8A8_SNORM", + "GL_RGBA4": "B4G4R4A4_UNORM", + "GL_SRGB8": "R8G8B8A8_UNORM_SRGB", + "GL_STENCIL_INDEX8": "D24_UNORM_S8_UINT", + "GL_RGB16_EXT": "R16G16B16A16_UNORM", + "GL_RGBA16_EXT": "R16G16B16A16_UNORM", + "GL_RGB16_SNORM_EXT": "R16G16B16A16_SNORM", + "GL_RGB32F": "R32G32B32A32_FLOAT", + "GL_RGB32I": "R32G32B32A32_SINT", + "GL_RGB32UI": "R32G32B32A32_UINT" } diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table.cpp new file mode 100644 index 00000000000..6697a117792 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table.cpp @@ -0,0 +1,56 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Helper routines for the D3D11 texture format table. + +#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" + +#include "libANGLE/renderer/load_functions_table.h" + +namespace rx +{ + +namespace d3d11 +{ + +Format::Format() + : internalFormat(GL_NONE), + format(angle::Format::Get(angle::Format::ID::NONE)), + texFormat(DXGI_FORMAT_UNKNOWN), + srvFormat(DXGI_FORMAT_UNKNOWN), + rtvFormat(DXGI_FORMAT_UNKNOWN), + dsvFormat(DXGI_FORMAT_UNKNOWN), + blitSRVFormat(DXGI_FORMAT_UNKNOWN), + swizzle(*this), + dataInitializerFunction(nullptr) +{ +} + +Format::Format(GLenum internalFormat, + angle::Format::ID formatID, + DXGI_FORMAT texFormat, + DXGI_FORMAT srvFormat, + DXGI_FORMAT rtvFormat, + DXGI_FORMAT dsvFormat, + DXGI_FORMAT blitSRVFormat, + GLenum swizzleFormat, + InitializeTextureDataFunction internalFormatInitializer, + const Renderer11DeviceCaps &deviceCaps) + : internalFormat(internalFormat), + format(angle::Format::Get(formatID)), + texFormat(texFormat), + srvFormat(srvFormat), + rtvFormat(rtvFormat), + dsvFormat(dsvFormat), + blitSRVFormat(blitSRVFormat), + swizzle(swizzleFormat == internalFormat ? *this : Format::Get(swizzleFormat, deviceCaps)), + dataInitializerFunction(internalFormatInitializer), + loadFunctions(GetLoadFunctionsMap(internalFormat, formatID)) +{ +} + +} // namespace d3d11 + +} // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table.h index 95d104f455e..8e05a2eb871 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table.h +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table.h @@ -14,9 +14,9 @@ #include "common/angleutils.h" #include "common/platform.h" +#include "libANGLE/renderer/Format.h" #include "libANGLE/renderer/renderer_utils.h" #include "libANGLE/renderer/d3d/formatutilsD3D.h" -#include "libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.h" namespace rx { @@ -26,39 +26,28 @@ struct Renderer11DeviceCaps; namespace d3d11 { -struct LoadImageFunctionInfo +// For sized GL internal formats, there are several possible corresponding D3D11 formats depending +// on device capabilities. +// This structure allows querying for the DXGI texture formats to use for textures, SRVs, RTVs and +// DSVs given a GL internal format. +struct Format final : angle::NonCopyable { - LoadImageFunctionInfo() : loadFunction(nullptr), requiresConversion(false) {} - LoadImageFunctionInfo(LoadImageFunction loadFunction, bool requiresConversion) - : loadFunction(loadFunction), requiresConversion(requiresConversion) - { - } - - LoadImageFunction loadFunction; - bool requiresConversion; -}; - -struct ANGLEFormatSet -{ - ANGLEFormatSet(); - ANGLEFormatSet(ANGLEFormat format, - GLenum glInternalFormat, - DXGI_FORMAT texFormat, - DXGI_FORMAT srvFormat, - DXGI_FORMAT rtvFormat, - DXGI_FORMAT dsvFormat, - DXGI_FORMAT blitSRVFormat, - ANGLEFormat swizzleFormat, - MipGenerationFunction mipGenerationFunction, - ColorReadFunction colorReadFunction); - ANGLEFormatSet(const ANGLEFormatSet &) = default; - ANGLEFormatSet &operator=(const ANGLEFormatSet &) = default; - - ANGLEFormat format; - - // The closest matching GL internal format for the DXGI formats this format uses. Note that this - // may be a different internal format than the one this ANGLE format is used for. - GLenum glInternalFormat; + Format(); + Format(GLenum internalFormat, + angle::Format::ID formatID, + DXGI_FORMAT texFormat, + DXGI_FORMAT srvFormat, + DXGI_FORMAT rtvFormat, + DXGI_FORMAT dsvFormat, + DXGI_FORMAT blitSRVFormat, + GLenum swizzleFormat, + InitializeTextureDataFunction internalFormatInitializer, + const Renderer11DeviceCaps &deviceCaps); + + static const Format &Get(GLenum internalFormat, const Renderer11DeviceCaps &deviceCaps); + + GLenum internalFormat; + const angle::Format &format; DXGI_FORMAT texFormat; DXGI_FORMAT srvFormat; @@ -67,32 +56,13 @@ struct ANGLEFormatSet DXGI_FORMAT blitSRVFormat; - ANGLEFormat swizzleFormat; - - MipGenerationFunction mipGenerationFunction; - ColorReadFunction colorReadFunction; -}; - -struct TextureFormat : public angle::NonCopyable -{ - TextureFormat(GLenum internalFormat, - const ANGLEFormat angleFormat, - InitializeTextureDataFunction internalFormatInitializer); - - const ANGLEFormatSet *formatSet; - const ANGLEFormatSet *swizzleFormatSet; + const Format &swizzle; InitializeTextureDataFunction dataInitializerFunction; - typedef std::map<GLenum, LoadImageFunctionInfo> LoadFunctionMap; LoadFunctionMap loadFunctions; }; -const ANGLEFormatSet &GetANGLEFormatSet(ANGLEFormat angleFormat); - -const TextureFormat &GetTextureFormatInfo(GLenum internalformat, - const Renderer11DeviceCaps &renderer11DeviceCaps); - } // namespace d3d11 } // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp index b559db3df53..d5eab7bc159 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.cpp @@ -11,12 +11,15 @@ #include "libANGLE/renderer/d3d/d3d11/texture_format_table.h" -#include "libANGLE/renderer/copyimage.h" +#include "image_util/copyimage.h" +#include "image_util/generatemip.h" +#include "image_util/loadimage.h" + #include "libANGLE/renderer/d3d/d3d11/formatutils11.h" -#include "libANGLE/renderer/d3d/d3d11/load_functions_table.h" #include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h" -#include "libANGLE/renderer/d3d/generatemip.h" -#include "libANGLE/renderer/d3d/loadimage.h" +#include "libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h" + +using namespace angle; namespace rx { @@ -24,1962 +27,1916 @@ namespace rx namespace d3d11 { -namespace -{ - -typedef bool (*FormatSupportFunction)(const Renderer11DeviceCaps &); - -bool OnlyFL10Plus(const Renderer11DeviceCaps &deviceCaps) -{ - return (deviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0); -} - -bool OnlyFL9_3(const Renderer11DeviceCaps &deviceCaps) -{ - return (deviceCaps.featureLevel == D3D_FEATURE_LEVEL_9_3); -} - -template <DXGI_FORMAT format, bool requireSupport> -bool SupportsFormat(const Renderer11DeviceCaps &deviceCaps) -{ - // Must support texture, SRV and RTV support - UINT mustSupport = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURECUBE | - D3D11_FORMAT_SUPPORT_SHADER_SAMPLE | D3D11_FORMAT_SUPPORT_MIP | - D3D11_FORMAT_SUPPORT_RENDER_TARGET; - - if (d3d11_gl::GetMaximumClientVersion(deviceCaps.featureLevel) > 2) - { - mustSupport |= D3D11_FORMAT_SUPPORT_TEXTURE3D; - } - - bool fullSupport = false; - if (format == DXGI_FORMAT_B5G6R5_UNORM) - { - // All hardware that supports DXGI_FORMAT_B5G6R5_UNORM should support autogen mipmaps, but - // check anyway. - mustSupport |= D3D11_FORMAT_SUPPORT_MIP_AUTOGEN; - fullSupport = ((deviceCaps.B5G6R5support & mustSupport) == mustSupport); - } - else if (format == DXGI_FORMAT_B4G4R4A4_UNORM) - { - fullSupport = ((deviceCaps.B4G4R4A4support & mustSupport) == mustSupport); - } - else if (format == DXGI_FORMAT_B5G5R5A1_UNORM) - { - fullSupport = ((deviceCaps.B5G5R5A1support & mustSupport) == mustSupport); - } - else - { - UNREACHABLE(); - return false; - } - - // This 'SupportsFormat' function is used by individual entries in the D3D11 Format Map below, - // which maps GL formats to DXGI formats. - if (requireSupport) - { - // This means that ANGLE would like to use the entry in the map if the inputted DXGI format - // *IS* supported. - // e.g. the entry might map GL_RGB5_A1 to DXGI_FORMAT_B5G5R5A1, which should only be used if - // DXGI_FORMAT_B5G5R5A1 is supported. - // In this case, we should only return 'true' if the format *IS* supported. - return fullSupport; - } - else - { - // This means that ANGLE would like to use the entry in the map if the inputted DXGI format - // *ISN'T* supported. - // This might be a fallback entry. e.g. for ANGLE to use DXGI_FORMAT_R8G8B8A8_UNORM if - // DXGI_FORMAT_B5G5R5A1 isn't supported. - // In this case, we should only return 'true' if the format *ISN'T* supported. - return !fullSupport; - } -} - -// End Format Support Functions -} // namespace - -ANGLEFormatSet::ANGLEFormatSet() - : format(ANGLE_FORMAT_NONE), - glInternalFormat(GL_NONE), - texFormat(DXGI_FORMAT_UNKNOWN), - srvFormat(DXGI_FORMAT_UNKNOWN), - rtvFormat(DXGI_FORMAT_UNKNOWN), - dsvFormat(DXGI_FORMAT_UNKNOWN), - blitSRVFormat(DXGI_FORMAT_UNKNOWN), - swizzleFormat(ANGLE_FORMAT_NONE), - mipGenerationFunction(nullptr), - colorReadFunction(nullptr) -{ -} - -// For sized GL internal formats, there are several possible corresponding D3D11 formats depending -// on device capabilities. -// This function allows querying for the DXGI texture formats to use for textures, SRVs, RTVs and -// DSVs given a GL internal format. -TextureFormat::TextureFormat(GLenum internalFormat, - const ANGLEFormat angleFormat, - InitializeTextureDataFunction internalFormatInitializer) - : dataInitializerFunction(internalFormatInitializer) -{ - formatSet = &GetANGLEFormatSet(angleFormat); - swizzleFormatSet = &GetANGLEFormatSet(formatSet->swizzleFormat); - - // Gather all the load functions for this internal format - loadFunctions = GetLoadFunctionsMap(internalFormat, formatSet->texFormat); - - ASSERT(loadFunctions.size() != 0 || internalFormat == GL_NONE); -} - -ANGLEFormatSet::ANGLEFormatSet(ANGLEFormat format, - GLenum glInternalFormat, - DXGI_FORMAT texFormat, - DXGI_FORMAT srvFormat, - DXGI_FORMAT rtvFormat, - DXGI_FORMAT dsvFormat, - DXGI_FORMAT blitSRVFormat, - ANGLEFormat swizzleFormat, - MipGenerationFunction mipGenerationFunction, - ColorReadFunction colorReadFunction) - : format(format), - glInternalFormat(glInternalFormat), - texFormat(texFormat), - srvFormat(srvFormat), - rtvFormat(rtvFormat), - dsvFormat(dsvFormat), - blitSRVFormat(blitSRVFormat), - swizzleFormat(swizzleFormat), - mipGenerationFunction(mipGenerationFunction), - colorReadFunction(colorReadFunction) -{ -} - -const ANGLEFormatSet &GetANGLEFormatSet(ANGLEFormat angleFormat) -{ - // clang-format off - switch (angleFormat) - { - case ANGLE_FORMAT_A8_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_A8_UNORM, - GL_ALPHA8_EXT, - DXGI_FORMAT_A8_UNORM, - DXGI_FORMAT_A8_UNORM, - DXGI_FORMAT_A8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_A8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<A8>, - ReadColor<A8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_B4G4R4A4_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_B4G4R4A4_UNORM, - GL_RGBA4, - DXGI_FORMAT_B4G4R4A4_UNORM, - DXGI_FORMAT_B4G4R4A4_UNORM, - DXGI_FORMAT_B4G4R4A4_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_B4G4R4A4_UNORM, - ANGLE_FORMAT_B4G4R4A4_UNORM, - GenerateMip<A4R4G4B4>, - ReadColor<A4R4G4B4, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_B5G5R5A1_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_B5G5R5A1_UNORM, - GL_RGB5_A1, - DXGI_FORMAT_B5G5R5A1_UNORM, - DXGI_FORMAT_B5G5R5A1_UNORM, - DXGI_FORMAT_B5G5R5A1_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_B5G5R5A1_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<A1R5G5B5>, - ReadColor<A1R5G5B5, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_B5G6R5_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_B5G6R5_UNORM, - GL_RGB565, - DXGI_FORMAT_B5G6R5_UNORM, - DXGI_FORMAT_B5G6R5_UNORM, - DXGI_FORMAT_B5G6R5_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_B5G6R5_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R5G6B5>, - ReadColor<R5G6B5, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_B8G8R8A8_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_B8G8R8A8_UNORM, - GL_BGRA8_EXT, - DXGI_FORMAT_B8G8R8A8_UNORM, - DXGI_FORMAT_B8G8R8A8_UNORM, - DXGI_FORMAT_B8G8R8A8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_B8G8R8A8_UNORM, - ANGLE_FORMAT_B8G8R8A8_UNORM, - GenerateMip<B8G8R8A8>, - ReadColor<B8G8R8A8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_BC1_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_BC1_UNORM, - GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, - DXGI_FORMAT_BC1_UNORM, - DXGI_FORMAT_BC1_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_BC1_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_BC2_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_BC2_UNORM, - GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, - DXGI_FORMAT_BC2_UNORM, - DXGI_FORMAT_BC2_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_BC2_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_BC3_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_BC3_UNORM, - GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, - DXGI_FORMAT_BC3_UNORM, - DXGI_FORMAT_BC3_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_BC3_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_D16_UNORM_FL10: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_D16_UNORM_FL10, - GL_DEPTH_COMPONENT16, - DXGI_FORMAT_R16_TYPELESS, - DXGI_FORMAT_R16_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_D16_UNORM, - DXGI_FORMAT_R16_UNORM, - ANGLE_FORMAT_R16G16B16A16_UNORM, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_D16_UNORM_FL9_3: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_D16_UNORM_FL9_3, - GL_DEPTH_COMPONENT16, - DXGI_FORMAT_D16_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_D16_UNORM, - DXGI_FORMAT_UNKNOWN, - ANGLE_FORMAT_R16G16B16A16_UNORM, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10, - GL_DEPTH24_STENCIL8_OES, - DXGI_FORMAT_R24G8_TYPELESS, - DXGI_FORMAT_R24_UNORM_X8_TYPELESS, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_D24_UNORM_S8_UINT, - DXGI_FORMAT_R24_UNORM_X8_TYPELESS, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3, - GL_DEPTH24_STENCIL8_OES, - DXGI_FORMAT_D24_UNORM_S8_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_D24_UNORM_S8_UINT, - DXGI_FORMAT_UNKNOWN, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_D32_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_D32_FLOAT, - GL_DEPTH_COMPONENT32F, - DXGI_FORMAT_R32_TYPELESS, - DXGI_FORMAT_R32_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_D32_FLOAT, - DXGI_FORMAT_R32_FLOAT, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_D32_FLOAT_S8X24_UINT_FL10: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_D32_FLOAT_S8X24_UINT_FL10, - GL_DEPTH32F_STENCIL8, - DXGI_FORMAT_R32G8X24_TYPELESS, - DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_D32_FLOAT_S8X24_UINT, - DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_NONE: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_NONE, - GL_NONE, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - ANGLE_FORMAT_NONE, - nullptr, - nullptr); - return formatInfo; - } - case ANGLE_FORMAT_R10G10B10A2_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R10G10B10A2_UINT, - GL_RGB10_A2UI, - DXGI_FORMAT_R10G10B10A2_UINT, - DXGI_FORMAT_R10G10B10A2_UINT, - DXGI_FORMAT_R10G10B10A2_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R10G10B10A2_UINT, - ANGLE_FORMAT_R16G16B16A16_UINT, - GenerateMip<R10G10B10A2>, - ReadColor<R10G10B10A2, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R10G10B10A2_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R10G10B10A2_UNORM, - GL_RGB10_A2, - DXGI_FORMAT_R10G10B10A2_UNORM, - DXGI_FORMAT_R10G10B10A2_UNORM, - DXGI_FORMAT_R10G10B10A2_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R10G10B10A2_UNORM, - ANGLE_FORMAT_R16G16B16A16_UNORM, - GenerateMip<R10G10B10A2>, - ReadColor<R10G10B10A2, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R11G11B10_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R11G11B10_FLOAT, - GL_R11F_G11F_B10F, - DXGI_FORMAT_R11G11B10_FLOAT, - DXGI_FORMAT_R11G11B10_FLOAT, - DXGI_FORMAT_R11G11B10_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R11G11B10_FLOAT, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - GenerateMip<R11G11B10F>, - ReadColor<R11G11B10F, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16B16A16_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16B16A16_FLOAT, - GL_RGBA16F, - DXGI_FORMAT_R16G16B16A16_FLOAT, - DXGI_FORMAT_R16G16B16A16_FLOAT, - DXGI_FORMAT_R16G16B16A16_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16B16A16_FLOAT, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - GenerateMip<R16G16B16A16F>, - ReadColor<R16G16B16A16F, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16B16A16_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16B16A16_SINT, - GL_RGBA16I, - DXGI_FORMAT_R16G16B16A16_SINT, - DXGI_FORMAT_R16G16B16A16_SINT, - DXGI_FORMAT_R16G16B16A16_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16B16A16_SINT, - ANGLE_FORMAT_R16G16B16A16_SINT, - GenerateMip<R16G16B16A16S>, - ReadColor<R16G16B16A16S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16B16A16_SNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16B16A16_SNORM, - GL_RGBA16_SNORM_EXT, - DXGI_FORMAT_R16G16B16A16_SNORM, - DXGI_FORMAT_R16G16B16A16_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16B16A16_SNORM, - ANGLE_FORMAT_R16G16B16A16_SNORM, - GenerateMip<R16G16B16A16S>, - ReadColor<R16G16B16A16S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16B16A16_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16B16A16_UINT, - GL_RGBA16UI, - DXGI_FORMAT_R16G16B16A16_UINT, - DXGI_FORMAT_R16G16B16A16_UINT, - DXGI_FORMAT_R16G16B16A16_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16B16A16_UINT, - ANGLE_FORMAT_R16G16B16A16_UINT, - GenerateMip<R16G16B16A16>, - ReadColor<R16G16B16A16, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16B16A16_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16B16A16_UNORM, - GL_NONE, - DXGI_FORMAT_R16G16B16A16_UNORM, - DXGI_FORMAT_R16G16B16A16_UNORM, - DXGI_FORMAT_R16G16B16A16_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16B16A16_UNORM, - ANGLE_FORMAT_R16G16B16A16_UNORM, - GenerateMip<R16G16B16A16>, - ReadColor<R16G16B16A16, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16_FLOAT, - GL_RG16F, - DXGI_FORMAT_R16G16_FLOAT, - DXGI_FORMAT_R16G16_FLOAT, - DXGI_FORMAT_R16G16_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16_FLOAT, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - GenerateMip<R16G16F>, - ReadColor<R16G16F, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16_SINT, - GL_RG16I, - DXGI_FORMAT_R16G16_SINT, - DXGI_FORMAT_R16G16_SINT, - DXGI_FORMAT_R16G16_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16_SINT, - ANGLE_FORMAT_R16G16B16A16_SINT, - GenerateMip<R16G16S>, - ReadColor<R16G16S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16_SNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16_SNORM, - GL_RG16_SNORM_EXT, - DXGI_FORMAT_R16G16_SNORM, - DXGI_FORMAT_R16G16_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16_SNORM, - ANGLE_FORMAT_R16G16B16A16_SNORM, - GenerateMip<R16G16S>, - ReadColor<R16G16S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16_UINT, - GL_RG16UI, - DXGI_FORMAT_R16G16_UINT, - DXGI_FORMAT_R16G16_UINT, - DXGI_FORMAT_R16G16_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16_UINT, - ANGLE_FORMAT_R16G16B16A16_UINT, - GenerateMip<R16G16>, - ReadColor<R16G16, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R16G16_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16G16_UNORM, - GL_NONE, - DXGI_FORMAT_R16G16_UNORM, - DXGI_FORMAT_R16G16_UNORM, - DXGI_FORMAT_R16G16_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16G16_UNORM, - ANGLE_FORMAT_R16G16B16A16_UNORM, - GenerateMip<R16G16>, - ReadColor<R16G16, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16_FLOAT, - GL_R16F, - DXGI_FORMAT_R16_FLOAT, - DXGI_FORMAT_R16_FLOAT, - DXGI_FORMAT_R16_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16_FLOAT, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - GenerateMip<R16F>, - ReadColor<R16F, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16_SINT, - GL_R16I, - DXGI_FORMAT_R16_SINT, - DXGI_FORMAT_R16_SINT, - DXGI_FORMAT_R16_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16_SINT, - ANGLE_FORMAT_R16G16B16A16_SINT, - GenerateMip<R16S>, - ReadColor<R16S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R16_SNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16_SNORM, - GL_R16_SNORM_EXT, - DXGI_FORMAT_R16_SNORM, - DXGI_FORMAT_R16_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16_SNORM, - ANGLE_FORMAT_R16G16B16A16_SNORM, - GenerateMip<R16S>, - ReadColor<R16S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R16_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16_UINT, - GL_R16UI, - DXGI_FORMAT_R16_UINT, - DXGI_FORMAT_R16_UINT, - DXGI_FORMAT_R16_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16_UINT, - ANGLE_FORMAT_R16G16B16A16_UINT, - GenerateMip<R16>, - ReadColor<R16, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R16_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R16_UNORM, - GL_NONE, - DXGI_FORMAT_R16_UNORM, - DXGI_FORMAT_R16_UNORM, - DXGI_FORMAT_R16_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R16_UNORM, - ANGLE_FORMAT_R16G16B16A16_UNORM, - GenerateMip<R16>, - ReadColor<R16, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R32G32B32A32_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32G32B32A32_FLOAT, - GL_RGBA32F, - DXGI_FORMAT_R32G32B32A32_FLOAT, - DXGI_FORMAT_R32G32B32A32_FLOAT, - DXGI_FORMAT_R32G32B32A32_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32G32B32A32_FLOAT, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - GenerateMip<R32G32B32A32F>, - ReadColor<R32G32B32A32F, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R32G32B32A32_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32G32B32A32_SINT, - GL_RGBA32I, - DXGI_FORMAT_R32G32B32A32_SINT, - DXGI_FORMAT_R32G32B32A32_SINT, - DXGI_FORMAT_R32G32B32A32_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32G32B32A32_SINT, - ANGLE_FORMAT_R32G32B32A32_SINT, - GenerateMip<R32G32B32A32S>, - ReadColor<R32G32B32A32S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R32G32B32A32_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32G32B32A32_UINT, - GL_RGBA32UI, - DXGI_FORMAT_R32G32B32A32_UINT, - DXGI_FORMAT_R32G32B32A32_UINT, - DXGI_FORMAT_R32G32B32A32_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32G32B32A32_UINT, - ANGLE_FORMAT_R32G32B32A32_UINT, - GenerateMip<R32G32B32A32>, - ReadColor<R32G32B32A32, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R32G32_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32G32_FLOAT, - GL_RG32F, - DXGI_FORMAT_R32G32_FLOAT, - DXGI_FORMAT_R32G32_FLOAT, - DXGI_FORMAT_R32G32_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32G32_FLOAT, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - GenerateMip<R32G32F>, - ReadColor<R32G32F, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R32G32_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32G32_SINT, - GL_RG32I, - DXGI_FORMAT_R32G32_SINT, - DXGI_FORMAT_R32G32_SINT, - DXGI_FORMAT_R32G32_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32G32_SINT, - ANGLE_FORMAT_R32G32B32A32_SINT, - GenerateMip<R32G32S>, - ReadColor<R32G32S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R32G32_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32G32_UINT, - GL_RG32UI, - DXGI_FORMAT_R32G32_UINT, - DXGI_FORMAT_R32G32_UINT, - DXGI_FORMAT_R32G32_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32G32_UINT, - ANGLE_FORMAT_R32G32B32A32_UINT, - GenerateMip<R32G32>, - ReadColor<R32G32, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R32_FLOAT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32_FLOAT, - GL_R32F, - DXGI_FORMAT_R32_FLOAT, - DXGI_FORMAT_R32_FLOAT, - DXGI_FORMAT_R32_FLOAT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32_FLOAT, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - GenerateMip<R32F>, - ReadColor<R32F, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R32_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32_SINT, - GL_R32I, - DXGI_FORMAT_R32_SINT, - DXGI_FORMAT_R32_SINT, - DXGI_FORMAT_R32_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32_SINT, - ANGLE_FORMAT_R32G32B32A32_SINT, - GenerateMip<R32S>, - ReadColor<R32S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R32_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R32_UINT, - GL_R32UI, - DXGI_FORMAT_R32_UINT, - DXGI_FORMAT_R32_UINT, - DXGI_FORMAT_R32_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R32_UINT, - ANGLE_FORMAT_R32G32B32A32_UINT, - GenerateMip<R32>, - ReadColor<R32, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8B8A8_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8B8A8_SINT, - GL_RGBA8I, - DXGI_FORMAT_R8G8B8A8_SINT, - DXGI_FORMAT_R8G8B8A8_SINT, - DXGI_FORMAT_R8G8B8A8_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8B8A8_SINT, - ANGLE_FORMAT_R8G8B8A8_SINT, - GenerateMip<R8G8B8A8S>, - ReadColor<R8G8B8A8S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8B8A8_SNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8B8A8_SNORM, - GL_RGBA8_SNORM, - DXGI_FORMAT_R8G8B8A8_SNORM, - DXGI_FORMAT_R8G8B8A8_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8B8A8_SNORM, - ANGLE_FORMAT_R8G8B8A8_SNORM, - GenerateMip<R8G8B8A8S>, - ReadColor<R8G8B8A8S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8B8A8_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8B8A8_UINT, - GL_RGBA8UI, - DXGI_FORMAT_R8G8B8A8_UINT, - DXGI_FORMAT_R8G8B8A8_UINT, - DXGI_FORMAT_R8G8B8A8_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8B8A8_UINT, - ANGLE_FORMAT_R8G8B8A8_UINT, - GenerateMip<R8G8B8A8>, - ReadColor<R8G8B8A8, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8B8A8_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8B8A8_UNORM, - GL_RGBA8, - DXGI_FORMAT_R8G8B8A8_UNORM, - DXGI_FORMAT_R8G8B8A8_UNORM, - DXGI_FORMAT_R8G8B8A8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8B8A8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R8G8B8A8>, - ReadColor<R8G8B8A8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE, - GL_RGBA8, - DXGI_FORMAT_R8G8B8A8_UNORM, - DXGI_FORMAT_R8G8B8A8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8B8A8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R8G8B8A8>, - ReadColor<R8G8B8A8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB, - GL_SRGB8_ALPHA8, - DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, - DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, - DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB, - GenerateMip<R8G8B8A8>, - ReadColor<R8G8B8A8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE, - GL_SRGB8_ALPHA8, - DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, - DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R8G8B8A8>, - ReadColor<R8G8B8A8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8_SINT, - GL_RG8I, - DXGI_FORMAT_R8G8_SINT, - DXGI_FORMAT_R8G8_SINT, - DXGI_FORMAT_R8G8_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8_SINT, - ANGLE_FORMAT_R8G8B8A8_SINT, - GenerateMip<R8G8S>, - ReadColor<R8G8S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8_SNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8_SNORM, - GL_RG8_SNORM, - DXGI_FORMAT_R8G8_SNORM, - DXGI_FORMAT_R8G8_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8_SNORM, - ANGLE_FORMAT_R8G8B8A8_SNORM, - GenerateMip<R8G8S>, - ReadColor<R8G8S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8_SNORM_NONRENDERABLE: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8_SNORM_NONRENDERABLE, - GL_RG8_SNORM, - DXGI_FORMAT_R8G8_SNORM, - DXGI_FORMAT_R8G8_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8_SNORM, - ANGLE_FORMAT_R8G8B8A8_SNORM, - GenerateMip<R8G8S>, - ReadColor<R8G8S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8_UINT, - GL_RG8UI, - DXGI_FORMAT_R8G8_UINT, - DXGI_FORMAT_R8G8_UINT, - DXGI_FORMAT_R8G8_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8_UINT, - ANGLE_FORMAT_R8G8B8A8_UINT, - GenerateMip<R8G8>, - ReadColor<R8G8, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8_UNORM, - GL_RG8, - DXGI_FORMAT_R8G8_UNORM, - DXGI_FORMAT_R8G8_UNORM, - DXGI_FORMAT_R8G8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R8G8>, - ReadColor<R8G8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8G8_UNORM_NONRENDERABLE: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8G8_UNORM_NONRENDERABLE, - GL_RG8, - DXGI_FORMAT_R8G8_UNORM, - DXGI_FORMAT_R8G8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8G8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R8G8>, - ReadColor<R8G8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8_SINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8_SINT, - GL_R8I, - DXGI_FORMAT_R8_SINT, - DXGI_FORMAT_R8_SINT, - DXGI_FORMAT_R8_SINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8_SINT, - ANGLE_FORMAT_R8G8B8A8_SINT, - GenerateMip<R8S>, - ReadColor<R8S, GLint>); - return formatInfo; - } - case ANGLE_FORMAT_R8_SNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8_SNORM, - GL_R8_SNORM, - DXGI_FORMAT_R8_SNORM, - DXGI_FORMAT_R8_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8_SNORM, - ANGLE_FORMAT_R8G8B8A8_SNORM, - GenerateMip<R8S>, - ReadColor<R8S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8_SNORM_NONRENDERABLE: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8_SNORM_NONRENDERABLE, - GL_R8_SNORM, - DXGI_FORMAT_R8_SNORM, - DXGI_FORMAT_R8_SNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8_SNORM, - ANGLE_FORMAT_R8G8B8A8_SNORM, - GenerateMip<R8S>, - ReadColor<R8S, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8_UINT, - GL_R8UI, - DXGI_FORMAT_R8_UINT, - DXGI_FORMAT_R8_UINT, - DXGI_FORMAT_R8_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8_UINT, - ANGLE_FORMAT_R8G8B8A8_UINT, - GenerateMip<R8>, - ReadColor<R8, GLuint>); - return formatInfo; - } - case ANGLE_FORMAT_R8_UNORM: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8_UNORM, - GL_R8, - DXGI_FORMAT_R8_UNORM, - DXGI_FORMAT_R8_UNORM, - DXGI_FORMAT_R8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R8>, - ReadColor<R8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R8_UNORM_NONRENDERABLE: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R8_UNORM_NONRENDERABLE, - GL_R8, - DXGI_FORMAT_R8_UNORM, - DXGI_FORMAT_R8_UNORM, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM, - GenerateMip<R8>, - ReadColor<R8, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_R9G9B9E5_SHAREDEXP: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_R9G9B9E5_SHAREDEXP, - GL_RGB9_E5, - DXGI_FORMAT_R9G9B9E5_SHAREDEXP, - DXGI_FORMAT_R9G9B9E5_SHAREDEXP, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_R9G9B9E5_SHAREDEXP, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - GenerateMip<R9G9B9E5>, - ReadColor<R9G9B9E5, GLfloat>); - return formatInfo; - } - case ANGLE_FORMAT_X24_TYPELESS_G8_UINT: - { - static const ANGLEFormatSet formatInfo(ANGLE_FORMAT_X24_TYPELESS_G8_UINT, - GL_DEPTH24_STENCIL8_OES, - DXGI_FORMAT_R24G8_TYPELESS, - DXGI_FORMAT_X24_TYPELESS_G8_UINT, - DXGI_FORMAT_UNKNOWN, - DXGI_FORMAT_D24_UNORM_S8_UINT, - DXGI_FORMAT_X24_TYPELESS_G8_UINT, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr, - nullptr); - return formatInfo; - } - - default: - break; - } - // clang-format on - - UNREACHABLE(); - static const ANGLEFormatSet defaultInfo; - return defaultInfo; -} - -const TextureFormat &GetTextureFormatInfo(GLenum internalFormat, - const Renderer11DeviceCaps &renderer11DeviceCaps) +// static +const Format &Format::Get(GLenum internalFormat, const Renderer11DeviceCaps &deviceCaps) { // clang-format off switch (internalFormat) { - case GL_ALPHA: - { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_A8_UNORM, - nullptr); - return textureFormat; - } - else if (OnlyFL9_3(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; - } - else - { - break; - } - } case GL_ALPHA16F_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_ALPHA16F_EXT, + angle::Format::ID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + GL_RGBA16F, + nullptr, + deviceCaps); + return info; } case GL_ALPHA32F_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_ALPHA32F_EXT, + angle::Format::ID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } case GL_ALPHA8_EXT: { - if (OnlyFL10Plus(renderer11DeviceCaps)) + if (OnlyFL10Plus(deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_ALPHA8_EXT, + angle::Format::ID::A8_UNORM, + DXGI_FORMAT_A8_UNORM, + DXGI_FORMAT_A8_UNORM, + DXGI_FORMAT_A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } - else if (OnlyFL9_3(renderer11DeviceCaps)) + else { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_ALPHA8_EXT, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; + } + } + case GL_BGR565_ANGLEX: + { + if (SupportsFormat(DXGI_FORMAT_B5G6R5_UNORM, deviceCaps)) + { + static const Format info(GL_BGR565_ANGLEX, + angle::Format::ID::B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G6R5_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_BGR565_ANGLEX, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } } case GL_BGR5_A1_ANGLEX: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_B8G8R8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_BGR5_A1_ANGLEX, + angle::Format::ID::B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + GL_BGRA8_EXT, + nullptr, + deviceCaps); + return info; } case GL_BGRA4_ANGLEX: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_B8G8R8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_BGRA4_ANGLEX, + angle::Format::ID::B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + GL_BGRA8_EXT, + nullptr, + deviceCaps); + return info; } case GL_BGRA8_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_B8G8R8A8_UNORM, - nullptr); - return textureFormat; - } - case GL_BGRA_EXT: - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_B8G8R8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_BGRA8_EXT, + angle::Format::ID::B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_B8G8R8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B8G8R8A8_UNORM, + GL_BGRA8_EXT, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_R11_EAC: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8_UNORM_NONRENDERABLE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_R11_EAC, + angle::Format::ID::R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_RG11_EAC: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8_UNORM_NONRENDERABLE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_RG11_EAC, + angle::Format::ID::R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_RGB8_ETC2: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_RGB8_ETC2, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_COMPRESSED_RGBA8_ETC2_EAC: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_RGBA8_ETC2_EAC, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x10_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_10x10_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x5_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_10x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x6_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_10x6_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_10x8_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_10x8_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_12x10_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_12x10_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_12x12_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_12x12_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_4x4_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_4x4_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_5x4_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_5x4_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_5x5_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_5x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_6x5_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_6x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_6x6_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_6x6_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_8x5_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_8x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_8x6_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_8x6_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_RGBA_ASTC_8x8_KHR: + { + static const Format info(GL_COMPRESSED_RGBA_ASTC_8x8_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_BC1_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, + angle::Format::ID::BC1_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_BC2_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_COMPRESSED_RGBA_S3TC_DXT3_ANGLE, + angle::Format::ID::BC2_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC2_UNORM, + DXGI_FORMAT_BC2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC2_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_BC3_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_COMPRESSED_RGBA_S3TC_DXT5_ANGLE, + angle::Format::ID::BC3_RGBA_UNORM_BLOCK, + DXGI_FORMAT_BC3_UNORM, + DXGI_FORMAT_BC3_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC3_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_RGB_S3TC_DXT1_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_BC1_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_COMPRESSED_RGB_S3TC_DXT1_EXT, + angle::Format::ID::BC1_RGB_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_SIGNED_R11_EAC: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8_SNORM_NONRENDERABLE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_SIGNED_R11_EAC, + angle::Format::ID::R8_SNORM, + DXGI_FORMAT_R8_SNORM, + DXGI_FORMAT_R8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_SNORM, + GL_RGBA8_SNORM, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_SIGNED_RG11_EAC: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8_SNORM_NONRENDERABLE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_SIGNED_RG11_EAC, + angle::Format::ID::R8G8_SNORM, + DXGI_FORMAT_R8G8_SNORM, + DXGI_FORMAT_R8G8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_SNORM, + GL_RGBA8_SNORM, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; + } + case GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR: + { + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC, + angle::Format::ID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + GL_SRGB8_ALPHA8, + nullptr, + deviceCaps); + return info; } case GL_COMPRESSED_SRGB8_ETC2: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_SRGB8_ETC2, + angle::Format::ID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + GL_SRGB8_ALPHA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2, + angle::Format::ID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + GL_SRGB8_ALPHA8, + nullptr, + deviceCaps); + return info; } case GL_DEPTH24_STENCIL8: { - if (OnlyFL10Plus(renderer11DeviceCaps)) + if (OnlyFL10Plus(deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10, - nullptr); - return textureFormat; - } - else if (OnlyFL9_3(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3, - nullptr); - return textureFormat; + static const Format info(GL_DEPTH24_STENCIL8, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_DEPTH24_STENCIL8, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } } case GL_DEPTH32F_STENCIL8: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D32_FLOAT_S8X24_UINT_FL10, - nullptr); - return textureFormat; - } - else if (OnlyFL9_3(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_NONE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_DEPTH32F_STENCIL8, + angle::Format::ID::D32_FLOAT_S8X24_UINT, + DXGI_FORMAT_R32G8X24_TYPELESS, + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D32_FLOAT_S8X24_UINT, + DXGI_FORMAT_R32_FLOAT_X8X24_TYPELESS, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } case GL_DEPTH_COMPONENT16: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D16_UNORM_FL10, - nullptr); - return textureFormat; - } - else if (OnlyFL9_3(renderer11DeviceCaps)) + if (OnlyFL10Plus(deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D16_UNORM_FL9_3, - nullptr); - return textureFormat; + static const Format info(GL_DEPTH_COMPONENT16, + angle::Format::ID::D16_UNORM, + DXGI_FORMAT_R16_TYPELESS, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D16_UNORM, + DXGI_FORMAT_R16_UNORM, + GL_RGBA16_EXT, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_DEPTH_COMPONENT16, + angle::Format::ID::D16_UNORM, + DXGI_FORMAT_D16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D16_UNORM, + DXGI_FORMAT_UNKNOWN, + GL_RGBA16_EXT, + nullptr, + deviceCaps); + return info; } } case GL_DEPTH_COMPONENT24: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10, - nullptr); - return textureFormat; - } - else if (OnlyFL9_3(renderer11DeviceCaps)) + if (OnlyFL10Plus(deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3, - nullptr); - return textureFormat; + static const Format info(GL_DEPTH_COMPONENT24, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_DEPTH_COMPONENT24, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } } case GL_DEPTH_COMPONENT32F: { - if (OnlyFL10Plus(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D32_FLOAT, - nullptr); - return textureFormat; - } - else if (OnlyFL9_3(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_NONE, - nullptr); - return textureFormat; - } - else - { - break; - } + static const Format info(GL_DEPTH_COMPONENT32F, + angle::Format::ID::D32_FLOAT, + DXGI_FORMAT_R32_TYPELESS, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } case GL_DEPTH_COMPONENT32_OES: { - if (OnlyFL10Plus(renderer11DeviceCaps)) + if (OnlyFL10Plus(deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10, - nullptr); - return textureFormat; + static const Format info(GL_DEPTH_COMPONENT32_OES, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_DEPTH_COMPONENT32_OES, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } } case GL_ETC1_RGB8_LOSSY_DECODE_ANGLE: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_BC1_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_ETC1_RGB8_LOSSY_DECODE_ANGLE, + angle::Format::ID::BC1_RGB_UNORM_BLOCK, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_BC1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_BC1_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_ETC1_RGB8_OES: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; - } - case GL_LUMINANCE: - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; + static const Format info(GL_ETC1_RGB8_OES, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_LUMINANCE16F_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>); - return textureFormat; + static const Format info(GL_LUMINANCE16F_EXT, + angle::Format::ID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + GL_RGBA16F, + Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>, + deviceCaps); + return info; } case GL_LUMINANCE32F_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>); - return textureFormat; + static const Format info(GL_LUMINANCE32F_EXT, + angle::Format::ID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + GL_RGBA32F, + Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>, + deviceCaps); + return info; } case GL_LUMINANCE8_ALPHA8_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_LUMINANCE8_ALPHA8_EXT, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_LUMINANCE8_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; - } - case GL_LUMINANCE_ALPHA: - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_LUMINANCE8_EXT, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_LUMINANCE_ALPHA16F_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_LUMINANCE_ALPHA16F_EXT, + angle::Format::ID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + GL_RGBA16F, + nullptr, + deviceCaps); + return info; } case GL_LUMINANCE_ALPHA32F_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_LUMINANCE_ALPHA32F_EXT, + angle::Format::ID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } case GL_NONE: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_NONE, - nullptr); - return textureFormat; + static const Format info(GL_NONE, + angle::Format::ID::NONE, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + GL_NONE, + nullptr, + deviceCaps); + return info; } case GL_R11F_G11F_B10F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R11G11B10_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_R11F_G11F_B10F, + angle::Format::ID::R11G11B10_FLOAT, + DXGI_FORMAT_R11G11B10_FLOAT, + DXGI_FORMAT_R11G11B10_FLOAT, + DXGI_FORMAT_R11G11B10_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R11G11B10_FLOAT, + GL_RGBA16F_EXT, + nullptr, + deviceCaps); + return info; } case GL_R16F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_R16F, + angle::Format::ID::R16_FLOAT, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_R16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_FLOAT, + GL_RGBA16F_EXT, + nullptr, + deviceCaps); + return info; } case GL_R16I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16_SINT, - nullptr); - return textureFormat; + static const Format info(GL_R16I, + angle::Format::ID::R16_SINT, + DXGI_FORMAT_R16_SINT, + DXGI_FORMAT_R16_SINT, + DXGI_FORMAT_R16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_SINT, + GL_RGBA16I, + nullptr, + deviceCaps); + return info; } case GL_R16UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16_UINT, - nullptr); - return textureFormat; + static const Format info(GL_R16UI, + angle::Format::ID::R16_UINT, + DXGI_FORMAT_R16_UINT, + DXGI_FORMAT_R16_UINT, + DXGI_FORMAT_R16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UINT, + GL_RGBA16I, + nullptr, + deviceCaps); + return info; } case GL_R16_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_R16_EXT, + angle::Format::ID::R16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_R16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_UNORM, + GL_RGBA16_EXT, + nullptr, + deviceCaps); + return info; } case GL_R16_SNORM_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16_SNORM, - nullptr); - return textureFormat; + static const Format info(GL_R16_SNORM_EXT, + angle::Format::ID::R16_SNORM, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_R16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16_SNORM, + GL_RGBA16_SNORM_EXT, + nullptr, + deviceCaps); + return info; } case GL_R32F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_R32F, + angle::Format::ID::R32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_R32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_FLOAT, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } case GL_R32I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32_SINT, - nullptr); - return textureFormat; + static const Format info(GL_R32I, + angle::Format::ID::R32_SINT, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_R32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_SINT, + GL_RGBA32I, + nullptr, + deviceCaps); + return info; } case GL_R32UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32_UINT, - nullptr); - return textureFormat; + static const Format info(GL_R32UI, + angle::Format::ID::R32_UINT, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_R32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32_UINT, + GL_RGBA32I, + nullptr, + deviceCaps); + return info; } case GL_R8: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_R8, + angle::Format::ID::R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_R8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_R8I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8_SINT, - nullptr); - return textureFormat; + static const Format info(GL_R8I, + angle::Format::ID::R8_SINT, + DXGI_FORMAT_R8_SINT, + DXGI_FORMAT_R8_SINT, + DXGI_FORMAT_R8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_SINT, + GL_RGBA8I, + nullptr, + deviceCaps); + return info; } case GL_R8UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8_UINT, - nullptr); - return textureFormat; + static const Format info(GL_R8UI, + angle::Format::ID::R8_UINT, + DXGI_FORMAT_R8_UINT, + DXGI_FORMAT_R8_UINT, + DXGI_FORMAT_R8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_UINT, + GL_RGBA8I, + nullptr, + deviceCaps); + return info; } case GL_R8_SNORM: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8_SNORM, - nullptr); - return textureFormat; + static const Format info(GL_R8_SNORM, + angle::Format::ID::R8_SNORM, + DXGI_FORMAT_R8_SNORM, + DXGI_FORMAT_R8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8_SNORM, + GL_RGBA8_SNORM, + nullptr, + deviceCaps); + return info; } case GL_RG16F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_RG16F, + angle::Format::ID::R16G16_FLOAT, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_R16G16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_FLOAT, + GL_RGBA16F_EXT, + nullptr, + deviceCaps); + return info; } case GL_RG16I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16_SINT, - nullptr); - return textureFormat; + static const Format info(GL_RG16I, + angle::Format::ID::R16G16_SINT, + DXGI_FORMAT_R16G16_SINT, + DXGI_FORMAT_R16G16_SINT, + DXGI_FORMAT_R16G16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_SINT, + GL_RGBA16I, + nullptr, + deviceCaps); + return info; } case GL_RG16UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16_UINT, - nullptr); - return textureFormat; + static const Format info(GL_RG16UI, + angle::Format::ID::R16G16_UINT, + DXGI_FORMAT_R16G16_UINT, + DXGI_FORMAT_R16G16_UINT, + DXGI_FORMAT_R16G16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UINT, + GL_RGBA16I, + nullptr, + deviceCaps); + return info; } case GL_RG16_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RG16_EXT, + angle::Format::ID::R16G16_UNORM, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_R16G16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_UNORM, + GL_RGBA16_EXT, + nullptr, + deviceCaps); + return info; } case GL_RG16_SNORM_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16_SNORM, - nullptr); - return textureFormat; + static const Format info(GL_RG16_SNORM_EXT, + angle::Format::ID::R16G16_SNORM, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_R16G16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16_SNORM, + GL_RGBA16_SNORM_EXT, + nullptr, + deviceCaps); + return info; } case GL_RG32F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_RG32F, + angle::Format::ID::R32G32_FLOAT, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_R32G32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_FLOAT, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } case GL_RG32I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32_SINT, - nullptr); - return textureFormat; + static const Format info(GL_RG32I, + angle::Format::ID::R32G32_SINT, + DXGI_FORMAT_R32G32_SINT, + DXGI_FORMAT_R32G32_SINT, + DXGI_FORMAT_R32G32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_SINT, + GL_RGBA32I, + nullptr, + deviceCaps); + return info; } case GL_RG32UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32_UINT, - nullptr); - return textureFormat; + static const Format info(GL_RG32UI, + angle::Format::ID::R32G32_UINT, + DXGI_FORMAT_R32G32_UINT, + DXGI_FORMAT_R32G32_UINT, + DXGI_FORMAT_R32G32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32_UINT, + GL_RGBA32I, + nullptr, + deviceCaps); + return info; } case GL_RG8: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RG8, + angle::Format::ID::R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_R8G8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_RG8I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8_SINT, - nullptr); - return textureFormat; + static const Format info(GL_RG8I, + angle::Format::ID::R8G8_SINT, + DXGI_FORMAT_R8G8_SINT, + DXGI_FORMAT_R8G8_SINT, + DXGI_FORMAT_R8G8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_SINT, + GL_RGBA8I, + nullptr, + deviceCaps); + return info; } case GL_RG8UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8_UINT, - nullptr); - return textureFormat; + static const Format info(GL_RG8UI, + angle::Format::ID::R8G8_UINT, + DXGI_FORMAT_R8G8_UINT, + DXGI_FORMAT_R8G8_UINT, + DXGI_FORMAT_R8G8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_UINT, + GL_RGBA8I, + nullptr, + deviceCaps); + return info; } case GL_RG8_SNORM: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8_SNORM, - nullptr); - return textureFormat; + static const Format info(GL_RG8_SNORM, + angle::Format::ID::R8G8_SNORM, + DXGI_FORMAT_R8G8_SNORM, + DXGI_FORMAT_R8G8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8_SNORM, + GL_RGBA8_SNORM, + nullptr, + deviceCaps); + return info; } case GL_RGB: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; + static const Format info(GL_RGB, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_RGB10_A2: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R10G10B10A2_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGB10_A2, + angle::Format::ID::R10G10B10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_R10G10B10A2_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UNORM, + GL_RGBA16_EXT, + nullptr, + deviceCaps); + return info; } case GL_RGB10_A2UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R10G10B10A2_UINT, - nullptr); - return textureFormat; + static const Format info(GL_RGB10_A2UI, + angle::Format::ID::R10G10B10A2_UINT, + DXGI_FORMAT_R10G10B10A2_UINT, + DXGI_FORMAT_R10G10B10A2_UINT, + DXGI_FORMAT_R10G10B10A2_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R10G10B10A2_UINT, + GL_RGBA16I, + nullptr, + deviceCaps); + return info; } case GL_RGB16F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>); - return textureFormat; + static const Format info(GL_RGB16F, + angle::Format::ID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + GL_RGBA16F, + Initialize4ComponentData<GLhalf, 0x0000, 0x0000, 0x0000, gl::Float16One>, + deviceCaps); + return info; } case GL_RGB16I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_SINT, - Initialize4ComponentData<GLshort, 0x0000, 0x0000, 0x0000, 0x0001>); - return textureFormat; + static const Format info(GL_RGB16I, + angle::Format::ID::R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SINT, + GL_RGBA16I, + Initialize4ComponentData<GLshort, 0x0000, 0x0000, 0x0000, 0x0001>, + deviceCaps); + return info; } case GL_RGB16UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_UINT, - Initialize4ComponentData<GLushort, 0x0000, 0x0000, 0x0000, 0x0001>); - return textureFormat; + static const Format info(GL_RGB16UI, + angle::Format::ID::R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UINT, + GL_RGBA16UI, + Initialize4ComponentData<GLushort, 0x0000, 0x0000, 0x0000, 0x0001>, + deviceCaps); + return info; } case GL_RGB16_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_UNORM, - Initialize4ComponentData<GLubyte, 0x0000, 0x0000, 0x0000, 0xFFFF>); - return textureFormat; + static const Format info(GL_RGB16_EXT, + angle::Format::ID::R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UNORM, + GL_RGBA16_EXT, + Initialize4ComponentData<GLubyte, 0x0000, 0x0000, 0x0000, 0xFFFF>, + deviceCaps); + return info; } case GL_RGB16_SNORM_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_SNORM, - Initialize4ComponentData<GLushort, 0x0000, 0x0000, 0x0000, 0x7FFF>); - return textureFormat; + static const Format info(GL_RGB16_SNORM_EXT, + angle::Format::ID::R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SNORM, + GL_RGBA16_SNORM_EXT, + Initialize4ComponentData<GLushort, 0x0000, 0x0000, 0x0000, 0x7FFF>, + deviceCaps); + return info; } case GL_RGB32F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>); - return textureFormat; + static const Format info(GL_RGB32F, + angle::Format::ID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + GL_RGBA32F, + Initialize4ComponentData<GLfloat, 0x00000000, 0x00000000, 0x00000000, gl::Float32One>, + deviceCaps); + return info; } case GL_RGB32I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_SINT, - Initialize4ComponentData<GLint, 0x00000000, 0x00000000, 0x00000000, 0x00000001>); - return textureFormat; + static const Format info(GL_RGB32I, + angle::Format::ID::R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_SINT, + GL_RGBA32I, + Initialize4ComponentData<GLint, 0x00000000, 0x00000000, 0x00000000, 0x00000001>, + deviceCaps); + return info; } case GL_RGB32UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_UINT, - Initialize4ComponentData<GLuint, 0x00000000, 0x00000000, 0x00000000, 0x00000001>); - return textureFormat; + static const Format info(GL_RGB32UI, + angle::Format::ID::R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_UINT, + GL_RGBA32UI, + Initialize4ComponentData<GLuint, 0x00000000, 0x00000000, 0x00000000, 0x00000001>, + deviceCaps); + return info; } case GL_RGB565: { - if (SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,false>(renderer11DeviceCaps)) + if (SupportsFormat(DXGI_FORMAT_B5G6R5_UNORM, deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; - } - else if (SupportsFormat<DXGI_FORMAT_B5G6R5_UNORM,true>(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_B5G6R5_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGB565, + angle::Format::ID::B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_B5G6R5_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G6R5_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_RGB565, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } } case GL_RGB5_A1: { - if (SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,false>(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; - } - else if (SupportsFormat<DXGI_FORMAT_B5G5R5A1_UNORM,true>(renderer11DeviceCaps)) + if (SupportsFormat(DXGI_FORMAT_B5G5R5A1_UNORM, deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_B5G5R5A1_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGB5_A1, + angle::Format::ID::B5G5R5A1_UNORM, + DXGI_FORMAT_B5G5R5A1_UNORM, + DXGI_FORMAT_B5G5R5A1_UNORM, + DXGI_FORMAT_B5G5R5A1_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B5G5R5A1_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_RGB5_A1, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } } case GL_RGB8: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; + static const Format info(GL_RGB8, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_RGB8I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_SINT, - Initialize4ComponentData<GLbyte, 0x00, 0x00, 0x00, 0x01>); - return textureFormat; + static const Format info(GL_RGB8I, + angle::Format::ID::R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SINT, + GL_RGBA8I, + Initialize4ComponentData<GLbyte, 0x00, 0x00, 0x00, 0x01>, + deviceCaps); + return info; } case GL_RGB8UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UINT, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0x01>); - return textureFormat; + static const Format info(GL_RGB8UI, + angle::Format::ID::R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UINT, + GL_RGBA8UI, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0x01>, + deviceCaps); + return info; } case GL_RGB8_SNORM: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_SNORM, - Initialize4ComponentData<GLbyte, 0x00, 0x00, 0x00, 0x7F>); - return textureFormat; + static const Format info(GL_RGB8_SNORM, + angle::Format::ID::R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SNORM, + GL_RGBA8_SNORM, + Initialize4ComponentData<GLbyte, 0x00, 0x00, 0x00, 0x7F>, + deviceCaps); + return info; } case GL_RGB9_E5: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R9G9B9E5_SHAREDEXP, - nullptr); - return textureFormat; + static const Format info(GL_RGB9_E5, + angle::Format::ID::R9G9B9E5_SHAREDEXP, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R9G9B9E5_SHAREDEXP, + GL_RGBA16F_EXT, + nullptr, + deviceCaps); + return info; } case GL_RGBA: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGBA, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_RGBA16F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA16F, + angle::Format::ID::R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_R16G16B16A16_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_FLOAT, + GL_RGBA16F, + nullptr, + deviceCaps); + return info; } case GL_RGBA16I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_SINT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA16I, + angle::Format::ID::R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_R16G16B16A16_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SINT, + GL_RGBA16I, + nullptr, + deviceCaps); + return info; } case GL_RGBA16UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_UINT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA16UI, + angle::Format::ID::R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_R16G16B16A16_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UINT, + GL_RGBA16UI, + nullptr, + deviceCaps); + return info; } case GL_RGBA16_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGBA16_EXT, + angle::Format::ID::R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_R16G16B16A16_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_UNORM, + GL_RGBA16_EXT, + nullptr, + deviceCaps); + return info; } case GL_RGBA16_SNORM_EXT: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R16G16B16A16_SNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGBA16_SNORM_EXT, + angle::Format::ID::R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_R16G16B16A16_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R16G16B16A16_SNORM, + GL_RGBA16_SNORM_EXT, + nullptr, + deviceCaps); + return info; } case GL_RGBA32F: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA32F, + angle::Format::ID::R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_R32G32B32A32_FLOAT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_FLOAT, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } case GL_RGBA32I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_SINT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA32I, + angle::Format::ID::R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_R32G32B32A32_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_SINT, + GL_RGBA32I, + nullptr, + deviceCaps); + return info; } case GL_RGBA32UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R32G32B32A32_UINT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA32UI, + angle::Format::ID::R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_R32G32B32A32_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R32G32B32A32_UINT, + GL_RGBA32UI, + nullptr, + deviceCaps); + return info; } case GL_RGBA4: { - if (SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,false>(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; - } - else if (SupportsFormat<DXGI_FORMAT_B4G4R4A4_UNORM,true>(renderer11DeviceCaps)) + if (SupportsFormat(DXGI_FORMAT_B4G4R4A4_UNORM, deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_B4G4R4A4_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGBA4, + angle::Format::ID::B4G4R4A4_UNORM, + DXGI_FORMAT_B4G4R4A4_UNORM, + DXGI_FORMAT_B4G4R4A4_UNORM, + DXGI_FORMAT_B4G4R4A4_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_B4G4R4A4_UNORM, + GL_RGBA4, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_RGBA4, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } } case GL_RGBA8: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGBA8, + angle::Format::ID::R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_R8G8B8A8_UNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM, + GL_RGBA8, + nullptr, + deviceCaps); + return info; } case GL_RGBA8I: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_SINT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA8I, + angle::Format::ID::R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_R8G8B8A8_SINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SINT, + GL_RGBA8I, + nullptr, + deviceCaps); + return info; } case GL_RGBA8UI: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UINT, - nullptr); - return textureFormat; + static const Format info(GL_RGBA8UI, + angle::Format::ID::R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_R8G8B8A8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UINT, + GL_RGBA8UI, + nullptr, + deviceCaps); + return info; } case GL_RGBA8_SNORM: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_SNORM, - nullptr); - return textureFormat; + static const Format info(GL_RGBA8_SNORM, + angle::Format::ID::R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_R8G8B8A8_SNORM, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_SNORM, + GL_RGBA8_SNORM, + nullptr, + deviceCaps); + return info; } case GL_SRGB8: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE, - Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>); - return textureFormat; + static const Format info(GL_SRGB8, + angle::Format::ID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + GL_SRGB8_ALPHA8, + Initialize4ComponentData<GLubyte, 0x00, 0x00, 0x00, 0xFF>, + deviceCaps); + return info; } case GL_SRGB8_ALPHA8: { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB, - nullptr); - return textureFormat; + static const Format info(GL_SRGB8_ALPHA8, + angle::Format::ID::R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_R8G8B8A8_UNORM_SRGB, + GL_SRGB8_ALPHA8, + nullptr, + deviceCaps); + return info; } case GL_STENCIL_INDEX8: { - if (OnlyFL10Plus(renderer11DeviceCaps)) + if (OnlyFL10Plus(deviceCaps)) { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_X24_TYPELESS_G8_UINT, - nullptr); - return textureFormat; - } - else if (OnlyFL9_3(renderer11DeviceCaps)) - { - static const TextureFormat textureFormat(internalFormat, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3, - nullptr); - return textureFormat; + static const Format info(GL_STENCIL_INDEX8, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_R24G8_TYPELESS, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_R24_UNORM_X8_TYPELESS, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } else { - break; + static const Format info(GL_STENCIL_INDEX8, + angle::Format::ID::D24_UNORM_S8_UINT, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_UNKNOWN, + DXGI_FORMAT_D24_UNORM_S8_UINT, + DXGI_FORMAT_UNKNOWN, + GL_RGBA32F, + nullptr, + deviceCaps); + return info; } } @@ -1988,9 +1945,10 @@ const TextureFormat &GetTextureFormatInfo(GLenum internalFormat, } // clang-format on - static const TextureFormat defaultInfo(GL_NONE, ANGLE_FORMAT_NONE, nullptr); + UNREACHABLE(); + static const Format defaultInfo; return defaultInfo; -} // GetTextureFormatInfo +} } // namespace d3d11 diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.h deleted file mode 100644 index 9259577f4fd..00000000000 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_autogen.h +++ /dev/null @@ -1,84 +0,0 @@ -// GENERATED FILE - DO NOT EDIT. -// Generated by gen_texture_format_table.py using data from texture_format_data.json -// -// Copyright 2016 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// - -namespace rx -{ - -namespace d3d11 -{ - -enum ANGLEFormat -{ - ANGLE_FORMAT_A8_UNORM, - ANGLE_FORMAT_B4G4R4A4_UNORM, - ANGLE_FORMAT_B5G5R5A1_UNORM, - ANGLE_FORMAT_B5G6R5_UNORM, - ANGLE_FORMAT_B8G8R8A8_UNORM, - ANGLE_FORMAT_BC1_UNORM, - ANGLE_FORMAT_BC2_UNORM, - ANGLE_FORMAT_BC3_UNORM, - ANGLE_FORMAT_D16_UNORM_FL10, - ANGLE_FORMAT_D16_UNORM_FL9_3, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL10, - ANGLE_FORMAT_D24_UNORM_S8_UINT_FL9_3, - ANGLE_FORMAT_D32_FLOAT, - ANGLE_FORMAT_D32_FLOAT_S8X24_UINT_FL10, - ANGLE_FORMAT_NONE, - ANGLE_FORMAT_R10G10B10A2_UINT, - ANGLE_FORMAT_R10G10B10A2_UNORM, - ANGLE_FORMAT_R11G11B10_FLOAT, - ANGLE_FORMAT_R16G16B16A16_FLOAT, - ANGLE_FORMAT_R16G16B16A16_SINT, - ANGLE_FORMAT_R16G16B16A16_SNORM, - ANGLE_FORMAT_R16G16B16A16_UINT, - ANGLE_FORMAT_R16G16B16A16_UNORM, - ANGLE_FORMAT_R16G16_FLOAT, - ANGLE_FORMAT_R16G16_SINT, - ANGLE_FORMAT_R16G16_SNORM, - ANGLE_FORMAT_R16G16_UINT, - ANGLE_FORMAT_R16G16_UNORM, - ANGLE_FORMAT_R16_FLOAT, - ANGLE_FORMAT_R16_SINT, - ANGLE_FORMAT_R16_SNORM, - ANGLE_FORMAT_R16_UINT, - ANGLE_FORMAT_R16_UNORM, - ANGLE_FORMAT_R32G32B32A32_FLOAT, - ANGLE_FORMAT_R32G32B32A32_SINT, - ANGLE_FORMAT_R32G32B32A32_UINT, - ANGLE_FORMAT_R32G32_FLOAT, - ANGLE_FORMAT_R32G32_SINT, - ANGLE_FORMAT_R32G32_UINT, - ANGLE_FORMAT_R32_FLOAT, - ANGLE_FORMAT_R32_SINT, - ANGLE_FORMAT_R32_UINT, - ANGLE_FORMAT_R8G8B8A8_SINT, - ANGLE_FORMAT_R8G8B8A8_SNORM, - ANGLE_FORMAT_R8G8B8A8_UINT, - ANGLE_FORMAT_R8G8B8A8_UNORM, - ANGLE_FORMAT_R8G8B8A8_UNORM_NONRENDERABLE, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB, - ANGLE_FORMAT_R8G8B8A8_UNORM_SRGB_NONRENDERABLE, - ANGLE_FORMAT_R8G8_SINT, - ANGLE_FORMAT_R8G8_SNORM, - ANGLE_FORMAT_R8G8_SNORM_NONRENDERABLE, - ANGLE_FORMAT_R8G8_UINT, - ANGLE_FORMAT_R8G8_UNORM, - ANGLE_FORMAT_R8G8_UNORM_NONRENDERABLE, - ANGLE_FORMAT_R8_SINT, - ANGLE_FORMAT_R8_SNORM, - ANGLE_FORMAT_R8_SNORM_NONRENDERABLE, - ANGLE_FORMAT_R8_UINT, - ANGLE_FORMAT_R8_UNORM, - ANGLE_FORMAT_R8_UNORM_NONRENDERABLE, - ANGLE_FORMAT_R9G9B9E5_SHAREDEXP, - ANGLE_FORMAT_X24_TYPELESS_G8_UINT -}; - -} // namespace d3d11 - -} // namespace rx diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h new file mode 100644 index 00000000000..bffea6af920 --- /dev/null +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/texture_format_table_utils.h @@ -0,0 +1,77 @@ +// +// Copyright 2016 The ANGLE Project Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. +// +// Helper routines for the D3D11 texture format table. + +#ifndef LIBANGLE_RENDERER_D3D_D3D11_TEXTURE_FORMAT_TABLE_UTILS_H_ +#define LIBANGLE_RENDERER_D3D_D3D11_TEXTURE_FORMAT_TABLE_UTILS_H_ + +#include "libANGLE/renderer/d3d/d3d11/Renderer11.h" + +namespace rx +{ + +namespace d3d11 +{ + +using FormatSupportFunction = bool (*)(const Renderer11DeviceCaps &); + +inline bool OnlyFL10Plus(const Renderer11DeviceCaps &deviceCaps) +{ + return (deviceCaps.featureLevel >= D3D_FEATURE_LEVEL_10_0); +} + +inline bool OnlyFL9_3(const Renderer11DeviceCaps &deviceCaps) +{ + return (deviceCaps.featureLevel == D3D_FEATURE_LEVEL_9_3); +} + +inline bool SupportsFormat(DXGI_FORMAT format, const Renderer11DeviceCaps &deviceCaps) +{ + // Must support texture, SRV and RTV support + UINT mustSupport = D3D11_FORMAT_SUPPORT_TEXTURE2D | D3D11_FORMAT_SUPPORT_TEXTURECUBE | + D3D11_FORMAT_SUPPORT_SHADER_SAMPLE | D3D11_FORMAT_SUPPORT_MIP | + D3D11_FORMAT_SUPPORT_RENDER_TARGET; + + if (d3d11_gl::GetMaximumClientVersion(deviceCaps.featureLevel) > 2) + { + mustSupport |= D3D11_FORMAT_SUPPORT_TEXTURE3D; + } + + bool fullSupport = false; + if (format == DXGI_FORMAT_B5G6R5_UNORM) + { + // All hardware that supports DXGI_FORMAT_B5G6R5_UNORM should support autogen mipmaps, but + // check anyway. + mustSupport |= D3D11_FORMAT_SUPPORT_MIP_AUTOGEN; + fullSupport = ((deviceCaps.B5G6R5support & mustSupport) == mustSupport); + } + else if (format == DXGI_FORMAT_B4G4R4A4_UNORM) + { + fullSupport = ((deviceCaps.B4G4R4A4support & mustSupport) == mustSupport); + } + else if (format == DXGI_FORMAT_B5G5R5A1_UNORM) + { + fullSupport = ((deviceCaps.B5G5R5A1support & mustSupport) == mustSupport); + } + else + { + UNREACHABLE(); + return false; + } + + // This means that ANGLE would like to use the entry in the map if the inputted DXGI format + // *IS* supported. + // e.g. the entry might map GL_RGB5_A1 to DXGI_FORMAT_B5G5R5A1, which should only be used if + // DXGI_FORMAT_B5G5R5A1 is supported. + // In this case, we should only return 'true' if the format *IS* supported. + return fullSupport; +} + +} // namespace d3d11 + +} // namespace rx + +#endif // LIBANGLE_RENDERER_D3D_D3D11_TEXTURE_FORMAT_TABLE_UTILS_H_ diff --git a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp index fa00d60f68f..0211e6887a5 100644 --- a/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp +++ b/chromium/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp @@ -167,17 +167,6 @@ HRESULT CoreWindowNativeWindow::createSwapChain(ID3D11Device *device, HRESULT result = factory->CreateSwapChainForCoreWindow(device, mCoreWindow.Get(), &swapChainDesc, nullptr, newSwapChain.ReleaseAndGetAddressOf()); if (SUCCEEDED(result)) { - -#if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) - // Test if swapchain supports resize. On Windows Phone devices, this will return DXGI_ERROR_UNSUPPORTED. On - // other devices DXGI_ERROR_INVALID_CALL should be returned because the combination of flags passed - // (DXGI_SWAP_CHAIN_FLAG_NONPREROTATED | DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE) are invalid flag combinations. - if (newSwapChain->ResizeBuffers(swapChainDesc.BufferCount, swapChainDesc.Width, swapChainDesc.Height, swapChainDesc.Format, DXGI_SWAP_CHAIN_FLAG_NONPREROTATED | DXGI_SWAP_CHAIN_FLAG_GDI_COMPATIBLE) == DXGI_ERROR_UNSUPPORTED) - { - mSupportsSwapChainResize = false; - } -#endif // (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) - result = newSwapChain.CopyTo(swapChain); } |