summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp')
-rw-r--r--src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp756
1 files changed, 467 insertions, 289 deletions
diff --git a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
index 42c336c8cf..dcfd06484d 100644
--- a/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
+++ b/src/3rdparty/angle/src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
@@ -11,9 +11,9 @@
#include <EGL/eglext.h>
#include "libANGLE/features.h"
-#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
-#include "libANGLE/renderer/d3d/d3d11/NativeWindow.h"
+#include "libANGLE/renderer/d3d/d3d11/NativeWindow11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
+#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
#include "third_party/trace_event/trace_event.h"
@@ -21,6 +21,7 @@
// Precompiled shaders
#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthrough2d11vs.h"
#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2d11ps.h"
+#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/passthroughrgba2dms11ps.h"
#ifdef ANGLE_ENABLE_KEYEDMUTEX
#define ANGLE_RESOURCE_SHARE_TYPE D3D11_RESOURCE_MISC_SHARED_KEYEDMUTEX
@@ -33,22 +34,30 @@ namespace rx
namespace
{
-bool NeedsOffscreenTexture(Renderer11 *renderer, NativeWindow nativeWindow, EGLint orientation)
+// To avoid overflow in QPC to Microseconds calculations, since we multiply
+// by kMicrosecondsPerSecond, then the QPC value should not exceed
+// (2^63 - 1) / 1E6. If it exceeds that threshold, we divide then multiply.
+static constexpr int64_t kQPCOverflowThreshold = 0x8637BD05AF7;
+static constexpr int64_t kMicrosecondsPerSecond = 1000000;
+
+bool NeedsOffscreenTexture(Renderer11 *renderer, NativeWindow11 *nativeWindow, EGLint orientation)
{
// We don't need an offscreen texture if either orientation = INVERT_Y,
// or present path fast is enabled and we're not rendering onto an offscreen surface.
return orientation != EGL_SURFACE_ORIENTATION_INVERT_Y_ANGLE &&
- !(renderer->presentPathFastEnabled() && nativeWindow.getNativeWindow());
+ !(renderer->presentPathFastEnabled() && nativeWindow->getNativeWindow());
}
} // anonymous namespace
SwapChain11::SwapChain11(Renderer11 *renderer,
- NativeWindow nativeWindow,
+ NativeWindow11 *nativeWindow,
HANDLE shareHandle,
+ IUnknown *d3dTexture,
GLenum backBufferFormat,
GLenum depthBufferFormat,
- EGLint orientation)
- : SwapChainD3D(nativeWindow, shareHandle, backBufferFormat, depthBufferFormat),
+ EGLint orientation,
+ EGLint samples)
+ : SwapChainD3D(shareHandle, d3dTexture, backBufferFormat, depthBufferFormat),
mRenderer(renderer),
mWidth(-1),
mHeight(-1),
@@ -56,33 +65,42 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
mAppCreatedShareHandle(mShareHandle != nullptr),
mSwapInterval(0),
mPassThroughResourcesInit(false),
+ mNativeWindow(nativeWindow),
mFirstSwap(true),
mSwapChain(nullptr),
-#if defined(ANGLE_ENABLE_D3D11_1)
mSwapChain1(nullptr),
-#endif
mKeyedMutex(nullptr),
- mBackBufferTexture(nullptr),
- mBackBufferRTView(nullptr),
- mBackBufferSRView(nullptr),
+ mBackBufferTexture(),
+ mBackBufferRTView(),
+ mBackBufferSRView(),
mNeedsOffscreenTexture(NeedsOffscreenTexture(renderer, nativeWindow, orientation)),
- mOffscreenTexture(nullptr),
- mOffscreenRTView(nullptr),
- mOffscreenSRView(nullptr),
- mDepthStencilTexture(nullptr),
- mDepthStencilDSView(nullptr),
- mDepthStencilSRView(nullptr),
- mQuadVB(nullptr),
- mPassThroughSampler(nullptr),
- mPassThroughIL(nullptr),
- mPassThroughVS(nullptr),
- mPassThroughPS(nullptr),
- mPassThroughRS(nullptr),
+ mOffscreenTexture(),
+ mOffscreenRTView(),
+ mOffscreenSRView(),
+ mNeedsOffscreenTextureCopy(false),
+ mOffscreenTextureCopyForSRV(),
+ mDepthStencilTexture(),
+ mDepthStencilDSView(),
+ mDepthStencilSRView(),
+ mQuadVB(),
+ mPassThroughSampler(),
+ mPassThroughIL(),
+ mPassThroughVS(),
+ mPassThroughPS(),
+ mPassThroughRS(),
mColorRenderTarget(this, renderer, false),
- mDepthStencilRenderTarget(this, renderer, true)
+ mDepthStencilRenderTarget(this, renderer, true),
+ mEGLSamples(samples)
{
// Sanity check that if present path fast is active then we're using the default orientation
ASSERT(!mRenderer->presentPathFastEnabled() || orientation == 0);
+
+ // Get the performance counter
+ LARGE_INTEGER counterFreqency = {};
+ BOOL success = QueryPerformanceFrequency(&counterFreqency);
+ ASSERT(success);
+
+ mQPCFrequency = counterFreqency.QuadPart;
}
SwapChain11::~SwapChain11()
@@ -92,52 +110,56 @@ SwapChain11::~SwapChain11()
void SwapChain11::release()
{
-#if defined(ANGLE_ENABLE_D3D11_1)
+ // TODO(jmadill): Should probably signal that the RenderTarget is dirty.
+
SafeRelease(mSwapChain1);
-#endif
SafeRelease(mSwapChain);
SafeRelease(mKeyedMutex);
- SafeRelease(mBackBufferTexture);
- SafeRelease(mBackBufferRTView);
- SafeRelease(mBackBufferSRView);
- SafeRelease(mOffscreenTexture);
- SafeRelease(mOffscreenRTView);
- SafeRelease(mOffscreenSRView);
- SafeRelease(mDepthStencilTexture);
- SafeRelease(mDepthStencilDSView);
- SafeRelease(mDepthStencilSRView);
- SafeRelease(mQuadVB);
- SafeRelease(mPassThroughSampler);
- SafeRelease(mPassThroughIL);
- SafeRelease(mPassThroughVS);
- SafeRelease(mPassThroughPS);
- SafeRelease(mPassThroughRS);
+ mBackBufferTexture.reset();
+ mBackBufferRTView.reset();
+ mBackBufferSRView.reset();
+ mOffscreenTexture.reset();
+ mOffscreenRTView.reset();
+ mOffscreenSRView.reset();
+ mDepthStencilTexture.reset();
+ mDepthStencilDSView.reset();
+ mDepthStencilSRView.reset();
+ mQuadVB.reset();
+ mPassThroughSampler.reset();
+ mPassThroughIL.reset();
+ mPassThroughVS.reset();
+ mPassThroughPS.reset();
+ mPassThroughRS.reset();
if (!mAppCreatedShareHandle)
{
- mShareHandle = NULL;
+ mShareHandle = nullptr;
}
}
void SwapChain11::releaseOffscreenColorBuffer()
{
- SafeRelease(mOffscreenTexture);
- SafeRelease(mOffscreenRTView);
- SafeRelease(mOffscreenSRView);
+ mOffscreenTexture.reset();
+ mOffscreenRTView.reset();
+ mOffscreenSRView.reset();
+ mNeedsOffscreenTextureCopy = false;
+ mOffscreenTextureCopyForSRV.reset();
}
void SwapChain11::releaseOffscreenDepthBuffer()
{
- SafeRelease(mDepthStencilTexture);
- SafeRelease(mDepthStencilDSView);
- SafeRelease(mDepthStencilSRView);
+ mDepthStencilTexture.reset();
+ mDepthStencilDSView.reset();
+ mDepthStencilSRView.reset();
}
-EGLint SwapChain11::resetOffscreenBuffers(int backbufferWidth, int backbufferHeight)
+EGLint SwapChain11::resetOffscreenBuffers(const gl::Context *context,
+ int backbufferWidth,
+ int backbufferHeight)
{
if (mNeedsOffscreenTexture)
{
- EGLint result = resetOffscreenColorBuffer(backbufferWidth, backbufferHeight);
+ EGLint result = resetOffscreenColorBuffer(context, backbufferWidth, backbufferHeight);
if (result != EGL_SUCCESS)
{
return result;
@@ -156,117 +178,106 @@ EGLint SwapChain11::resetOffscreenBuffers(int backbufferWidth, int backbufferHei
return EGL_SUCCESS;
}
-EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbufferHeight)
+EGLint SwapChain11::resetOffscreenColorBuffer(const gl::Context *context,
+ int backbufferWidth,
+ int backbufferHeight)
{
ASSERT(mNeedsOffscreenTexture);
TRACE_EVENT0("gpu.angle", "SwapChain11::resetOffscreenTexture");
ID3D11Device *device = mRenderer->getDevice();
- ASSERT(device != NULL);
+ ASSERT(device != nullptr);
// D3D11 does not allow zero size textures
ASSERT(backbufferWidth >= 1);
ASSERT(backbufferHeight >= 1);
// Preserve the render target content
- ID3D11Texture2D *previousOffscreenTexture = mOffscreenTexture;
- if (previousOffscreenTexture)
- {
- previousOffscreenTexture->AddRef();
- }
+ TextureHelper11 previousOffscreenTexture(std::move(mOffscreenTexture));
const int previousWidth = mWidth;
const int previousHeight = mHeight;
releaseOffscreenColorBuffer();
- const d3d11::TextureFormat &backbufferFormatInfo = d3d11::GetTextureFormatInfo(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps());
+ const d3d11::Format &backbufferFormatInfo =
+ d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps());
+ D3D11_TEXTURE2D_DESC offscreenTextureDesc = {0};
- // If the app passed in a share handle, open the resource
- // See EGL_ANGLE_d3d_share_handle_client_buffer
- if (mAppCreatedShareHandle)
+ // If the app passed in a share handle or D3D texture, open the resource
+ // See EGL_ANGLE_d3d_share_handle_client_buffer and EGL_ANGLE_d3d_texture_client_buffer
+ if (mAppCreatedShareHandle || mD3DTexture != nullptr)
{
- ID3D11Resource *tempResource11;
- HRESULT result = device->OpenSharedResource(mShareHandle, __uuidof(ID3D11Resource), (void**)&tempResource11);
+ if (mAppCreatedShareHandle)
+ {
+ ID3D11Resource *tempResource11;
+ HRESULT result = device->OpenSharedResource(mShareHandle, __uuidof(ID3D11Resource),
+ (void **)&tempResource11);
+ ASSERT(SUCCEEDED(result));
- if (FAILED(result))
+ mOffscreenTexture.set(d3d11::DynamicCastComObject<ID3D11Texture2D>(tempResource11),
+ backbufferFormatInfo);
+ SafeRelease(tempResource11);
+ }
+ else if (mD3DTexture != nullptr)
{
- ERR("Failed to open the swap chain pbuffer share handle: %08lX", result);
- release();
- return EGL_BAD_PARAMETER;
+ mOffscreenTexture.set(d3d11::DynamicCastComObject<ID3D11Texture2D>(mD3DTexture),
+ backbufferFormatInfo);
}
-
- result = tempResource11->QueryInterface(__uuidof(ID3D11Texture2D), (void**)&mOffscreenTexture);
- SafeRelease(tempResource11);
-
- if (FAILED(result))
+ else
{
- ERR("Failed to query texture2d interface in pbuffer share handle: %08lX", result);
- release();
- return EGL_BAD_PARAMETER;
+ UNREACHABLE();
}
+ ASSERT(mOffscreenTexture.valid());
+ mOffscreenTexture.getDesc(&offscreenTextureDesc);
- // Validate offscreen texture parameters
- D3D11_TEXTURE2D_DESC offscreenTextureDesc = {0};
- mOffscreenTexture->GetDesc(&offscreenTextureDesc);
-
- if (offscreenTextureDesc.Width != (UINT)backbufferWidth ||
- offscreenTextureDesc.Height != (UINT)backbufferHeight ||
- offscreenTextureDesc.Format != backbufferFormatInfo.texFormat ||
- offscreenTextureDesc.MipLevels != 1 ||
- offscreenTextureDesc.ArraySize != 1)
+ // Fail if the offscreen texture is not renderable.
+ if ((offscreenTextureDesc.BindFlags & D3D11_BIND_RENDER_TARGET) == 0)
{
- ERR("Invalid texture parameters in the shared offscreen texture pbuffer");
+ ERR() << "Could not use provided offscreen texture, texture not renderable.";
release();
- return EGL_BAD_PARAMETER;
+ return EGL_BAD_SURFACE;
}
}
else
{
- const bool useSharedResource = !mNativeWindow.getNativeWindow() && mRenderer->getShareHandleSupport();
+ const bool useSharedResource =
+ !mNativeWindow->getNativeWindow() && mRenderer->getShareHandleSupport();
- D3D11_TEXTURE2D_DESC offscreenTextureDesc = {0};
offscreenTextureDesc.Width = backbufferWidth;
offscreenTextureDesc.Height = backbufferHeight;
- offscreenTextureDesc.Format = backbufferFormatInfo.texFormat;
+ offscreenTextureDesc.Format = backbufferFormatInfo.texFormat;
offscreenTextureDesc.MipLevels = 1;
offscreenTextureDesc.ArraySize = 1;
- offscreenTextureDesc.SampleDesc.Count = 1;
+ offscreenTextureDesc.SampleDesc.Count = getD3DSamples();
offscreenTextureDesc.SampleDesc.Quality = 0;
offscreenTextureDesc.Usage = D3D11_USAGE_DEFAULT;
offscreenTextureDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
offscreenTextureDesc.CPUAccessFlags = 0;
offscreenTextureDesc.MiscFlags = useSharedResource ? ANGLE_RESOURCE_SHARE_TYPE : 0;
- HRESULT result = device->CreateTexture2D(&offscreenTextureDesc, NULL, &mOffscreenTexture);
-
- if (FAILED(result))
+ gl::Error err = mRenderer->allocateTexture(offscreenTextureDesc, backbufferFormatInfo,
+ &mOffscreenTexture);
+ if (err.isError())
{
- ERR("Could not create offscreen texture: %08lX", result);
+ ERR() << "Could not create offscreen texture, " << err;
release();
-
- if (d3d11::isDeviceLostError(result))
- {
- return EGL_CONTEXT_LOST;
- }
- else
- {
- return EGL_BAD_ALLOC;
- }
+ return EGL_BAD_ALLOC;
}
- d3d11::SetDebugName(mOffscreenTexture, "Offscreen back buffer texture");
+ mOffscreenTexture.setDebugName("Offscreen back buffer texture");
// EGL_ANGLE_surface_d3d_texture_2d_share_handle requires that we store a share handle for the client
if (useSharedResource)
{
- IDXGIResource *offscreenTextureResource = NULL;
- result = mOffscreenTexture->QueryInterface(__uuidof(IDXGIResource), (void**)&offscreenTextureResource);
+ IDXGIResource *offscreenTextureResource = nullptr;
+ HRESULT result = mOffscreenTexture.get()->QueryInterface(
+ __uuidof(IDXGIResource), (void **)&offscreenTextureResource);
// Fall back to no share handle on failure
if (FAILED(result))
{
- ERR("Could not query offscreen texture resource: %08lX", result);
+ ERR() << "Could not query offscreen texture resource, " << gl::FmtHR(result);
}
else
{
@@ -275,36 +286,49 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
if (FAILED(result))
{
- mShareHandle = NULL;
- ERR("Could not get offscreen texture shared handle: %08lX", result);
+ mShareHandle = nullptr;
+ ERR() << "Could not get offscreen texture shared handle, " << gl::FmtHR(result);
}
}
}
}
// This may return null if the original texture was created without a keyed mutex.
- mKeyedMutex = d3d11::DynamicCastComObject<IDXGIKeyedMutex>(mOffscreenTexture);
+ mKeyedMutex = d3d11::DynamicCastComObject<IDXGIKeyedMutex>(mOffscreenTexture.get());
D3D11_RENDER_TARGET_VIEW_DESC offscreenRTVDesc;
- offscreenRTVDesc.Format = backbufferFormatInfo.rtvFormat;
- offscreenRTVDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
+ offscreenRTVDesc.Format = backbufferFormatInfo.rtvFormat;
+ offscreenRTVDesc.ViewDimension =
+ (mEGLSamples <= 1) ? D3D11_RTV_DIMENSION_TEXTURE2D : D3D11_RTV_DIMENSION_TEXTURE2DMS;
offscreenRTVDesc.Texture2D.MipSlice = 0;
- HRESULT result = device->CreateRenderTargetView(mOffscreenTexture, &offscreenRTVDesc, &mOffscreenRTView);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mOffscreenRTView, "Offscreen back buffer render target");
+ gl::Error err =
+ mRenderer->allocateResource(offscreenRTVDesc, mOffscreenTexture.get(), &mOffscreenRTView);
+ ASSERT(!err.isError());
+ mOffscreenRTView.setDebugName("Offscreen back buffer render target");
D3D11_SHADER_RESOURCE_VIEW_DESC offscreenSRVDesc;
- offscreenSRVDesc.Format = backbufferFormatInfo.srvFormat;
- offscreenSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+ offscreenSRVDesc.Format = backbufferFormatInfo.srvFormat;
+ offscreenSRVDesc.ViewDimension =
+ (mEGLSamples <= 1) ? D3D11_SRV_DIMENSION_TEXTURE2D : D3D11_SRV_DIMENSION_TEXTURE2DMS;
offscreenSRVDesc.Texture2D.MostDetailedMip = 0;
offscreenSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1);
- result = device->CreateShaderResourceView(mOffscreenTexture, &offscreenSRVDesc, &mOffscreenSRView);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mOffscreenSRView, "Offscreen back buffer shader resource");
+ if (offscreenTextureDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE)
+ {
+ err = mRenderer->allocateResource(offscreenSRVDesc, mOffscreenTexture.get(),
+ &mOffscreenSRView);
+ ASSERT(!err.isError());
+ mOffscreenSRView.setDebugName("Offscreen back buffer shader resource");
+ }
+ else
+ {
+ // Special case for external textures that cannot support sampling. Since internally we
+ // assume our SwapChain is always readable, we make a copy texture that is compatible.
+ mNeedsOffscreenTextureCopy = true;
+ }
- if (previousOffscreenTexture != nullptr)
+ if (previousOffscreenTexture.valid())
{
D3D11_BOX sourceBox = {0};
sourceBox.left = 0;
@@ -316,14 +340,12 @@ EGLint SwapChain11::resetOffscreenColorBuffer(int backbufferWidth, int backbuffe
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
const int yoffset = std::max(backbufferHeight - previousHeight, 0);
- deviceContext->CopySubresourceRegion(mOffscreenTexture, 0, 0, yoffset, 0,
- previousOffscreenTexture, 0, &sourceBox);
-
- SafeRelease(previousOffscreenTexture);
+ deviceContext->CopySubresourceRegion(mOffscreenTexture.get(), 0, 0, yoffset, 0,
+ previousOffscreenTexture.get(), 0, &sourceBox);
if (mSwapChain)
{
- swapRect(0, 0, backbufferWidth, backbufferHeight);
+ swapRect(context, 0, 0, backbufferWidth, backbufferHeight);
}
}
@@ -336,21 +358,38 @@ 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.texFormat;
+ depthStencilTextureDesc.Format = depthBufferFormatInfo.texFormat;
depthStencilTextureDesc.MipLevels = 1;
depthStencilTextureDesc.ArraySize = 1;
- depthStencilTextureDesc.SampleDesc.Count = 1;
- depthStencilTextureDesc.SampleDesc.Quality = 0;
+ depthStencilTextureDesc.SampleDesc.Count = getD3DSamples();
depthStencilTextureDesc.Usage = D3D11_USAGE_DEFAULT;
depthStencilTextureDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
- if (depthBufferFormatInfo.srvFormat != DXGI_FORMAT_UNKNOWN)
+ // If there is a multisampled offscreen color texture, the offscreen depth-stencil texture
+ // must also have the same quality value.
+ if (mOffscreenTexture.valid() && getD3DSamples() > 1)
+ {
+ D3D11_TEXTURE2D_DESC offscreenTextureDesc = {0};
+ mOffscreenTexture.getDesc(&offscreenTextureDesc);
+ depthStencilTextureDesc.SampleDesc.Quality = offscreenTextureDesc.SampleDesc.Quality;
+ }
+ else
+ {
+ depthStencilTextureDesc.SampleDesc.Quality = 0;
+ }
+
+ // Only create an SRV if it is supported
+ bool depthStencilSRV =
+ depthBufferFormatInfo.srvFormat != DXGI_FORMAT_UNKNOWN &&
+ (mRenderer->getRenderer11DeviceCaps().supportsMultisampledDepthStencilSRVs ||
+ depthStencilTextureDesc.SampleDesc.Count <= 1);
+ if (depthStencilSRV)
{
depthStencilTextureDesc.BindFlags |= D3D11_BIND_SHADER_RESOURCE;
}
@@ -358,58 +397,56 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
depthStencilTextureDesc.CPUAccessFlags = 0;
depthStencilTextureDesc.MiscFlags = 0;
- ID3D11Device *device = mRenderer->getDevice();
- HRESULT result =
- device->CreateTexture2D(&depthStencilTextureDesc, NULL, &mDepthStencilTexture);
- if (FAILED(result))
+ gl::Error err = mRenderer->allocateTexture(depthStencilTextureDesc, depthBufferFormatInfo,
+ &mDepthStencilTexture);
+ if (err.isError())
{
- ERR("Could not create depthstencil surface for new swap chain: 0x%08X", result);
+ ERR() << "Could not create depthstencil surface for new swap chain, " << err;
release();
-
- if (d3d11::isDeviceLostError(result))
- {
- return EGL_CONTEXT_LOST;
- }
- else
- {
- return EGL_BAD_ALLOC;
- }
+ return EGL_BAD_ALLOC;
}
- d3d11::SetDebugName(mDepthStencilTexture, "Offscreen depth stencil texture");
+ mDepthStencilTexture.setDebugName("Offscreen depth stencil texture");
D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilDesc;
- depthStencilDesc.Format = depthBufferFormatInfo.dsvFormat;
- depthStencilDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
+ depthStencilDesc.Format = depthBufferFormatInfo.dsvFormat;
+ depthStencilDesc.ViewDimension =
+ (mEGLSamples <= 1) ? D3D11_DSV_DIMENSION_TEXTURE2D : D3D11_DSV_DIMENSION_TEXTURE2DMS;
depthStencilDesc.Flags = 0;
depthStencilDesc.Texture2D.MipSlice = 0;
- result = device->CreateDepthStencilView(mDepthStencilTexture, &depthStencilDesc, &mDepthStencilDSView);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mDepthStencilDSView, "Offscreen depth stencil view");
+ err = mRenderer->allocateResource(depthStencilDesc, mDepthStencilTexture.get(),
+ &mDepthStencilDSView);
+ ASSERT(!err.isError());
+ mDepthStencilDSView.setDebugName("Offscreen depth stencil view");
- if (depthBufferFormatInfo.srvFormat != DXGI_FORMAT_UNKNOWN)
+ if (depthStencilSRV)
{
D3D11_SHADER_RESOURCE_VIEW_DESC depthStencilSRVDesc;
- depthStencilSRVDesc.Format = depthBufferFormatInfo.srvFormat;
- depthStencilSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
+ depthStencilSRVDesc.Format = depthBufferFormatInfo.srvFormat;
+ depthStencilSRVDesc.ViewDimension = (mEGLSamples <= 1)
+ ? D3D11_SRV_DIMENSION_TEXTURE2D
+ : D3D11_SRV_DIMENSION_TEXTURE2DMS;
depthStencilSRVDesc.Texture2D.MostDetailedMip = 0;
depthStencilSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1);
- result = device->CreateShaderResourceView(mDepthStencilTexture, &depthStencilSRVDesc, &mDepthStencilSRView);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mDepthStencilSRView, "Offscreen depth stencil shader resource");
+ err = mRenderer->allocateResource(depthStencilSRVDesc, mDepthStencilTexture.get(),
+ &mDepthStencilSRView);
+ ASSERT(!err.isError());
+ mDepthStencilSRView.setDebugName("Offscreen depth stencil shader resource");
}
}
return EGL_SUCCESS;
}
-EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
+EGLint SwapChain11::resize(const gl::Context *context,
+ EGLint backbufferWidth,
+ EGLint backbufferHeight)
{
TRACE_EVENT0("gpu.angle", "SwapChain11::resize");
ID3D11Device *device = mRenderer->getDevice();
- if (device == NULL)
+ if (device == nullptr)
{
return EGL_BAD_ACCESS;
}
@@ -427,18 +464,19 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
}
// Can only call resize if we have already created our swap buffer and resources
- ASSERT(mSwapChain && mBackBufferTexture && mBackBufferRTView && mBackBufferSRView);
+ ASSERT(mSwapChain && mBackBufferTexture.valid() && mBackBufferRTView.valid() &&
+ mBackBufferSRView.valid());
- SafeRelease(mBackBufferTexture);
- SafeRelease(mBackBufferRTView);
- SafeRelease(mBackBufferSRView);
+ mBackBufferTexture.reset();
+ mBackBufferRTView.reset();
+ mBackBufferSRView.reset();
// Resize swap chain
DXGI_SWAP_CHAIN_DESC desc;
HRESULT result = mSwapChain->GetDesc(&desc);
if (FAILED(result))
{
- ERR("Error reading swap chain description: 0x%08X", result);
+ ERR() << "Error reading swap chain description, " << gl::FmtHR(result);
release();
return EGL_BAD_ALLOC;
}
@@ -447,7 +485,7 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
if (FAILED(result))
{
- ERR("Error resizing swap chain buffers: 0x%08X", result);
+ ERR() << "Error resizing swap chain buffers, " << gl::FmtHR(result);
release();
if (d3d11::isDeviceLostError(result))
@@ -460,39 +498,64 @@ EGLint SwapChain11::resize(EGLint backbufferWidth, EGLint backbufferHeight)
}
}
- result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackBufferTexture);
+ ID3D11Texture2D *backbufferTexture = nullptr;
+ result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+ reinterpret_cast<void **>(&backbufferTexture));
ASSERT(SUCCEEDED(result));
if (SUCCEEDED(result))
{
- d3d11::SetDebugName(mBackBufferTexture, "Back buffer texture");
- result = device->CreateRenderTargetView(mBackBufferTexture, NULL, &mBackBufferRTView);
- ASSERT(SUCCEEDED(result));
- if (SUCCEEDED(result))
- {
- d3d11::SetDebugName(mBackBufferRTView, "Back buffer render target");
- }
-
- result = device->CreateShaderResourceView(mBackBufferTexture, nullptr, &mBackBufferSRView);
- ASSERT(SUCCEEDED(result));
- if (SUCCEEDED(result))
- {
- d3d11::SetDebugName(mBackBufferSRView, "Back buffer shader resource");
- }
+ const auto &format =
+ d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps());
+ mBackBufferTexture.set(backbufferTexture, format);
+ mBackBufferTexture.setDebugName("Back buffer texture");
+
+ gl::Error err =
+ mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferRTView);
+ ASSERT(!err.isError());
+ mBackBufferRTView.setDebugName("Back buffer render target");
+
+ err = mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferSRView);
+ ASSERT(!err.isError());
+ mBackBufferSRView.setDebugName("Back buffer shader resource");
}
mFirstSwap = true;
- return resetOffscreenBuffers(backbufferWidth, backbufferHeight);
+ return resetOffscreenBuffers(context, backbufferWidth, backbufferHeight);
}
DXGI_FORMAT SwapChain11::getSwapChainNativeFormat() const
{
// Return a render target format for offscreen rendering is supported by IDXGISwapChain.
// MSDN https://msdn.microsoft.com/en-us/library/windows/desktop/bb173064(v=vs.85).aspx
- return (mOffscreenRenderTargetFormat == GL_BGRA8_EXT) ? DXGI_FORMAT_B8G8R8A8_UNORM : DXGI_FORMAT_R8G8B8A8_UNORM;
+ switch (mOffscreenRenderTargetFormat)
+ {
+ case GL_RGBA8:
+ case GL_RGBA4:
+ case GL_RGB5_A1:
+ case GL_RGB8:
+ case GL_RGB565:
+ return DXGI_FORMAT_R8G8B8A8_UNORM;
+
+ case GL_BGRA8_EXT:
+ return DXGI_FORMAT_B8G8R8A8_UNORM;
+
+ case GL_RGB10_A2:
+ return DXGI_FORMAT_R10G10B10A2_UNORM;
+
+ case GL_RGBA16F:
+ return DXGI_FORMAT_R16G16B16A16_FLOAT;
+
+ default:
+ UNREACHABLE();
+ return DXGI_FORMAT_UNKNOWN;
+ }
}
-EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swapInterval)
+EGLint SwapChain11::reset(const gl::Context *context,
+ EGLint backbufferWidth,
+ EGLint backbufferHeight,
+ EGLint swapInterval)
{
mSwapInterval = static_cast<unsigned int>(swapInterval);
if (mSwapInterval > 4)
@@ -505,25 +568,23 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
// If the swap chain already exists, just resize
if (mSwapChain != nullptr)
{
- return resize(backbufferWidth, backbufferHeight);
+ return resize(context, backbufferWidth, backbufferHeight);
}
TRACE_EVENT0("gpu.angle", "SwapChain11::reset");
ID3D11Device *device = mRenderer->getDevice();
- if (device == NULL)
+ if (device == nullptr)
{
return EGL_BAD_ACCESS;
}
// Release specific resources to free up memory for the new render target, while the
// old render target still exists for the purpose of preserving its contents.
-#if defined(ANGLE_ENABLE_D3D11_1)
SafeRelease(mSwapChain1);
-#endif
SafeRelease(mSwapChain);
- SafeRelease(mBackBufferTexture);
- SafeRelease(mBackBufferRTView);
+ mBackBufferTexture.reset();
+ mBackBufferRTView.reset();
// EGL allows creating a surface with 0x0 dimension, however, DXGI does not like 0x0 swapchains
if (backbufferWidth < 1 || backbufferHeight < 1)
@@ -532,15 +593,16 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
return EGL_SUCCESS;
}
- if (mNativeWindow.getNativeWindow())
+ if (mNativeWindow->getNativeWindow())
{
- HRESULT result = mNativeWindow.createSwapChain(device, mRenderer->getDxgiFactory(),
- getSwapChainNativeFormat(),
- backbufferWidth, backbufferHeight, &mSwapChain);
+ HRESULT result = mNativeWindow->createSwapChain(
+ device, mRenderer->getDxgiFactory(), getSwapChainNativeFormat(), backbufferWidth,
+ backbufferHeight, getD3DSamples(), &mSwapChain);
if (FAILED(result))
{
- ERR("Could not create additional swap chains or offscreen surfaces: %08lX", result);
+ ERR() << "Could not create additional swap chains or offscreen surfaces, "
+ << gl::FmtHR(result);
release();
if (d3d11::isDeviceLostError(result))
@@ -555,27 +617,31 @@ EGLint SwapChain11::reset(int backbufferWidth, int backbufferHeight, EGLint swap
if (mRenderer->getRenderer11DeviceCaps().supportsDXGI1_2)
{
-#if defined(ANGLE_ENABLE_D3D11_1)
mSwapChain1 = d3d11::DynamicCastComObject<IDXGISwapChain1>(mSwapChain);
-#endif
}
- result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (LPVOID*)&mBackBufferTexture);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mBackBufferTexture, "Back buffer texture");
-
- result = device->CreateRenderTargetView(mBackBufferTexture, NULL, &mBackBufferRTView);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mBackBufferRTView, "Back buffer render target");
-
- result = device->CreateShaderResourceView(mBackBufferTexture, nullptr, &mBackBufferSRView);
+ ID3D11Texture2D *backbufferTex = nullptr;
+ result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
+ reinterpret_cast<LPVOID *>(&backbufferTex));
ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mBackBufferSRView, "Back buffer shader resource view");
+ const auto &format =
+ d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps());
+ mBackBufferTexture.set(backbufferTex, format);
+ mBackBufferTexture.setDebugName("Back buffer texture");
+
+ gl::Error err =
+ mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferRTView);
+ ASSERT(!err.isError());
+ mBackBufferRTView.setDebugName("Back buffer render target");
+
+ err = mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferSRView);
+ ASSERT(!err.isError());
+ mBackBufferSRView.setDebugName("Back buffer shader resource view");
}
mFirstSwap = true;
- return resetOffscreenBuffers(backbufferWidth, backbufferHeight);
+ return resetOffscreenBuffers(context, backbufferWidth, backbufferHeight);
}
void SwapChain11::initPassThroughResources()
@@ -588,11 +654,11 @@ void SwapChain11::initPassThroughResources()
TRACE_EVENT0("gpu.angle", "SwapChain11::initPassThroughResources");
ID3D11Device *device = mRenderer->getDevice();
- ASSERT(device != NULL);
+ ASSERT(device != nullptr);
// Make sure our resources are all not allocated, when we create
- ASSERT(mQuadVB == NULL && mPassThroughSampler == NULL);
- ASSERT(mPassThroughIL == NULL && mPassThroughVS == NULL && mPassThroughPS == NULL);
+ ASSERT(!mQuadVB.valid() && !mPassThroughSampler.valid());
+ ASSERT(!mPassThroughIL.valid() && !mPassThroughVS.valid() && !mPassThroughPS.valid());
D3D11_BUFFER_DESC vbDesc;
vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
@@ -602,9 +668,9 @@ void SwapChain11::initPassThroughResources()
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
- HRESULT result = device->CreateBuffer(&vbDesc, NULL, &mQuadVB);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mQuadVB, "Swap chain quad vertex buffer");
+ gl::Error err = mRenderer->allocateResource(vbDesc, &mQuadVB);
+ ASSERT(!err.isError());
+ mQuadVB.setDebugName("Swap chain quad vertex buffer");
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
@@ -621,9 +687,9 @@ void SwapChain11::initPassThroughResources()
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
- result = device->CreateSamplerState(&samplerDesc, &mPassThroughSampler);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mPassThroughSampler, "Swap chain pass through sampler");
+ err = mRenderer->allocateResource(samplerDesc, &mPassThroughSampler);
+ ASSERT(!err.isError());
+ mPassThroughSampler.setDebugName("Swap chain pass through sampler");
D3D11_INPUT_ELEMENT_DESC quadLayout[] =
{
@@ -631,17 +697,30 @@ void SwapChain11::initPassThroughResources()
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
- result = device->CreateInputLayout(quadLayout, 2, g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), &mPassThroughIL);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mPassThroughIL, "Swap chain pass through layout");
+ InputElementArray quadElements(quadLayout);
+ ShaderData vertexShaderData(g_VS_Passthrough2D);
- result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), NULL, &mPassThroughVS);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mPassThroughVS, "Swap chain pass through vertex shader");
+ err = mRenderer->allocateResource(quadElements, &vertexShaderData, &mPassThroughIL);
+ ASSERT(!err.isError());
+ mPassThroughIL.setDebugName("Swap chain pass through layout");
- result = device->CreatePixelShader(g_PS_PassthroughRGBA2D, sizeof(g_PS_PassthroughRGBA2D), NULL, &mPassThroughPS);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mPassThroughPS, "Swap chain pass through pixel shader");
+ err = mRenderer->allocateResource(vertexShaderData, &mPassThroughVS);
+ ASSERT(!err.isError());
+ mPassThroughVS.setDebugName("Swap chain pass through vertex shader");
+
+ if (mEGLSamples <= 1)
+ {
+ ShaderData pixelShaderData(g_PS_PassthroughRGBA2D);
+ err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
+ }
+ else
+ {
+ ShaderData pixelShaderData(g_PS_PassthroughRGBA2DMS);
+ err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
+ }
+
+ ASSERT(!err.isError());
+ mPassThroughPS.setDebugName("Swap chain pass through pixel shader");
// Use the default rasterizer state but without culling
D3D11_RASTERIZER_DESC rasterizerDesc;
@@ -655,26 +734,31 @@ void SwapChain11::initPassThroughResources()
rasterizerDesc.ScissorEnable = FALSE;
rasterizerDesc.MultisampleEnable = FALSE;
rasterizerDesc.AntialiasedLineEnable = FALSE;
- result = device->CreateRasterizerState(&rasterizerDesc, &mPassThroughRS);
- ASSERT(SUCCEEDED(result));
- d3d11::SetDebugName(mPassThroughRS, "Swap chain pass through rasterizer state");
+
+ err = mRenderer->allocateResource(rasterizerDesc, &mPassThroughRS);
+ ASSERT(!err.isError());
+ mPassThroughRS.setDebugName("Swap chain pass through rasterizer state");
mPassThroughResourcesInit = true;
}
// parameters should be validated/clamped by caller
-EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
+EGLint SwapChain11::swapRect(const gl::Context *context,
+ EGLint x,
+ EGLint y,
+ EGLint width,
+ EGLint height)
{
if (mNeedsOffscreenTexture)
{
- EGLint result = copyOffscreenToBackbuffer(x, y, width, height);
+ EGLint result = copyOffscreenToBackbuffer(context, x, y, width, height);
if (result != EGL_SUCCESS)
{
return result;
}
}
- EGLint result = present(x, y, width, height);
+ EGLint result = present(context, x, y, width, height);
if (result != EGL_SUCCESS)
{
return result;
@@ -685,7 +769,11 @@ EGLint SwapChain11::swapRect(EGLint x, EGLint y, EGLint width, EGLint height)
return EGL_SUCCESS;
}
-EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width, EGLint height)
+EGLint SwapChain11::copyOffscreenToBackbuffer(const gl::Context *context,
+ EGLint x,
+ EGLint y,
+ EGLint width,
+ EGLint height)
{
if (!mSwapChain)
{
@@ -698,7 +786,8 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
// Set vertices
D3D11_MAPPED_SUBRESOURCE mappedResource;
- HRESULT result = deviceContext->Map(mQuadVB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
+ HRESULT result =
+ deviceContext->Map(mQuadVB.get(), 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource);
if (FAILED(result))
{
return EGL_BAD_ACCESS;
@@ -716,7 +805,6 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
float v1 = y / float(height);
float u2 = (x + width) / float(width);
float v2 = (y + height) / float(height);
-
// Invert the quad vertices depending on the surface orientation.
if ((mOrientation & EGL_SURFACE_ORIENTATION_INVERT_X_ANGLE) != 0)
{
@@ -732,60 +820,43 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
d3d11::SetPositionTexCoordVertex(&vertices[2], x2, y1, u2, v1);
d3d11::SetPositionTexCoordVertex(&vertices[3], x2, y2, u2, v2);
- deviceContext->Unmap(mQuadVB, 0);
+ deviceContext->Unmap(mQuadVB.get(), 0);
- static UINT stride = sizeof(d3d11::PositionTexCoordVertex);
- static UINT startIdx = 0;
- deviceContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &startIdx);
-
- // Apply state
- deviceContext->OMSetDepthStencilState(NULL, 0xFFFFFFFF);
+ StateManager11 *stateManager = mRenderer->getStateManager();
- static const float blendFactor[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
- deviceContext->OMSetBlendState(NULL, blendFactor, 0xFFFFFFF);
+ constexpr UINT stride = sizeof(d3d11::PositionTexCoordVertex);
+ stateManager->setSingleVertexBuffer(&mQuadVB, stride, 0);
- deviceContext->RSSetState(mPassThroughRS);
+ // Apply state
+ stateManager->setDepthStencilState(nullptr, 0xFFFFFFFF);
+ stateManager->setSimpleBlendState(nullptr);
+ stateManager->setRasterizerState(&mPassThroughRS);
// Apply shaders
- deviceContext->IASetInputLayout(mPassThroughIL);
- deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
- deviceContext->VSSetShader(mPassThroughVS, NULL, 0);
- deviceContext->PSSetShader(mPassThroughPS, NULL, 0);
- deviceContext->GSSetShader(NULL, NULL, 0);
+ stateManager->setInputLayout(&mPassThroughIL);
+ stateManager->setPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
+ stateManager->setDrawShaders(&mPassThroughVS, nullptr, &mPassThroughPS);
- // Apply render targets
- mRenderer->setOneTimeRenderTarget(mBackBufferRTView);
+ // Apply render targets. Use the proxy context in display.
+ stateManager->setRenderTarget(mBackBufferRTView.get(), nullptr);
// Set the viewport
- D3D11_VIEWPORT viewport;
- viewport.TopLeftX = 0;
- viewport.TopLeftY = 0;
- viewport.Width = static_cast<FLOAT>(width);
- viewport.Height = static_cast<FLOAT>(height);
- viewport.MinDepth = 0.0f;
- viewport.MaxDepth = 1.0f;
- deviceContext->RSSetViewports(1, &viewport);
+ stateManager->setSimpleViewport(mWidth, mHeight);
// Apply textures
- auto stateManager = mRenderer->getStateManager();
- stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, mOffscreenSRView);
- deviceContext->PSSetSamplers(0, 1, &mPassThroughSampler);
+ stateManager->setSimplePixelTextureAndSampler(mOffscreenSRView, mPassThroughSampler);
// Draw
deviceContext->Draw(4, 0);
- // Rendering to the swapchain is now complete. Now we can call Present().
- // Before that, we perform any cleanup on the D3D device. We do this before Present() to make sure the
- // cleanup is caught under the current eglSwapBuffers() PIX/Graphics Diagnostics call rather than the next one.
- stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, NULL);
-
- mRenderer->unapplyRenderTargets();
- mRenderer->markAllStateDirty();
-
return EGL_SUCCESS;
}
-EGLint SwapChain11::present(EGLint x, EGLint y, EGLint width, EGLint height)
+EGLint SwapChain11::present(const gl::Context *context,
+ EGLint x,
+ EGLint y,
+ EGLint width,
+ EGLint height)
{
if (!mSwapChain)
{
@@ -799,9 +870,9 @@ EGLint SwapChain11::present(EGLint x, EGLint y, EGLint width, EGLint height)
HRESULT result = S_OK;
-#if defined(ANGLE_ENABLE_D3D11_1)
// Use IDXGISwapChain1::Present1 with a dirty rect if DXGI 1.2 is available.
- if (mSwapChain1 != nullptr)
+ // Dirty rect present is not supported with a multisampled swapchain.
+ if (mSwapChain1 != nullptr && mEGLSamples <= 1)
{
if (mFirstSwap)
{
@@ -818,7 +889,6 @@ EGLint SwapChain11::present(EGLint x, EGLint y, EGLint width, EGLint height)
}
}
else
-#endif
{
result = mSwapChain->Present(swapInterval, 0);
}
@@ -826,60 +896,111 @@ EGLint SwapChain11::present(EGLint x, EGLint y, EGLint width, EGLint height)
mFirstSwap = false;
// Some swapping mechanisms such as DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL unbind the current render
- // target. Mark it dirty.
+ // target. Mark it dirty. Use the proxy context in display since there is none available.
mRenderer->getStateManager()->invalidateRenderTarget();
if (result == DXGI_ERROR_DEVICE_REMOVED)
{
- ERR("Present failed: the D3D11 device was removed: 0x%08X",
- mRenderer->getDevice()->GetDeviceRemovedReason());
+ ERR() << "Present failed: the D3D11 device was removed, "
+ << gl::FmtHR(mRenderer->getDevice()->GetDeviceRemovedReason());
return EGL_CONTEXT_LOST;
}
else if (result == DXGI_ERROR_DEVICE_RESET)
{
- ERR("Present failed: the D3D11 device was reset from a bad command.");
+ ERR() << "Present failed: the D3D11 device was reset from a bad command.";
return EGL_CONTEXT_LOST;
}
else if (FAILED(result))
{
- ERR("Present failed with error code 0x%08X", result);
+ ERR() << "Present failed with " << gl::FmtHR(result);
}
- mNativeWindow.commitChange();
+ mNativeWindow->commitChange();
return EGL_SUCCESS;
}
-ID3D11Texture2D *SwapChain11::getOffscreenTexture()
+const TextureHelper11 &SwapChain11::getOffscreenTexture()
{
return mNeedsOffscreenTexture ? mOffscreenTexture : mBackBufferTexture;
}
-ID3D11RenderTargetView *SwapChain11::getRenderTarget()
+const d3d11::RenderTargetView &SwapChain11::getRenderTarget()
{
return mNeedsOffscreenTexture ? mOffscreenRTView : mBackBufferRTView;
}
-ID3D11ShaderResourceView *SwapChain11::getRenderTargetShaderResource()
+const d3d11::SharedSRV &SwapChain11::getRenderTargetShaderResource()
{
- return mNeedsOffscreenTexture ? mOffscreenSRView : mBackBufferSRView;
+ if (!mNeedsOffscreenTexture)
+ {
+ ASSERT(mBackBufferSRView.valid());
+ return mBackBufferSRView;
+ }
+
+ if (!mNeedsOffscreenTextureCopy)
+ {
+ ASSERT(mOffscreenSRView.valid());
+ return mOffscreenSRView;
+ }
+
+ if (!mOffscreenTextureCopyForSRV.valid())
+ {
+ const d3d11::Format &backbufferFormatInfo =
+ d3d11::Format::Get(mOffscreenRenderTargetFormat, mRenderer->getRenderer11DeviceCaps());
+
+ D3D11_TEXTURE2D_DESC offscreenCopyDesc;
+ mOffscreenTexture.getDesc(&offscreenCopyDesc);
+
+ offscreenCopyDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+ offscreenCopyDesc.MiscFlags = 0;
+ offscreenCopyDesc.CPUAccessFlags = 0;
+ gl::Error err = mRenderer->allocateTexture(offscreenCopyDesc, backbufferFormatInfo,
+ &mOffscreenTextureCopyForSRV);
+ ASSERT(!err.isError());
+ mOffscreenTextureCopyForSRV.setDebugName("Offscreen back buffer copy for SRV");
+
+ D3D11_SHADER_RESOURCE_VIEW_DESC offscreenSRVDesc;
+ offscreenSRVDesc.Format = backbufferFormatInfo.srvFormat;
+ offscreenSRVDesc.ViewDimension =
+ (mEGLSamples <= 1) ? D3D11_SRV_DIMENSION_TEXTURE2D : D3D11_SRV_DIMENSION_TEXTURE2DMS;
+ offscreenSRVDesc.Texture2D.MostDetailedMip = 0;
+ offscreenSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1);
+
+ err = mRenderer->allocateResource(offscreenSRVDesc, mOffscreenTextureCopyForSRV.get(),
+ &mOffscreenSRView);
+ ASSERT(!err.isError());
+ mOffscreenSRView.setDebugName("Offscreen back buffer shader resource");
+ }
+
+ // Need to copy the offscreen texture into the shader-readable copy, since it's external and
+ // we don't know if the copy is up-to-date. This works around the problem we have when the app
+ // passes in a texture that isn't shader-readable.
+ mRenderer->getDeviceContext()->CopyResource(mOffscreenTextureCopyForSRV.get(),
+ mOffscreenTexture.get());
+ return mOffscreenSRView;
}
-ID3D11DepthStencilView *SwapChain11::getDepthStencil()
+const d3d11::DepthStencilView &SwapChain11::getDepthStencil()
{
return mDepthStencilDSView;
}
-ID3D11ShaderResourceView * SwapChain11::getDepthStencilShaderResource()
+const d3d11::SharedSRV &SwapChain11::getDepthStencilShaderResource()
{
return mDepthStencilSRView;
}
-ID3D11Texture2D *SwapChain11::getDepthStencilTexture()
+const TextureHelper11 &SwapChain11::getDepthStencilTexture()
{
return mDepthStencilTexture;
}
+void *SwapChain11::getKeyedMutex()
+{
+ return mKeyedMutex;
+}
+
void SwapChain11::recreate()
{
// possibly should use this method instead of reset
@@ -890,4 +1011,61 @@ void *rx::SwapChain11::getDevice()
return mRenderer->getDevice();
}
+RenderTargetD3D *SwapChain11::getColorRenderTarget()
+{
+ return &mColorRenderTarget;
+}
+
+RenderTargetD3D *SwapChain11::getDepthStencilRenderTarget()
+{
+ return &mDepthStencilRenderTarget;
+}
+
+egl::Error SwapChain11::getSyncValues(EGLuint64KHR *ust, EGLuint64KHR *msc, EGLuint64KHR *sbc)
+{
+ if (!mSwapChain)
+ {
+ return egl::EglNotInitialized() << "Swap chain uninitialized";
+ }
+
+ DXGI_FRAME_STATISTICS stats = {};
+ HRESULT result = mSwapChain->GetFrameStatistics(&stats);
+
+ if (FAILED(result))
+ {
+ return egl::EglBadAlloc() << "Failed to get frame statistics, " << gl::FmtHR(result);
+ }
+
+ // Conversion from DXGI_FRAME_STATISTICS to the output values:
+ // stats.SyncRefreshCount -> msc
+ // stats.PresentCount -> sbc
+ // stats.SyncQPCTime -> ust with conversion to microseconds via QueryPerformanceFrequency
+ *msc = stats.SyncRefreshCount;
+ *sbc = stats.PresentCount;
+
+ LONGLONG syncQPCValue = stats.SyncQPCTime.QuadPart;
+ // If the QPC Value is below the overflow threshold, we proceed with
+ // simple multiply and divide.
+ if (syncQPCValue < kQPCOverflowThreshold)
+ {
+ *ust = syncQPCValue * kMicrosecondsPerSecond / mQPCFrequency;
+ }
+ else
+ {
+ // Otherwise, calculate microseconds in a round about manner to avoid
+ // overflow and precision issues.
+ int64_t wholeSeconds = syncQPCValue / mQPCFrequency;
+ int64_t leftoverTicks = syncQPCValue - (wholeSeconds * mQPCFrequency);
+ *ust = wholeSeconds * kMicrosecondsPerSecond +
+ leftoverTicks * kMicrosecondsPerSecond / mQPCFrequency;
+ }
+
+ return egl::NoError();
+}
+
+UINT SwapChain11::getD3DSamples() const
+{
+ return (mEGLSamples == 0) ? 1 : mEGLSamples;
}
+
+} // namespace rx
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-18 13:02:06 +0000