Skip to content

A
angle
Commit 5978e28d by Jamie Madill Committed by Commit Bot
Options

D3D11: Consolidate InputLayout allocation.

This introduces a helper type to act as the initialization data type for input element arrays. A WrappedArray class acts as a helper class to wrap a C array and size into a C++ class, similar to std::array but without the data storage. Also move resource deallocation memory counting into a single code path. BUG=angleproject:2034 Change-Id: I5e108254777f0df65f5f60fe26e760c71b95b542 Reviewed-on: https://chromium-review.googlesource.com/506775Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Reviewed-by: 's avatarCorentin Wallez <cwallez@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>
parent 8d4db1fa
Showing with 141 additions and 152 deletions
src/common/angleutils.h
......@@ -47,6 +47,27 @@ constexpr inline size_t ArraySize(T (&)[N])
return N;
}
template <typename T>
class WrappedArray final : angle::NonCopyable
{
public:
template <size_t N>
constexpr WrappedArray(const T (&data)[N]) : mArray(&data[0]), mSize(N)
{
}
constexpr WrappedArray() : mArray(nullptr), mSize(0) {}
constexpr WrappedArray(const T *data, size_t size) : mArray(data), mSize(size) {}
~WrappedArray() {}
constexpr const T *get() const { return mArray; }
constexpr size_t size() const { return mSize; }
private:
const T *mArray;
size_t mSize;
};
template <typename T, unsigned int N>
void SafeRelease(T (&resourceBlock)[N])
{
......
src/libANGLE/renderer/d3d/d3d11/Blit11.cpp
......@@ -597,11 +597,9 @@ Blit11::Blit11(Renderer11 *renderer)
Blit11::~Blit11()
{
mQuad2DIL.release();
mQuad2DVS.release();
mDepthPS.release();
mQuad3DIL.release();
mQuad3DVS.release();
mQuad3DGS.release();
......@@ -955,28 +953,29 @@ Blit11::SwizzleShaderType Blit11::GetSwizzleShaderType(GLenum type,
}
}
Blit11::ShaderSupport Blit11::getShaderSupport(const Shader &shader)
gl::Error Blit11::getShaderSupport(const Shader &shader, Blit11::ShaderSupport *supportOut)
{
ID3D11Device *device = mRenderer->getDevice();
ShaderSupport support;
if (shader.dimension == SHADER_2D)
{
support.inputLayout = mQuad2DIL.resolve(device);
support.vertexShader = mQuad2DVS.resolve(device);
support.geometryShader = nullptr;
support.vertexWriteFunction = Write2DVertices;
ANGLE_TRY(mQuad2DIL.resolve(mRenderer));
supportOut->inputLayout = mQuad2DIL.get();
supportOut->vertexShader = mQuad2DVS.resolve(device);
supportOut->geometryShader = nullptr;
supportOut->vertexWriteFunction = Write2DVertices;
}
else
{
ASSERT(shader.dimension == SHADER_3D);
support.inputLayout = mQuad3DIL.resolve(device);
support.vertexShader = mQuad3DVS.resolve(device);
support.geometryShader = mQuad3DGS.resolve(device);
support.vertexWriteFunction = Write3DVertices;
ANGLE_TRY(mQuad3DIL.resolve(mRenderer));
supportOut->inputLayout = mQuad2DIL.get();
supportOut->vertexShader = mQuad3DVS.resolve(device);
supportOut->geometryShader = mQuad3DGS.resolve(device);
supportOut->vertexWriteFunction = Write3DVertices;
}
return support;
return gl::NoError();
}
gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
......@@ -1041,7 +1040,8 @@ gl::Error Blit11::swizzleTexture(const d3d11::SharedSRV &source,
return gl::OutOfMemory() << "Failed to map internal vertex buffer for swizzle, " << result;
}
const ShaderSupport &support = getShaderSupport(*shader);
ShaderSupport support;
ANGLE_TRY(getShaderSupport(*shader, &support));
UINT stride = 0;
UINT startIdx = 0;
......@@ -1167,7 +1167,8 @@ gl::Error Blit11::copyTexture(const d3d11::SharedSRV &source,
ANGLE_TRY(getBlitShader(destFormat, sourceFormat, isSigned, unpackPremultiplyAlpha,
unpackUnmultiplyAlpha, dimension, &shader));
const ShaderSupport &support = getShaderSupport(*shader);
ShaderSupport support;
ANGLE_TRY(getShaderSupport(*shader, &support));
// Set vertices
D3D11_MAPPED_SUBRESOURCE mappedResource;
......@@ -1361,7 +1362,8 @@ gl::Error Blit11::copyDepth(const d3d11::SharedSRV &source,
}
// Apply shaders
deviceContext->IASetInputLayout(mQuad2DIL.resolve(device));
ANGLE_TRY(mQuad2DIL.resolve(mRenderer));
deviceContext->IASetInputLayout(mQuad2DIL.get());
deviceContext->IASetPrimitiveTopology(topology);
deviceContext->VSSetShader(quad2DVS, nullptr, 0);
......
src/libANGLE/renderer/d3d/d3d11/Blit11.h
......@@ -195,7 +195,7 @@ class Blit11 : angle::NonCopyable
gl::Error initResources();
ShaderSupport getShaderSupport(const Shader &shader);
gl::Error getShaderSupport(const Shader &shader, ShaderSupport *supportOut);
static BlitShaderType GetBlitShaderType(GLenum destinationFormat,
GLenum sourceFormat,
......
src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
......@@ -82,7 +82,7 @@ bool UpdateDataCache(RtvDsvClearInfo<T> *dataCache,
} // anonymous namespace
Clear11::ShaderManager::ShaderManager()
: mIl9(nullptr),
: mIl9(),
mVs9(g_VS_Clear_FL9, ArraySize(g_VS_Clear_FL9), "Clear11 VS FL9"),
mPsFloat9(g_PS_ClearFloat_FL9, ArraySize(g_PS_ClearFloat_FL9), "Clear11 PS FloatFL9"),
mVs(g_VS_Clear, ArraySize(g_VS_Clear), "Clear11 VS"),
......@@ -102,31 +102,35 @@ Clear11::ShaderManager::~ShaderManager()
mPsSInt.release();
}
void Clear11::ShaderManager::getShadersAndLayout(ID3D11Device *device,
D3D_FEATURE_LEVEL featureLevel,
const INT clearType,
ID3D11InputLayout **il,
ID3D11VertexShader **vs,
ID3D11PixelShader **ps)
gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
const INT clearType,
ID3D11InputLayout **il,
ID3D11VertexShader **vs,
ID3D11PixelShader **ps)
{
auto featureLevel = renderer->getRenderer11DeviceCaps().featureLevel;
auto device = renderer->getDevice();
if (featureLevel <= D3D_FEATURE_LEVEL_9_3)
{
ASSERT(clearType == GL_FLOAT);
*vs = mVs9.resolve(device);
if (mIl9.Get() == nullptr)
if (!mIl9.valid())
{
const D3D11_INPUT_ELEMENT_DESC ilDesc = {
"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0};
const D3D11_INPUT_ELEMENT_DESC ilDesc[] = {
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0}};
InputElementArray ilDescArray(ilDesc);
ShaderData vertexShader(g_VS_Clear_FL9);
device->CreateInputLayout(&ilDesc, 1, g_VS_Clear_FL9, ArraySize(g_PS_ClearFloat_FL9),
mIl9.GetAddressOf());
ANGLE_TRY(renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
}
*il = mIl9.Get();
*il = mIl9.get();
*ps = mPsFloat9.resolve(device);
return;
return gl::NoError();
}
*vs = mVs.resolve(device);
......@@ -147,6 +151,8 @@ void Clear11::ShaderManager::getShadersAndLayout(ID3D11Device *device,
UNREACHABLE();
break;
}
return gl::NoError();
}
Clear11::Clear11(Renderer11 *renderer)
......@@ -692,13 +698,11 @@ gl::Error Clear11::clearFramebuffer(const ClearParameters &clearParams,
}
// Get Shaders
const D3D_FEATURE_LEVEL fl = mRenderer->getRenderer11DeviceCaps().featureLevel;
ID3D11Device *device = mRenderer->getDevice();
ID3D11VertexShader *vs;
ID3D11InputLayout *il;
ID3D11PixelShader *ps;
ID3D11VertexShader *vs = nullptr;
ID3D11InputLayout *il = nullptr;
ID3D11PixelShader *ps = nullptr;
mShaderManager.getShadersAndLayout(device, fl, clearParams.colorType, &il, &vs, &ps);
ANGLE_TRY(mShaderManager.getShadersAndLayout(mRenderer, clearParams.colorType, &il, &vs, &ps));
// Apply Shaders
deviceContext->VSSetShader(vs, nullptr, 0);
......
src/libANGLE/renderer/d3d/d3d11/Clear11.h
......@@ -47,15 +47,14 @@ class Clear11 : angle::NonCopyable
public:
ShaderManager();
~ShaderManager();
void getShadersAndLayout(ID3D11Device *device,
D3D_FEATURE_LEVEL featureLevel,
const INT clearType,
ID3D11InputLayout **il,
ID3D11VertexShader **vs,
ID3D11PixelShader **ps);
gl::Error getShadersAndLayout(Renderer11 *renderer,
const INT clearType,
ID3D11InputLayout **il,
ID3D11VertexShader **vs,
ID3D11PixelShader **ps);
private:
angle::ComPtr<ID3D11InputLayout> mIl9;
d3d11::InputLayout mIl9;
d3d11::LazyShader<ID3D11VertexShader> mVs9;
d3d11::LazyShader<ID3D11PixelShader> mPsFloat9;
d3d11::LazyShader<ID3D11VertexShader> mVs;
......
src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp
......@@ -195,10 +195,6 @@ void InputLayoutCache::initialize()
void InputLayoutCache::clear()
{
for (auto &layout : mLayoutMap)
{
SafeRelease(layout.second);
}
mLayoutMap.clear();
mPointSpriteVertexBuffer.reset();
mPointSpriteIndexBuffer.reset();
......@@ -504,12 +500,13 @@ gl::Error InputLayoutCache::updateInputLayout(Renderer11 *renderer,
auto layoutMapIt = mLayoutMap.find(layout);
if (layoutMapIt != mLayoutMap.end())
{
inputLayout = layoutMapIt->second;
inputLayout = layoutMapIt->second.get();
}
else
{
d3d11::InputLayout newInputLayout;
ANGLE_TRY(createInputLayout(renderer, sortedSemanticIndices, mode, program,
numIndicesPerInstance, &inputLayout));
numIndicesPerInstance, &newInputLayout));
if (mLayoutMap.size() >= mCacheSize)
{
WARN() << "Overflowed the limit of " << mCacheSize
......@@ -523,13 +520,13 @@ gl::Error InputLayoutCache::updateInputLayout(Renderer11 *renderer,
if (it != mLayoutMap.end())
{
// c++11 erase allows us to easily delete the current iterator.
SafeRelease(it->second);
it = mLayoutMap.erase(it);
}
}
}
mLayoutMap[layout] = inputLayout;
inputLayout = newInputLayout.get();
mLayoutMap[layout] = std::move(newInputLayout);
}
}
......@@ -548,7 +545,7 @@ gl::Error InputLayoutCache::createInputLayout(Renderer11 *renderer,
GLenum mode,
gl::Program *program,
GLsizei numIndicesPerInstance,
ID3D11InputLayout **inputLayoutOut)
d3d11::InputLayout *inputLayoutOut)
{
ProgramD3D *programD3D = GetImplAs<ProgramD3D>(program);
auto featureLevel = renderer->getRenderer11DeviceCaps().featureLevel;
......@@ -638,15 +635,10 @@ gl::Error InputLayoutCache::createInputLayout(Renderer11 *renderer,
ShaderExecutableD3D *shader11 = GetAs<ShaderExecutable11>(shader);
ID3D11Device *device = renderer->getDevice();
HRESULT result =
device->CreateInputLayout(inputElements.data(), inputElementCount, shader11->getFunction(),
shader11->getLength(), inputLayoutOut);
if (FAILED(result))
{
return gl::Error(GL_OUT_OF_MEMORY,
"Failed to create internal input layout, HRESULT: 0x%08x", result);
}
InputElementArray inputElementArray(inputElements.data(), inputElementCount);
ShaderData vertexShaderData(shader11->getFunction(), shader11->getLength());
ANGLE_TRY(renderer->allocateResource(inputElementArray, &vertexShaderData, inputLayoutOut));
return gl::NoError();
}
......
src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.h
......@@ -101,9 +101,9 @@ class InputLayoutCache : angle::NonCopyable
GLenum mode,
gl::Program *program,
GLsizei numIndicesPerInstance,
ID3D11InputLayout **inputLayoutOut);
d3d11::InputLayout *inputLayoutOut);
std::map<PackedAttributeLayout, ID3D11InputLayout *> mLayoutMap;
std::map<PackedAttributeLayout, d3d11::InputLayout> mLayoutMap;
uintptr_t mCurrentIL;
std::array<ID3D11Buffer *, gl::MAX_VERTEX_ATTRIBS> mCurrentBuffers;
......
src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp
......@@ -121,6 +121,15 @@ HRESULT CreateResource(ID3D11Device *device,
}
HRESULT CreateResource(ID3D11Device *device,
const InputElementArray *desc,
const ShaderData *initData,
ID3D11InputLayout **resourceOut)
{
return device->CreateInputLayout(desc->get(), static_cast<UINT>(desc->size()), initData->get(),
initData->size(), resourceOut);
}
HRESULT CreateResource(ID3D11Device *device,
const D3D11_RASTERIZER_DESC *desc,
void * /*initData*/,
ID3D11RasterizerState **rasterizerState)
......@@ -337,30 +346,13 @@ void ResourceManager11::decrResource(ResourceType resourceType, size_t memorySiz
mAllocatedResourceDeviceMemory[ResourceTypeIndex(resourceType)] -= memorySize;
}
void ResourceManager11::onReleaseResource(ResourceType resourceType, ID3D11Resource *resource)
void ResourceManager11::onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource)
{
ASSERT(resource);
decrResource(resourceType, ComputeGenericMemoryUsage(resourceType, resource));
}
template <>
void ResourceManager11::onRelease(ID3D11Resource *resource)
{
// For untyped ID3D11Resource, they must call onReleaseResource.
UNREACHABLE();
}
template <typename T>
void ResourceManager11::onRelease(T *resource)
{
ASSERT(resource);
GetDescFromD3D11<T> desc;
resource->GetDesc(&desc);
decrResource(GetResourceTypeFromD3D11<T>(), ComputeMemoryUsage(&desc));
}
template <>
const D3D11_SUBRESOURCE_DATA *ResourceManager11::createInitDataIfNeeded<ID3D11Texture2D>(
const D3D11_TEXTURE2D_DESC *desc)
{
......@@ -456,21 +448,12 @@ GetInitDataFromD3D11<T> *ResourceManager11::createInitDataIfNeeded(const GetDesc
return nullptr;
}
#define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \
\
template gl::Error \
ResourceManager11::allocate(\
Renderer11 *, \
\
const DESCTYPE *, \
\
INITDATATYPE *, \
\
Resource11<D3D11TYPE> *); \
#define ANGLE_INSTANTIATE_OP(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) \
\
\
template void \
ResourceManager11::onRelease(D3D11TYPE *);
template \
gl::Error \
ResourceManager11::allocate(Renderer11 *, const DESCTYPE *, INITDATATYPE *, \
Resource11<D3D11TYPE> *);
ANGLE_RESOURCE_TYPE_OP(Instantitate, ANGLE_INSTANTIATE_OP)
} // namespace rx
src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h
......@@ -25,6 +25,9 @@ template <typename T>
class SharedResource11;
class TextureHelper11;
using InputElementArray = WrappedArray<D3D11_INPUT_ELEMENT_DESC>;
using ShaderData = WrappedArray<uint8_t>;
// Format: ResourceType, D3D11 type, DESC type, init data type.
#define ANGLE_RESOURCE_TYPE_OP(NAME, OP) \
OP(NAME, BlendState, ID3D11BlendState, D3D11_BLEND_DESC, void) \
......@@ -32,6 +35,7 @@ class TextureHelper11;
OP(NAME, DepthStencilState, ID3D11DepthStencilState, D3D11_DEPTH_STENCIL_DESC, void) \
OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC, \
ID3D11Resource) \
OP(NAME, InputLayout, ID3D11InputLayout, InputElementArray, const ShaderData) \
OP(NAME, RasterizerState, ID3D11RasterizerState, D3D11_RASTERIZER_DESC, void) \
OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC, \
ID3D11Resource) \
......@@ -277,8 +281,12 @@ class ResourceManager11 final : angle::NonCopyable
}
template <typename T>
void onRelease(T *resource);
void onReleaseResource(ResourceType resourceType, ID3D11Resource *resource);
void onRelease(T *resource)
{
onReleaseGeneric(GetResourceTypeFromD3D11<T>(), resource);
}
void onReleaseGeneric(ResourceType resourceType, ID3D11DeviceChild *resource);
private:
void incrResource(ResourceType resourceType, size_t memorySize);
......
src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
......@@ -82,7 +82,7 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
mDepthStencilSRView(),
mQuadVB(),
mPassThroughSampler(),
mPassThroughIL(nullptr),
mPassThroughIL(),
mPassThroughVS(nullptr),
mPassThroughPS(nullptr),
mPassThroughRS(),
......@@ -122,7 +122,7 @@ void SwapChain11::release()
mDepthStencilSRView.reset();
mQuadVB.reset();
mPassThroughSampler.reset();
SafeRelease(mPassThroughIL);
mPassThroughIL.reset();
SafeRelease(mPassThroughVS);
SafeRelease(mPassThroughPS);
mPassThroughRS.reset();
......@@ -612,7 +612,7 @@ void SwapChain11::initPassThroughResources()
// Make sure our resources are all not allocated, when we create
ASSERT(!mQuadVB.valid() && !mPassThroughSampler.valid());
ASSERT(mPassThroughIL == nullptr && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
ASSERT(!mPassThroughIL.valid() && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
D3D11_BUFFER_DESC vbDesc;
vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
......@@ -651,13 +651,15 @@ void SwapChain11::initPassThroughResources()
{ "TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
HRESULT result = device->CreateInputLayout(quadLayout, 2, g_VS_Passthrough2D,
sizeof(g_VS_Passthrough2D), &mPassThroughIL);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughIL, "Swap chain pass through layout");
InputElementArray quadElements(quadLayout);
ShaderData vertexShaderData(g_VS_Passthrough2D);
err = mRenderer->allocateResource(quadElements, &vertexShaderData, &mPassThroughIL);
ASSERT(!err.isError());
mPassThroughIL.setDebugName("Swap chain pass through layout");
result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D), nullptr,
&mPassThroughVS);
HRESULT result = device->CreateVertexShader(g_VS_Passthrough2D, sizeof(g_VS_Passthrough2D),
nullptr, &mPassThroughVS);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughVS, "Swap chain pass through vertex shader");
......@@ -782,7 +784,7 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
deviceContext->RSSetState(mPassThroughRS.get());
// Apply shaders
deviceContext->IASetInputLayout(mPassThroughIL);
deviceContext->IASetInputLayout(mPassThroughIL.get());
deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
deviceContext->VSSetShader(mPassThroughVS, nullptr, 0);
deviceContext->PSSetShader(mPassThroughPS, nullptr, 0);
......
src/libANGLE/renderer/d3d/d3d11/SwapChain11.h
......@@ -100,7 +100,7 @@ class SwapChain11 final : public SwapChainD3D
d3d11::Buffer mQuadVB;
d3d11::SamplerState mPassThroughSampler;
ID3D11InputLayout *mPassThroughIL;
d3d11::InputLayout mPassThroughIL;
ID3D11VertexShader *mPassThroughVS;
ID3D11PixelShader *mPassThroughPS;
d3d11::RasterizerState mPassThroughRS;
......
src/libANGLE/renderer/d3d/d3d11/renderer11_utils.cpp
......@@ -1940,36 +1940,9 @@ HRESULT SetDebugName(ID3D11DeviceChild *resource, const char *name)
#endif
}
LazyInputLayout::LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
size_t inputDescLen,
const BYTE *byteCode,
size_t byteCodeLen,
const char *debugName)
: mInputDesc(inputDescLen),
mByteCodeLen(byteCodeLen),
mByteCode(byteCode),
mDebugName(debugName)
gl::Error LazyInputLayout::resolve(Renderer11 *renderer)
{
if (inputDesc)
{
memcpy(&mInputDesc[0], inputDesc, sizeof(D3D11_INPUT_ELEMENT_DESC) * inputDescLen);
}
}
ID3D11InputLayout *LazyInputLayout::resolve(ID3D11Device *device)
{
checkAssociatedDevice(device);
if (mResource == nullptr && mByteCode != nullptr)
{
HRESULT result =
device->CreateInputLayout(&mInputDesc[0], static_cast<UINT>(mInputDesc.size()),
mByteCode, mByteCodeLen, &mResource);
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mResource, mDebugName);
}
return mResource;
return resolveImpl(renderer, mInputDesc, &mByteCode, mDebugName);
}
LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName)
......@@ -1979,7 +1952,7 @@ LazyBlendState::LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugNa
gl::Error LazyBlendState::resolve(Renderer11 *renderer)
{
return resolveImpl(renderer, mDesc, mDebugName);
return resolveImpl(renderer, mDesc, nullptr, mDebugName);
}
angle::WorkaroundsD3D GenerateWorkarounds(const Renderer11DeviceCaps &deviceCaps,
......
src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
......@@ -262,7 +262,7 @@ template <ResourceType ResourceT>
class LazyResource2 : angle::NonCopyable
{
public:
LazyResource2() : mResource() {}
constexpr LazyResource2() : mResource() {}
virtual ~LazyResource2() {}
virtual gl::Error resolve(Renderer11 *renderer) = 0;
......@@ -276,11 +276,12 @@ class LazyResource2 : angle::NonCopyable
protected:
gl::Error resolveImpl(Renderer11 *renderer,
const GetDescType<ResourceT> &desc,
GetInitDataType<ResourceT> *initData,
const char *name)
{
if (!mResource.valid())
{
ANGLE_TRY(renderer->allocateResource(desc, &mResource));
ANGLE_TRY(renderer->allocateResource(desc, initData, &mResource));
mResource.setDebugName(name);
}
return gl::NoError();
......@@ -351,21 +352,25 @@ inline ID3D11PixelShader *LazyShader<ID3D11PixelShader>::resolve(ID3D11Device *d
return mResource;
}
class LazyInputLayout final : public LazyResource<ID3D11InputLayout>
class LazyInputLayout final : public LazyResource2<ResourceType::InputLayout>
{
public:
LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
size_t inputDescLen,
const BYTE *byteCode,
size_t byteCodeLen,
const char *debugName);
constexpr LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
size_t inputDescLen,
const BYTE *byteCode,
size_t byteCodeLen,
const char *debugName)
: mInputDesc(inputDesc, inputDescLen),
mByteCode(byteCode, byteCodeLen),
mDebugName(debugName)
{
}
ID3D11InputLayout *resolve(ID3D11Device *device) override;
gl::Error resolve(Renderer11 *renderer) override;
private:
std::vector<D3D11_INPUT_ELEMENT_DESC> mInputDesc;
size_t mByteCodeLen;
const BYTE *mByteCode;
InputElementArray mInputDesc;
ShaderData mByteCode;
const char *mDebugName;
};
......@@ -420,7 +425,7 @@ struct GenericData
// We can have a nullptr factory when holding passed-in resources.
if (manager)
{
manager->onReleaseResource(resourceType, object);
manager->onReleaseGeneric(resourceType, object);
manager = nullptr;
}
object->Release();
......
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