Add a Program::Data shared state structure.

src/libANGLE/Program.h

@@ -27,10 +27,9 @@
 
 namespace rx
 {
-class Renderer;
-class Renderer;
-struct TranslatedAttribute;
+class ImplFactory;
 class ProgramImpl;
+struct TranslatedAttribute;
 }
 
 namespace gl
@@ -163,7 +162,28 @@ struct LinkedVarying
 class Program : angle::NonCopyable
 {
   public:
-    Program(rx::ProgramImpl *impl, ResourceManager *manager, GLuint handle);
+    class Data final : angle::NonCopyable
+    {
+      public:
+        Data();
+        ~Data();
+
+        const Shader *getAttachedVertexShader() const { return mAttachedVertexShader; }
+        const Shader *getAttachedFragmentShader() const { return mAttachedFragmentShader; }
+
+      private:
+        friend class Program;
+
+        Shader *mAttachedFragmentShader;
+        Shader *mAttachedVertexShader;
+
+        std::vector<std::string> mTransformFeedbackVaryings;
+        GLenum mTransformFeedbackBufferMode;
+
+        // TODO(jmadill): move more state into Data.
+    };
+
+    Program(rx::ImplFactory *factory, ResourceManager *manager, GLuint handle);
     ~Program();
 
     GLuint id() const { return mHandle; }
@@ -177,7 +197,7 @@ class Program : angle::NonCopyable
 
     void bindAttributeLocation(GLuint index, const char *name);
 
-    Error link(const Data &data);
+    Error link(const gl::Data &data);
     bool isLinked();
 
     Error loadBinary(GLenum binaryFormat, const void *binary, GLsizei length);
@@ -195,7 +215,7 @@ class Program : angle::NonCopyable
     void getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
     GLint getActiveAttributeCount();
     GLint getActiveAttributeMaxLength();
-    const sh::Attribute *getLinkedAttributes() const { return mLinkedAttribute; }
+    const std::vector<sh::Attribute> &getLinkedAttributes() const { return mLinkedAttributes; }
 
     GLint getSamplerMapping(SamplerType type, unsigned int samplerIndex, const Caps &caps);
     GLenum getSamplerTextureType(SamplerType type, unsigned int samplerIndex);
@@ -280,7 +300,7 @@ class Program : angle::NonCopyable
     void unlink(bool destroy = false);
     void resetUniformBlockBindings();
 
-    bool linkAttributes(const Data &data,
+    bool linkAttributes(const gl::Data &data,
                         InfoLog &infoLog,
                         const AttributeBindings &attributeBindings,
                         const Shader *vertexShader);
@@ -303,24 +323,19 @@ class Program : angle::NonCopyable
     bool assignUniformBlockRegister(InfoLog &infoLog, UniformBlock *uniformBlock, GLenum shader, unsigned int registerIndex, const Caps &caps);
     void defineOutputVariables(Shader *fragmentShader);
 
+    Data mData;
     rx::ProgramImpl *mProgram;
 
-    sh::Attribute mLinkedAttribute[MAX_VERTEX_ATTRIBS];
+    std::vector<sh::Attribute> mLinkedAttributes;
 
     std::map<int, VariableLocation> mOutputVariables;
 
     bool mValidated;
 
-    Shader *mFragmentShader;
-    Shader *mVertexShader;
-
     AttributeBindings mAttributeBindings;
 
     GLuint mUniformBlockBindings[IMPLEMENTATION_MAX_COMBINED_SHADER_UNIFORM_BUFFERS];
 
-    std::vector<std::string> mTransformFeedbackVaryings;
-    GLenum mTransformFeedbackBufferMode;
-
     bool mLinked;
     bool mDeleteStatus;   // Flag to indicate that the program can be deleted when no longer in use
 

src/libANGLE/ResourceManager.cpp

@@ -106,7 +106,7 @@ GLuint ResourceManager::createProgram()
 {
     GLuint handle = mProgramShaderHandleAllocator.allocate();
 
-    mProgramMap[handle] = new Program(mFactory->createProgram(), this, handle);
+    mProgramMap[handle] = new Program(mFactory, this, handle);
 
     return handle;
 }

src/libANGLE/renderer/ImplFactory.h

@@ -11,6 +11,7 @@
 #define LIBANGLE_RENDERER_IMPLFACTORY_H_
 
 #include "libANGLE/Framebuffer.h"
+#include "libANGLE/Program.h"
 #include "libANGLE/VertexArray.h"
 
 namespace rx
@@ -37,7 +38,7 @@ class ImplFactory : angle::NonCopyable
     // Shader creation
     virtual CompilerImpl *createCompiler(const gl::Data &data) = 0;
     virtual ShaderImpl *createShader(GLenum type) = 0;
-    virtual ProgramImpl *createProgram() = 0;
+    virtual ProgramImpl *createProgram(const gl::Program::Data &data) = 0;
 
     // Framebuffer creation
     virtual FramebufferImpl *createDefaultFramebuffer(const gl::Framebuffer::Data &data) = 0;

src/libANGLE/renderer/ProgramImpl.cpp

@@ -19,6 +19,10 @@ LinkResult::LinkResult(bool linkSuccess, const gl::Error &error)
 {
 }
 
+ProgramImpl::ProgramImpl(const gl::Program::Data &data) : mData(data)
+{
+}
+
 ProgramImpl::~ProgramImpl()
 {
     // Ensure that reset was called by the inherited class during destruction

src/libANGLE/renderer/ProgramImpl.h

@@ -33,7 +33,7 @@ class ProgramImpl : angle::NonCopyable
   public:
     typedef int SemanticIndexArray[gl::MAX_VERTEX_ATTRIBS];
 
-    ProgramImpl() { }
+    ProgramImpl(const gl::Program::Data &data);
     virtual ~ProgramImpl();
 
     virtual bool usesPointSize() const = 0;
@@ -87,8 +87,7 @@ class ProgramImpl : angle::NonCopyable
     virtual void updateSamplerMapping() = 0;
     virtual bool validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps) = 0;
 
-    virtual LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                                 int registers) = 0;
+    virtual LinkResult compileProgramExecutables(gl::InfoLog &infoLog, int registers) = 0;
 
     virtual bool linkUniforms(gl::InfoLog &infoLog, const gl::Shader &vertexShader, const gl::Shader &fragmentShader,
                               const gl::Caps &caps) = 0;
@@ -127,6 +126,8 @@ class ProgramImpl : angle::NonCopyable
     virtual void reset();
 
   protected:
+    const gl::Program::Data &mData;
+
     std::vector<gl::LinkedUniform*> mUniforms;
 
     // TODO: use a hash map

src/libANGLE/renderer/d3d/DynamicHLSL.cpp

@@ -1114,14 +1114,18 @@ void DynamicHLSL::defineOutputVariables(ShaderD3D *fragmentShader, std::map<int,
     }
 }
 
-std::string DynamicHLSL::generateGeometryShaderHLSL(int registers, ShaderD3D *fragmentShader, ShaderD3D *vertexShader) const
+std::string DynamicHLSL::generateGeometryShaderHLSL(int registers,
+                                                    const ShaderD3D *fragmentShader,
+                                                    const ShaderD3D *vertexShader) const
 {
     // for now we only handle point sprite emulation
     ASSERT(vertexShader->mUsesPointSize && mRenderer->getMajorShaderModel() >= 4);
     return generatePointSpriteHLSL(registers, fragmentShader, vertexShader);
 }
 
-std::string DynamicHLSL::generatePointSpriteHLSL(int registers, ShaderD3D *fragmentShader, ShaderD3D *vertexShader) const
+std::string DynamicHLSL::generatePointSpriteHLSL(int registers,
+                                                 const ShaderD3D *fragmentShader,
+                                                 const ShaderD3D *vertexShader) const
 {
     ASSERT(registers >= 0);
     ASSERT(vertexShader->mUsesPointSize);

src/libANGLE/renderer/d3d/DynamicHLSL.h

@@ -70,7 +70,9 @@ class DynamicHLSL : angle::NonCopyable
                                 std::vector<PixelShaderOutputVariable> *outPixelShaderKey,
                                 bool *outUsesFragDepth) const;
 
-    std::string generateGeometryShaderHLSL(int registers, ShaderD3D *fragmentShader, ShaderD3D *vertexShader) const;
+    std::string generateGeometryShaderHLSL(int registers,
+                                           const ShaderD3D *fragmentShader,
+                                           const ShaderD3D *vertexShader) const;
 
   private:
     RendererD3D *const mRenderer;
@@ -85,7 +87,9 @@ class DynamicHLSL : angle::NonCopyable
     void storeUserLinkedVaryings(const ShaderD3D *vertexShader, std::vector<gl::LinkedVarying> *linkedVaryings) const;
     void storeBuiltinLinkedVaryings(const SemanticInfo &info, std::vector<gl::LinkedVarying> *linkedVaryings) const;
     void defineOutputVariables(ShaderD3D *fragmentShader, std::map<int, gl::VariableLocation> *programOutputVars) const;
-    std::string generatePointSpriteHLSL(int registers, ShaderD3D *fragmentShader, ShaderD3D *vertexShader) const;
+    std::string generatePointSpriteHLSL(int registers,
+                                        const ShaderD3D *fragmentShader,
+                                        const ShaderD3D *vertexShader) const;
 
     // Prepend an underscore
     static std::string decorateVariable(const std::string &name);

src/libANGLE/renderer/d3d/ProgramD3D.cpp

@@ -198,8 +198,8 @@ ProgramD3D::Sampler::Sampler() : active(false), logicalTextureUnit(0), textureTy
 
 unsigned int ProgramD3D::mCurrentSerial = 1;
 
-ProgramD3D::ProgramD3D(RendererD3D *renderer)
-    : ProgramImpl(),
+ProgramD3D::ProgramD3D(const gl::Program::Data &data, RendererD3D *renderer)
+    : ProgramImpl(data),
       mRenderer(renderer),
       mDynamicHLSL(NULL),
       mGeometryExecutable(NULL),
@@ -1005,13 +1005,13 @@ gl::Error ProgramD3D::getVertexExecutableForInputLayout(const gl::InputLayout &i
     return gl::Error(GL_NO_ERROR);
 }
 
-LinkResult ProgramD3D::compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                                 int registers)
+LinkResult ProgramD3D::compileProgramExecutables(gl::InfoLog &infoLog, int registers)
 {
-    ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(vertexShader);
-    ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(fragmentShader);
+    const ShaderD3D *vertexShaderD3D   = GetImplAs<ShaderD3D>(mData.getAttachedVertexShader());
+    const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(mData.getAttachedFragmentShader());
 
-    const gl::InputLayout &defaultInputLayout    = GetDefaultInputLayoutFromShader(vertexShader);
+    const gl::InputLayout &defaultInputLayout =
+        GetDefaultInputLayoutFromShader(mData.getAttachedVertexShader());
     ShaderExecutableD3D *defaultVertexExecutable = NULL;
     gl::Error error = getVertexExecutableForInputLayout(defaultInputLayout, &defaultVertexExecutable, &infoLog);
     if (error.isError())

src/libANGLE/renderer/d3d/ProgramD3D.h

@@ -42,7 +42,7 @@ class ShaderExecutableD3D;
 class ProgramD3D : public ProgramImpl
 {
   public:
-    ProgramD3D(RendererD3D *renderer);
+    ProgramD3D(const gl::Program::Data &data, RendererD3D *renderer);
     virtual ~ProgramD3D();
 
     const std::vector<PixelShaderOutputVariable> &getPixelShaderKey() { return mPixelShaderKey; }
@@ -69,8 +69,7 @@ class ProgramD3D : public ProgramImpl
     gl::Error getVertexExecutableForInputLayout(const gl::InputLayout &inputLayout, ShaderExecutableD3D **outExectuable, gl::InfoLog *infoLog);
     ShaderExecutableD3D *getGeometryExecutable() const { return mGeometryExecutable; }
 
-    LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                         int registers);
+    LinkResult compileProgramExecutables(gl::InfoLog &infoLog, int registers);
 
     LinkResult link(const gl::Data &data, gl::InfoLog &infoLog,
                     gl::Shader *fragmentShader, gl::Shader *vertexShader,

src/libANGLE/renderer/d3d/d3d11/InputLayoutCache.cpp

@@ -46,21 +46,19 @@ gl::InputLayout GetInputLayout(
     return inputLayout;
 }
 
-GLenum GetNextGLSLAttributeType(const sh::Attribute *linkedAttributes, int index)
+GLenum GetNextGLSLAttributeType(const std::vector<sh::Attribute> &linkedAttributes, int index)
 {
     // Count matrices differently
     int subIndex = 0;
-    for (int attribIndex = 0; attribIndex < gl::MAX_VERTEX_ATTRIBS; ++attribIndex)
+    for (const sh::Attribute &attrib : linkedAttributes)
     {
-        GLenum attribType = linkedAttributes[attribIndex].type;
-
-        if (attribType == GL_NONE)
+        if (attrib.type == GL_NONE)
         {
             continue;
         }
 
-        GLenum transposedType = gl::TransposeMatrixType(attribType);
-        subIndex += gl::VariableRowCount(transposedType);
+        GLenum transposedType = gl::TransposeMatrixType(attrib.type);
+        subIndex += gl::VariableRowCount(attrib.type);
         if (subIndex > index)
         {
             return transposedType;
@@ -202,7 +200,7 @@ gl::Error InputLayoutCache::applyVertexBuffers(const std::vector<TranslatedAttri
     unsigned int firstInstancedElement = gl::MAX_VERTEX_ATTRIBS;
     unsigned int nextAvailableInputSlot = 0;
 
-    const sh::Attribute *linkedAttributes = program->getLinkedAttributes();
+    const std::vector<sh::Attribute> &linkedAttributes = program->getLinkedAttributes();
 
     for (unsigned int i = 0; i < unsortedAttributes.size(); i++)
     {

src/libANGLE/renderer/d3d/d3d11/Renderer11.cpp

@@ -2982,9 +2982,9 @@ ShaderImpl *Renderer11::createShader(GLenum type)
     return new ShaderD3D(type);
 }
 
-ProgramImpl *Renderer11::createProgram()
+ProgramImpl *Renderer11::createProgram(const gl::Program::Data &data)
 {
-    return new ProgramD3D(this);
+    return new ProgramD3D(data, this);
 }
 
 gl::Error Renderer11::loadExecutable(const void *function, size_t length, ShaderType type,

src/libANGLE/renderer/d3d/d3d11/Renderer11.h

@@ -188,7 +188,7 @@ class Renderer11 : public RendererD3D
     // Shader creation
     virtual CompilerImpl *createCompiler(const gl::Data &data);
     virtual ShaderImpl *createShader(GLenum type);
-    virtual ProgramImpl *createProgram();
+    virtual ProgramImpl *createProgram(const gl::Program::Data &data);
 
     // Shader operations
     virtual gl::Error loadExecutable(const void *function, size_t length, ShaderType type,

src/libANGLE/renderer/d3d/d3d9/Renderer9.cpp

@@ -2672,9 +2672,9 @@ ShaderImpl *Renderer9::createShader(GLenum type)
     return new ShaderD3D(type);
 }
 
-ProgramImpl *Renderer9::createProgram()
+ProgramImpl *Renderer9::createProgram(const gl::Program::Data &data)
 {
-    return new ProgramD3D(this);
+    return new ProgramD3D(data, this);
 }
 
 gl::Error Renderer9::loadExecutable(const void *function, size_t length, ShaderType type,

src/libANGLE/renderer/d3d/d3d9/Renderer9.h

@@ -173,7 +173,7 @@ class Renderer9 : public RendererD3D
     // Shader creation
     virtual CompilerImpl *createCompiler(const gl::Data &data);
     virtual ShaderImpl *createShader(GLenum type);
-    virtual ProgramImpl *createProgram();
+    virtual ProgramImpl *createProgram(const gl::Program::Data &data);
 
     // Shader operations
     virtual gl::Error loadExecutable(const void *function, size_t length, ShaderType type,

src/libANGLE/renderer/gl/ProgramGL.cpp

@@ -17,11 +17,10 @@
 namespace rx
 {
 
-ProgramGL::ProgramGL(const FunctionsGL *functions, StateManagerGL *stateManager)
-    : ProgramImpl(),
-      mFunctions(functions),
-      mStateManager(stateManager),
-      mProgramID(0)
+ProgramGL::ProgramGL(const gl::Program::Data &data,
+                     const FunctionsGL *functions,
+                     StateManagerGL *stateManager)
+    : ProgramImpl(data), mFunctions(functions), mStateManager(stateManager), mProgramID(0)
 {
     ASSERT(mFunctions);
     ASSERT(mStateManager);
@@ -398,8 +397,7 @@ bool ProgramGL::validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps)
     return true;
 }
 
-LinkResult ProgramGL::compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                                int registers)
+LinkResult ProgramGL::compileProgramExecutables(gl::InfoLog &infoLog, int registers)
 {
     //UNIMPLEMENTED();
     return LinkResult(true, gl::Error(GL_NO_ERROR));

src/libANGLE/renderer/gl/ProgramGL.h

@@ -26,7 +26,9 @@ struct SamplerBindingGL
 class ProgramGL : public ProgramImpl
 {
   public:
-    ProgramGL(const FunctionsGL *functions, StateManagerGL *stateManager);
+    ProgramGL(const gl::Program::Data &data,
+              const FunctionsGL *functions,
+              StateManagerGL *stateManager);
     ~ProgramGL() override;
 
     bool usesPointSize() const override;
@@ -78,8 +80,7 @@ class ProgramGL : public ProgramImpl
     void updateSamplerMapping() override;
     bool validateSamplers(gl::InfoLog *infoLog, const gl::Caps &caps) override;
 
-    LinkResult compileProgramExecutables(gl::InfoLog &infoLog, gl::Shader *fragmentShader, gl::Shader *vertexShader,
-                                         int registers) override;
+    LinkResult compileProgramExecutables(gl::InfoLog &infoLog, int registers) override;
 
     bool linkUniforms(gl::InfoLog &infoLog, const gl::Shader &vertexShader, const gl::Shader &fragmentShader,
                       const gl::Caps &caps) override;

src/libANGLE/renderer/gl/RendererGL.cpp

@@ -176,9 +176,9 @@ ShaderImpl *RendererGL::createShader(GLenum type)
     return new ShaderGL(type, mFunctions);
 }
 
-ProgramImpl *RendererGL::createProgram()
+ProgramImpl *RendererGL::createProgram(const gl::Program::Data &data)
 {
-    return new ProgramGL(mFunctions, mStateManager);
+    return new ProgramGL(data, mFunctions, mStateManager);
 }
 
 FramebufferImpl *RendererGL::createDefaultFramebuffer(const gl::Framebuffer::Data &data)

src/libANGLE/renderer/gl/RendererGL.h

@@ -36,7 +36,7 @@ class RendererGL : public Renderer
     // Shader creation
     CompilerImpl *createCompiler(const gl::Data &data) override;
     ShaderImpl *createShader(GLenum type) override;
-    ProgramImpl *createProgram() override;
+    ProgramImpl *createProgram(const gl::Program::Data &data) override;
 
     // Framebuffer creation
     FramebufferImpl *createDefaultFramebuffer(const gl::Framebuffer::Data &data) override;

src/tests/angle_unittests_utils.h

@@ -23,7 +23,7 @@ class NullFactory : public ImplFactory
     // Shader creation
     CompilerImpl *createCompiler(const gl::Data &data) override { return nullptr; }
     ShaderImpl *createShader(GLenum type) override { return nullptr; }
-    ProgramImpl *createProgram() override { return nullptr; }
+    ProgramImpl *createProgram(const gl::Program::Data &data) override { return nullptr; }
 
     // Framebuffer creation
     FramebufferImpl *createDefaultFramebuffer(const gl::Framebuffer::Data &data) override { return nullptr; }