Skip to content

A
angle
Commit 7a5814e2 by Jamie Madill Committed by Commit Bot
Options

D3D11: Use angle::Result error pattern. 3/3

This completes the initial refactor for the D3D11 back-end. Bug: angleproject:2738 Change-Id: I6bc59d6a1a724b3c64d6cd904e6748c2acf8f67d Reviewed-on: https://chromium-review.googlesource.com/1151452 Commit-Queue: Jamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org>
parent 038e725a
Showing with 466 additions and 342 deletions
src/libANGLE/renderer/d3d/d3d11/Blit11.cpp
......@@ -643,7 +643,9 @@ angle::Result Blit11::initResources(const gl::Context *context)
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(vbDesc, &mVertexBuffer));
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(mRenderer->allocateResource(context11, vbDesc, &mVertexBuffer));
mVertexBuffer.setDebugName("Blit11 vertex buffer");
D3D11_SAMPLER_DESC pointSamplerDesc;
......@@ -661,7 +663,7 @@ angle::Result Blit11::initResources(const gl::Context *context)
pointSamplerDesc.MinLOD = 0.0f;
pointSamplerDesc.MaxLOD = FLT_MAX;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(pointSamplerDesc, &mPointSampler));
ANGLE_TRY(mRenderer->allocateResource(context11, pointSamplerDesc, &mPointSampler));
mPointSampler.setDebugName("Blit11 point sampler");
D3D11_SAMPLER_DESC linearSamplerDesc;
......@@ -679,7 +681,7 @@ angle::Result Blit11::initResources(const gl::Context *context)
linearSamplerDesc.MinLOD = 0.0f;
linearSamplerDesc.MaxLOD = FLT_MAX;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(linearSamplerDesc, &mLinearSampler));
ANGLE_TRY(mRenderer->allocateResource(context11, linearSamplerDesc, &mLinearSampler));
mLinearSampler.setDebugName("Blit11 linear sampler");
// Use a rasterizer state that will not cull so that inverted quads will not be culled
......@@ -695,13 +697,11 @@ angle::Result Blit11::initResources(const gl::Context *context)
rasterDesc.AntialiasedLineEnable = FALSE;
rasterDesc.ScissorEnable = TRUE;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(rasterDesc, &mScissorEnabledRasterizerState));
ANGLE_TRY(mRenderer->allocateResource(context11, rasterDesc, &mScissorEnabledRasterizerState));
mScissorEnabledRasterizerState.setDebugName("Blit11 scissoring rasterizer state");
rasterDesc.ScissorEnable = FALSE;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(rasterDesc, &mScissorDisabledRasterizerState));
ANGLE_TRY(mRenderer->allocateResource(context11, rasterDesc, &mScissorDisabledRasterizerState));
mScissorDisabledRasterizerState.setDebugName("Blit11 no scissoring rasterizer state");
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
......@@ -720,7 +720,7 @@ angle::Result Blit11::initResources(const gl::Context *context)
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(depthStencilDesc, &mDepthStencilState));
ANGLE_TRY(mRenderer->allocateResource(context11, depthStencilDesc, &mDepthStencilState));
mDepthStencilState.setDebugName("Blit11 depth stencil state");
D3D11_BUFFER_DESC swizzleBufferDesc;
......@@ -731,7 +731,7 @@ angle::Result Blit11::initResources(const gl::Context *context)
swizzleBufferDesc.MiscFlags = 0;
swizzleBufferDesc.StructureByteStride = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(swizzleBufferDesc, &mSwizzleCB));
ANGLE_TRY(mRenderer->allocateResource(context11, swizzleBufferDesc, &mSwizzleCB));
mSwizzleCB.setDebugName("Blit11 swizzle constant buffer");
mResourcesInitialized = true;
......@@ -1041,10 +1041,11 @@ angle::Result Blit11::getShaderSupport(const gl::Context *context,
const Shader &shader,
Blit11::ShaderSupport *supportOut)
{
Context11 *context11 = GetImplAs<Context11>(context);
if (shader.dimension == SHADER_2D)
{
ANGLE_TRY_HANDLE(context, mQuad2DIL.resolve(mRenderer));
ANGLE_TRY_HANDLE(context, mQuad2DVS.resolve(mRenderer));
ANGLE_TRY(mQuad2DIL.resolve(context11, mRenderer));
ANGLE_TRY(mQuad2DVS.resolve(context11, mRenderer));
supportOut->inputLayout = &mQuad2DIL.getObj();
supportOut->vertexShader = &mQuad2DVS.getObj();
supportOut->geometryShader = nullptr;
......@@ -1053,9 +1054,9 @@ angle::Result Blit11::getShaderSupport(const gl::Context *context,
else
{
ASSERT(shader.dimension == SHADER_3D);
ANGLE_TRY_HANDLE(context, mQuad3DIL.resolve(mRenderer));
ANGLE_TRY_HANDLE(context, mQuad3DVS.resolve(mRenderer));
ANGLE_TRY_HANDLE(context, mQuad3DGS.resolve(mRenderer));
ANGLE_TRY(mQuad3DIL.resolve(context11, mRenderer));
ANGLE_TRY(mQuad3DVS.resolve(context11, mRenderer));
ANGLE_TRY(mQuad3DGS.resolve(context11, mRenderer));
supportOut->inputLayout = &mQuad2DIL.getObj();
supportOut->vertexShader = &mQuad3DVS.getObj();
supportOut->geometryShader = &mQuad3DGS.getObj();
......@@ -1246,7 +1247,7 @@ angle::Result Blit11::copyTexture(const gl::Context *context,
// Apply state
if (maskOffAlpha)
{
ANGLE_TRY_HANDLE(context, mAlphaMaskBlendState.resolve(mRenderer));
ANGLE_TRY(mAlphaMaskBlendState.resolve(GetImplAs<Context11>(context), mRenderer));
stateManager->setSimpleBlendState(&mAlphaMaskBlendState.getObj());
}
else
......@@ -1361,9 +1362,11 @@ angle::Result Blit11::copyDepth(const gl::Context *context,
stateManager->setRasterizerState(&mScissorDisabledRasterizerState);
}
ANGLE_TRY_HANDLE(context, mQuad2DIL.resolve(mRenderer));
ANGLE_TRY_HANDLE(context, mQuad2DVS.resolve(mRenderer));
ANGLE_TRY_HANDLE(context, mDepthPS.resolve(mRenderer));
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(mQuad2DIL.resolve(context11, mRenderer));
ANGLE_TRY(mQuad2DVS.resolve(context11, mRenderer));
ANGLE_TRY(mDepthPS.resolve(context11, mRenderer));
// Apply shaders
stateManager->setInputLayout(&mQuad2DIL.getObj());
......@@ -1589,7 +1592,7 @@ angle::Result Blit11::addBlitShaderToMap(const gl::Context *context,
ASSERT(mBlitShaderMap.find(blitShaderType) == mBlitShaderMap.end());
d3d11::PixelShader ps;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(shaderData, &ps));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), shaderData, &ps));
ps.setDebugName(name);
Shader shader;
......@@ -1609,7 +1612,7 @@ angle::Result Blit11::addSwizzleShaderToMap(const gl::Context *context,
ASSERT(mSwizzleShaderMap.find(swizzleShaderType) == mSwizzleShaderMap.end());
d3d11::PixelShader ps;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(shaderData, &ps));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), shaderData, &ps));
ps.setDebugName(name);
Shader shader;
......@@ -2067,8 +2070,10 @@ angle::Result Blit11::resolveDepth(const gl::Context *context,
ANGLE_TRY(initResolveDepthOnly(context, depth->getFormatSet(), extents));
ANGLE_TRY_HANDLE(context, mResolveDepthStencilVS.resolve(mRenderer));
ANGLE_TRY_HANDLE(context, mResolveDepthPS.resolve(mRenderer));
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(mResolveDepthStencilVS.resolve(context11, mRenderer));
ANGLE_TRY(mResolveDepthPS.resolve(context11, mRenderer));
// Apply the necessary state changes to the D3D11 immediate device context.
stateManager->setInputLayout(nullptr);
......@@ -2083,7 +2088,7 @@ angle::Result Blit11::resolveDepth(const gl::Context *context,
// Set the viewport
stateManager->setShaderResourceShared(gl::ShaderType::Fragment, 0,
&depth->getShaderResourceView());
&depth->getShaderResourceView(context));
// Trigger the blit on the GPU.
deviceContext->Draw(6, 0);
......@@ -2115,7 +2120,9 @@ angle::Result Blit11::initResolveDepthOnly(const gl::Context *context,
textureDesc.CPUAccessFlags = 0;
textureDesc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(textureDesc, format, &mResolvedDepth));
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(mRenderer->allocateTexture(context11, textureDesc, format, &mResolvedDepth));
mResolvedDepth.setDebugName("Blit11::mResolvedDepth");
D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
......@@ -2124,8 +2131,8 @@ angle::Result Blit11::initResolveDepthOnly(const gl::Context *context,
dsvDesc.Texture2D.MipSlice = 0;
dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
ANGLE_TRY_HANDLE(
context, mRenderer->allocateResource(dsvDesc, mResolvedDepth.get(), &mResolvedDepthDSView));
ANGLE_TRY(mRenderer->allocateResource(context11, dsvDesc, mResolvedDepth.get(),
&mResolvedDepthDSView));
mResolvedDepthDSView.setDebugName("Blit11::mResolvedDepthDSView");
// Possibly D3D11 bug or undefined behaviour: Clear the DSV so that our first render
......@@ -2166,11 +2173,13 @@ angle::Result Blit11::initResolveDepthStencil(const gl::Context *context,
textureDesc.CPUAccessFlags = 0;
textureDesc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateTexture(textureDesc, formatSet, &mResolvedDepthStencil));
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(
mRenderer->allocateTexture(context11, textureDesc, formatSet, &mResolvedDepthStencil));
mResolvedDepthStencil.setDebugName("Blit11::mResolvedDepthStencil");
ANGLE_TRY_HANDLE(context, mRenderer->allocateResourceNoDesc(mResolvedDepthStencil.get(),
ANGLE_TRY(mRenderer->allocateResourceNoDesc(context11, mResolvedDepthStencil.get(),
&mResolvedDepthStencilRTView));
mResolvedDepthStencilRTView.setDebugName("Blit11::mResolvedDepthStencilRTView");
......@@ -2209,19 +2218,21 @@ angle::Result Blit11::resolveStencil(const gl::Context *context,
SafeRelease(priorResource);
}
Context11 *context11 = GetImplAs<Context11>(context);
if (!mStencilSRV.valid())
{
D3D11_SHADER_RESOURCE_VIEW_DESC srViewDesc;
srViewDesc.Format = GetStencilSRVFormat(depthStencil->getFormatSet());
srViewDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(srViewDesc, stencilResource, &mStencilSRV));
ANGLE_TRY(
mRenderer->allocateResource(context11, srViewDesc, stencilResource, &mStencilSRV));
mStencilSRV.setDebugName("Blit11::mStencilSRV");
}
// Notify the Renderer that all state should be invalidated.
ANGLE_TRY_HANDLE(context, mResolveDepthStencilVS.resolve(mRenderer));
ANGLE_TRY(mResolveDepthStencilVS.resolve(context11, mRenderer));
// 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
......@@ -2229,12 +2240,12 @@ angle::Result Blit11::resolveStencil(const gl::Context *context,
const d3d11::PixelShader *pixelShader = nullptr;
if (alsoDepth)
{
ANGLE_TRY_HANDLE(context, mResolveDepthStencilPS.resolve(mRenderer));
ANGLE_TRY(mResolveDepthStencilPS.resolve(context11, mRenderer));
pixelShader = &mResolveDepthStencilPS.getObj();
}
else
{
ANGLE_TRY_HANDLE(context, mResolveStencilPS.resolve(mRenderer));
ANGLE_TRY(mResolveStencilPS.resolve(context11, mRenderer));
pixelShader = &mResolveStencilPS.getObj();
}
......@@ -2250,7 +2261,7 @@ angle::Result Blit11::resolveStencil(const gl::Context *context,
// Set the viewport
stateManager->setSimpleViewport(extents);
stateManager->setShaderResourceShared(gl::ShaderType::Fragment, 0,
&depthStencil->getShaderResourceView());
&depthStencil->getShaderResourceView(context));
stateManager->setShaderResource(gl::ShaderType::Fragment, 1, &mStencilSRV);
// Trigger the blit on the GPU.
......
src/libANGLE/renderer/d3d/d3d11/Buffer11.cpp
......@@ -1068,7 +1068,8 @@ angle::Result Buffer11::NativeStorage::resize(const gl::Context *context,
FillBufferDesc(&bufferDesc, mRenderer, mUsage, static_cast<unsigned int>(size));
d3d11::Buffer newBuffer;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(bufferDesc, &newBuffer));
ANGLE_TRY(
mRenderer->allocateResource(SafeGetImplAs<Context11>(context), bufferDesc, &newBuffer));
newBuffer.setDebugName("Buffer11::NativeStorage");
if (mBuffer.valid() && preserveData)
......@@ -1222,8 +1223,8 @@ angle::Result Buffer11::NativeStorage::getSRVForFormat(const gl::Context *contex
bufferSRVDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;
bufferSRVDesc.Format = srvFormat;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(bufferSRVDesc, mBuffer.get(),
&mBufferResourceViews[srvFormat]));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferSRVDesc,
mBuffer.get(), &mBufferResourceViews[srvFormat]));
*srvOut = &mBufferResourceViews[srvFormat];
return angle::Result::Continue();
......@@ -1342,8 +1343,8 @@ angle::Result Buffer11::EmulatedIndexedStorage::getBuffer(const gl::Context *con
D3D11_SUBRESOURCE_DATA subResourceData = {expandedData.data(), 0, 0};
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(bufferDesc, &subResourceData, &mBuffer));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc,
&subResourceData, &mBuffer));
mBuffer.setDebugName("Buffer11::EmulatedIndexedStorage");
}
......
src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
......@@ -14,6 +14,7 @@
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/FramebufferD3D.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
......@@ -155,12 +156,14 @@ angle::Result Clear11::ShaderManager::getShadersAndLayout(const gl::Context *con
const d3d11::GeometryShader **gs,
const d3d11::PixelShader **ps)
{
Context11 *context11 = GetImplAs<Context11>(context);
if (renderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
{
ASSERT(clearType == GL_FLOAT);
ANGLE_TRY_HANDLE(context, mVs9.resolve(renderer));
ANGLE_TRY_HANDLE(context, mPsFloat9.resolve(renderer));
ANGLE_TRY(mVs9.resolve(context11, renderer));
ANGLE_TRY(mPsFloat9.resolve(context11, renderer));
if (!mIl9.valid())
{
......@@ -170,8 +173,7 @@ angle::Result Clear11::ShaderManager::getShadersAndLayout(const gl::Context *con
InputElementArray ilDescArray(ilDesc);
ShaderData vertexShader(g_VS_Clear_FL9);
ANGLE_TRY_HANDLE(context,
renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
ANGLE_TRY(renderer->allocateResource(context11, ilDescArray, &vertexShader, &mIl9));
}
*vs = &mVs9.getObj();
......@@ -183,15 +185,15 @@ angle::Result Clear11::ShaderManager::getShadersAndLayout(const gl::Context *con
if (!hasLayeredLayout)
{
ANGLE_TRY_HANDLE(context, mVs.resolve(renderer));
ANGLE_TRY(mVs.resolve(context11, renderer));
*vs = &mVs.getObj();
*gs = nullptr;
}
else
{
// For layered framebuffers we have to use the multi-view versions of the VS and GS.
ANGLE_TRY_HANDLE(context, mVsMultiview.resolve(renderer));
ANGLE_TRY_HANDLE(context, mGsMultiview.resolve(renderer));
ANGLE_TRY(mVsMultiview.resolve(context11, renderer));
ANGLE_TRY(mGsMultiview.resolve(context11, renderer));
*vs = &mVsMultiview.getObj();
*gs = &mGsMultiview.getObj();
}
......@@ -200,7 +202,7 @@ angle::Result Clear11::ShaderManager::getShadersAndLayout(const gl::Context *con
if (numRTs == 0)
{
ANGLE_TRY_HANDLE(context, mPsDepth.resolve(renderer));
ANGLE_TRY(mPsDepth.resolve(context11, renderer));
*ps = &mPsDepth.getObj();
return angle::Result::Continue();
}
......@@ -208,15 +210,15 @@ angle::Result Clear11::ShaderManager::getShadersAndLayout(const gl::Context *con
switch (clearType)
{
case GL_FLOAT:
ANGLE_TRY_HANDLE(context, mPsFloat[numRTs - 1].resolve(renderer));
ANGLE_TRY(mPsFloat[numRTs - 1].resolve(context11, renderer));
*ps = &mPsFloat[numRTs - 1].getObj();
break;
case GL_UNSIGNED_INT:
ANGLE_TRY_HANDLE(context, mPsUInt[numRTs - 1].resolve(renderer));
ANGLE_TRY(mPsUInt[numRTs - 1].resolve(context11, renderer));
*ps = &mPsUInt[numRTs - 1].getObj();
break;
case GL_INT:
ANGLE_TRY_HANDLE(context, mPsSInt[numRTs - 1].resolve(renderer));
ANGLE_TRY(mPsSInt[numRTs - 1].resolve(context11, renderer));
*ps = &mPsSInt[numRTs - 1].getObj();
break;
default:
......@@ -275,12 +277,13 @@ angle::Result Clear11::ensureResourcesInitialized(const gl::Context *context)
rsDesc.MultisampleEnable = FALSE;
rsDesc.AntialiasedLineEnable = FALSE;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(rsDesc, &mScissorDisabledRasterizerState));
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(mRenderer->allocateResource(context11, rsDesc, &mScissorDisabledRasterizerState));
mScissorDisabledRasterizerState.setDebugName("Clear11 Rasterizer State with scissor disabled");
rsDesc.ScissorEnable = TRUE;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(rsDesc, &mScissorEnabledRasterizerState));
ANGLE_TRY(mRenderer->allocateResource(context11, rsDesc, &mScissorEnabledRasterizerState));
mScissorEnabledRasterizerState.setDebugName("Clear11 Rasterizer State with scissor enabled");
// Initialize Depthstencil state with defaults
......@@ -343,8 +346,8 @@ angle::Result Clear11::ensureConstantBufferCreated(const gl::Context *context)
initialData.SysMemPitch = g_ConstantBufferSize;
initialData.SysMemSlicePitch = g_ConstantBufferSize;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(bufferDesc, &initialData, &mConstantBuffer));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &initialData,
&mConstantBuffer));
mConstantBuffer.setDebugName("Clear11 Constant Buffer");
return angle::Result::Continue();
}
......@@ -381,8 +384,8 @@ angle::Result Clear11::ensureVertexBufferCreated(const gl::Context *context)
initialData.SysMemPitch = vbSize;
initialData.SysMemSlicePitch = initialData.SysMemPitch;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(bufferDesc, &initialData, &mVertexBuffer));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &initialData,
&mVertexBuffer));
mVertexBuffer.setDebugName("Clear11 Vertex Buffer");
return angle::Result::Continue();
}
......
src/libANGLE/renderer/d3d/d3d11/Context11.cpp
......@@ -241,12 +241,12 @@ std::vector<PathImpl *> Context11::createPaths(GLsizei)
gl::Error Context11::flush(const gl::Context *context)
{
return mRenderer->flush();
return mRenderer->flush(this);
}
gl::Error Context11::finish(const gl::Context *context)
{
return mRenderer->finish();
return mRenderer->finish(this);
}
gl::Error Context11::drawArrays(const gl::Context *context,
......
src/libANGLE/renderer/d3d/d3d11/Image11.cpp
......@@ -14,6 +14,7 @@
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h"
......@@ -477,7 +478,8 @@ angle::Result Image11::copyWithoutConversion(const gl::Context *context,
resolveDesc.MiscFlags = 0;
d3d11::Texture2D resolveTex;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(resolveDesc, &resolveTex));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), resolveDesc, &resolveTex));
deviceContext->ResolveSubresource(resolveTex.get(), 0, textureHelper.get(),
sourceSubResource, textureHelper.getFormat());
......@@ -533,6 +535,8 @@ angle::Result Image11::createStagingTexture(const gl::Context *context)
// adjust size if needed for compressed textures
d3d11::MakeValidSize(false, dxgiFormat, &width, &height, &lodOffset);
Context11 *context11 = GetImplAs<Context11>(context);
switch (mType)
{
case gl::TextureType::_3D:
......@@ -555,14 +559,13 @@ angle::Result Image11::createStagingTexture(const gl::Context *context)
context, mInternalFormat, mRenderer->getRenderer11DeviceCaps(), width, height,
mDepth, lodOffset + 1, &initialData));
ANGLE_TRY_HANDLE(context,
mRenderer->allocateTexture(desc, formatInfo, initialData.data(),
&mStagingTexture));
ANGLE_TRY(mRenderer->allocateTexture(context11, desc, formatInfo,
initialData.data(), &mStagingTexture));
}
else
{
ANGLE_TRY_HANDLE(context,
mRenderer->allocateTexture(desc, formatInfo, &mStagingTexture));
ANGLE_TRY(
mRenderer->allocateTexture(context11, desc, formatInfo, &mStagingTexture));
}
mStagingTexture.setDebugName("Image11::StagingTexture3D");
......@@ -594,14 +597,13 @@ angle::Result Image11::createStagingTexture(const gl::Context *context)
context, mInternalFormat, mRenderer->getRenderer11DeviceCaps(), width, height,
1, lodOffset + 1, &initialData));
ANGLE_TRY_HANDLE(context,
mRenderer->allocateTexture(desc, formatInfo, initialData.data(),
&mStagingTexture));
ANGLE_TRY(mRenderer->allocateTexture(context11, desc, formatInfo,
initialData.data(), &mStagingTexture));
}
else
{
ANGLE_TRY_HANDLE(context,
mRenderer->allocateTexture(desc, formatInfo, &mStagingTexture));
ANGLE_TRY(
mRenderer->allocateTexture(context11, desc, formatInfo, &mStagingTexture));
}
mStagingTexture.setDebugName("Image11::StagingTexture2D");
......
src/libANGLE/renderer/d3d/d3d11/IndexBuffer11.cpp
......@@ -8,6 +8,8 @@
#include "libANGLE/renderer/d3d/d3d11/IndexBuffer11.h"
#include "libANGLE/Context.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
......@@ -42,7 +44,7 @@ gl::Error IndexBuffer11::initialize(const gl::Context *context,
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &mBuffer));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &mBuffer));
if (dynamic)
{
......
src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp
......@@ -301,8 +301,8 @@ angle::Result InputLayoutCache::createInputLayout(
InputElementArray inputElementArray(inputElements.data(), inputElementCount);
ShaderData vertexShaderData(shader11->getFunction(), shader11->getLength());
ANGLE_TRY_HANDLE(
context, renderer->allocateResource(inputElementArray, &vertexShaderData, inputLayoutOut));
ANGLE_TRY(renderer->allocateResource(GetImplAs<Context11>(context), inputElementArray,
&vertexShaderData, inputLayoutOut));
return angle::Result::Continue();
}
......
src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp
......@@ -13,15 +13,16 @@
#include "libANGLE/Buffer.h"
#include "libANGLE/Context.h"
#include "libANGLE/Texture.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/d3d11/Buffer11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
#include "libANGLE/renderer/d3d/d3d11/texture_format_table.h"
#include "libANGLE/renderer/d3d/d3d11/TextureStorage11.h"
#include "libANGLE/Texture.h"
// Precompiled shaders
#include "libANGLE/renderer/d3d/d3d11/shaders/compiled/buffertotexture11_gs.h"
......@@ -67,7 +68,9 @@ angle::Result PixelTransfer11::loadResources(const gl::Context *context)
rasterDesc.MultisampleEnable = FALSE;
rasterDesc.AntialiasedLineEnable = FALSE;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(rasterDesc, &mCopyRasterizerState));
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(mRenderer->allocateResource(context11, rasterDesc, &mCopyRasterizerState));
D3D11_DEPTH_STENCIL_DESC depthStencilDesc;
depthStencilDesc.DepthEnable = true;
......@@ -85,8 +88,7 @@ angle::Result PixelTransfer11::loadResources(const gl::Context *context)
depthStencilDesc.BackFace.StencilPassOp = D3D11_STENCIL_OP_KEEP;
depthStencilDesc.BackFace.StencilFunc = D3D11_COMPARISON_ALWAYS;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(depthStencilDesc, &mCopyDepthStencilState));
ANGLE_TRY(mRenderer->allocateResource(context11, depthStencilDesc, &mCopyDepthStencilState));
D3D11_BUFFER_DESC constantBufferDesc = { 0 };
constantBufferDesc.ByteWidth = roundUp<UINT>(sizeof(CopyShaderParams), 32u);
......@@ -96,16 +98,15 @@ angle::Result PixelTransfer11::loadResources(const gl::Context *context)
constantBufferDesc.MiscFlags = 0;
constantBufferDesc.StructureByteStride = 0;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(constantBufferDesc, &mParamsConstantBuffer));
ANGLE_TRY(mRenderer->allocateResource(context11, constantBufferDesc, &mParamsConstantBuffer));
mParamsConstantBuffer.setDebugName("PixelTransfer11 constant buffer");
// init shaders
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(ShaderData(g_VS_BufferToTexture),
ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_VS_BufferToTexture),
&mBufferToTextureVS));
mBufferToTextureVS.setDebugName("BufferToTexture VS");
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(ShaderData(g_GS_BufferToTexture),
ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_GS_BufferToTexture),
&mBufferToTextureGS));
mBufferToTextureGS.setDebugName("BufferToTexture GS");
......@@ -229,11 +230,13 @@ angle::Result PixelTransfer11::buildShaderMap(const gl::Context *context)
d3d11::PixelShader bufferToTextureInt;
d3d11::PixelShader bufferToTextureUint;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4F),
Context11 *context11 = GetImplAs<Context11>(context);
ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_PS_BufferToTexture_4F),
&bufferToTextureFloat));
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4I),
ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_PS_BufferToTexture_4I),
&bufferToTextureInt));
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4UI),
ANGLE_TRY(mRenderer->allocateResource(context11, ShaderData(g_PS_BufferToTexture_4UI),
&bufferToTextureUint));
bufferToTextureFloat.setDebugName("BufferToTexture RGBA ps");
......
src/libANGLE/renderer/d3d/d3d11/Query11.cpp
......@@ -165,7 +165,7 @@ angle::Result Query11::resume(Context11 *context11)
queryDesc.Query = d3dQueryType;
queryDesc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context11, mRenderer->allocateResource(queryDesc, &mActiveQuery->query));
ANGLE_TRY(mRenderer->allocateResource(context11, queryDesc, &mActiveQuery->query));
// If we are doing time elapsed we also need a query to actually query the timestamp
if (type == gl::QueryType::TimeElapsed)
......@@ -174,10 +174,8 @@ angle::Result Query11::resume(Context11 *context11)
desc.Query = D3D11_QUERY_TIMESTAMP;
desc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context11,
mRenderer->allocateResource(desc, &mActiveQuery->beginTimestamp));
ANGLE_TRY_HANDLE(context11,
mRenderer->allocateResource(desc, &mActiveQuery->endTimestamp));
ANGLE_TRY(mRenderer->allocateResource(context11, desc, &mActiveQuery->beginTimestamp));
ANGLE_TRY(mRenderer->allocateResource(context11, desc, &mActiveQuery->endTimestamp));
}
ID3D11DeviceContext *context = mRenderer->getDeviceContext();
......
src/libANGLE/renderer/d3d/d3d11/RenderStateCache.cpp
......@@ -15,6 +15,7 @@
#include "libANGLE/Context.h"
#include "libANGLE/Framebuffer.h"
#include "libANGLE/FramebufferAttachment.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/Framebuffer11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
......@@ -115,7 +116,7 @@ angle::Result RenderStateCache::getBlendState(const gl::Context *context,
}
d3d11::BlendState d3dBlendState;
ANGLE_TRY_HANDLE(context, renderer->allocateResource(blendDesc, &d3dBlendState));
ANGLE_TRY(renderer->allocateResource(GetImplAs<Context11>(context), blendDesc, &d3dBlendState));
const auto &iter = mBlendStateCache.Put(key, std::move(d3dBlendState));
*outBlendState = &iter->second;
......@@ -174,7 +175,8 @@ angle::Result RenderStateCache::getRasterizerState(const gl::Context *context,
}
d3d11::RasterizerState dx11RasterizerState;
ANGLE_TRY_HANDLE(context, renderer->allocateResource(rasterDesc, &dx11RasterizerState));
ANGLE_TRY(renderer->allocateResource(GetImplAs<Context11>(context), rasterDesc,
&dx11RasterizerState));
*outRasterizerState = dx11RasterizerState.get();
mRasterizerStateCache.Put(key, std::move(dx11RasterizerState));
......@@ -212,7 +214,8 @@ angle::Result RenderStateCache::getDepthStencilState(const gl::Context *context,
dsDesc.BackFace.StencilFunc = ConvertComparison(glState.stencilBackFunc);
d3d11::DepthStencilState dx11DepthStencilState;
ANGLE_TRY_HANDLE(context, renderer->allocateResource(dsDesc, &dx11DepthStencilState));
ANGLE_TRY(
renderer->allocateResource(GetImplAs<Context11>(context), dsDesc, &dx11DepthStencilState));
const auto &iter = mDepthStencilStateCache.Put(glState, std::move(dx11DepthStencilState));
*outDSState = &iter->second;
......@@ -267,7 +270,8 @@ angle::Result RenderStateCache::getSamplerState(const gl::Context *context,
}
d3d11::SamplerState dx11SamplerState;
ANGLE_TRY_HANDLE(context, renderer->allocateResource(samplerDesc, &dx11SamplerState));
ANGLE_TRY(
renderer->allocateResource(GetImplAs<Context11>(context), samplerDesc, &dx11SamplerState));
*outSamplerState = dx11SamplerState.get();
mSamplerStateCache.Put(samplerState, std::move(dx11SamplerState));
......
src/libANGLE/renderer/d3d/d3d11/RenderTarget11.cpp
......@@ -9,6 +9,8 @@
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
#include "libANGLE/Context.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/SwapChain11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
......@@ -280,12 +282,14 @@ const d3d11::DepthStencilView &TextureRenderTarget11::getDepthStencilView() cons
return mDepthStencil;
}
const d3d11::SharedSRV &TextureRenderTarget11::getShaderResourceView() const
const d3d11::SharedSRV &TextureRenderTarget11::getShaderResourceView(
const gl::Context *context) const
{
return mShaderResource;
}
const d3d11::SharedSRV &TextureRenderTarget11::getBlitShaderResourceView() const
const d3d11::SharedSRV &TextureRenderTarget11::getBlitShaderResourceView(
const gl::Context *context) const
{
return mBlitShaderResource;
}
......@@ -376,16 +380,18 @@ const d3d11::DepthStencilView &SurfaceRenderTarget11::getDepthStencilView() cons
return mSwapChain->getDepthStencil();
}
const d3d11::SharedSRV &SurfaceRenderTarget11::getShaderResourceView() const
const d3d11::SharedSRV &SurfaceRenderTarget11::getShaderResourceView(
const gl::Context *context) const
{
return (mDepth ? mSwapChain->getDepthStencilShaderResource()
: mSwapChain->getRenderTargetShaderResource());
: mSwapChain->getRenderTargetShaderResource(GetImplAs<Context11>(context)));
}
const d3d11::SharedSRV &SurfaceRenderTarget11::getBlitShaderResourceView() const
const d3d11::SharedSRV &SurfaceRenderTarget11::getBlitShaderResourceView(
const gl::Context *context) const
{
// The SurfaceRenderTargetView format should always be such that the normal SRV works for blits.
return getShaderResourceView();
return getShaderResourceView(context);
}
unsigned int SurfaceRenderTarget11::getSubresourceIndex() const
......
src/libANGLE/renderer/d3d/d3d11/RenderTarget11.h
......@@ -29,8 +29,8 @@ class RenderTarget11 : public RenderTargetD3D
virtual const TextureHelper11 &getTexture() const = 0;
virtual const d3d11::RenderTargetView &getRenderTargetView() const = 0;
virtual const d3d11::DepthStencilView &getDepthStencilView() const = 0;
virtual const d3d11::SharedSRV &getShaderResourceView() const = 0;
virtual const d3d11::SharedSRV &getBlitShaderResourceView() const = 0;
virtual const d3d11::SharedSRV &getShaderResourceView(const gl::Context *context) const = 0;
virtual const d3d11::SharedSRV &getBlitShaderResourceView(const gl::Context *context) const = 0;
virtual unsigned int getSubresourceIndex() const = 0;
......@@ -74,8 +74,8 @@ class TextureRenderTarget11 : public RenderTarget11
const TextureHelper11 &getTexture() const override;
const d3d11::RenderTargetView &getRenderTargetView() const override;
const d3d11::DepthStencilView &getDepthStencilView() const override;
const d3d11::SharedSRV &getShaderResourceView() const override;
const d3d11::SharedSRV &getBlitShaderResourceView() const override;
const d3d11::SharedSRV &getShaderResourceView(const gl::Context *context) const override;
const d3d11::SharedSRV &getBlitShaderResourceView(const gl::Context *context) const override;
unsigned int getSubresourceIndex() const override;
......@@ -112,8 +112,8 @@ class SurfaceRenderTarget11 : public RenderTarget11
const TextureHelper11 &getTexture() const override;
const d3d11::RenderTargetView &getRenderTargetView() const override;
const d3d11::DepthStencilView &getDepthStencilView() const override;
const d3d11::SharedSRV &getShaderResourceView() const override;
const d3d11::SharedSRV &getBlitShaderResourceView() const override;
const d3d11::SharedSRV &getShaderResourceView(const gl::Context *context) const override;
const d3d11::SharedSRV &getBlitShaderResourceView(const gl::Context *context) const override;
unsigned int getSubresourceIndex() const override;
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -1188,13 +1188,13 @@ void Renderer11::generateDisplayExtensions(egl::DisplayExtensions *outExtensions
outExtensions->robustResourceInitialization = true;
}
gl::Error Renderer11::flush()
gl::Error Renderer11::flush(Context11 *context11)
{
mDeviceContext->Flush();
return gl::NoError();
}
gl::Error Renderer11::finish()
gl::Error Renderer11::finish(Context11 *context11)
{
if (!mSyncQuery.valid())
{
......@@ -1202,7 +1202,7 @@ gl::Error Renderer11::finish()
queryDesc.Query = D3D11_QUERY_EVENT;
queryDesc.MiscFlags = 0;
ANGLE_TRY(allocateResource(queryDesc, &mSyncQuery));
ANGLE_TRY(allocateResource(context11, queryDesc, &mSyncQuery));
}
mDeviceContext->End(mSyncQuery.get());
......@@ -2212,7 +2212,7 @@ gl::Error Renderer11::copyImageInternal(const gl::Context *context,
viewDesc.Texture2D.MostDetailedMip = 0;
d3d11::SharedSRV readSRV;
ANGLE_TRY(allocateResource(viewDesc, tex.get(), &readSRV));
ANGLE_TRY(allocateResource(GetImplAs<Context11>(context), viewDesc, tex.get(), &readSRV));
ASSERT(readSRV.valid());
ANGLE_TRY(mBlit->copyTexture(context, readSRV, sourceArea, sourceSize, sourceFormat, dest,
......@@ -2224,7 +2224,7 @@ gl::Error Renderer11::copyImageInternal(const gl::Context *context,
ASSERT(!sourceRenderTarget->isMultisampled());
const d3d11::SharedSRV &source = sourceRenderTarget->getBlitShaderResourceView();
const d3d11::SharedSRV &source = sourceRenderTarget->getBlitShaderResourceView(context);
ASSERT(source.valid());
ANGLE_TRY(mBlit->copyTexture(context, source, sourceArea, sourceSize, sourceFormat, dest,
......@@ -2477,6 +2477,8 @@ gl::Error Renderer11::createRenderTarget(const gl::Context *context,
const gl::TextureCaps &textureCaps = getNativeTextureCaps().get(format);
GLuint supportedSamples = textureCaps.getNearestSamples(samples);
Context11 *context11 = GetImplAs<Context11>(context);
if (width > 0 && height > 0)
{
// Create texture resource
......@@ -2515,7 +2517,7 @@ gl::Error Renderer11::createRenderTarget(const gl::Context *context,
ASSERT(bindRTV != bindDSV);
TextureHelper11 texture;
ANGLE_TRY(allocateTexture(desc, formatInfo, &texture));
ANGLE_TRY(allocateTexture(context11, desc, formatInfo, &texture));
texture.setDebugName("createRenderTarget.Texture");
d3d11::SharedSRV srv;
......@@ -2529,7 +2531,7 @@ gl::Error Renderer11::createRenderTarget(const gl::Context *context,
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = 1;
ANGLE_TRY(allocateResource(srvDesc, texture.get(), &srv));
ANGLE_TRY(allocateResource(context11, srvDesc, texture.get(), &srv));
srv.setDebugName("createRenderTarget.SRV");
if (formatInfo.blitSRVFormat != formatInfo.srvFormat)
......@@ -2542,7 +2544,7 @@ gl::Error Renderer11::createRenderTarget(const gl::Context *context,
blitSRVDesc.Texture2D.MostDetailedMip = 0;
blitSRVDesc.Texture2D.MipLevels = 1;
ANGLE_TRY(allocateResource(blitSRVDesc, texture.get(), &blitSRV));
ANGLE_TRY(allocateResource(context11, blitSRVDesc, texture.get(), &blitSRV));
blitSRV.setDebugName("createRenderTarget.BlitSRV");
}
else
......@@ -2561,7 +2563,7 @@ gl::Error Renderer11::createRenderTarget(const gl::Context *context,
dsvDesc.Flags = 0;
d3d11::DepthStencilView dsv;
ANGLE_TRY(allocateResource(dsvDesc, texture.get(), &dsv));
ANGLE_TRY(allocateResource(context11, dsvDesc, texture.get(), &dsv));
dsv.setDebugName("createRenderTarget.DSV");
*outRT = new TextureRenderTarget11(std::move(dsv), texture, srv, format, formatInfo,
......@@ -2576,7 +2578,7 @@ gl::Error Renderer11::createRenderTarget(const gl::Context *context,
rtvDesc.Texture2D.MipSlice = 0;
d3d11::RenderTargetView rtv;
ANGLE_TRY(allocateResource(rtvDesc, texture.get(), &rtv));
ANGLE_TRY(allocateResource(context11, rtvDesc, texture.get(), &rtv));
rtv.setDebugName("createRenderTarget.RTV");
if (formatInfo.dataInitializerFunction != nullptr)
......@@ -2634,13 +2636,15 @@ gl::Error Renderer11::loadExecutable(const gl::Context *context,
{
ShaderData shaderData(function, length);
Context11 *context11 = GetImplAs<Context11>(context);
switch (type)
{
case gl::ShaderType::Vertex:
{
d3d11::VertexShader vertexShader;
d3d11::GeometryShader streamOutShader;
ANGLE_TRY(allocateResource(shaderData, &vertexShader));
ANGLE_TRY(allocateResource(context11, shaderData, &vertexShader));
if (!streamOutVaryings.empty())
{
......@@ -2660,7 +2664,8 @@ gl::Error Renderer11::loadExecutable(const gl::Context *context,
soDeclaration.push_back(entry);
}
ANGLE_TRY(allocateResource(shaderData, &soDeclaration, &streamOutShader));
ANGLE_TRY(
allocateResource(context11, shaderData, &soDeclaration, &streamOutShader));
}
*outExecutable = new ShaderExecutable11(function, length, std::move(vertexShader),
......@@ -2670,21 +2675,21 @@ gl::Error Renderer11::loadExecutable(const gl::Context *context,
case gl::ShaderType::Fragment:
{
d3d11::PixelShader pixelShader;
ANGLE_TRY(allocateResource(shaderData, &pixelShader));
ANGLE_TRY(allocateResource(context11, shaderData, &pixelShader));
*outExecutable = new ShaderExecutable11(function, length, std::move(pixelShader));
}
break;
case gl::ShaderType::Geometry:
{
d3d11::GeometryShader geometryShader;
ANGLE_TRY(allocateResource(shaderData, &geometryShader));
ANGLE_TRY(allocateResource(context11, shaderData, &geometryShader));
*outExecutable = new ShaderExecutable11(function, length, std::move(geometryShader));
}
break;
case gl::ShaderType::Compute:
{
d3d11::ComputeShader computeShader;
ANGLE_TRY(allocateResource(shaderData, &computeShader));
ANGLE_TRY(allocateResource(context11, shaderData, &computeShader));
*outExecutable = new ShaderExecutable11(function, length, std::move(computeShader));
}
break;
......@@ -3078,8 +3083,8 @@ gl::Error Renderer11::readFromAttachment(const gl::Context *context,
resolveDesc.CPUAccessFlags = 0;
resolveDesc.MiscFlags = 0;
ANGLE_TRY(
allocateTexture(resolveDesc, textureHelper.getFormatSet(), &resolvedTextureHelper));
ANGLE_TRY(allocateTexture(GetImplAs<Context11>(context), resolveDesc,
textureHelper.getFormatSet(), &resolvedTextureHelper));
resolvedTextureHelper.setDebugName("readFromAttachment::resolvedTextureHelper");
mDeviceContext->ResolveSubresource(resolvedTextureHelper.get(), 0, textureHelper.get(),
......@@ -3202,7 +3207,8 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Context *context,
viewDesc.Texture2D.MipLevels = 1;
viewDesc.Texture2D.MostDetailedMip = 0;
ANGLE_TRY(allocateResource(viewDesc, readTexture.get(), &readSRV));
ANGLE_TRY(allocateResource(GetImplAs<Context11>(context), viewDesc, readTexture.get(),
&readSRV));
}
}
else
......@@ -3210,11 +3216,11 @@ gl::Error Renderer11::blitRenderbufferRect(const gl::Context *context,
ASSERT(readRenderTarget11);
readTexture = readRenderTarget11->getTexture();
readSubresource = readRenderTarget11->getSubresourceIndex();
readSRV = readRenderTarget11->getBlitShaderResourceView().makeCopy();
readSRV = readRenderTarget11->getBlitShaderResourceView(context).makeCopy();
if (!readSRV.valid())
{
ASSERT(depthBlit || stencilBlit);
readSRV = readRenderTarget11->getShaderResourceView().makeCopy();
readSRV = readRenderTarget11->getShaderResourceView(context).makeCopy();
}
ASSERT(readSRV.valid());
}
......@@ -3497,7 +3503,7 @@ gl::Error Renderer11::resolveMultisampledTexture(const gl::Context *context,
const auto &formatSet = renderTarget->getFormatSet();
ASSERT(renderTarget->isMultisampled());
const d3d11::SharedSRV &sourceSRV = renderTarget->getShaderResourceView();
const d3d11::SharedSRV &sourceSRV = renderTarget->getShaderResourceView(context);
D3D11_SHADER_RESOURCE_VIEW_DESC sourceSRVDesc;
sourceSRV.get()->GetDesc(&sourceSRVDesc);
ASSERT(sourceSRVDesc.ViewDimension == D3D_SRV_DIMENSION_TEXTURE2DMS);
......@@ -3520,7 +3526,8 @@ gl::Error Renderer11::resolveMultisampledTexture(const gl::Context *context,
resolveDesc.CPUAccessFlags = 0;
resolveDesc.MiscFlags = 0;
ANGLE_TRY(allocateTexture(resolveDesc, formatSet, &mCachedResolveTexture));
ANGLE_TRY(allocateTexture(GetImplAs<Context11>(context), resolveDesc, formatSet,
&mCachedResolveTexture));
}
mDeviceContext->ResolveSubresource(mCachedResolveTexture.get(), 0,
......@@ -3690,6 +3697,8 @@ angle::Result Renderer11::createStagingTexture(const gl::Context *context,
StagingAccess readAndWriteAccess,
TextureHelper11 *textureOut)
{
Context11 *context11 = GetImplAs<Context11>(context);
if (textureType == ResourceType::Texture2D)
{
D3D11_TEXTURE2D_DESC stagingDesc;
......@@ -3710,7 +3719,7 @@ angle::Result Renderer11::createStagingTexture(const gl::Context *context,
stagingDesc.CPUAccessFlags |= D3D11_CPU_ACCESS_WRITE;
}
ANGLE_TRY_HANDLE(context, allocateTexture(stagingDesc, formatSet, textureOut));
ANGLE_TRY(allocateTexture(context11, stagingDesc, formatSet, textureOut));
return angle::Result::Continue();
}
ASSERT(textureType == ResourceType::Texture3D);
......@@ -3726,28 +3735,30 @@ angle::Result Renderer11::createStagingTexture(const gl::Context *context,
stagingDesc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;
stagingDesc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context, allocateTexture(stagingDesc, formatSet, textureOut));
ANGLE_TRY(allocateTexture(context11, stagingDesc, formatSet, textureOut));
return angle::Result::Continue();
}
gl::Error Renderer11::allocateTexture(const D3D11_TEXTURE2D_DESC &desc,
angle::Result Renderer11::allocateTexture(d3d::Context *context,
const D3D11_TEXTURE2D_DESC &desc,
const d3d11::Format &format,
const D3D11_SUBRESOURCE_DATA *initData,
TextureHelper11 *textureOut)
{
d3d11::Texture2D texture;
ANGLE_TRY(mResourceManager11.allocate(this, &desc, initData, &texture));
ANGLE_TRY(mResourceManager11.allocate(context, this, &desc, initData, &texture));
textureOut->init(std::move(texture), desc, format);
return angle::Result::Continue();
}
gl::Error Renderer11::allocateTexture(const D3D11_TEXTURE3D_DESC &desc,
angle::Result Renderer11::allocateTexture(d3d::Context *context,
const D3D11_TEXTURE3D_DESC &desc,
const d3d11::Format &format,
const D3D11_SUBRESOURCE_DATA *initData,
TextureHelper11 *textureOut)
{
d3d11::Texture3D texture;
ANGLE_TRY(mResourceManager11.allocate(this, &desc, initData, &texture));
ANGLE_TRY(mResourceManager11.allocate(context, this, &desc, initData, &texture));
textureOut->init(std::move(texture), desc, format);
return angle::Result::Continue();
}
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.h
......@@ -124,8 +124,8 @@ class Renderer11 : public RendererD3D
ContextImpl *createContext(const gl::ContextState &state) override;
gl::Error flush();
gl::Error finish();
gl::Error flush(Context11 *context11);
gl::Error finish(Context11 *context11);
bool isValidNativeWindow(EGLNativeWindowType window) const override;
NativeWindowD3D *createNativeWindow(EGLNativeWindowType window,
......@@ -415,37 +415,45 @@ class Renderer11 : public RendererD3D
TextureHelper11 *textureOut);
template <typename DescT, typename ResourceT>
gl::Error allocateResource(const DescT &desc, ResourceT *resourceOut)
angle::Result allocateResource(d3d::Context *context, const DescT &desc, ResourceT *resourceOut)
{
return mResourceManager11.allocate(this, &desc, nullptr, resourceOut);
return mResourceManager11.allocate(context, this, &desc, nullptr, resourceOut);
}
template <typename DescT, typename InitDataT, typename ResourceT>
gl::Error allocateResource(const DescT &desc, InitDataT *initData, ResourceT *resourceOut)
angle::Result allocateResource(d3d::Context *context,
const DescT &desc,
InitDataT *initData,
ResourceT *resourceOut)
{
return mResourceManager11.allocate(this, &desc, initData, resourceOut);
return mResourceManager11.allocate(context, this, &desc, initData, resourceOut);
}
template <typename InitDataT, typename ResourceT>
gl::Error allocateResourceNoDesc(InitDataT *initData, ResourceT *resourceOut)
angle::Result allocateResourceNoDesc(d3d::Context *context,
InitDataT *initData,
ResourceT *resourceOut)
{
return mResourceManager11.allocate(this, nullptr, initData, resourceOut);
return mResourceManager11.allocate(context, this, nullptr, initData, resourceOut);
}
template <typename DescT>
gl::Error allocateTexture(const DescT &desc,
angle::Result allocateTexture(d3d::Context *context,
const DescT &desc,
const d3d11::Format &format,
TextureHelper11 *textureOut)
{
return allocateTexture(desc, format, nullptr, textureOut);
return allocateTexture(context, desc, format, nullptr, textureOut);
}
gl::Error allocateTexture(const D3D11_TEXTURE2D_DESC &desc,
angle::Result allocateTexture(d3d::Context *context,
const D3D11_TEXTURE2D_DESC &desc,
const d3d11::Format &format,
const D3D11_SUBRESOURCE_DATA *initData,
TextureHelper11 *textureOut);
gl::Error allocateTexture(const D3D11_TEXTURE3D_DESC &desc,
angle::Result allocateTexture(d3d::Context *context,
const D3D11_TEXTURE3D_DESC &desc,
const d3d11::Format &format,
const D3D11_SUBRESOURCE_DATA *initData,
TextureHelper11 *textureOut);
......
src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp
......@@ -260,18 +260,22 @@ DXGI_FORMAT GetTypedDepthStencilFormat(DXGI_FORMAT dxgiFormat)
}
template <typename DescT, typename ResourceT>
gl::Error ClearResource(Renderer11 *renderer, const DescT *desc, ResourceT *texture)
angle::Result ClearResource(d3d::Context *context,
Renderer11 *renderer,
const DescT *desc,
ResourceT *texture)
{
// No-op.
return gl::NoError();
return angle::Result::Continue();
}
template <>
gl::Error ClearResource(Renderer11 *renderer,
angle::Result ClearResource(d3d::Context *context,
Renderer11 *renderer,
const D3D11_TEXTURE2D_DESC *desc,
ID3D11Texture2D *texture)
{
ID3D11DeviceContext *context = renderer->getDeviceContext();
ID3D11DeviceContext *deviceContext = renderer->getDeviceContext();
if ((desc->BindFlags & D3D11_BIND_DEPTH_STENCIL) != 0)
{
......@@ -297,9 +301,9 @@ gl::Error ClearResource(Renderer11 *renderer,
}
d3d11::DepthStencilView dsv;
ANGLE_TRY(renderer->allocateResource(dsvDesc, texture, &dsv));
ANGLE_TRY(renderer->allocateResource(context, dsvDesc, texture, &dsv));
context->ClearDepthStencilView(dsv.get(), clearFlags, kDebugDepthInitValue,
deviceContext->ClearDepthStencilView(dsv.get(), clearFlags, kDebugDepthInitValue,
kDebugStencilInitValue);
}
}
......@@ -307,36 +311,38 @@ gl::Error ClearResource(Renderer11 *renderer,
{
ASSERT((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0);
d3d11::RenderTargetView rtv;
ANGLE_TRY(renderer->allocateResourceNoDesc(texture, &rtv));
ANGLE_TRY(renderer->allocateResourceNoDesc(context, texture, &rtv));
context->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue);
deviceContext->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue);
}
return gl::NoError();
return angle::Result::Continue();
}
template <>
gl::Error ClearResource(Renderer11 *renderer,
angle::Result ClearResource(d3d::Context *context,
Renderer11 *renderer,
const D3D11_TEXTURE3D_DESC *desc,
ID3D11Texture3D *texture)
{
ID3D11DeviceContext *context = renderer->getDeviceContext();
ID3D11DeviceContext *deviceContext = renderer->getDeviceContext();
ASSERT((desc->BindFlags & D3D11_BIND_DEPTH_STENCIL) == 0);
ASSERT((desc->BindFlags & D3D11_BIND_RENDER_TARGET) != 0);
d3d11::RenderTargetView rtv;
ANGLE_TRY(renderer->allocateResourceNoDesc(texture, &rtv));
ANGLE_TRY(renderer->allocateResourceNoDesc(context, texture, &rtv));
context->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue);
return gl::NoError();
deviceContext->ClearRenderTargetView(rtv.get(), kDebugColorInitClearValue);
return angle::Result::Continue();
}
#define ANGLE_RESOURCE_STRINGIFY_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) #RESTYPE,
#define ANGLE_RESOURCE_STRINGIFY_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \
"Error allocating " #RESTYPE,
constexpr std::array<const char *, NumResourceTypes> kResourceTypeNames = {
constexpr std::array<const char *, NumResourceTypes> kResourceTypeErrors = {
{ANGLE_RESOURCE_TYPE_OP(Stringify, ANGLE_RESOURCE_STRINGIFY_OP)}};
static_assert(kResourceTypeNames[NumResourceTypes - 1] != nullptr,
static_assert(kResourceTypeErrors[NumResourceTypes - 1] != nullptr,
"All members must be initialized.");
} // anonymous namespace
......@@ -363,7 +369,8 @@ ResourceManager11::~ResourceManager11()
}
template <typename T>
gl::Error ResourceManager11::allocate(Renderer11 *renderer,
angle::Result ResourceManager11::allocate(d3d::Context *context,
Renderer11 *renderer,
const GetDescFromD3D11<T> *desc,
GetInitDataFromD3D11<T> *initData,
Resource11<T> *resourceOut)
......@@ -378,27 +385,17 @@ gl::Error ResourceManager11::allocate(Renderer11 *renderer,
}
HRESULT hr = CreateResource(device, desc, shadowInitData, &resource);
if (FAILED(hr))
{
ASSERT(!resource);
if (d3d11::isDeviceLostError(hr))
{
renderer->notifyDeviceLost();
}
return gl::OutOfMemory() << "Error allocating "
<< std::string(kResourceTypeNames[ResourceTypeIndex<T>()]) << ". "
<< gl::FmtHR(hr);
}
ANGLE_TRY_HR(context, hr, kResourceTypeErrors[ResourceTypeIndex<T>()]);
if (!shadowInitData && mInitializeAllocations)
{
ANGLE_TRY(ClearResource(renderer, desc, resource));
ANGLE_TRY(ClearResource(context, renderer, desc, resource));
}
ASSERT(resource);
incrResource(GetResourceTypeFromD3D11<T>(), ComputeMemoryUsage(desc));
*resourceOut = std::move(Resource11<T>(resource, this));
return gl::NoError();
return angle::Result::Continue();
}
void ResourceManager11::incrResource(ResourceType resourceType, uint64_t memorySize)
......@@ -533,8 +530,8 @@ void ResourceManager11::setAllocationsInitialized(bool initialize)
#define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \
\
template \
gl::Error \
ResourceManager11::allocate(Renderer11 *, const DESCTYPE *, INITDATATYPE *, \
angle::Result \
ResourceManager11::allocate(d3d::Context *, Renderer11 *, const DESCTYPE *, INITDATATYPE *, \
Resource11<D3D11TYPE> *);
ANGLE_RESOURCE_TYPE_OP(Instantitate, ANGLE_INSTANTIATE_OP)
......
src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h
......@@ -32,6 +32,11 @@ HRESULT SetDebugName(angle::ComPtr<T> &resource, const char *name)
}
} // namespace d3d11
namespace d3d
{
class Context;
} // namespace d3d
class Renderer11;
class ResourceManager11;
template <typename T>
......@@ -294,19 +299,21 @@ class ResourceManager11 final : angle::NonCopyable
~ResourceManager11();
template <typename T>
gl::Error allocate(Renderer11 *renderer,
angle::Result allocate(d3d::Context *context,
Renderer11 *renderer,
const GetDescFromD3D11<T> *desc,
GetInitDataFromD3D11<T> *initData,
Resource11<T> *resourceOut);
template <typename T>
gl::Error allocate(Renderer11 *renderer,
angle::Result allocate(d3d::Context *context,
Renderer11 *renderer,
const GetDescFromD3D11<T> *desc,
GetInitDataFromD3D11<T> *initData,
SharedResource11<T> *sharedRes)
{
Resource11<T> res;
ANGLE_TRY(allocate(renderer, desc, initData, &res));
ANGLE_TRY(allocate(context, renderer, desc, initData, &res));
*sharedRes = std::move(res);
return angle::Result::Continue();
}
......
src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp
......@@ -10,6 +10,7 @@
#include "libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h"
#include "libANGLE/Context.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
namespace rx
......@@ -113,7 +114,8 @@ angle::Result UniformStorage11::getConstantBuffer(const gl::Context *context,
desc.Usage = D3D11_USAGE_DEFAULT;
desc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
ANGLE_TRY_HANDLE(context, renderer->allocateResource(desc, &mConstantBuffer));
ANGLE_TRY(
renderer->allocateResource(GetImplAs<Context11>(context), desc, &mConstantBuffer));
}
*bufferOut = &mConstantBuffer;
......
src/libANGLE/renderer/d3d/d3d11/StateManager11.cpp
......@@ -2791,6 +2791,8 @@ angle::Result StateManager11::applyVertexBuffers(const gl::Context *context,
queueVertexBufferChange(bufferIndex, buffer, vertexStride, vertexOffset);
}
Context11 *context11 = GetImplAs<Context11>(context);
// Instanced PointSprite emulation requires two additional ID3D11Buffers. A vertex buffer needs
// to be created and added to the list of current buffers, strides and offsets collections.
// This buffer contains the vertices for a single PointSprite quad.
......@@ -2823,8 +2825,7 @@ angle::Result StateManager11::applyVertexBuffers(const gl::Context *context,
vertexBufferDesc.MiscFlags = 0;
vertexBufferDesc.StructureByteStride = 0;
ANGLE_TRY_HANDLE(context,
mRenderer->allocateResource(vertexBufferDesc, &vertexBufferData,
ANGLE_TRY(mRenderer->allocateResource(context11, vertexBufferDesc, &vertexBufferData,
&mPointSpriteVertexBuffer));
}
......@@ -2849,7 +2850,7 @@ angle::Result StateManager11::applyVertexBuffers(const gl::Context *context,
indexBufferDesc.MiscFlags = 0;
indexBufferDesc.StructureByteStride = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(indexBufferDesc, &indexBufferData,
ANGLE_TRY(mRenderer->allocateResource(context11, indexBufferDesc, &indexBufferData,
&mPointSpriteIndexBuffer));
}
......@@ -3100,8 +3101,8 @@ angle::Result StateManager11::applyDriverUniformsForShader(const gl::Context *co
D3D11_BUFFER_DESC constantBufferDescription = {0};
d3d11::InitConstantBufferDesc(&constantBufferDescription, requiredSize);
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(constantBufferDescription,
&shaderDriverConstantBuffer));
ANGLE_TRY(mRenderer->allocateResource(
GetImplAs<Context11>(context), constantBufferDescription, &shaderDriverConstantBuffer));
ID3D11Buffer *driverConstants = shaderDriverConstantBuffer.get();
switch (shaderType)
......@@ -3196,8 +3197,8 @@ angle::Result StateManager11::applyComputeUniforms(const gl::Context *context,
D3D11_BUFFER_DESC constantBufferDescription = {0};
d3d11::InitConstantBufferDesc(&constantBufferDescription, requiredSize);
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(
constantBufferDescription,
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), constantBufferDescription,
&mShaderDriverConstantBuffers[gl::ShaderType::Compute]));
ID3D11Buffer *buffer = mShaderDriverConstantBuffers[gl::ShaderType::Compute].get();
deviceContext->CSSetConstantBuffers(d3d11::RESERVED_CONSTANT_BUFFER_SLOT_DRIVER, 1,
......
src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
......@@ -11,6 +11,7 @@
#include <EGL/eglext.h>
#include "libANGLE/features.h"
#include "libANGLE/renderer/d3d/DisplayD3D.h"
#include "libANGLE/renderer/d3d/d3d11/NativeWindow11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
......@@ -166,7 +167,7 @@ EGLint SwapChain11::resetOffscreenBuffers(DisplayD3D *displayD3D,
}
}
EGLint result = resetOffscreenDepthBuffer(backbufferWidth, backbufferHeight);
EGLint result = resetOffscreenDepthBuffer(displayD3D, backbufferWidth, backbufferHeight);
if (result != EGL_SUCCESS)
{
return result;
......@@ -261,11 +262,11 @@ EGLint SwapChain11::resetOffscreenColorBuffer(DisplayD3D *displayD3D,
offscreenTextureDesc.CPUAccessFlags = 0;
offscreenTextureDesc.MiscFlags = useSharedResource ? ANGLE_RESOURCE_SHARE_TYPE : 0;
gl::Error err = mRenderer->allocateTexture(offscreenTextureDesc, backbufferFormatInfo,
&mOffscreenTexture);
if (err.isError())
angle::Result result = mRenderer->allocateTexture(displayD3D, offscreenTextureDesc,
backbufferFormatInfo, &mOffscreenTexture);
if (result == angle::Result::Stop())
{
ERR() << "Could not create offscreen texture, " << err;
ERR() << "Could not create offscreen texture, " << displayD3D->getStoredErrorString();
release();
return EGL_BAD_ALLOC;
}
......@@ -276,23 +277,23 @@ EGLint SwapChain11::resetOffscreenColorBuffer(DisplayD3D *displayD3D,
if (useSharedResource)
{
IDXGIResource *offscreenTextureResource = nullptr;
HRESULT result = mOffscreenTexture.get()->QueryInterface(
HRESULT hr = mOffscreenTexture.get()->QueryInterface(
__uuidof(IDXGIResource), (void **)&offscreenTextureResource);
// Fall back to no share handle on failure
if (FAILED(result))
if (FAILED(hr))
{
ERR() << "Could not query offscreen texture resource, " << gl::FmtHR(result);
ERR() << "Could not query offscreen texture resource, " << gl::FmtHR(hr);
}
else
{
result = offscreenTextureResource->GetSharedHandle(&mShareHandle);
hr = offscreenTextureResource->GetSharedHandle(&mShareHandle);
SafeRelease(offscreenTextureResource);
if (FAILED(result))
if (FAILED(hr))
{
mShareHandle = nullptr;
ERR() << "Could not get offscreen texture shared handle, " << gl::FmtHR(result);
ERR() << "Could not get offscreen texture shared handle, " << gl::FmtHR(hr);
}
}
}
......@@ -307,9 +308,9 @@ EGLint SwapChain11::resetOffscreenColorBuffer(DisplayD3D *displayD3D,
(mEGLSamples <= 1) ? D3D11_RTV_DIMENSION_TEXTURE2D : D3D11_RTV_DIMENSION_TEXTURE2DMS;
offscreenRTVDesc.Texture2D.MipSlice = 0;
gl::Error err =
mRenderer->allocateResource(offscreenRTVDesc, mOffscreenTexture.get(), &mOffscreenRTView);
ASSERT(!err.isError());
angle::Result result = mRenderer->allocateResource(displayD3D, offscreenRTVDesc,
mOffscreenTexture.get(), &mOffscreenRTView);
ASSERT(result != angle::Result::Stop());
mOffscreenRTView.setDebugName("Offscreen back buffer render target");
D3D11_SHADER_RESOURCE_VIEW_DESC offscreenSRVDesc;
......@@ -321,9 +322,9 @@ EGLint SwapChain11::resetOffscreenColorBuffer(DisplayD3D *displayD3D,
if (offscreenTextureDesc.BindFlags & D3D11_BIND_SHADER_RESOURCE)
{
err = mRenderer->allocateResource(offscreenSRVDesc, mOffscreenTexture.get(),
result = mRenderer->allocateResource(displayD3D, offscreenSRVDesc, mOffscreenTexture.get(),
&mOffscreenSRView);
ASSERT(!err.isError());
ASSERT(result != angle::Result::Stop());
mOffscreenSRView.setDebugName("Offscreen back buffer shader resource");
}
else
......@@ -357,7 +358,9 @@ EGLint SwapChain11::resetOffscreenColorBuffer(DisplayD3D *displayD3D,
return EGL_SUCCESS;
}
EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbufferHeight)
EGLint SwapChain11::resetOffscreenDepthBuffer(DisplayD3D *displayD3D,
int backbufferWidth,
int backbufferHeight)
{
releaseOffscreenDepthBuffer();
......@@ -402,11 +405,12 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
depthStencilTextureDesc.CPUAccessFlags = 0;
depthStencilTextureDesc.MiscFlags = 0;
gl::Error err = mRenderer->allocateTexture(depthStencilTextureDesc, depthBufferFormatInfo,
&mDepthStencilTexture);
if (err.isError())
angle::Result result = mRenderer->allocateTexture(
displayD3D, depthStencilTextureDesc, depthBufferFormatInfo, &mDepthStencilTexture);
if (result == angle::Result::Stop())
{
ERR() << "Could not create depthstencil surface for new swap chain, " << err;
ERR() << "Could not create depthstencil surface for new swap chain, "
<< displayD3D->getStoredErrorString();
release();
return EGL_BAD_ALLOC;
}
......@@ -419,9 +423,9 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
depthStencilDesc.Flags = 0;
depthStencilDesc.Texture2D.MipSlice = 0;
err = mRenderer->allocateResource(depthStencilDesc, mDepthStencilTexture.get(),
&mDepthStencilDSView);
ASSERT(!err.isError());
result = mRenderer->allocateResource(displayD3D, depthStencilDesc,
mDepthStencilTexture.get(), &mDepthStencilDSView);
ASSERT(result != angle::Result::Stop());
mDepthStencilDSView.setDebugName("Offscreen depth stencil view");
if (depthStencilSRV)
......@@ -434,9 +438,9 @@ EGLint SwapChain11::resetOffscreenDepthBuffer(int backbufferWidth, int backbuffe
depthStencilSRVDesc.Texture2D.MostDetailedMip = 0;
depthStencilSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1);
err = mRenderer->allocateResource(depthStencilSRVDesc, mDepthStencilTexture.get(),
&mDepthStencilSRView);
ASSERT(!err.isError());
result = mRenderer->allocateResource(displayD3D, depthStencilSRVDesc,
mDepthStencilTexture.get(), &mDepthStencilSRView);
ASSERT(result != angle::Result::Stop());
mDepthStencilSRView.setDebugName("Offscreen depth stencil shader resource");
}
}
......@@ -476,22 +480,23 @@ EGLint SwapChain11::resize(DisplayD3D *displayD3D, EGLint backbufferWidth, EGLin
// Resize swap chain
DXGI_SWAP_CHAIN_DESC desc;
HRESULT result = mSwapChain->GetDesc(&desc);
if (FAILED(result))
HRESULT hr = mSwapChain->GetDesc(&desc);
if (FAILED(hr))
{
ERR() << "Error reading swap chain description, " << gl::FmtHR(result);
ERR() << "Error reading swap chain description, " << gl::FmtHR(hr);
release();
return EGL_BAD_ALLOC;
}
result = mSwapChain->ResizeBuffers(desc.BufferCount, backbufferWidth, backbufferHeight, getSwapChainNativeFormat(), 0);
hr = mSwapChain->ResizeBuffers(desc.BufferCount, backbufferWidth, backbufferHeight,
getSwapChainNativeFormat(), 0);
if (FAILED(result))
if (FAILED(hr))
{
ERR() << "Error resizing swap chain buffers, " << gl::FmtHR(result);
ERR() << "Error resizing swap chain buffers, " << gl::FmtHR(hr);
release();
if (d3d11::isDeviceLostError(result))
if (d3d11::isDeviceLostError(hr))
{
return EGL_CONTEXT_LOST;
}
......@@ -502,23 +507,24 @@ EGLint SwapChain11::resize(DisplayD3D *displayD3D, EGLint backbufferWidth, EGLin
}
ID3D11Texture2D *backbufferTexture = nullptr;
result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
reinterpret_cast<void **>(&backbufferTexture));
ASSERT(SUCCEEDED(result));
if (SUCCEEDED(result))
ASSERT(SUCCEEDED(hr));
if (SUCCEEDED(hr))
{
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());
angle::Result result = mRenderer->allocateResourceNoDesc(
displayD3D, mBackBufferTexture.get(), &mBackBufferRTView);
ASSERT(result != angle::Result::Stop());
mBackBufferRTView.setDebugName("Back buffer render target");
err = mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferSRView);
ASSERT(!err.isError());
result = mRenderer->allocateResourceNoDesc(displayD3D, mBackBufferTexture.get(),
&mBackBufferSRView);
ASSERT(result != angle::Result::Stop());
mBackBufferSRView.setDebugName("Back buffer shader resource");
}
......@@ -598,17 +604,17 @@ EGLint SwapChain11::reset(DisplayD3D *displayD3D,
if (mNativeWindow->getNativeWindow())
{
HRESULT result = mNativeWindow->createSwapChain(
device, mRenderer->getDxgiFactory(), getSwapChainNativeFormat(), backbufferWidth,
HRESULT hr = mNativeWindow->createSwapChain(device, mRenderer->getDxgiFactory(),
getSwapChainNativeFormat(), backbufferWidth,
backbufferHeight, getD3DSamples(), &mSwapChain);
if (FAILED(result))
if (FAILED(hr))
{
ERR() << "Could not create additional swap chains or offscreen surfaces, "
<< gl::FmtHR(result);
<< gl::FmtHR(hr);
release();
if (d3d11::isDeviceLostError(result))
if (d3d11::isDeviceLostError(hr))
{
return EGL_CONTEXT_LOST;
}
......@@ -624,21 +630,22 @@ EGLint SwapChain11::reset(DisplayD3D *displayD3D,
}
ID3D11Texture2D *backbufferTex = nullptr;
result = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
hr = mSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D),
reinterpret_cast<LPVOID *>(&backbufferTex));
ASSERT(SUCCEEDED(result));
ASSERT(SUCCEEDED(hr));
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());
angle::Result result = mRenderer->allocateResourceNoDesc(
displayD3D, mBackBufferTexture.get(), &mBackBufferRTView);
ASSERT(result != angle::Result::Stop());
mBackBufferRTView.setDebugName("Back buffer render target");
err = mRenderer->allocateResourceNoDesc(mBackBufferTexture.get(), &mBackBufferSRView);
ASSERT(!err.isError());
result = mRenderer->allocateResourceNoDesc(displayD3D, mBackBufferTexture.get(),
&mBackBufferSRView);
ASSERT(result != angle::Result::Stop());
mBackBufferSRView.setDebugName("Back buffer shader resource view");
}
......@@ -647,11 +654,11 @@ EGLint SwapChain11::reset(DisplayD3D *displayD3D,
return resetOffscreenBuffers(displayD3D, backbufferWidth, backbufferHeight);
}
void SwapChain11::initPassThroughResources()
angle::Result SwapChain11::initPassThroughResources(DisplayD3D *displayD3D)
{
if (mPassThroughResourcesInit)
{
return;
return angle::Result::Continue();
}
TRACE_EVENT0("gpu.angle", "SwapChain11::initPassThroughResources");
......@@ -671,8 +678,7 @@ void SwapChain11::initPassThroughResources()
vbDesc.MiscFlags = 0;
vbDesc.StructureByteStride = 0;
gl::Error err = mRenderer->allocateResource(vbDesc, &mQuadVB);
ASSERT(!err.isError());
ANGLE_TRY(mRenderer->allocateResource(displayD3D, vbDesc, &mQuadVB));
mQuadVB.setDebugName("Swap chain quad vertex buffer");
D3D11_SAMPLER_DESC samplerDesc;
......@@ -690,8 +696,7 @@ void SwapChain11::initPassThroughResources()
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
err = mRenderer->allocateResource(samplerDesc, &mPassThroughSampler);
ASSERT(!err.isError());
ANGLE_TRY(mRenderer->allocateResource(displayD3D, samplerDesc, &mPassThroughSampler));
mPassThroughSampler.setDebugName("Swap chain pass through sampler");
D3D11_INPUT_ELEMENT_DESC quadLayout[] =
......@@ -703,26 +708,24 @@ void SwapChain11::initPassThroughResources()
InputElementArray quadElements(quadLayout);
ShaderData vertexShaderData(g_VS_Passthrough2D);
err = mRenderer->allocateResource(quadElements, &vertexShaderData, &mPassThroughIL);
ASSERT(!err.isError());
ANGLE_TRY(
mRenderer->allocateResource(displayD3D, quadElements, &vertexShaderData, &mPassThroughIL));
mPassThroughIL.setDebugName("Swap chain pass through layout");
err = mRenderer->allocateResource(vertexShaderData, &mPassThroughVS);
ASSERT(!err.isError());
ANGLE_TRY(mRenderer->allocateResource(displayD3D, vertexShaderData, &mPassThroughVS));
mPassThroughVS.setDebugName("Swap chain pass through vertex shader");
if (mEGLSamples <= 1)
{
ShaderData pixelShaderData(g_PS_PassthroughRGBA2D);
err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
ANGLE_TRY(mRenderer->allocateResource(displayD3D, pixelShaderData, &mPassThroughPS));
}
else
{
ShaderData pixelShaderData(g_PS_PassthroughRGBA2DMS);
err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
ANGLE_TRY(mRenderer->allocateResource(displayD3D, pixelShaderData, &mPassThroughPS));
}
ASSERT(!err.isError());
mPassThroughPS.setDebugName("Swap chain pass through pixel shader");
// Use the default rasterizer state but without culling
......@@ -738,11 +741,11 @@ void SwapChain11::initPassThroughResources()
rasterizerDesc.MultisampleEnable = FALSE;
rasterizerDesc.AntialiasedLineEnable = FALSE;
err = mRenderer->allocateResource(rasterizerDesc, &mPassThroughRS);
ASSERT(!err.isError());
ANGLE_TRY(mRenderer->allocateResource(displayD3D, rasterizerDesc, &mPassThroughRS));
mPassThroughRS.setDebugName("Swap chain pass through rasterizer state");
mPassThroughResourcesInit = true;
return angle::Result::Continue();
}
// parameters should be validated/clamped by caller
......@@ -783,7 +786,10 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(DisplayD3D *displayD3D,
return EGL_SUCCESS;
}
initPassThroughResources();
if (initPassThroughResources(displayD3D) == angle::Result::Stop())
{
return EGL_BAD_ALLOC;
}
ID3D11DeviceContext *deviceContext = mRenderer->getDeviceContext();
......@@ -930,7 +936,7 @@ const d3d11::RenderTargetView &SwapChain11::getRenderTarget()
return mNeedsOffscreenTexture ? mOffscreenRTView : mBackBufferRTView;
}
const d3d11::SharedSRV &SwapChain11::getRenderTargetShaderResource()
const d3d11::SharedSRV &SwapChain11::getRenderTargetShaderResource(d3d::Context *context)
{
if (!mNeedsOffscreenTexture)
{
......@@ -955,9 +961,9 @@ const d3d11::SharedSRV &SwapChain11::getRenderTargetShaderResource()
offscreenCopyDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
offscreenCopyDesc.MiscFlags = 0;
offscreenCopyDesc.CPUAccessFlags = 0;
gl::Error err = mRenderer->allocateTexture(offscreenCopyDesc, backbufferFormatInfo,
&mOffscreenTextureCopyForSRV);
ASSERT(!err.isError());
angle::Result result = mRenderer->allocateTexture(
context, offscreenCopyDesc, backbufferFormatInfo, &mOffscreenTextureCopyForSRV);
ASSERT(result != angle::Result::Stop());
mOffscreenTextureCopyForSRV.setDebugName("Offscreen back buffer copy for SRV");
D3D11_SHADER_RESOURCE_VIEW_DESC offscreenSRVDesc;
......@@ -967,9 +973,9 @@ const d3d11::SharedSRV &SwapChain11::getRenderTargetShaderResource()
offscreenSRVDesc.Texture2D.MostDetailedMip = 0;
offscreenSRVDesc.Texture2D.MipLevels = static_cast<UINT>(-1);
err = mRenderer->allocateResource(offscreenSRVDesc, mOffscreenTextureCopyForSRV.get(),
&mOffscreenSRView);
ASSERT(!err.isError());
result = mRenderer->allocateResource(context, offscreenSRVDesc,
mOffscreenTextureCopyForSRV.get(), &mOffscreenSRView);
ASSERT(result != angle::Result::Stop());
mOffscreenSRView.setDebugName("Offscreen back buffer shader resource");
}
......
src/libANGLE/renderer/d3d/d3d11/SwapChain11.h
......@@ -48,7 +48,7 @@ class SwapChain11 final : public SwapChainD3D
const TextureHelper11 &getOffscreenTexture();
const d3d11::RenderTargetView &getRenderTarget();
const d3d11::SharedSRV &getRenderTargetShaderResource();
const d3d11::SharedSRV &getRenderTargetShaderResource(d3d::Context *context);
const TextureHelper11 &getDepthStencilTexture();
const d3d11::DepthStencilView &getDepthStencil();
......@@ -63,7 +63,7 @@ class SwapChain11 final : public SwapChainD3D
private:
void release();
void initPassThroughResources();
angle::Result initPassThroughResources(DisplayD3D *displayD3D);
void releaseOffscreenColorBuffer();
void releaseOffscreenDepthBuffer();
......@@ -71,7 +71,9 @@ class SwapChain11 final : public SwapChainD3D
EGLint resetOffscreenColorBuffer(DisplayD3D *displayD3D,
int backbufferWidth,
int backbufferHeight);
EGLint resetOffscreenDepthBuffer(int backbufferWidth, int backbufferHeight);
EGLint resetOffscreenDepthBuffer(DisplayD3D *displayD3D,
int backbufferWidth,
int backbufferHeight);
DXGI_FORMAT getSwapChainNativeFormat() const;
......
src/libANGLE/renderer/d3d/d3d11/TextureStorage11.cpp
......@@ -20,6 +20,7 @@
#include "libANGLE/renderer/d3d/EGLImageD3D.h"
#include "libANGLE/renderer/d3d/TextureD3D.h"
#include "libANGLE/renderer/d3d/d3d11/Blit11.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/Image11.h"
#include "libANGLE/renderer/d3d/d3d11/RenderTarget11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
......@@ -641,7 +642,7 @@ gl::Error TextureStorage11::generateMipmap(const gl::Context *context,
ANGLE_TRY(getRenderTarget(context, destIndex, &dest));
RenderTarget11 *rt11 = GetAs<RenderTarget11>(source);
const d3d11::SharedSRV &sourceSRV = rt11->getBlitShaderResourceView();
const d3d11::SharedSRV &sourceSRV = rt11->getBlitShaderResourceView(context);
const d3d11::RenderTargetView &destRTV = rt11->getRenderTargetView();
gl::Box sourceArea(0, 0, 0, source->getWidth(), source->getHeight(), source->getDepth());
......@@ -1131,7 +1132,8 @@ angle::Result TextureStorage11_2D::ensureTextureExists(const gl::Context *contex
desc.CPUAccessFlags = 0;
desc.MiscFlags = getMiscFlags();
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, mFormatInfo, outputTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo,
outputTexture));
if (useLevelZeroTexture)
{
......@@ -1186,6 +1188,8 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::Context *context,
const d3d11::SharedSRV *blitSRV = nullptr;
ANGLE_TRY(getSRVLevel(context, level, true, &blitSRV));
Context11 *context11 = GetImplAs<Context11>(context);
if (mUseLevelZeroTexture)
{
if (!mLevelZeroRenderTarget)
......@@ -1196,7 +1200,8 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::Context *context,
rtvDesc.Texture2D.MipSlice = mTopLevel + level;
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mLevelZeroTexture.get(), &rtv));
ANGLE_TRY(
mRenderer->allocateResource(context11, rtvDesc, mLevelZeroTexture.get(), &rtv));
rtv.setDebugName("TexStorage2D.Level0RTV");
mLevelZeroRenderTarget.reset(new TextureRenderTarget11(
......@@ -1217,7 +1222,7 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::Context *context,
rtvDesc.Texture2D.MipSlice = mTopLevel + level;
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv));
rtv.setDebugName("TexStorage2D.RTV");
mRenderTarget[level].reset(new TextureRenderTarget11(
......@@ -1237,7 +1242,7 @@ gl::Error TextureStorage11_2D::getRenderTarget(const gl::Context *context,
dsvDesc.Flags = 0;
d3d11::DepthStencilView dsv;
ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
ANGLE_TRY(mRenderer->allocateResource(context11, dsvDesc, texture->get(), &dsv));
dsv.setDebugName("TexStorage2D.DSV");
mRenderTarget[level].reset(new TextureRenderTarget11(
......@@ -1286,7 +1291,8 @@ angle::Result TextureStorage11_2D::createSRVForSampler(const gl::Context *contex
}
}
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, srvTexture->get(), outSRV));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, srvTexture->get(),
outSRV));
outSRV->setDebugName("TexStorage2D.SRV");
return angle::Result::Continue();
......@@ -1304,7 +1310,8 @@ angle::Result TextureStorage11_2D::createSRVForImage(const gl::Context *context,
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MostDetailedMip = mTopLevel + level;
srvDesc.Texture2D.MipLevels = 1;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorage2D.SRVForImage");
return angle::Result::Continue();
}
......@@ -1320,7 +1327,8 @@ angle::Result TextureStorage11_2D::createUAVForImage(const gl::Context *context,
uavDesc.Format = format;
uavDesc.ViewDimension = D3D11_UAV_DIMENSION_TEXTURE2D;
uavDesc.Texture2D.MipSlice = mTopLevel + level;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(uavDesc, texture.get(), outUAV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV));
outUAV->setDebugName("TexStorage2D.UAVForImage");
return angle::Result::Continue();
}
......@@ -1347,7 +1355,8 @@ angle::Result TextureStorage11_2D::getSwizzleTexture(const gl::Context *context,
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format,
&mSwizzleTexture));
mSwizzleTexture.setDebugName("TexStorage2D.SwizzleTexture");
}
......@@ -1373,7 +1382,8 @@ angle::Result TextureStorage11_2D::getSwizzleRenderTarget(const gl::Context *con
rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc,
mSwizzleTexture.get(),
&mSwizzleRenderTargets[mipLevel]));
}
......@@ -1405,7 +1415,8 @@ angle::Result TextureStorage11_2D::ensureDropStencilTexture(const gl::Context *c
const auto &format =
d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps());
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(dropDesc, format, &mDropStencilTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), dropDesc, format,
&mDropStencilTexture));
mDropStencilTexture.setDebugName("TexStorage2D.DropStencil");
ANGLE_TRY(initDropStencilTexture(context, gl::ImageIndexIterator::Make2D(0, mMipLevels)));
......@@ -1538,7 +1549,8 @@ angle::Result TextureStorage11_External::createSRVForSampler(const gl::Context *
srvDesc.Texture2DArray.FirstArraySlice = mSubresourceIndex;
srvDesc.Texture2DArray.ArraySize = 1;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorage2D.SRV");
return angle::Result::Continue();
......@@ -1715,7 +1727,8 @@ angle::Result TextureStorage11_EGLImage::getSwizzleTexture(const gl::Context *co
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format,
&mSwizzleTexture));
mSwizzleTexture.setDebugName("TexStorageEGLImage.SwizzleTexture");
}
......@@ -1742,7 +1755,8 @@ angle::Result TextureStorage11_EGLImage::getSwizzleRenderTarget(
rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rtvDesc.Texture2D.MipSlice = mTopLevel + mipLevel;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc,
mSwizzleTexture.get(),
&mSwizzleRenderTargets[mipLevel]));
}
......@@ -1785,7 +1799,8 @@ angle::Result TextureStorage11_EGLImage::createSRVForSampler(const gl::Context *
srvDesc.Texture2D.MostDetailedMip = mTopLevel + baseLevel;
srvDesc.Texture2D.MipLevels = mipLevels;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(),
outSRV));
outSRV->setDebugName("TexStorageEGLImage.SRV");
}
else
......@@ -1795,7 +1810,7 @@ angle::Result TextureStorage11_EGLImage::createSRVForSampler(const gl::Context *
ASSERT(texture == renderTarget->getTexture());
*outSRV = renderTarget->getShaderResourceView().makeCopy();
*outSRV = renderTarget->getShaderResourceView(context).makeCopy();
}
return angle::Result::Continue();
......@@ -2148,7 +2163,8 @@ angle::Result TextureStorage11_Cube::ensureTextureExists(const gl::Context *cont
desc.CPUAccessFlags = 0;
desc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE | getMiscFlags();
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, mFormatInfo, outputTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo,
outputTexture));
outputTexture->setDebugName("TexStorageCube.Texture");
}
......@@ -2178,7 +2194,8 @@ angle::Result TextureStorage11_Cube::createRenderTargetSRV(const gl::Context *co
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DARRAY;
}
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), srv));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), srv));
return angle::Result::Continue();
}
......@@ -2192,6 +2209,8 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::Context *context,
ASSERT(level >= 0 && level < getLevelCount());
ASSERT(faceIndex >= 0 && faceIndex < static_cast<GLint>(gl::CUBE_FACE_COUNT));
Context11 *context11 = GetImplAs<Context11>(context);
if (!mRenderTarget[faceIndex][level])
{
if (mRenderer->getWorkarounds().zeroMaxLodWorkaround)
......@@ -2215,7 +2234,8 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::Context *context,
rtvDesc.Texture2DArray.ArraySize = 1;
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, mLevelZeroTexture.get(), &rtv));
ANGLE_TRY(
mRenderer->allocateResource(context11, rtvDesc, mLevelZeroTexture.get(), &rtv));
mLevelZeroRenderTarget[faceIndex].reset(new TextureRenderTarget11(
std::move(rtv), mLevelZeroTexture, d3d11::SharedSRV(), d3d11::SharedSRV(),
......@@ -2253,7 +2273,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::Context *context,
rtvDesc.Texture2DArray.ArraySize = 1;
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv));
rtv.setDebugName("TexStorageCube.RenderTargetRTV");
mRenderTarget[faceIndex][level].reset(new TextureRenderTarget11(
......@@ -2271,7 +2291,7 @@ gl::Error TextureStorage11_Cube::getRenderTarget(const gl::Context *context,
dsvDesc.Texture2DArray.ArraySize = 1;
d3d11::DepthStencilView dsv;
ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
ANGLE_TRY(mRenderer->allocateResource(context11, dsvDesc, texture->get(), &dsv));
dsv.setDebugName("TexStorageCube.RenderTargetDSV");
mRenderTarget[faceIndex][level].reset(new TextureRenderTarget11(
......@@ -2342,7 +2362,8 @@ angle::Result TextureStorage11_Cube::createSRVForSampler(const gl::Context *cont
}
}
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, srvTexture->get(), outSRV));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, srvTexture->get(),
outSRV));
outSRV->setDebugName("TexStorageCube.SRV");
return angle::Result::Continue();
......@@ -2362,7 +2383,8 @@ angle::Result TextureStorage11_Cube::createSRVForImage(const gl::Context *contex
srvDesc.Texture2DArray.MipLevels = 1;
srvDesc.Texture2DArray.FirstArraySlice = 0;
srvDesc.Texture2DArray.ArraySize = gl::CUBE_FACE_COUNT;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorageCube.SRVForImage");
return angle::Result::Continue();
}
......@@ -2380,7 +2402,8 @@ angle::Result TextureStorage11_Cube::createUAVForImage(const gl::Context *contex
uavDesc.Texture2DArray.MipSlice = mTopLevel + level;
uavDesc.Texture2DArray.FirstArraySlice = 0;
uavDesc.Texture2DArray.ArraySize = gl::CUBE_FACE_COUNT;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(uavDesc, texture.get(), outUAV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV));
outUAV->setDebugName("TexStorageCube.UAVForImage");
return angle::Result::Continue();
}
......@@ -2407,7 +2430,8 @@ angle::Result TextureStorage11_Cube::getSwizzleTexture(const gl::Context *contex
desc.CPUAccessFlags = 0;
desc.MiscFlags = D3D11_RESOURCE_MISC_TEXTURECUBE;
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format,
&mSwizzleTexture));
mSwizzleTexture.setDebugName("TexStorageCube.SwizzleTexture");
}
......@@ -2435,7 +2459,8 @@ angle::Result TextureStorage11_Cube::getSwizzleRenderTarget(const gl::Context *c
rtvDesc.Texture2DArray.FirstArraySlice = 0;
rtvDesc.Texture2DArray.ArraySize = gl::CUBE_FACE_COUNT;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc,
mSwizzleTexture.get(),
&mSwizzleRenderTargets[mipLevel]));
}
......@@ -2467,7 +2492,8 @@ angle::Result TextureStorage11_Cube::ensureDropStencilTexture(const gl::Context
const auto &format =
d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps());
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(dropDesc, format, &mDropStencilTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), dropDesc, format,
&mDropStencilTexture));
mDropStencilTexture.setDebugName("TexStorageCube.DropStencil");
ANGLE_TRY(initDropStencilTexture(context, gl::ImageIndexIterator::MakeCube(0, mMipLevels)));
......@@ -2608,7 +2634,8 @@ angle::Result TextureStorage11_3D::getResource(const gl::Context *context,
desc.CPUAccessFlags = 0;
desc.MiscFlags = getMiscFlags();
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, mFormatInfo, &mTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo,
&mTexture));
mTexture.setDebugName("TexStorage3D.Texture");
}
......@@ -2631,7 +2658,8 @@ angle::Result TextureStorage11_3D::createSRVForSampler(const gl::Context *contex
srvDesc.Texture3D.MostDetailedMip = baseLevel;
srvDesc.Texture3D.MipLevels = mipLevels;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorage3D.SRV");
return angle::Result::Continue();
......@@ -2649,7 +2677,8 @@ angle::Result TextureStorage11_3D::createSRVForImage(const gl::Context *context,
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE3D;
srvDesc.Texture3D.MostDetailedMip = mTopLevel + level;
srvDesc.Texture3D.MipLevels = 1;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorage3D.SRVForImage");
return angle::Result::Continue();
}
......@@ -2667,7 +2696,8 @@ angle::Result TextureStorage11_3D::createUAVForImage(const gl::Context *context,
uavDesc.Texture3D.MipSlice = mTopLevel + level;
uavDesc.Texture3D.FirstWSlice = 0;
uavDesc.Texture3D.WSize = mTextureDepth;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(uavDesc, texture.get(), outUAV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV));
outUAV->setDebugName("TexStorage3D.UAVForImage");
return angle::Result::Continue();
}
......@@ -2681,6 +2711,8 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::Context *context,
ASSERT(mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN);
Context11 *context11 = GetImplAs<Context11>(context);
if (!index.hasLayer())
{
if (!mLevelRenderTargets[mipLevel])
......@@ -2702,7 +2734,7 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::Context *context,
rtvDesc.Texture3D.WSize = static_cast<UINT>(-1);
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv));
rtv.setDebugName("TexStorage3D.RTV");
mLevelRenderTargets[mipLevel].reset(new TextureRenderTarget11(
......@@ -2736,7 +2768,7 @@ gl::Error TextureStorage11_3D::getRenderTarget(const gl::Context *context,
rtvDesc.Texture3D.WSize = 1;
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv));
rtv.setDebugName("TexStorage3D.LayerRTV");
mLevelLayerRenderTargets[key].reset(new TextureRenderTarget11(
......@@ -2769,7 +2801,8 @@ angle::Result TextureStorage11_3D::getSwizzleTexture(const gl::Context *context,
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format,
&mSwizzleTexture));
mSwizzleTexture.setDebugName("TexStorage3D.SwizzleTexture");
}
......@@ -2797,7 +2830,8 @@ angle::Result TextureStorage11_3D::getSwizzleRenderTarget(const gl::Context *con
rtvDesc.Texture3D.FirstWSlice = 0;
rtvDesc.Texture3D.WSize = static_cast<UINT>(-1);
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc,
mSwizzleTexture.get(),
&mSwizzleRenderTargets[mipLevel]));
mSwizzleRenderTargets[mipLevel].setDebugName("TexStorage3D.SwizzleRTV");
}
......@@ -2950,7 +2984,8 @@ angle::Result TextureStorage11_2DArray::getResource(const gl::Context *context,
desc.CPUAccessFlags = 0;
desc.MiscFlags = getMiscFlags();
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, mFormatInfo, &mTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo,
&mTexture));
mTexture.setDebugName("TexStorage2DArray.Texture");
}
......@@ -2973,7 +3008,8 @@ angle::Result TextureStorage11_2DArray::createSRVForSampler(const gl::Context *c
srvDesc.Texture2DArray.FirstArraySlice = 0;
srvDesc.Texture2DArray.ArraySize = mTextureDepth;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorage2DArray.SRV");
return angle::Result::Continue();
......@@ -2993,7 +3029,8 @@ angle::Result TextureStorage11_2DArray::createSRVForImage(const gl::Context *con
srvDesc.Texture2DArray.MipLevels = 1;
srvDesc.Texture2DArray.FirstArraySlice = 0;
srvDesc.Texture2DArray.ArraySize = mTextureDepth;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorage2DArray.SRVForImage");
return angle::Result::Continue();
}
......@@ -3011,7 +3048,8 @@ angle::Result TextureStorage11_2DArray::createUAVForImage(const gl::Context *con
uavDesc.Texture2DArray.MipSlice = mTopLevel + level;
uavDesc.Texture2DArray.FirstArraySlice = 0;
uavDesc.Texture2DArray.ArraySize = mTextureDepth;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(uavDesc, texture.get(), outUAV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), uavDesc, texture.get(), outUAV));
outUAV->setDebugName("TexStorage2DArray.UAVForImage");
return angle::Result::Continue();
}
......@@ -3030,7 +3068,8 @@ angle::Result TextureStorage11_2DArray::createRenderTargetSRV(const gl::Context
srvDesc.Texture2DArray.FirstArraySlice = index.getLayerIndex();
srvDesc.Texture2DArray.ArraySize = index.getLayerCount();
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), srv));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), srv));
return angle::Result::Continue();
}
......@@ -3077,7 +3116,8 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::Context *context,
rtvDesc.Texture2DArray.ArraySize = numLayers;
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc,
texture->get(), &rtv));
rtv.setDebugName("TexStorage2DArray.RenderTargetRTV");
mRenderTargets[key].reset(new TextureRenderTarget11(
......@@ -3097,7 +3137,8 @@ gl::Error TextureStorage11_2DArray::getRenderTarget(const gl::Context *context,
dsvDesc.Flags = 0;
d3d11::DepthStencilView dsv;
ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), dsvDesc,
texture->get(), &dsv));
dsv.setDebugName("TexStorage2DArray.RenderTargetDSV");
mRenderTargets[key].reset(new TextureRenderTarget11(
......@@ -3131,7 +3172,8 @@ angle::Result TextureStorage11_2DArray::getSwizzleTexture(const gl::Context *con
desc.CPUAccessFlags = 0;
desc.MiscFlags = 0;
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, format, &mSwizzleTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, format,
&mSwizzleTexture));
mSwizzleTexture.setDebugName("TexStorage2DArray.SwizzleTexture");
}
......@@ -3160,7 +3202,8 @@ angle::Result TextureStorage11_2DArray::getSwizzleRenderTarget(
rtvDesc.Texture2DArray.FirstArraySlice = 0;
rtvDesc.Texture2DArray.ArraySize = mTextureDepth;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(rtvDesc, mSwizzleTexture.get(),
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), rtvDesc,
mSwizzleTexture.get(),
&mSwizzleRenderTargets[mipLevel]));
}
......@@ -3192,7 +3235,8 @@ angle::Result TextureStorage11_2DArray::ensureDropStencilTexture(const gl::Conte
const auto &format =
d3d11::Format::Get(GL_DEPTH_COMPONENT32F, mRenderer->getRenderer11DeviceCaps());
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(dropDesc, format, &mDropStencilTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), dropDesc, format,
&mDropStencilTexture));
mDropStencilTexture.setDebugName("TexStorage2DArray.DropStencil");
std::vector<GLsizei> layerCounts(mMipLevels, mTextureDepth);
......@@ -3305,7 +3349,8 @@ angle::Result TextureStorage11_2DMultisample::ensureTextureExists(const gl::Cont
desc.SampleDesc.Count = (supportedSamples == 0) ? 1 : supportedSamples;
desc.SampleDesc.Quality = static_cast<UINT>(D3D11_STANDARD_MULTISAMPLE_PATTERN);
ANGLE_TRY_HANDLE(context, mRenderer->allocateTexture(desc, mFormatInfo, &mTexture));
ANGLE_TRY(mRenderer->allocateTexture(GetImplAs<Context11>(context), desc, mFormatInfo,
&mTexture));
mTexture.setDebugName("TexStorage2DMS.Texture");
}
......@@ -3337,6 +3382,8 @@ gl::Error TextureStorage11_2DMultisample::getRenderTarget(const gl::Context *con
const d3d11::SharedSRV *blitSRV = nullptr;
ANGLE_TRY(getSRVLevel(context, level, true, &blitSRV));
Context11 *context11 = GetImplAs<Context11>(context);
if (mFormatInfo.rtvFormat != DXGI_FORMAT_UNKNOWN)
{
D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
......@@ -3344,7 +3391,7 @@ gl::Error TextureStorage11_2DMultisample::getRenderTarget(const gl::Context *con
rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2DMS;
d3d11::RenderTargetView rtv;
ANGLE_TRY(mRenderer->allocateResource(rtvDesc, texture->get(), &rtv));
ANGLE_TRY(mRenderer->allocateResource(context11, rtvDesc, texture->get(), &rtv));
mRenderTarget.reset(new TextureRenderTarget11(
std::move(rtv), *texture, *srv, *blitSRV, mFormatInfo.internalFormat, getFormatSet(),
......@@ -3362,7 +3409,7 @@ gl::Error TextureStorage11_2DMultisample::getRenderTarget(const gl::Context *con
dsvDesc.Flags = 0;
d3d11::DepthStencilView dsv;
ANGLE_TRY(mRenderer->allocateResource(dsvDesc, texture->get(), &dsv));
ANGLE_TRY(mRenderer->allocateResource(context11, dsvDesc, texture->get(), &dsv));
mRenderTarget.reset(new TextureRenderTarget11(
std::move(dsv), *texture, *srv, mFormatInfo.internalFormat, getFormatSet(),
......@@ -3385,7 +3432,8 @@ angle::Result TextureStorage11_2DMultisample::createSRVForSampler(const gl::Cont
srvDesc.Format = format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2DMS;
ANGLE_TRY_HANDLE(context, mRenderer->allocateResource(srvDesc, texture.get(), outSRV));
ANGLE_TRY(
mRenderer->allocateResource(GetImplAs<Context11>(context), srvDesc, texture.get(), outSRV));
outSRV->setDebugName("TexStorage2DMS.SRV");
return angle::Result::Continue();
}
......
src/libANGLE/renderer/d3d/d3d11/VertexBuffer11.cpp
......@@ -9,11 +9,13 @@
#include "libANGLE/renderer/d3d/d3d11/VertexBuffer11.h"
#include "libANGLE/Buffer.h"
#include "libANGLE/Context.h"
#include "libANGLE/VertexAttribute.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/d3d11/Buffer11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
#include "libANGLE/renderer/d3d/d3d11/Context11.h"
#include "libANGLE/renderer/d3d/d3d11/Renderer11.h"
#include "libANGLE/renderer/d3d/d3d11/formatutils11.h"
#include "libANGLE/renderer/d3d/d3d11/renderer11_utils.h"
namespace rx
......@@ -50,7 +52,7 @@ gl::Error VertexBuffer11::initialize(const gl::Context *context,
bufferDesc.MiscFlags = 0;
bufferDesc.StructureByteStride = 0;
ANGLE_TRY(mRenderer->allocateResource(bufferDesc, &mBuffer));
ANGLE_TRY(mRenderer->allocateResource(GetImplAs<Context11>(context), bufferDesc, &mBuffer));
if (dynamicUsage)
{
......
src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
......@@ -2170,42 +2170,51 @@ HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name)
// allocateResource is only compatible with Clang and MSVS, which support calling a
// method on a forward declared class in a template.
template <ResourceType ResourceT>
gl::Error LazyResource<ResourceT>::resolveImpl(Renderer11 *renderer,
angle::Result LazyResource<ResourceT>::resolveImpl(d3d::Context *context,
Renderer11 *renderer,
const GetDescType<ResourceT> &desc,
GetInitDataType<ResourceT> *initData,
const char *name)
{
if (!mResource.valid())
{
ANGLE_TRY(renderer->allocateResource(desc, initData, &mResource));
ANGLE_TRY(renderer->allocateResource(context, desc, initData, &mResource));
mResource.setDebugName(name);
}
return angle::Result::Continue();
}
template gl::Error LazyResource<ResourceType::BlendState>::resolveImpl(Renderer11 *renderer,
template angle::Result LazyResource<ResourceType::BlendState>::resolveImpl(
d3d::Context *context,
Renderer11 *renderer,
const D3D11_BLEND_DESC &desc,
void *initData,
const char *name);
template gl::Error LazyResource<ResourceType::ComputeShader>::resolveImpl(Renderer11 *renderer,
template angle::Result LazyResource<ResourceType::ComputeShader>::resolveImpl(
d3d::Context *context,
Renderer11 *renderer,
const ShaderData &desc,
void *initData,
const char *name);
template gl::Error LazyResource<ResourceType::GeometryShader>::resolveImpl(
template angle::Result LazyResource<ResourceType::GeometryShader>::resolveImpl(
d3d::Context *context,
Renderer11 *renderer,
const ShaderData &desc,
const std::vector<D3D11_SO_DECLARATION_ENTRY> *initData,
const char *name);
template gl::Error LazyResource<ResourceType::InputLayout>::resolveImpl(
template angle::Result LazyResource<ResourceType::InputLayout>::resolveImpl(
d3d::Context *context,
Renderer11 *renderer,
const InputElementArray &desc,
const ShaderData *initData,
const char *name);
template gl::Error LazyResource<ResourceType::PixelShader>::resolveImpl(Renderer11 *renderer,
template angle::Result LazyResource<ResourceType::PixelShader>::resolveImpl(d3d::Context *context,
Renderer11 *renderer,
const ShaderData &desc,
void *initData,
const char *name);
template gl::Error LazyResource<ResourceType::VertexShader>::resolveImpl(Renderer11 *renderer,
template angle::Result LazyResource<ResourceType::VertexShader>::resolveImpl(d3d::Context *context,
Renderer11 *renderer,
const ShaderData &desc,
void *initData,
const char *name);
......@@ -2223,9 +2232,9 @@ LazyInputLayout::~LazyInputLayout()
{
}
gl::Error LazyInputLayout::resolve(Renderer11 *renderer)
angle::Result LazyInputLayout::resolve(d3d::Context *context, Renderer11 *renderer)
{
return resolveImpl(renderer, mInputDesc, &mByteCode, mDebugName);
return resolveImpl(context, renderer, mInputDesc, &mByteCode, mDebugName);
}
LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName)
......@@ -2233,9 +2242,9 @@ LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugNa
{
}
gl::Error LazyBlendState::resolve(Renderer11 *renderer)
angle::Result LazyBlendState::resolve(d3d::Context *context, Renderer11 *renderer)
{
return resolveImpl(renderer, mDesc, nullptr, mDebugName);
return resolveImpl(context, renderer, mDesc, nullptr, mDebugName);
}
angle::WorkaroundsD3D GenerateWorkarounds(const Renderer11DeviceCaps &deviceCaps,
......
src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
......@@ -198,7 +198,7 @@ class LazyResource : angle::NonCopyable
constexpr LazyResource() : mResource() {}
virtual ~LazyResource() {}
virtual gl::Error resolve(Renderer11 *renderer) = 0;
virtual angle::Result resolve(d3d::Context *context, Renderer11 *renderer) = 0;
void reset() { mResource.reset(); }
GetD3D11Type<ResourceT> *get() const
{
......@@ -212,7 +212,8 @@ class LazyResource : angle::NonCopyable
LazyResource(LazyResource &&other) : mResource(std::move(other.mResource)) {}
// Specialized in the cpp file to avoid MSVS/Clang specific code.
gl::Error resolveImpl(Renderer11 *renderer,
angle::Result resolveImpl(d3d::Context *context,
Renderer11 *renderer,
const GetDescType<ResourceT> &desc,
GetInitDataType<ResourceT> *initData,
const char *name);
......@@ -237,9 +238,9 @@ class LazyShader final : public LazyResource<GetResourceTypeFromD3D11<D3D11Shade
{
}
gl::Error resolve(Renderer11 *renderer) override
angle::Result resolve(d3d::Context *context, Renderer11 *renderer) override
{
return this->resolveImpl(renderer, mByteCode, nullptr, mName);
return this->resolveImpl(context, renderer, mByteCode, nullptr, mName);
}
private:
......@@ -257,7 +258,7 @@ class LazyInputLayout final : public LazyResource<ResourceType::InputLayout>
const char *debugName);
~LazyInputLayout() override;
gl::Error resolve(Renderer11 *renderer) override;
angle::Result resolve(d3d::Context *context, Renderer11 *renderer) override;
private:
InputElementArray mInputDesc;
......@@ -270,7 +271,7 @@ class LazyBlendState final : public LazyResource<ResourceType::BlendState>
public:
LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName);
gl::Error resolve(Renderer11 *renderer) override;
angle::Result resolve(d3d::Context *context, Renderer11 *renderer) override;
private:
D3D11_BLEND_DESC mDesc;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment