Skip to content

A
angle
Commit 0fd806f1 by Jamie Madill Committed by Commit Bot
Options

D3D11: Consolidate Shader allocation.

Similar to the InputLayout init, this adds a small helper type to act as a wrapper around shader init data (binary and size). This also adds error trapping to the blit shader compilation. It also removes the LazyResource2 class, and the CompileXS helper methods. BUG=angleproject:2034 Change-Id: I3fd718393c8a0250e4263890f00d0e9147ec9567 Reviewed-on: https://chromium-review.googlesource.com/506776Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Reviewed-by: 's avatarCorentin Wallez <cwallez@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>
parent fccbac2c
Showing with 210 additions and 320 deletions
src/libANGLE/renderer/d3d/RendererD3D.h
......@@ -195,7 +195,7 @@ class RendererD3D : public BufferFactoryD3D
virtual gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) = 0;
// Shader operations
virtual gl::Error loadExecutable(const void *function,
virtual gl::Error loadExecutable(const uint8_t *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &streamOutVaryings,
......
src/libANGLE/renderer/d3d/d3d11/Blit11.h
......@@ -182,7 +182,7 @@ class Blit11 : angle::NonCopyable
struct Shader
{
ShaderDimension dimension;
ID3D11PixelShader *pixelShader;
d3d11::PixelShader pixelShader;
};
struct ShaderSupport
......@@ -247,9 +247,10 @@ class Blit11 : angle::NonCopyable
size_t destPixelStride,
BlitConvertFunction *convertFunction);
void addBlitShaderToMap(BlitShaderType blitShaderType,
ShaderDimension dimension,
ID3D11PixelShader *ps);
gl::Error addBlitShaderToMap(BlitShaderType blitShaderType,
ShaderDimension dimension,
const ShaderData &shaderData,
const char *name);
gl::Error getBlitShader(GLenum destFormat,
GLenum sourceFormat,
......@@ -262,9 +263,10 @@ class Blit11 : angle::NonCopyable
D3D11_SRV_DIMENSION viewDimension,
const Shader **shaderOut);
void addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
ShaderDimension dimension,
ID3D11PixelShader *ps);
gl::Error addSwizzleShaderToMap(SwizzleShaderType swizzleShaderType,
ShaderDimension dimension,
const ShaderData &shaderData,
const char *name);
void clearShaderMap();
void releaseResolveDepthStencilResources();
......
src/libANGLE/renderer/d3d/d3d11/Clear11.cpp
......@@ -94,12 +94,6 @@ Clear11::ShaderManager::ShaderManager()
Clear11::ShaderManager::~ShaderManager()
{
mVs9.release();
mPsFloat9.release();
mVs.release();
mPsFloat.release();
mPsUInt.release();
mPsSInt.release();
}
gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
......@@ -108,14 +102,12 @@ gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
ID3D11VertexShader **vs,
ID3D11PixelShader **ps)
{
auto featureLevel = renderer->getRenderer11DeviceCaps().featureLevel;
auto device = renderer->getDevice();
if (featureLevel <= D3D_FEATURE_LEVEL_9_3)
if (renderer->getRenderer11DeviceCaps().featureLevel <= D3D_FEATURE_LEVEL_9_3)
{
ASSERT(clearType == GL_FLOAT);
*vs = mVs9.resolve(device);
ANGLE_TRY(mVs9.resolve(renderer));
ANGLE_TRY(mPsFloat9.resolve(renderer));
if (!mIl9.valid())
{
......@@ -128,24 +120,29 @@ gl::Error Clear11::ShaderManager::getShadersAndLayout(Renderer11 *renderer,
ANGLE_TRY(renderer->allocateResource(ilDescArray, &vertexShader, &mIl9));
}
*vs = mVs9.get();
*il = mIl9.get();
*ps = mPsFloat9.resolve(device);
*ps = mPsFloat9.get();
return gl::NoError();
}
*vs = mVs.resolve(device);
ANGLE_TRY(mVs.resolve(renderer));
*vs = mVs.get();
*il = nullptr;
switch (clearType)
{
case GL_FLOAT:
*ps = mPsFloat.resolve(device);
ANGLE_TRY(mPsFloat.resolve(renderer));
*ps = mPsFloat.get();
break;
case GL_UNSIGNED_INT:
*ps = mPsUInt.resolve(device);
ANGLE_TRY(mPsUInt.resolve(renderer));
*ps = mPsUInt.get();
break;
case GL_INT:
*ps = mPsSInt.resolve(device);
ANGLE_TRY(mPsSInt.resolve(renderer));
*ps = mPsSInt.get();
break;
default:
UNREACHABLE();
......
src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.cpp
......@@ -36,8 +36,8 @@ namespace rx
PixelTransfer11::PixelTransfer11(Renderer11 *renderer)
: mRenderer(renderer),
mResourcesLoaded(false),
mBufferToTextureVS(nullptr),
mBufferToTextureGS(nullptr),
mBufferToTextureVS(),
mBufferToTextureGS(),
mParamsConstantBuffer(),
mCopyRasterizerState(),
mCopyDepthStencilState()
......@@ -46,15 +46,6 @@ PixelTransfer11::PixelTransfer11(Renderer11 *renderer)
PixelTransfer11::~PixelTransfer11()
{
for (auto shaderMapIt = mBufferToTexturePSMap.begin(); shaderMapIt != mBufferToTexturePSMap.end(); shaderMapIt++)
{
SafeRelease(shaderMapIt->second);
}
mBufferToTexturePSMap.clear();
SafeRelease(mBufferToTextureVS);
SafeRelease(mBufferToTextureGS);
}
gl::Error PixelTransfer11::loadResources()
......@@ -108,18 +99,11 @@ gl::Error PixelTransfer11::loadResources()
mParamsConstantBuffer.setDebugName("PixelTransfer11 constant buffer");
// init shaders
ID3D11Device *device = mRenderer->getDevice();
mBufferToTextureVS = d3d11::CompileVS(device, g_VS_BufferToTexture, "BufferToTexture VS");
if (!mBufferToTextureVS)
{
return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture vertex shader.");
}
ANGLE_TRY(mRenderer->allocateResource(ShaderData(g_VS_BufferToTexture), &mBufferToTextureVS));
mBufferToTextureVS.setDebugName("BufferToTexture VS");
mBufferToTextureGS = d3d11::CompileGS(device, g_GS_BufferToTexture, "BufferToTexture GS");
if (!mBufferToTextureGS)
{
return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture geometry shader.");
}
ANGLE_TRY(mRenderer->allocateResource(ShaderData(g_GS_BufferToTexture), &mBufferToTextureGS));
mBufferToTextureGS.setDebugName("BufferToTexture GS");
ANGLE_TRY(buildShaderMap());
......@@ -200,10 +184,11 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
UINT zero = 0;
// Are we doing a 2D or 3D copy?
ID3D11GeometryShader *geometryShader = ((destSize.depth > 1) ? mBufferToTextureGS : nullptr);
ID3D11GeometryShader *geometryShader =
((destSize.depth > 1) ? mBufferToTextureGS.get() : nullptr);
auto stateManager = mRenderer->getStateManager();
deviceContext->VSSetShader(mBufferToTextureVS, nullptr, 0);
deviceContext->VSSetShader(mBufferToTextureVS.get(), nullptr, 0);
deviceContext->GSSetShader(geometryShader, nullptr, 0);
deviceContext->PSSetShader(pixelShader, nullptr, 0);
stateManager->setShaderResource(gl::SAMPLER_PIXEL, 0, bufferSRV);
......@@ -250,20 +235,24 @@ gl::Error PixelTransfer11::copyBufferToTexture(const gl::PixelUnpackState &unpac
gl::Error PixelTransfer11::buildShaderMap()
{
ID3D11Device *device = mRenderer->getDevice();
d3d11::PixelShader bufferToTextureFloat;
d3d11::PixelShader bufferToTextureInt;
d3d11::PixelShader bufferToTextureUint;
mBufferToTexturePSMap[GL_FLOAT] = d3d11::CompilePS(device, g_PS_BufferToTexture_4F, "BufferToTexture RGBA ps");
mBufferToTexturePSMap[GL_INT] = d3d11::CompilePS(device, g_PS_BufferToTexture_4I, "BufferToTexture RGBA-I ps");
mBufferToTexturePSMap[GL_UNSIGNED_INT] = d3d11::CompilePS(device, g_PS_BufferToTexture_4UI, "BufferToTexture RGBA-UI ps");
ANGLE_TRY(
mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4F), &bufferToTextureFloat));
ANGLE_TRY(
mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4I), &bufferToTextureInt));
ANGLE_TRY(
mRenderer->allocateResource(ShaderData(g_PS_BufferToTexture_4UI), &bufferToTextureUint));
// Check that all the shaders were created successfully
for (auto shaderMapIt = mBufferToTexturePSMap.begin(); shaderMapIt != mBufferToTexturePSMap.end(); shaderMapIt++)
{
if (shaderMapIt->second == nullptr)
{
return gl::Error(GL_OUT_OF_MEMORY, "Failed to create internal buffer to texture pixel shader.");
}
}
bufferToTextureFloat.setDebugName("BufferToTexture RGBA ps");
bufferToTextureInt.setDebugName("BufferToTexture RGBA-I ps");
bufferToTextureUint.setDebugName("BufferToTexture RGBA-UI ps");
mBufferToTexturePSMap[GL_FLOAT] = std::move(bufferToTextureFloat);
mBufferToTexturePSMap[GL_INT] = std::move(bufferToTextureInt);
mBufferToTexturePSMap[GL_UNSIGNED_INT] = std::move(bufferToTextureUint);
return gl::NoError();
}
......@@ -277,7 +266,7 @@ ID3D11PixelShader *PixelTransfer11::findBufferToTexturePS(GLenum internalFormat)
}
auto shaderMapIt = mBufferToTexturePSMap.find(componentType);
return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : shaderMapIt->second);
return (shaderMapIt == mBufferToTexturePSMap.end() ? nullptr : shaderMapIt->second.get());
}
} // namespace rx
src/libANGLE/renderer/d3d/d3d11/PixelTransfer11.h
......@@ -73,9 +73,9 @@ class PixelTransfer11
Renderer11 *mRenderer;
bool mResourcesLoaded;
std::map<GLenum, ID3D11PixelShader *> mBufferToTexturePSMap;
ID3D11VertexShader *mBufferToTextureVS;
ID3D11GeometryShader *mBufferToTextureGS;
std::map<GLenum, d3d11::PixelShader> mBufferToTexturePSMap;
d3d11::VertexShader mBufferToTextureVS;
d3d11::GeometryShader mBufferToTextureGS;
d3d11::Buffer mParamsConstantBuffer;
CopyShaderParams mParamsData;
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp
......@@ -3647,26 +3647,22 @@ gl::Error Renderer11::createRenderTargetCopy(RenderTargetD3D *source, RenderTarg
return gl::NoError();
}
gl::Error Renderer11::loadExecutable(const void *function,
gl::Error Renderer11::loadExecutable(const uint8_t *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &streamOutVaryings,
bool separatedOutputBuffers,
ShaderExecutableD3D **outExecutable)
{
ShaderData shaderData(function, length);
switch (type)
{
case SHADER_VERTEX:
{
ID3D11VertexShader *vertexShader = nullptr;
ID3D11GeometryShader *streamOutShader = nullptr;
HRESULT result = mDevice->CreateVertexShader(function, length, nullptr, &vertexShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create vertex shader, " << result;
}
d3d11::VertexShader vertexShader;
d3d11::GeometryShader streamOutShader;
ANGLE_TRY(allocateResource(shaderData, &vertexShader));
if (!streamOutVaryings.empty())
{
......@@ -3686,63 +3682,32 @@ gl::Error Renderer11::loadExecutable(const void *function,
soDeclaration.push_back(entry);
}
result = mDevice->CreateGeometryShaderWithStreamOutput(
function, static_cast<unsigned int>(length), soDeclaration.data(),
static_cast<unsigned int>(soDeclaration.size()), nullptr, 0, 0, nullptr,
&streamOutShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create steam output shader, " << result;
}
ANGLE_TRY(allocateResource(shaderData, &soDeclaration, &streamOutShader));
}
*outExecutable =
new ShaderExecutable11(function, length, vertexShader, streamOutShader);
*outExecutable = new ShaderExecutable11(function, length, std::move(vertexShader),
std::move(streamOutShader));
}
break;
case SHADER_PIXEL:
{
ID3D11PixelShader *pixelShader = nullptr;
HRESULT result = mDevice->CreatePixelShader(function, length, nullptr, &pixelShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create pixel shader, " << result;
}
*outExecutable = new ShaderExecutable11(function, length, pixelShader);
d3d11::PixelShader pixelShader;
ANGLE_TRY(allocateResource(shaderData, &pixelShader));
*outExecutable = new ShaderExecutable11(function, length, std::move(pixelShader));
}
break;
case SHADER_GEOMETRY:
{
ID3D11GeometryShader *geometryShader = nullptr;
HRESULT result =
mDevice->CreateGeometryShader(function, length, nullptr, &geometryShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create geometry shader, " << result;
}
*outExecutable = new ShaderExecutable11(function, length, geometryShader);
d3d11::GeometryShader geometryShader;
ANGLE_TRY(allocateResource(shaderData, &geometryShader));
*outExecutable = new ShaderExecutable11(function, length, std::move(geometryShader));
}
break;
case SHADER_COMPUTE:
{
ID3D11ComputeShader *computeShader = nullptr;
HRESULT result =
mDevice->CreateComputeShader(function, length, nullptr, &computeShader);
ASSERT(SUCCEEDED(result));
if (FAILED(result))
{
return gl::OutOfMemory() << "Failed to create compute shader, " << result;
}
*outExecutable = new ShaderExecutable11(function, length, computeShader);
d3d11::ComputeShader computeShader;
ANGLE_TRY(allocateResource(shaderData, &computeShader));
*outExecutable = new ShaderExecutable11(function, length, std::move(computeShader));
}
break;
default:
......@@ -3819,6 +3784,7 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
D3D_SHADER_MACRO loopMacros[] = {{"ANGLE_ENABLE_LOOP_FLATTEN", "1"}, {0, 0}};
// TODO(jmadill): Use ComPtr?
ID3DBlob *binary = nullptr;
std::string debugInfo;
ANGLE_TRY(mCompiler.compileToBinary(infoLog, shaderHLSL, profile, configs, loopMacros, &binary,
......@@ -3833,8 +3799,9 @@ gl::Error Renderer11::compileToExecutable(gl::InfoLog &infoLog,
return gl::NoError();
}
gl::Error error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
streamOutVaryings, separatedOutputBuffers, outExectuable);
gl::Error error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
binary->GetBufferSize(), type, streamOutVaryings,
separatedOutputBuffers, outExectuable);
SafeRelease(binary);
if (error.isError())
......
src/libANGLE/renderer/d3d/d3d11/Renderer11.h
......@@ -240,7 +240,7 @@ class Renderer11 : public RendererD3D
gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) override;
// Shader operations
gl::Error loadExecutable(const void *function,
gl::Error loadExecutable(const uint8_t *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &streamOutVaryings,
......
src/libANGLE/renderer/d3d/d3d11/ResourceManager11.cpp
......@@ -105,6 +105,14 @@ HRESULT CreateResource(ID3D11Device *device,
}
HRESULT CreateResource(ID3D11Device *device,
const ShaderData *desc,
void * /*initData*/,
ID3D11ComputeShader **resourceOut)
{
return device->CreateComputeShader(desc->get(), desc->size(), nullptr, resourceOut);
}
HRESULT CreateResource(ID3D11Device *device,
const D3D11_DEPTH_STENCIL_DESC *desc,
void * /*initData*/,
ID3D11DepthStencilState **resourceOut)
......@@ -121,6 +129,23 @@ HRESULT CreateResource(ID3D11Device *device,
}
HRESULT CreateResource(ID3D11Device *device,
const ShaderData *desc,
const std::vector<D3D11_SO_DECLARATION_ENTRY> *initData,
ID3D11GeometryShader **resourceOut)
{
if (initData)
{
return device->CreateGeometryShaderWithStreamOutput(
desc->get(), desc->size(), initData->data(), static_cast<UINT>(initData->size()),
nullptr, 0, 0, nullptr, resourceOut);
}
else
{
return device->CreateGeometryShader(desc->get(), desc->size(), nullptr, resourceOut);
}
}
HRESULT CreateResource(ID3D11Device *device,
const InputElementArray *desc,
const ShaderData *initData,
ID3D11InputLayout **resourceOut)
......@@ -130,6 +155,14 @@ HRESULT CreateResource(ID3D11Device *device,
}
HRESULT CreateResource(ID3D11Device *device,
const ShaderData *desc,
void * /*initData*/,
ID3D11PixelShader **resourceOut)
{
return device->CreatePixelShader(desc->get(), desc->size(), nullptr, resourceOut);
}
HRESULT CreateResource(ID3D11Device *device,
const D3D11_RASTERIZER_DESC *desc,
void * /*initData*/,
ID3D11RasterizerState **rasterizerState)
......@@ -177,6 +210,14 @@ HRESULT CreateResource(ID3D11Device *device,
return device->CreateTexture3D(desc, initData, texture);
}
HRESULT CreateResource(ID3D11Device *device,
const ShaderData *desc,
void * /*initData*/,
ID3D11VertexShader **resourceOut)
{
return device->CreateVertexShader(desc->get(), desc->size(), nullptr, resourceOut);
}
DXGI_FORMAT GetTypedDepthStencilFormat(DXGI_FORMAT dxgiFormat)
{
switch (dxgiFormat)
......
src/libANGLE/renderer/d3d/d3d11/ResourceManager11.h
......@@ -32,10 +32,14 @@ using ShaderData = WrappedArray<uint8_t>;
#define ANGLE_RESOURCE_TYPE_OP(NAME, OP) \
OP(NAME, BlendState, ID3D11BlendState, D3D11_BLEND_DESC, void) \
OP(NAME, Buffer, ID3D11Buffer, D3D11_BUFFER_DESC, const D3D11_SUBRESOURCE_DATA) \
OP(NAME, ComputeShader, ID3D11ComputeShader, ShaderData, void) \
OP(NAME, DepthStencilState, ID3D11DepthStencilState, D3D11_DEPTH_STENCIL_DESC, void) \
OP(NAME, DepthStencilView, ID3D11DepthStencilView, D3D11_DEPTH_STENCIL_VIEW_DESC, \
ID3D11Resource) \
OP(NAME, GeometryShader, ID3D11GeometryShader, ShaderData, \
const std::vector<D3D11_SO_DECLARATION_ENTRY>) \
OP(NAME, InputLayout, ID3D11InputLayout, InputElementArray, const ShaderData) \
OP(NAME, PixelShader, ID3D11PixelShader, ShaderData, void) \
OP(NAME, RasterizerState, ID3D11RasterizerState, D3D11_RASTERIZER_DESC, void) \
OP(NAME, RenderTargetView, ID3D11RenderTargetView, D3D11_RENDER_TARGET_VIEW_DESC, \
ID3D11Resource) \
......@@ -43,7 +47,8 @@ using ShaderData = WrappedArray<uint8_t>;
OP(NAME, ShaderResourceView, ID3D11ShaderResourceView, D3D11_SHADER_RESOURCE_VIEW_DESC, \
ID3D11Resource) \
OP(NAME, Texture2D, ID3D11Texture2D, D3D11_TEXTURE2D_DESC, const D3D11_SUBRESOURCE_DATA) \
OP(NAME, Texture3D, ID3D11Texture3D, D3D11_TEXTURE3D_DESC, const D3D11_SUBRESOURCE_DATA)
OP(NAME, Texture3D, ID3D11Texture3D, D3D11_TEXTURE3D_DESC, const D3D11_SUBRESOURCE_DATA) \
OP(NAME, VertexShader, ID3D11VertexShader, ShaderData, void)
#define ANGLE_RESOURCE_TYPE_LIST(NAME, RESTYPE, D3D11TYPE, DESCTYPE, INITDATATYPE) RESTYPE,
......
src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.cpp
......@@ -13,80 +13,82 @@
namespace rx
{
ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable)
: ShaderExecutableD3D(function, length)
ShaderExecutable11::ShaderExecutable11(const void *function,
size_t length,
d3d11::PixelShader &&executable)
: ShaderExecutableD3D(function, length),
mPixelExecutable(std::move(executable)),
mVertexExecutable(),
mGeometryExecutable(),
mStreamOutExecutable(),
mComputeExecutable()
{
mPixelExecutable = executable;
mVertexExecutable = nullptr;
mGeometryExecutable = nullptr;
mStreamOutExecutable = nullptr;
mComputeExecutable = nullptr;
}
ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut)
: ShaderExecutableD3D(function, length)
ShaderExecutable11::ShaderExecutable11(const void *function,
size_t length,
d3d11::VertexShader &&executable,
d3d11::GeometryShader &&streamOut)
: ShaderExecutableD3D(function, length),
mPixelExecutable(),
mVertexExecutable(std::move(executable)),
mGeometryExecutable(),
mStreamOutExecutable(std::move(streamOut)),
mComputeExecutable()
{
mVertexExecutable = executable;
mPixelExecutable = nullptr;
mGeometryExecutable = nullptr;
mStreamOutExecutable = streamOut;
mComputeExecutable = nullptr;
}
ShaderExecutable11::ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable)
: ShaderExecutableD3D(function, length)
ShaderExecutable11::ShaderExecutable11(const void *function,
size_t length,
d3d11::GeometryShader &&executable)
: ShaderExecutableD3D(function, length),
mPixelExecutable(),
mVertexExecutable(),
mGeometryExecutable(std::move(executable)),
mStreamOutExecutable(),
mComputeExecutable()
{
mGeometryExecutable = executable;
mVertexExecutable = nullptr;
mPixelExecutable = nullptr;
mStreamOutExecutable = nullptr;
mComputeExecutable = nullptr;
}
ShaderExecutable11::ShaderExecutable11(const void *function,
size_t length,
ID3D11ComputeShader *executable)
: ShaderExecutableD3D(function, length)
d3d11::ComputeShader &&executable)
: ShaderExecutableD3D(function, length),
mPixelExecutable(),
mVertexExecutable(),
mGeometryExecutable(),
mStreamOutExecutable(),
mComputeExecutable(std::move(executable))
{
mComputeExecutable = executable;
mPixelExecutable = nullptr;
mVertexExecutable = nullptr;
mGeometryExecutable = nullptr;
mStreamOutExecutable = nullptr;
}
ShaderExecutable11::~ShaderExecutable11()
{
SafeRelease(mVertexExecutable);
SafeRelease(mPixelExecutable);
SafeRelease(mGeometryExecutable);
SafeRelease(mStreamOutExecutable);
SafeRelease(mComputeExecutable);
}
ID3D11VertexShader *ShaderExecutable11::getVertexShader() const
{
return mVertexExecutable;
return mVertexExecutable.get();
}
ID3D11PixelShader *ShaderExecutable11::getPixelShader() const
{
return mPixelExecutable;
return mPixelExecutable.get();
}
ID3D11GeometryShader *ShaderExecutable11::getGeometryShader() const
{
return mGeometryExecutable;
return mGeometryExecutable.get();
}
ID3D11GeometryShader *ShaderExecutable11::getStreamOutShader() const
{
return mStreamOutExecutable;
return mStreamOutExecutable.get();
}
ID3D11ComputeShader *ShaderExecutable11::getComputeShader() const
{
return mComputeExecutable;
return mComputeExecutable.get();
}
UniformStorage11::UniformStorage11(size_t initialSize)
......
src/libANGLE/renderer/d3d/d3d11/ShaderExecutable11.h
......@@ -21,10 +21,13 @@ class UniformStorage11;
class ShaderExecutable11 : public ShaderExecutableD3D
{
public:
ShaderExecutable11(const void *function, size_t length, ID3D11PixelShader *executable);
ShaderExecutable11(const void *function, size_t length, ID3D11VertexShader *executable, ID3D11GeometryShader *streamOut);
ShaderExecutable11(const void *function, size_t length, ID3D11GeometryShader *executable);
ShaderExecutable11(const void *function, size_t length, ID3D11ComputeShader *executable);
ShaderExecutable11(const void *function, size_t length, d3d11::PixelShader &&executable);
ShaderExecutable11(const void *function,
size_t length,
d3d11::VertexShader &&executable,
d3d11::GeometryShader &&streamOut);
ShaderExecutable11(const void *function, size_t length, d3d11::GeometryShader &&executable);
ShaderExecutable11(const void *function, size_t length, d3d11::ComputeShader &&executable);
virtual ~ShaderExecutable11();
......@@ -35,11 +38,11 @@ class ShaderExecutable11 : public ShaderExecutableD3D
ID3D11ComputeShader *getComputeShader() const;
private:
ID3D11PixelShader *mPixelExecutable;
ID3D11VertexShader *mVertexExecutable;
ID3D11GeometryShader *mGeometryExecutable;
ID3D11GeometryShader *mStreamOutExecutable;
ID3D11ComputeShader *mComputeExecutable;
d3d11::PixelShader mPixelExecutable;
d3d11::VertexShader mVertexExecutable;
d3d11::GeometryShader mGeometryExecutable;
d3d11::GeometryShader mStreamOutExecutable;
d3d11::ComputeShader mComputeExecutable;
};
class UniformStorage11 : public UniformStorageD3D
......
src/libANGLE/renderer/d3d/d3d11/SwapChain11.cpp
......@@ -83,8 +83,8 @@ SwapChain11::SwapChain11(Renderer11 *renderer,
mQuadVB(),
mPassThroughSampler(),
mPassThroughIL(),
mPassThroughVS(nullptr),
mPassThroughPS(nullptr),
mPassThroughVS(),
mPassThroughPS(),
mPassThroughRS(),
mColorRenderTarget(this, renderer, false),
mDepthStencilRenderTarget(this, renderer, true),
......@@ -123,8 +123,8 @@ void SwapChain11::release()
mQuadVB.reset();
mPassThroughSampler.reset();
mPassThroughIL.reset();
SafeRelease(mPassThroughVS);
SafeRelease(mPassThroughPS);
mPassThroughVS.reset();
mPassThroughPS.reset();
mPassThroughRS.reset();
if (!mAppCreatedShareHandle)
......@@ -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.valid() && mPassThroughVS == nullptr && mPassThroughPS == nullptr);
ASSERT(!mPassThroughIL.valid() && !mPassThroughVS.valid() && !mPassThroughPS.valid());
D3D11_BUFFER_DESC vbDesc;
vbDesc.ByteWidth = sizeof(d3d11::PositionTexCoordVertex) * 4;
......@@ -658,24 +658,23 @@ void SwapChain11::initPassThroughResources()
ASSERT(!err.isError());
mPassThroughIL.setDebugName("Swap chain pass through layout");
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");
err = mRenderer->allocateResource(vertexShaderData, &mPassThroughVS);
ASSERT(!err.isError());
mPassThroughVS.setDebugName("Swap chain pass through vertex shader");
if (mEGLSamples <= 1)
{
result = device->CreatePixelShader(g_PS_PassthroughRGBA2D, sizeof(g_PS_PassthroughRGBA2D),
nullptr, &mPassThroughPS);
ShaderData pixelShaderData(g_PS_PassthroughRGBA2D);
err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
}
else
{
result = device->CreatePixelShader(
g_PS_PassthroughRGBA2DMS, sizeof(g_PS_PassthroughRGBA2DMS), nullptr, &mPassThroughPS);
ShaderData pixelShaderData(g_PS_PassthroughRGBA2DMS);
err = mRenderer->allocateResource(pixelShaderData, &mPassThroughPS);
}
ASSERT(SUCCEEDED(result));
d3d11::SetDebugName(mPassThroughPS, "Swap chain pass through pixel shader");
ASSERT(!err.isError());
mPassThroughPS.setDebugName("Swap chain pass through pixel shader");
// Use the default rasterizer state but without culling
D3D11_RASTERIZER_DESC rasterizerDesc;
......@@ -786,8 +785,8 @@ EGLint SwapChain11::copyOffscreenToBackbuffer(EGLint x, EGLint y, EGLint width,
// Apply shaders
deviceContext->IASetInputLayout(mPassThroughIL.get());
deviceContext->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP);
deviceContext->VSSetShader(mPassThroughVS, nullptr, 0);
deviceContext->PSSetShader(mPassThroughPS, nullptr, 0);
deviceContext->VSSetShader(mPassThroughVS.get(), nullptr, 0);
deviceContext->PSSetShader(mPassThroughPS.get(), nullptr, 0);
deviceContext->GSSetShader(nullptr, nullptr, 0);
auto stateManager = mRenderer->getStateManager();
......
src/libANGLE/renderer/d3d/d3d11/SwapChain11.h
......@@ -101,8 +101,8 @@ class SwapChain11 final : public SwapChainD3D
d3d11::Buffer mQuadVB;
d3d11::SamplerState mPassThroughSampler;
d3d11::InputLayout mPassThroughIL;
ID3D11VertexShader *mPassThroughVS;
ID3D11PixelShader *mPassThroughPS;
d3d11::VertexShader mPassThroughVS;
d3d11::PixelShader mPassThroughPS;
d3d11::RasterizerState mPassThroughRS;
SurfaceRenderTarget11 mColorRenderTarget;
......
src/libANGLE/renderer/d3d/d3d11/renderer11_utils.h
......@@ -184,86 +184,12 @@ inline bool isDeviceLostError(HRESULT errorCode)
}
}
inline ID3D11VertexShader *CompileVS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
{
ID3D11VertexShader *vs = nullptr;
HRESULT result = device->CreateVertexShader(byteCode, N, nullptr, &vs);
ASSERT(SUCCEEDED(result));
if (SUCCEEDED(result))
{
SetDebugName(vs, name);
return vs;
}
return nullptr;
}
template <unsigned int N>
ID3D11VertexShader *CompileVS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
{
return CompileVS(device, byteCode, N, name);
}
inline ID3D11GeometryShader *CompileGS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
{
ID3D11GeometryShader *gs = nullptr;
HRESULT result = device->CreateGeometryShader(byteCode, N, nullptr, &gs);
ASSERT(SUCCEEDED(result));
if (SUCCEEDED(result))
{
SetDebugName(gs, name);
return gs;
}
return nullptr;
}
template <unsigned int N>
ID3D11GeometryShader *CompileGS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
{
return CompileGS(device, byteCode, N, name);
}
inline ID3D11PixelShader *CompilePS(ID3D11Device *device, const BYTE *byteCode, size_t N, const char *name)
{
ID3D11PixelShader *ps = nullptr;
HRESULT result = device->CreatePixelShader(byteCode, N, nullptr, &ps);
ASSERT(SUCCEEDED(result));
if (SUCCEEDED(result))
{
SetDebugName(ps, name);
return ps;
}
return nullptr;
}
template <unsigned int N>
ID3D11PixelShader *CompilePS(ID3D11Device *device, const BYTE (&byteCode)[N], const char *name)
{
return CompilePS(device, byteCode, N, name);
}
template <typename ResourceType>
class LazyResource : angle::NonCopyable
{
public:
LazyResource() : mResource(nullptr), mAssociatedDevice(nullptr) {}
virtual ~LazyResource() { release(); }
virtual ResourceType *resolve(ID3D11Device *device) = 0;
void release() { SafeRelease(mResource); }
protected:
void checkAssociatedDevice(ID3D11Device *device);
ResourceType *mResource;
ID3D11Device *mAssociatedDevice;
};
template <ResourceType ResourceT>
class LazyResource2 : angle::NonCopyable
class LazyResource : angle::NonCopyable
{
public:
constexpr LazyResource2() : mResource() {}
virtual ~LazyResource2() {}
constexpr LazyResource() : mResource() {}
virtual ~LazyResource() {}
virtual gl::Error resolve(Renderer11 *renderer) = 0;
void reset() { mResource.reset(); }
......@@ -290,69 +216,27 @@ class LazyResource2 : angle::NonCopyable
Resource11<GetD3D11Type<ResourceT>> mResource;
};
template <typename ResourceType>
void LazyResource<ResourceType>::checkAssociatedDevice(ID3D11Device *device)
{
ASSERT(mAssociatedDevice == nullptr || device == mAssociatedDevice);
mAssociatedDevice = device;
}
template <typename D3D11ShaderType>
class LazyShader final : public LazyResource<D3D11ShaderType>
class LazyShader final : public LazyResource<GetResourceTypeFromD3D11<D3D11ShaderType>()>
{
public:
// All parameters must be constexpr. Not supported in VS2013.
LazyShader(const BYTE *byteCode,
size_t byteCodeSize,
const char *name)
: mByteCode(byteCode),
mByteCodeSize(byteCodeSize),
mName(name)
constexpr LazyShader(const BYTE *byteCode, size_t byteCodeSize, const char *name)
: mByteCode(byteCode, byteCodeSize), mName(name)
{
}
D3D11ShaderType *resolve(ID3D11Device *device) override;
gl::Error resolve(Renderer11 *renderer) override
{
return this->resolveImpl(renderer, mByteCode, nullptr, mName);
}
private:
const BYTE *mByteCode;
size_t mByteCodeSize;
ShaderData mByteCode;
const char *mName;
};
template <>
inline ID3D11VertexShader *LazyShader<ID3D11VertexShader>::resolve(ID3D11Device *device)
{
checkAssociatedDevice(device);
if (mResource == nullptr)
{
mResource = CompileVS(device, mByteCode, mByteCodeSize, mName);
}
return mResource;
}
template <>
inline ID3D11GeometryShader *LazyShader<ID3D11GeometryShader>::resolve(ID3D11Device *device)
{
checkAssociatedDevice(device);
if (mResource == nullptr)
{
mResource = CompileGS(device, mByteCode, mByteCodeSize, mName);
}
return mResource;
}
template <>
inline ID3D11PixelShader *LazyShader<ID3D11PixelShader>::resolve(ID3D11Device *device)
{
checkAssociatedDevice(device);
if (mResource == nullptr)
{
mResource = CompilePS(device, mByteCode, mByteCodeSize, mName);
}
return mResource;
}
class LazyInputLayout final : public LazyResource2<ResourceType::InputLayout>
class LazyInputLayout final : public LazyResource<ResourceType::InputLayout>
{
public:
constexpr LazyInputLayout(const D3D11_INPUT_ELEMENT_DESC *inputDesc,
......@@ -374,7 +258,7 @@ class LazyInputLayout final : public LazyResource2<ResourceType::InputLayout>
const char *mDebugName;
};
class LazyBlendState final : public LazyResource2<ResourceType::BlendState>
class LazyBlendState final : public LazyResource<ResourceType::BlendState>
{
public:
LazyBlendState(const D3D11_BLEND_DESC &desc, const char *debugName);
......
src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp
......@@ -2697,7 +2697,7 @@ gl::Error Renderer9::createRenderTargetCopy(RenderTargetD3D *source, RenderTarge
return gl::NoError();
}
gl::Error Renderer9::loadExecutable(const void *function,
gl::Error Renderer9::loadExecutable(const uint8_t *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &streamOutVaryings,
......@@ -2817,8 +2817,9 @@ gl::Error Renderer9::compileToExecutable(gl::InfoLog &infoLog,
return gl::NoError();
}
error = loadExecutable(binary->GetBufferPointer(), binary->GetBufferSize(), type,
streamOutVaryings, separatedOutputBuffers, outExectuable);
error = loadExecutable(reinterpret_cast<const uint8_t *>(binary->GetBufferPointer()),
binary->GetBufferSize(), type, streamOutVaryings, separatedOutputBuffers,
outExectuable);
SafeRelease(binary);
if (error.isError())
......
src/libANGLE/renderer/d3d/d3d9/Renderer9.h
......@@ -244,7 +244,7 @@ class Renderer9 : public RendererD3D
gl::Error createRenderTargetCopy(RenderTargetD3D *source, RenderTargetD3D **outRT) override;
// Shader operations
gl::Error loadExecutable(const void *function,
gl::Error loadExecutable(const uint8_t *function,
size_t length,
ShaderType type,
const std::vector<D3DVarying> &streamOutVaryings,
......
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