Skip to content

A
angle
Commit 5c6b7bfe by Jamie Madill
Options

Add a Program::Data shared state structure.

Similar to the Framebuffer and other classes, this gives the Impl class a read-only view of the object's state. BUG=angleproject:1123 Change-Id: I580eaebe2de236adf8131d6e3f54633cecce8c25 Reviewed-on: https://chromium-review.googlesource.com/293760Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Reviewed-by: 's avatarCorentin Wallez <cwallez@chromium.org> Tested-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 3b040eb8
Showing with 187 additions and 146 deletions
src/libANGLE/Program.cpp
......@@ -141,13 +141,31 @@ LinkedVarying::LinkedVarying(const std::string &name, GLenum type, GLsizei size,
{
}
Program::Program(rx::ProgramImpl *impl, ResourceManager *manager, GLuint handle)
: mProgram(impl),
mValidated(false),
mFragmentShader(nullptr),
mVertexShader(nullptr),
Program::Data::Data()
: mAttachedFragmentShader(nullptr),
mAttachedVertexShader(nullptr),
mTransformFeedbackVaryings(),
mTransformFeedbackBufferMode(GL_NONE),
mTransformFeedbackBufferMode(GL_NONE)
{
}
Program::Data::~Data()
{
if (mAttachedVertexShader != nullptr)
{
mAttachedVertexShader->release();
}
if (mAttachedFragmentShader != nullptr)
{
mAttachedFragmentShader->release();
}
}
Program::Program(rx::ImplFactory *factory, ResourceManager *manager, GLuint handle)
: mProgram(factory->createProgram(mData)),
mLinkedAttributes(gl::MAX_VERTEX_ATTRIBS),
mValidated(false),
mLinked(false),
mDeleteStatus(false),
mRefCount(0),
......@@ -164,16 +182,6 @@ Program::~Program()
{
unlink(true);
if (mVertexShader != nullptr)
{
mVertexShader->release();
}
if (mFragmentShader != nullptr)
{
mFragmentShader->release();
}
SafeDelete(mProgram);
}
......@@ -181,23 +189,23 @@ bool Program::attachShader(Shader *shader)
{
if (shader->getType() == GL_VERTEX_SHADER)
{
if (mVertexShader)
if (mData.mAttachedVertexShader)
{
return false;
}
mVertexShader = shader;
mVertexShader->addRef();
mData.mAttachedVertexShader = shader;
mData.mAttachedVertexShader->addRef();
}
else if (shader->getType() == GL_FRAGMENT_SHADER)
{
if (mFragmentShader)
if (mData.mAttachedFragmentShader)
{
return false;
}
mFragmentShader = shader;
mFragmentShader->addRef();
mData.mAttachedFragmentShader = shader;
mData.mAttachedFragmentShader->addRef();
}
else UNREACHABLE();
......@@ -208,23 +216,23 @@ bool Program::detachShader(Shader *shader)
{
if (shader->getType() == GL_VERTEX_SHADER)
{
if (mVertexShader != shader)
if (mData.mAttachedVertexShader != shader)
{
return false;
}
mVertexShader->release();
mVertexShader = nullptr;
shader->release();
mData.mAttachedVertexShader = nullptr;
}
else if (shader->getType() == GL_FRAGMENT_SHADER)
{
if (mFragmentShader != shader)
if (mData.mAttachedFragmentShader != shader)
{
return false;
}
mFragmentShader->release();
mFragmentShader = nullptr;
shader->release();
mData.mAttachedFragmentShader = nullptr;
}
else UNREACHABLE();
......@@ -233,7 +241,7 @@ bool Program::detachShader(Shader *shader)
int Program::getAttachedShadersCount() const
{
return (mVertexShader ? 1 : 0) + (mFragmentShader ? 1 : 0);
return (mData.mAttachedVertexShader ? 1 : 0) + (mData.mAttachedFragmentShader ? 1 : 0);
}
void AttributeBindings::bindAttributeLocation(GLuint index, const char *name)
......@@ -258,58 +266,64 @@ void Program::bindAttributeLocation(GLuint index, const char *name)
// Links the HLSL code of the vertex and pixel shader by matching up their varyings,
// compiling them into binaries, determining the attribute mappings, and collecting
// a list of uniforms
Error Program::link(const Data &data)
Error Program::link(const gl::Data &data)
{
unlink(false);
mInfoLog.reset();
resetUniformBlockBindings();
if (!mFragmentShader || !mFragmentShader->isCompiled())
if (!mData.mAttachedFragmentShader || !mData.mAttachedFragmentShader->isCompiled())
{
return Error(GL_NO_ERROR);
}
ASSERT(mFragmentShader->getType() == GL_FRAGMENT_SHADER);
ASSERT(mData.mAttachedFragmentShader->getType() == GL_FRAGMENT_SHADER);
if (!mVertexShader || !mVertexShader->isCompiled())
if (!mData.mAttachedVertexShader || !mData.mAttachedVertexShader->isCompiled())
{
return Error(GL_NO_ERROR);
}
ASSERT(mVertexShader->getType() == GL_VERTEX_SHADER);
ASSERT(mData.mAttachedVertexShader->getType() == GL_VERTEX_SHADER);
if (!linkAttributes(data, mInfoLog, mAttributeBindings, mVertexShader))
if (!linkAttributes(data, mInfoLog, mAttributeBindings, mData.mAttachedVertexShader))
{
return Error(GL_NO_ERROR);
}
int registers;
std::vector<LinkedVarying> linkedVaryings;
rx::LinkResult result = mProgram->link(data, mInfoLog, mFragmentShader, mVertexShader, mTransformFeedbackVaryings, mTransformFeedbackBufferMode,
&registers, &linkedVaryings, &mOutputVariables);
rx::LinkResult result =
mProgram->link(data, mInfoLog, mData.mAttachedFragmentShader, mData.mAttachedVertexShader,
mData.mTransformFeedbackVaryings, mData.mTransformFeedbackBufferMode,
&registers, &linkedVaryings, &mOutputVariables);
if (result.error.isError() || !result.linkSuccess)
{
return result.error;
}
if (!mProgram->linkUniforms(mInfoLog, *mVertexShader, *mFragmentShader, *data.caps))
if (!mProgram->linkUniforms(mInfoLog, *mData.mAttachedVertexShader,
*mData.mAttachedFragmentShader, *data.caps))
{
return Error(GL_NO_ERROR);
}
if (!linkUniformBlocks(mInfoLog, *mVertexShader, *mFragmentShader, *data.caps))
if (!linkUniformBlocks(mInfoLog, *mData.mAttachedVertexShader, *mData.mAttachedFragmentShader,
*data.caps))
{
return Error(GL_NO_ERROR);
}
if (!gatherTransformFeedbackLinkedVaryings(mInfoLog, linkedVaryings, mTransformFeedbackVaryings,
mTransformFeedbackBufferMode, &mProgram->getTransformFeedbackLinkedVaryings(), *data.caps))
if (!gatherTransformFeedbackLinkedVaryings(
mInfoLog, linkedVaryings, mData.mTransformFeedbackVaryings,
mData.mTransformFeedbackBufferMode, &mProgram->getTransformFeedbackLinkedVaryings(),
*data.caps))
{
return Error(GL_NO_ERROR);
}
// TODO: The concept of "executables" is D3D only, and as such this belongs in ProgramD3D. It must be called,
// however, last in this function, so it can't simply be moved to ProgramD3D::link without further shuffling.
result = mProgram->compileProgramExecutables(mInfoLog, mFragmentShader, mVertexShader, registers);
result = mProgram->compileProgramExecutables(mInfoLog, registers);
if (result.error.isError() || !result.linkSuccess)
{
mInfoLog << "Failed to create D3D shaders.";
......@@ -339,20 +353,20 @@ void Program::unlink(bool destroy)
{
if (destroy) // Object being destructed
{
if (mFragmentShader)
if (mData.mAttachedFragmentShader)
{
mFragmentShader->release();
mFragmentShader = nullptr;
mData.mAttachedFragmentShader->release();
mData.mAttachedFragmentShader = nullptr;
}
if (mVertexShader)
if (mData.mAttachedVertexShader)
{
mVertexShader->release();
mVertexShader = nullptr;
mData.mAttachedVertexShader->release();
mData.mAttachedVertexShader = nullptr;
}
}
std::fill(mLinkedAttribute, mLinkedAttribute + ArraySize(mLinkedAttribute), sh::Attribute());
mLinkedAttributes.assign(mLinkedAttributes.size(), sh::Attribute());
mOutputVariables.clear();
mProgram->reset();
......@@ -404,8 +418,8 @@ Error Program::loadBinary(GLenum binaryFormat, const void *binary, GLsizei lengt
// TODO(jmadill): replace MAX_VERTEX_ATTRIBS
for (int i = 0; i < MAX_VERTEX_ATTRIBS; ++i)
{
stream.readInt(&mLinkedAttribute[i].type);
stream.readString(&mLinkedAttribute[i].name);
stream.readInt(&mLinkedAttributes[i].type);
stream.readString(&mLinkedAttributes[i].name);
stream.readInt(&mProgram->getSemanticIndexes()[i]);
}
......@@ -448,8 +462,8 @@ Error Program::saveBinary(GLenum *binaryFormat, void *binary, GLsizei bufSize, G
// TODO(jmadill): replace MAX_VERTEX_ATTRIBS
for (unsigned int i = 0; i < MAX_VERTEX_ATTRIBS; ++i)
{
stream.writeInt(mLinkedAttribute[i].type);
stream.writeString(mLinkedAttribute[i].name);
stream.writeInt(mLinkedAttributes[i].type);
stream.writeString(mLinkedAttributes[i].name);
stream.writeInt(mProgram->getSemanticIndexes()[i]);
}
......@@ -550,21 +564,21 @@ void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shade
{
int total = 0;
if (mVertexShader)
if (mData.mAttachedVertexShader)
{
if (total < maxCount)
{
shaders[total] = mVertexShader->getHandle();
shaders[total] = mData.mAttachedVertexShader->getHandle();
}
total++;
}
if (mFragmentShader)
if (mData.mAttachedFragmentShader)
{
if (total < maxCount)
{
shaders[total] = mFragmentShader->getHandle();
shaders[total] = mData.mAttachedFragmentShader->getHandle();
}
total++;
......@@ -578,11 +592,11 @@ void Program::getAttachedShaders(GLsizei maxCount, GLsizei *count, GLuint *shade
GLuint Program::getAttributeLocation(const std::string &name)
{
for (int index = 0; index < MAX_VERTEX_ATTRIBS; index++)
for (size_t index = 0; index < mLinkedAttributes.size(); index++)
{
if (mLinkedAttribute[index].name == name)
if (mLinkedAttributes[index].name == name)
{
return index;
return static_cast<GLuint>(index);
}
}
......@@ -608,9 +622,10 @@ void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length,
// Skip over inactive attributes
unsigned int activeAttribute = 0;
unsigned int attribute;
for (attribute = 0; attribute < MAX_VERTEX_ATTRIBS; attribute++)
for (attribute = 0; attribute < static_cast<unsigned int>(mLinkedAttributes.size());
attribute++)
{
if (mLinkedAttribute[attribute].name.empty())
if (mLinkedAttributes[attribute].name.empty())
{
continue;
}
......@@ -625,7 +640,7 @@ void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length,
if (bufsize > 0)
{
const char *string = mLinkedAttribute[attribute].name.c_str();
const char *string = mLinkedAttributes[attribute].name.c_str();
strncpy(name, string, bufsize);
name[bufsize - 1] = '\0';
......@@ -638,7 +653,7 @@ void Program::getActiveAttribute(GLuint index, GLsizei bufsize, GLsizei *length,
*size = 1; // Always a single 'type' instance
*type = mLinkedAttribute[attribute].type;
*type = mLinkedAttributes[attribute].type;
}
else
{
......@@ -665,7 +680,7 @@ GLint Program::getActiveAttributeCount()
{
for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
{
if (!mLinkedAttribute[attributeIndex].name.empty())
if (!mLinkedAttributes[attributeIndex].name.empty())
{
count++;
}
......@@ -677,15 +692,17 @@ GLint Program::getActiveAttributeCount()
GLint Program::getActiveAttributeMaxLength()
{
int maxLength = 0;
GLint maxLength = 0;
if (mLinked)
{
for (int attributeIndex = 0; attributeIndex < MAX_VERTEX_ATTRIBS; attributeIndex++)
{
if (!mLinkedAttribute[attributeIndex].name.empty())
if (!mLinkedAttributes[attributeIndex].name.empty())
{
maxLength = std::max((int)(mLinkedAttribute[attributeIndex].name.length() + 1), maxLength);
maxLength = std::max(
static_cast<GLint>(mLinkedAttributes[attributeIndex].name.length() + 1),
maxLength);
}
}
}
......@@ -718,12 +735,12 @@ GLint Program::getFragDataLocation(const std::string &name) const
{
std::string baseName(name);
unsigned int arrayIndex = ParseAndStripArrayIndex(&baseName);
for (auto locationIt = mOutputVariables.begin(); locationIt != mOutputVariables.end(); locationIt++)
for (auto outputPair : mOutputVariables)
{
const VariableLocation &outputVariable = locationIt->second;
const VariableLocation &outputVariable = outputPair.second;
if (outputVariable.name == baseName && (arrayIndex == GL_INVALID_INDEX || arrayIndex == outputVariable.element))
{
return static_cast<GLint>(locationIt->first);
return static_cast<GLint>(outputPair.first);
}
}
return -1;
......@@ -1149,13 +1166,13 @@ void Program::resetUniformBlockBindings()
void Program::setTransformFeedbackVaryings(GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
{
mTransformFeedbackVaryings.resize(count);
mData.mTransformFeedbackVaryings.resize(count);
for (GLsizei i = 0; i < count; i++)
{
mTransformFeedbackVaryings[i] = varyings[i];
mData.mTransformFeedbackVaryings[i] = varyings[i];
}
mTransformFeedbackBufferMode = bufferMode;
mData.mTransformFeedbackBufferMode = bufferMode;
}
void Program::getTransformFeedbackVarying(GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name) const
......@@ -1218,7 +1235,7 @@ GLsizei Program::getTransformFeedbackVaryingMaxLength() const
GLenum Program::getTransformFeedbackBufferMode() const
{
return mTransformFeedbackBufferMode;
return mData.mTransformFeedbackBufferMode;
}
bool Program::linkVaryings(InfoLog &infoLog, Shader *fragmentShader, Shader *vertexShader)
......@@ -1283,7 +1300,7 @@ bool Program::linkValidateInterfaceBlockFields(InfoLog &infoLog, const std::stri
}
// Determines the mapping between GL attributes and Direct3D 9 vertex stream usage indices
bool Program::linkAttributes(const Data &data,
bool Program::linkAttributes(const gl::Data &data,
InfoLog &infoLog,
const AttributeBindings &attributeBindings,
const Shader *vertexShader)
......@@ -1325,23 +1342,22 @@ bool Program::linkAttributes(const Data &data,
for (int row = 0; row < rows; row++)
{
const int rowLocation = location + row;
sh::ShaderVariable &linkedAttribute = mLinkedAttribute[rowLocation];
sh::ShaderVariable *linkedAttribute = &mLinkedAttributes[rowLocation];
// In GLSL 3.00, attribute aliasing produces a link error
// In GLSL 1.00, attribute aliasing is allowed, but ANGLE currently has a bug
// TODO(jmadill): fix aliasing on ES2
// if (mProgram->getShaderVersion() >= 300)
{
if (!linkedAttribute.name.empty())
if (!linkedAttribute->name.empty())
{
infoLog << "Attribute '" << attribute.name
<< "' aliases attribute '" << linkedAttribute.name
<< "' at location " << rowLocation;
infoLog << "Attribute '" << attribute.name << "' aliases attribute '"
<< linkedAttribute->name << "' at location " << rowLocation;
return false;
}
}
linkedAttribute = attribute;
*linkedAttribute = attribute;
usedLocations |= 1 << rowLocation;
}
}
......@@ -1367,14 +1383,14 @@ bool Program::linkAttributes(const Data &data,
return false; // Fail to link
}
mLinkedAttribute[availableIndex] = attribute;
mLinkedAttributes[availableIndex] = attribute;
}
}
for (GLuint attributeIndex = 0; attributeIndex < maxAttribs;)
{
int index = vertexShader->getSemanticIndex(mLinkedAttribute[attributeIndex].name);
int rows = VariableRegisterCount(mLinkedAttribute[attributeIndex].type);
int index = vertexShader->getSemanticIndex(mLinkedAttributes[attributeIndex].name);
int rows = VariableRegisterCount(mLinkedAttributes[attributeIndex].type);
for (int r = 0; r < rows; r++)
{
......
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; }
......
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