diff options
author | Brandon Jones <bajones@chromium.org> | 2014-08-29 16:58:36 -0700 |
---|---|---|
committer | Brandon Jones <bajones@chromium.org> | 2014-09-12 21:15:42 +0000 |
commit | 22502d52956364879e2bd2feb8516a983714eb45 (patch) | |
tree | 521a84949332eb30952cfb6ea985780b2e07586f /src/libGLESv2/renderer | |
parent | e1f0d00c753ecdd6f0ac397fd944bf1fd7fee3dd (diff) | |
download | angle-22502d52956364879e2bd2feb8516a983714eb45.tar.gz |
Moving more D3D-only logic into ProgramBinaryD3D
BUG=angle:731
Change-Id: Ia62ec9a912c8bd63fcee51ca206d52688dd999da
Reviewed-on: https://chromium-review.googlesource.com/217495
Reviewed-by: Shannon Woods <shannonwoods@chromium.org>
Tested-by: Brandon Jones <bajones@chromium.org>
Diffstat (limited to 'src/libGLESv2/renderer')
-rw-r--r-- | src/libGLESv2/renderer/ProgramImpl.h | 21 | ||||
-rw-r--r-- | src/libGLESv2/renderer/d3d/ProgramD3D.cpp | 124 | ||||
-rw-r--r-- | src/libGLESv2/renderer/d3d/ProgramD3D.h | 30 |
3 files changed, 175 insertions, 0 deletions
diff --git a/src/libGLESv2/renderer/ProgramImpl.h b/src/libGLESv2/renderer/ProgramImpl.h index 28c026a2..ba0955fd 100644 --- a/src/libGLESv2/renderer/ProgramImpl.h +++ b/src/libGLESv2/renderer/ProgramImpl.h @@ -10,6 +10,7 @@ #define LIBGLESV2_RENDERER_PROGRAMIMPL_H_ #include "common/angleutils.h" +#include "libGLESv2/BinaryStream.h" #include "libGLESv2/Constants.h" #include "libGLESv2/ProgramBinary.h" @@ -27,6 +28,26 @@ public: // TODO: Temporary interfaces to ease migration. Remove soon! virtual Renderer *getRenderer() = 0; virtual DynamicHLSL *getDynamicHLSL() = 0; + virtual const std::vector<rx::PixelShaderOutputVariable> &getPixelShaderKey() = 0; + + virtual GLenum getBinaryFormat() = 0; + virtual bool load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) = 0; + virtual bool save(gl::BinaryOutputStream *stream) = 0; + + virtual rx::ShaderExecutable *getPixelExecutableForOutputLayout(gl::InfoLog &infoLog, const std::vector<GLenum> &outputSignature, + const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings, + bool separatedOutputBuffers) = 0; + virtual rx::ShaderExecutable *getVertexExecutableForInputLayout(gl::InfoLog &infoLog, + const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS], + const sh::Attribute shaderAttributes[], + const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings, + bool separatedOutputBuffers) = 0; + + virtual bool link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader, + const std::vector<std::string> &transformFeedbackVaryings, int *registers, + std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, + gl::VariableLocation> *outputVariables) = 0; + virtual void initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms) = 0; virtual void reset() = 0; diff --git a/src/libGLESv2/renderer/d3d/ProgramD3D.cpp b/src/libGLESv2/renderer/d3d/ProgramD3D.cpp index 87e01323..f74196c3 100644 --- a/src/libGLESv2/renderer/d3d/ProgramD3D.cpp +++ b/src/libGLESv2/renderer/d3d/ProgramD3D.cpp @@ -13,6 +13,7 @@ #include "libGLESv2/renderer/Renderer.h" #include "libGLESv2/renderer/ShaderExecutable.h" #include "libGLESv2/renderer/d3d/DynamicHLSL.h" +#include "libGLESv2/renderer/d3d/ShaderD3D.h" #include "libGLESv2/main.h" namespace rx @@ -22,6 +23,8 @@ ProgramD3D::ProgramD3D(rx::Renderer *renderer) : ProgramImpl(), mRenderer(renderer), mDynamicHLSL(NULL), + mVertexWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE), + mPixelWorkarounds(rx::ANGLE_D3D_WORKAROUND_NONE), mVertexUniformStorage(NULL), mFragmentUniformStorage(NULL) { @@ -46,6 +49,119 @@ const ProgramD3D *ProgramD3D::makeProgramD3D(const ProgramImpl *impl) return static_cast<const ProgramD3D*>(impl); } +bool ProgramD3D::load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream) +{ + stream->readString(&mVertexHLSL); + stream->readInt(&mVertexWorkarounds); + stream->readString(&mPixelHLSL); + stream->readInt(&mPixelWorkarounds); + stream->readBool(&mUsesFragDepth); + + const size_t pixelShaderKeySize = stream->readInt<unsigned int>(); + mPixelShaderKey.resize(pixelShaderKeySize); + for (size_t pixelShaderKeyIndex = 0; pixelShaderKeyIndex < pixelShaderKeySize; pixelShaderKeyIndex++) + { + stream->readInt(&mPixelShaderKey[pixelShaderKeyIndex].type); + stream->readString(&mPixelShaderKey[pixelShaderKeyIndex].name); + stream->readString(&mPixelShaderKey[pixelShaderKeyIndex].source); + stream->readInt(&mPixelShaderKey[pixelShaderKeyIndex].outputIndex); + } + + return true; +} + +bool ProgramD3D::save(gl::BinaryOutputStream *stream) +{ + stream->writeString(mVertexHLSL); + stream->writeInt(mVertexWorkarounds); + stream->writeString(mPixelHLSL); + stream->writeInt(mPixelWorkarounds); + stream->writeInt(mUsesFragDepth); + + const std::vector<rx::PixelShaderOutputVariable> &pixelShaderKey = mPixelShaderKey; + stream->writeInt(pixelShaderKey.size()); + for (size_t pixelShaderKeyIndex = 0; pixelShaderKeyIndex < pixelShaderKey.size(); pixelShaderKeyIndex++) + { + const rx::PixelShaderOutputVariable &variable = pixelShaderKey[pixelShaderKeyIndex]; + stream->writeInt(variable.type); + stream->writeString(variable.name); + stream->writeString(variable.source); + stream->writeInt(variable.outputIndex); + } + + return true; +} + +rx::ShaderExecutable *ProgramD3D::getPixelExecutableForOutputLayout(gl::InfoLog &infoLog, const std::vector<GLenum> &outputSignature, + const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings, + bool separatedOutputBuffers) +{ + std::string finalPixelHLSL = mDynamicHLSL->generatePixelShaderForOutputSignature(mPixelHLSL, mPixelShaderKey, mUsesFragDepth, + outputSignature); + + // Generate new pixel executable + rx::ShaderExecutable *pixelExecutable = mRenderer->compileToExecutable(infoLog, finalPixelHLSL.c_str(), rx::SHADER_PIXEL, + transformFeedbackLinkedVaryings, separatedOutputBuffers, + mPixelWorkarounds); + + return pixelExecutable; +} + +rx::ShaderExecutable *ProgramD3D::getVertexExecutableForInputLayout(gl::InfoLog &infoLog, + const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS], + const sh::Attribute shaderAttributes[], + const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings, + bool separatedOutputBuffers) +{ + // Generate new dynamic layout with attribute conversions + std::string finalVertexHLSL = mDynamicHLSL->generateVertexShaderForInputLayout(mVertexHLSL, inputLayout, shaderAttributes); + + // Generate new vertex executable + rx::ShaderExecutable *vertexExecutable = mRenderer->compileToExecutable(infoLog, finalVertexHLSL.c_str(), + rx::SHADER_VERTEX, + transformFeedbackLinkedVaryings, separatedOutputBuffers, + mVertexWorkarounds); + + return vertexExecutable; +} + +bool ProgramD3D::link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader, + const std::vector<std::string> &transformFeedbackVaryings, int *registers, + std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, gl::VariableLocation> *outputVariables) +{ + rx::ShaderD3D *vertexShaderD3D = rx::ShaderD3D::makeShaderD3D(vertexShader->getImplementation()); + rx::ShaderD3D *fragmentShaderD3D = rx::ShaderD3D::makeShaderD3D(fragmentShader->getImplementation()); + + mPixelHLSL = fragmentShaderD3D->getTranslatedSource(); + mPixelWorkarounds = fragmentShaderD3D->getD3DWorkarounds(); + + mVertexHLSL = vertexShaderD3D->getTranslatedSource(); + mVertexWorkarounds = vertexShaderD3D->getD3DWorkarounds(); + + // Map the varyings to the register file + rx::VaryingPacking packing = { NULL }; + *registers = mDynamicHLSL->packVaryings(infoLog, packing, fragmentShaderD3D, vertexShaderD3D, transformFeedbackVaryings); + + if (registers < 0) + { + return false; + } + + if (!gl::ProgramBinary::linkVaryings(infoLog, fragmentShader, vertexShader)) + { + return false; + } + + if (!mDynamicHLSL->generateShaderLinkHLSL(infoLog, *registers, packing, mPixelHLSL, mVertexHLSL, + fragmentShaderD3D, vertexShaderD3D, transformFeedbackVaryings, + linkedVaryings, outputVariables, &mPixelShaderKey, &mUsesFragDepth)) + { + return false; + } + + return true; +} + void ProgramD3D::initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms) { // Compute total default block size @@ -74,6 +190,14 @@ void ProgramD3D::initializeUniformStorage(const std::vector<gl::LinkedUniform*> void ProgramD3D::reset() { + mVertexHLSL.clear(); + mVertexWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE; + + mPixelHLSL.clear(); + mPixelWorkarounds = rx::ANGLE_D3D_WORKAROUND_NONE; + mUsesFragDepth = false; + mPixelShaderKey.clear(); + SafeDelete(mVertexUniformStorage); SafeDelete(mFragmentUniformStorage); } diff --git a/src/libGLESv2/renderer/d3d/ProgramD3D.h b/src/libGLESv2/renderer/d3d/ProgramD3D.h index 3dd3b1f4..d645c57d 100644 --- a/src/libGLESv2/renderer/d3d/ProgramD3D.h +++ b/src/libGLESv2/renderer/d3d/ProgramD3D.h @@ -11,9 +11,13 @@ #include "libGLESv2/renderer/ProgramImpl.h" +#include <string> +#include <vector> + namespace gl { struct LinkedUniform; +struct VariableLocation; struct VertexFormat; } @@ -33,6 +37,24 @@ class ProgramD3D : public ProgramImpl Renderer *getRenderer() { return mRenderer; } DynamicHLSL *getDynamicHLSL() { return mDynamicHLSL; } + const std::vector<rx::PixelShaderOutputVariable> &getPixelShaderKey() { return mPixelShaderKey; } + + GLenum getBinaryFormat() { return GL_PROGRAM_BINARY_ANGLE; } + bool load(gl::InfoLog &infoLog, gl::BinaryInputStream *stream); + bool save(gl::BinaryOutputStream *stream); + + ShaderExecutable *getPixelExecutableForOutputLayout(gl::InfoLog &infoLog, const std::vector<GLenum> &outputSignature, + const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings, + bool separatedOutputBuffers); + ShaderExecutable *getVertexExecutableForInputLayout(gl::InfoLog &infoLog, + const gl::VertexFormat inputLayout[gl::MAX_VERTEX_ATTRIBS], + const sh::Attribute shaderAttributes[], + const std::vector<gl::LinkedVarying> &transformFeedbackLinkedVaryings, + bool separatedOutputBuffers); + + bool link(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader, + const std::vector<std::string> &transformFeedbackVaryings, int *registers, + std::vector<gl::LinkedVarying> *linkedVaryings, std::map<int, gl::VariableLocation> *outputVariables); // D3D only void initializeUniformStorage(const std::vector<gl::LinkedUniform*> &uniforms); @@ -48,6 +70,14 @@ class ProgramD3D : public ProgramImpl Renderer *mRenderer; DynamicHLSL *mDynamicHLSL; + std::string mVertexHLSL; + rx::D3DWorkaroundType mVertexWorkarounds; + + std::string mPixelHLSL; + rx::D3DWorkaroundType mPixelWorkarounds; + bool mUsesFragDepth; + std::vector<rx::PixelShaderOutputVariable> mPixelShaderKey; + UniformStorage *mVertexUniformStorage; UniformStorage *mFragmentUniformStorage; }; |