Skip to content

A
angle
Commit 95892416 by daniel@transgaming.com
Options

Store ShaderExecutables on the ProgramBinary instead of d3d9 shaders

Trac #22155 Signed-off-by: Geoff Lang Signed-off-by: Nicolas Capens Also hooks up binary loading to the loadExecutable function. The other notable change is that getVertex/Pixel shader no longer add reference counts to the returned objects. git-svn-id: https://angleproject.googlecode.com/svn/branches/dx11proto@1505 736b8ea6-26fd-11df-bfd4-992fa37f6226
parent 5531890f
Showing with 40 additions and 56 deletions
src/libGLESv2/ProgramBinary.cpp
...@@ -96,15 +96,8 @@ ProgramBinary::ProgramBinary(rx::Renderer *renderer) : RefCountObject(0), mSeria ...@@ -96,15 +96,8 @@ ProgramBinary::ProgramBinary(rx::Renderer *renderer) : RefCountObject(0), mSeria
ProgramBinary::~ProgramBinary() ProgramBinary::~ProgramBinary()
{ {
if (mPixelExecutable) delete mPixelExecutable;
{ delete mVertexExecutable;
mPixelExecutable->Release();
}
if (mVertexExecutable)
{
mVertexExecutable->Release();
}
while (!mUniforms.empty()) while (!mUniforms.empty())
{ {
...@@ -123,12 +116,12 @@ unsigned int ProgramBinary::issueSerial() ...@@ -123,12 +116,12 @@ unsigned int ProgramBinary::issueSerial()
return mCurrentSerial++; return mCurrentSerial++;
} }
IDirect3DPixelShader9 *ProgramBinary::getPixelShader() rx::ShaderExecutable *ProgramBinary::getPixelExecutable()
{ {
return mPixelExecutable; return mPixelExecutable;
} }
IDirect3DVertexShader9 *ProgramBinary::getVertexShader() rx::ShaderExecutable *ProgramBinary::getVertexExecutable()
{ {
return mVertexExecutable; return mVertexExecutable;
} }
...@@ -1650,21 +1643,26 @@ bool ProgramBinary::load(InfoLog &infoLog, const void *binary, GLsizei length) ...@@ -1650,21 +1643,26 @@ bool ProgramBinary::load(InfoLog &infoLog, const void *binary, GLsizei length)
const char *vertexShaderFunction = ptr; const char *vertexShaderFunction = ptr;
ptr += vertexShaderSize; ptr += vertexShaderSize;
mPixelExecutable = mRenderer->createPixelShader(reinterpret_cast<const DWORD*>(pixelShaderFunction), pixelShaderSize); rx::ShaderExecutable *executable;
if (!mPixelExecutable) executable = mRenderer->loadExecutable(reinterpret_cast<const DWORD*>(pixelShaderFunction),
pixelShaderSize, GL_FRAGMENT_SHADER, NULL);
if (!executable)
{ {
infoLog.append("Could not create pixel shader."); infoLog.append("Could not create pixel shader.");
return false; return false;
} }
mPixelExecutable = rx::ShaderExecutable9::makeShaderExecutable9(executable);
mVertexExecutable = mRenderer->createVertexShader(reinterpret_cast<const DWORD*>(vertexShaderFunction), vertexShaderSize); executable = mRenderer->loadExecutable(reinterpret_cast<const DWORD*>(vertexShaderFunction),
if (!mVertexExecutable) vertexShaderSize, GL_VERTEX_SHADER, NULL);
if (!executable)
{ {
infoLog.append("Could not create vertex shader."); infoLog.append("Could not create vertex shader.");
mPixelExecutable->Release(); delete mPixelExecutable;
mPixelExecutable = NULL; mPixelExecutable = NULL;
return false; return false;
} }
mVertexExecutable = rx::ShaderExecutable9::makeShaderExecutable9(executable);
return true; return true;
} }
...@@ -1734,12 +1732,12 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length) ...@@ -1734,12 +1732,12 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length)
stream.write(mDxPointsOrLinesLocation); stream.write(mDxPointsOrLinesLocation);
UINT pixelShaderSize; UINT pixelShaderSize;
HRESULT result = mPixelExecutable->GetFunction(NULL, &pixelShaderSize); HRESULT result = mPixelExecutable->getPixelShader()->GetFunction(NULL, &pixelShaderSize);
ASSERT(SUCCEEDED(result)); ASSERT(SUCCEEDED(result));
stream.write(pixelShaderSize); stream.write(pixelShaderSize);
UINT vertexShaderSize; UINT vertexShaderSize;
result = mVertexExecutable->GetFunction(NULL, &vertexShaderSize); result = mVertexExecutable->getVertexShader()->GetFunction(NULL, &vertexShaderSize);
ASSERT(SUCCEEDED(result)); ASSERT(SUCCEEDED(result));
stream.write(vertexShaderSize); stream.write(vertexShaderSize);
...@@ -1769,11 +1767,11 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length) ...@@ -1769,11 +1767,11 @@ bool ProgramBinary::save(void* binary, GLsizei bufSize, GLsizei *length)
memcpy(ptr, &identifier, sizeof(GUID)); memcpy(ptr, &identifier, sizeof(GUID));
ptr += sizeof(GUID); ptr += sizeof(GUID);
result = mPixelExecutable->GetFunction(ptr, &pixelShaderSize); result = mPixelExecutable->getPixelShader()->GetFunction(ptr, &pixelShaderSize);
ASSERT(SUCCEEDED(result)); ASSERT(SUCCEEDED(result));
ptr += pixelShaderSize; ptr += pixelShaderSize;
result = mVertexExecutable->GetFunction(ptr, &vertexShaderSize); result = mVertexExecutable->getVertexShader()->GetFunction(ptr, &vertexShaderSize);
ASSERT(SUCCEEDED(result)); ASSERT(SUCCEEDED(result));
ptr += vertexShaderSize; ptr += vertexShaderSize;
...@@ -1829,27 +1827,21 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin ...@@ -1829,27 +1827,21 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
if (vertexExecutable && pixelExecutable) if (vertexExecutable && pixelExecutable)
{ {
rx::ShaderExecutable9 *vshader9 = rx::ShaderExecutable9::makeShaderExecutable9(vertexExecutable); mVertexExecutable = rx::ShaderExecutable9::makeShaderExecutable9(vertexExecutable);
rx::ShaderExecutable9 *pshader9 = rx::ShaderExecutable9::makeShaderExecutable9(pixelExecutable); mPixelExecutable = rx::ShaderExecutable9::makeShaderExecutable9(pixelExecutable);
mVertexExecutable = vshader9->getVertexShader();
mPixelExecutable = pshader9->getPixelShader();
if (!mPixelExecutable || !mVertexExecutable)
{
if (mVertexExecutable) mVertexExecutable->Release();
mVertexExecutable = NULL;
if (mPixelExecutable) mPixelExecutable->Release();
mPixelExecutable = NULL;
infoLog.append("Failed to create D3D shaders.");
success = false;
}
constantTableVS = vshader9->getConstantTable(); constantTableVS = mVertexExecutable->getConstantTable();
constantTablePS = pshader9->getConstantTable(); constantTablePS = mPixelExecutable->getConstantTable();
} }
else else
{ {
infoLog.append("Failed to create D3D shaders.");
success = false; success = false;
delete vertexExecutable;
vertexExecutable = NULL;
delete pixelExecutable;
pixelExecutable = NULL;
} }
if (!linkAttributes(infoLog, attributeBindings, fragmentShader, vertexShader)) if (!linkAttributes(infoLog, attributeBindings, fragmentShader, vertexShader))
...@@ -1864,8 +1856,6 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin ...@@ -1864,8 +1856,6 @@ bool ProgramBinary::link(InfoLog &infoLog, const AttributeBindings &attributeBin
success = false; success = false;
} }
} }
delete vertexExecutable;
delete pixelExecutable;
// these uniforms are searched as already-decorated because gl_ and dx_ // these uniforms are searched as already-decorated because gl_ and dx_
// are reserved prefixes, and do not receive additional decoration // are reserved prefixes, and do not receive additional decoration
......
src/libGLESv2/ProgramBinary.h
...@@ -104,8 +104,8 @@ class ProgramBinary : public RefCountObject ...@@ -104,8 +104,8 @@ class ProgramBinary : public RefCountObject
explicit ProgramBinary(rx::Renderer *renderer); explicit ProgramBinary(rx::Renderer *renderer);
~ProgramBinary(); ~ProgramBinary();
IDirect3DPixelShader9 *getPixelShader(); rx::ShaderExecutable *getPixelExecutable();
IDirect3DVertexShader9 *getVertexShader(); rx::ShaderExecutable *getVertexExecutable();
GLuint getAttributeLocation(const char *name); GLuint getAttributeLocation(const char *name);
int getSemanticIndex(int attributeIndex); int getSemanticIndex(int attributeIndex);
...@@ -189,8 +189,8 @@ class ProgramBinary : public RefCountObject ...@@ -189,8 +189,8 @@ class ProgramBinary : public RefCountObject
rx::Renderer9 *mRenderer; // D3D9_REPLACE rx::Renderer9 *mRenderer; // D3D9_REPLACE
IDirect3DDevice9 *mDevice; // D3D9_REPLACE IDirect3DDevice9 *mDevice; // D3D9_REPLACE
IDirect3DPixelShader9 *mPixelExecutable; // D3D9_REPLACE rx::ShaderExecutable9 *mPixelExecutable; // D3D9_REPLACE
IDirect3DVertexShader9 *mVertexExecutable; // D3D9_REPLACE rx::ShaderExecutable9 *mVertexExecutable; // D3D9_REPLACE
Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS]; Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
int mSemanticIndex[MAX_VERTEX_ATTRIBS]; int mSemanticIndex[MAX_VERTEX_ATTRIBS];
......
src/libGLESv2/renderer/Renderer9.cpp
...@@ -1377,8 +1377,14 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices, ...@@ -1377,8 +1377,14 @@ void Renderer9::drawLineLoop(GLsizei count, GLenum type, const GLvoid *indices,
void Renderer9::applyShaders(gl::ProgramBinary *programBinary) void Renderer9::applyShaders(gl::ProgramBinary *programBinary)
{ {
IDirect3DVertexShader9 *vertexShader = programBinary->getVertexShader(); ShaderExecutable *vertexExe = programBinary->getVertexExecutable();
IDirect3DPixelShader9 *pixelShader = programBinary->getPixelShader(); ShaderExecutable *pixelExe = programBinary->getPixelExecutable();
IDirect3DVertexShader9 *vertexShader = NULL;
if (vertexExe) vertexShader = ShaderExecutable9::makeShaderExecutable9(vertexExe)->getVertexShader();
IDirect3DPixelShader9 *pixelShader = NULL;
if (pixelExe) pixelShader = ShaderExecutable9::makeShaderExecutable9(pixelExe)->getPixelShader();
mDevice->SetPixelShader(pixelShader); mDevice->SetPixelShader(pixelShader);
mDevice->SetVertexShader(vertexShader); mDevice->SetVertexShader(vertexShader);
......
src/libGLESv2/renderer/ShaderExecutable9.cpp
...@@ -50,23 +50,11 @@ ShaderExecutable9 *ShaderExecutable9::makeShaderExecutable9(ShaderExecutable *ex ...@@ -50,23 +50,11 @@ ShaderExecutable9 *ShaderExecutable9::makeShaderExecutable9(ShaderExecutable *ex
IDirect3DVertexShader9 *ShaderExecutable9::getVertexShader() IDirect3DVertexShader9 *ShaderExecutable9::getVertexShader()
{ {
// Caller is responsible for releasing the returned shader reference.
if (mVertexExecutable)
{
mVertexExecutable->AddRef();
}
return mVertexExecutable; return mVertexExecutable;
} }
IDirect3DPixelShader9 *ShaderExecutable9::getPixelShader() IDirect3DPixelShader9 *ShaderExecutable9::getPixelShader()
{ {
// Caller is responsible for releasing the returned shader reference.
if (mPixelExecutable)
{
mPixelExecutable->AddRef();
}
return mPixelExecutable; return mPixelExecutable;
} }
......
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