Skip to content

A
angle
Commit bd044ed8 by Jamie Madill Committed by Commit Bot
Options

Defer shader compiles when possible.

When using the program binary memory cache inside ANGLE, this will give a potential fast path. If the user doesn't query the shader compile status or info log before calling LinkProgram, then we can check the program cache before translating the program, and if it finds a hit, we don't even need to call the translator. To preserve the shader settings at compile time, a reference to the current shader translator is kept in a binding pointer on the call to compile. This mirrors a similar implementation in Chromium's command buffer. Also the compile options and source are cached at compile to preserve the correct shader state. BUG=angleproject:1897 Change-Id: I3c046d7ac8c3b5c8cc169c4802ffe47f95537212 Reviewed-on: https://chromium-review.googlesource.com/517379Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Reviewed-by: 's avatarCorentin Wallez <cwallez@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>
parent dc0fa46a
Showing with 275 additions and 167 deletions
src/libANGLE/Context.cpp
......@@ -2136,7 +2136,7 @@ void Context::programPathFragmentInputGen(GLuint program,
{
auto *programObject = getProgram(program);
programObject->pathFragmentInputGen(location, genMode, components, coeffs);
programObject->pathFragmentInputGen(this, location, genMode, components, coeffs);
}
GLuint Context::getProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
......@@ -4319,14 +4319,14 @@ void Context::getShaderiv(GLuint shader, GLenum pname, GLint *params)
{
Shader *shaderObject = getShader(shader);
ASSERT(shaderObject);
QueryShaderiv(shaderObject, pname, params);
QueryShaderiv(this, shaderObject, pname, params);
}
void Context::getShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *infolog)
{
Shader *shaderObject = getShader(shader);
ASSERT(shaderObject);
shaderObject->getInfoLog(bufsize, length, infolog);
shaderObject->getInfoLog(this, bufsize, length, infolog);
}
void Context::getShaderPrecisionFormat(GLenum shadertype,
......
src/libANGLE/Program.h
......@@ -206,9 +206,9 @@ class ProgramState final : angle::NonCopyable
const std::string &getLabel();
const Shader *getAttachedVertexShader() const { return mAttachedVertexShader; }
const Shader *getAttachedFragmentShader() const { return mAttachedFragmentShader; }
const Shader *getAttachedComputeShader() const { return mAttachedComputeShader; }
Shader *getAttachedVertexShader() const { return mAttachedVertexShader; }
Shader *getAttachedFragmentShader() const { return mAttachedFragmentShader; }
Shader *getAttachedComputeShader() const { return mAttachedComputeShader; }
const std::vector<std::string> &getTransformFeedbackVaryingNames() const
{
return mTransformFeedbackVaryingNames;
......@@ -314,9 +314,10 @@ class Program final : angle::NonCopyable, public LabeledObject
void bindUniformLocation(GLuint index, const char *name);
// CHROMIUM_path_rendering
BindingInfo getFragmentInputBindingInfo(GLint index) const;
BindingInfo getFragmentInputBindingInfo(const Context *context, GLint index) const;
void bindFragmentInputLocation(GLint index, const char *name);
void pathFragmentInputGen(GLint index,
void pathFragmentInputGen(const Context *context,
GLint index,
GLenum genMode,
GLint components,
const GLfloat *coeffs);
......@@ -491,7 +492,7 @@ class Program final : angle::NonCopyable, public LabeledObject
void unlink();
void resetUniformBlockBindings();
bool linkAttributes(const ContextState &data, InfoLog &infoLog);
bool linkAttributes(const Context *context, InfoLog &infoLog);
bool validateUniformBlocksCount(GLuint maxUniformBlocks,
const std::vector<sh::InterfaceBlock> &block,
const std::string &errorMessage,
......@@ -501,10 +502,12 @@ class Program final : angle::NonCopyable, public LabeledObject
const std::vector<sh::InterfaceBlock> &fragmentInterfaceBlocks,
InfoLog &infoLog,
bool webglCompatibility) const;
bool linkUniformBlocks(InfoLog &infoLog, const Caps &caps, bool webglCompatibility);
bool linkVaryings(InfoLog &infoLog) const;
bool linkUniformBlocks(const Context *context, InfoLog &infoLog);
bool linkVaryings(const Context *context, InfoLog &infoLog) const;
bool linkUniforms(InfoLog &infoLog, const Caps &caps, const Bindings &uniformLocationBindings);
bool linkUniforms(const Context *context,
InfoLog &infoLog,
const Bindings &uniformLocationBindings);
void linkSamplerBindings();
bool areMatchingInterfaceBlocks(InfoLog &infoLog,
......@@ -517,7 +520,7 @@ class Program final : angle::NonCopyable, public LabeledObject
const sh::Varying &vertexVarying,
const sh::Varying &fragmentVarying,
int shaderVersion);
bool linkValidateBuiltInVaryings(InfoLog &infoLog) const;
bool linkValidateBuiltInVaryings(const Context *context, InfoLog &infoLog) const;
bool linkValidateTransformFeedback(const gl::Context *context,
InfoLog &infoLog,
const MergedVaryings &linkedVaryings,
......@@ -525,13 +528,13 @@ class Program final : angle::NonCopyable, public LabeledObject
void gatherTransformFeedbackVaryings(const MergedVaryings &varyings);
MergedVaryings getMergedVaryings() const;
MergedVaryings getMergedVaryings(const Context *context) const;
std::vector<PackedVarying> getPackedVaryings(const MergedVaryings &mergedVaryings) const;
void linkOutputVariables();
void linkOutputVariables(const Context *context);
void setUniformValuesFromBindingQualifiers();
void gatherInterfaceBlockInfo();
void gatherInterfaceBlockInfo(const Context *context);
template <typename VarT>
void defineUniformBlockMembers(const std::vector<VarT> &fields,
const std::string &prefix,
......
src/libANGLE/Shader.h
......@@ -12,16 +12,18 @@
#ifndef LIBANGLE_SHADER_H_
#define LIBANGLE_SHADER_H_
#include <string>
#include <list>
#include <memory>
#include <string>
#include <vector>
#include "angle_gl.h"
#include <GLSLANG/ShaderLang.h>
#include "common/Optional.h"
#include "common/angleutils.h"
#include "libANGLE/angletypes.h"
#include "libANGLE/Debug.h"
#include "libANGLE/angletypes.h"
namespace rx
{
......@@ -98,22 +100,27 @@ class Shader final : angle::NonCopyable, public LabeledObject
GLenum getType() const { return mType; }
GLuint getHandle() const;
rx::ShaderImpl *getImplementation() const { return mImplementation; }
rx::ShaderImpl *getImplementation() const { return mImplementation.get(); }
void deleteSource();
void setSource(GLsizei count, const char *const *string, const GLint *length);
int getInfoLogLength() const;
void getInfoLog(GLsizei bufSize, GLsizei *length, char *infoLog) const;
int getInfoLogLength(const Context *context);
void getInfoLog(const Context *context, GLsizei bufSize, GLsizei *length, char *infoLog);
int getSourceLength() const;
void getSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
int getTranslatedSourceLength() const;
int getTranslatedSourceWithDebugInfoLength() const;
const std::string &getTranslatedSource() const { return mState.getTranslatedSource(); }
void getTranslatedSource(GLsizei bufSize, GLsizei *length, char *buffer) const;
void getTranslatedSourceWithDebugInfo(GLsizei bufSize, GLsizei *length, char *buffer) const;
int getTranslatedSourceLength(const Context *context);
int getTranslatedSourceWithDebugInfoLength(const Context *context);
const std::string &getTranslatedSource(const Context *context);
void getTranslatedSource(const Context *context,
GLsizei bufSize,
GLsizei *length,
char *buffer);
void getTranslatedSourceWithDebugInfo(const Context *context,
GLsizei bufSize,
GLsizei *length,
char *buffer);
void compile(const Context *context);
bool isCompiled() const { return mCompiled; }
bool isCompiled(const Context *context);
void addRef();
void release(const Context *context);
......@@ -121,31 +128,50 @@ class Shader final : angle::NonCopyable, public LabeledObject
bool isFlaggedForDeletion() const;
void flagForDeletion();
int getShaderVersion() const;
int getShaderVersion(const Context *context);
const std::vector<sh::Varying> &getVaryings() const;
const std::vector<sh::Uniform> &getUniforms() const;
const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const;
const std::vector<sh::Attribute> &getActiveAttributes() const;
const std::vector<sh::OutputVariable> &getActiveOutputVariables() const;
const std::vector<sh::Varying> &getVaryings(const Context *context);
const std::vector<sh::Uniform> &getUniforms(const Context *context);
const std::vector<sh::InterfaceBlock> &getInterfaceBlocks(const Context *context);
const std::vector<sh::Attribute> &getActiveAttributes(const Context *context);
const std::vector<sh::OutputVariable> &getActiveOutputVariables(const Context *context);
int getSemanticIndex(const std::string &attributeName) const;
int getSemanticIndex(const Context *context, const std::string &attributeName);
const sh::WorkGroupSize &getWorkGroupSize() const { return mState.mLocalSize; }
const sh::WorkGroupSize &getWorkGroupSize(const Context *context);
private:
static void getSourceImpl(const std::string &source, GLsizei bufSize, GLsizei *length, char *buffer);
static void GetSourceImpl(const std::string &source,
GLsizei bufSize,
GLsizei *length,
char *buffer);
void resolveCompile(const Context *context);
// We defer the compile until link time, or until properties are queried.
enum class CompileStatus
{
NOT_COMPILED,
COMPILE_REQUESTED,
COMPILED,
};
ShaderState mState;
rx::ShaderImpl *mImplementation;
std::string mLastCompiledSource;
std::string mLastCompiledSourcePath;
ShCompileOptions mLastCompileOptions;
std::unique_ptr<rx::ShaderImpl> mImplementation;
const gl::Limitations &mRendererLimitations;
const GLuint mHandle;
const GLenum mType;
unsigned int mRefCount; // Number of program objects this shader is attached to
bool mDeleteStatus; // Flag to indicate that the shader can be deleted when no longer in use
bool mCompiled; // Indicates if this shader has been successfully compiled
CompileStatus mStatus; // Indicates if this shader has been successfully compiled
std::string mInfoLog;
// We keep a reference to the translator in order to defer compiles while preserving settings.
BindingPointer<Compiler> mBoundCompiler;
ShaderProgramManager *mResourceManager;
};
......
src/libANGLE/UniformLinker.cpp
......@@ -12,6 +12,7 @@
#include "common/utilities.h"
#include "libANGLE/Caps.h"
#include "libANGLE/Context.h"
#include "libANGLE/Shader.h"
#include "libANGLE/features.h"
......@@ -45,14 +46,14 @@ void UniformLinker::getResults(std::vector<LinkedUniform> *uniforms,
uniformLocations->swap(mUniformLocations);
}
bool UniformLinker::link(InfoLog &infoLog,
const Caps &caps,
bool UniformLinker::link(const Context *context,
InfoLog &infoLog,
const Program::Bindings &uniformLocationBindings)
{
if (mState.getAttachedVertexShader() && mState.getAttachedFragmentShader())
{
ASSERT(mState.getAttachedComputeShader() == nullptr);
if (!validateVertexAndFragmentUniforms(infoLog))
if (!validateVertexAndFragmentUniforms(context, infoLog))
{
return false;
}
......@@ -60,7 +61,7 @@ bool UniformLinker::link(InfoLog &infoLog,
// Flatten the uniforms list (nested fields) into a simple list (no nesting).
// Also check the maximum uniform vector and sampler counts.
if (!flattenUniformsAndCheckCaps(caps, infoLog))
if (!flattenUniformsAndCheckCaps(context, infoLog))
{
return false;
}
......@@ -73,14 +74,15 @@ bool UniformLinker::link(InfoLog &infoLog,
return true;
}
bool UniformLinker::validateVertexAndFragmentUniforms(InfoLog &infoLog) const
bool UniformLinker::validateVertexAndFragmentUniforms(const Context *context,
InfoLog &infoLog) const
{
// Check that uniforms defined in the vertex and fragment shaders are identical
std::map<std::string, LinkedUniform> linkedUniforms;
const std::vector<sh::Uniform> &vertexUniforms =
mState.getAttachedVertexShader()->getUniforms();
mState.getAttachedVertexShader()->getUniforms(context);
const std::vector<sh::Uniform> &fragmentUniforms =
mState.getAttachedFragmentShader()->getUniforms();
mState.getAttachedFragmentShader()->getUniforms(context);
for (const sh::Uniform &vertexUniform : vertexUniforms)
{
......@@ -319,7 +321,8 @@ void UniformLinker::pruneUnusedUniforms()
}
bool UniformLinker::flattenUniformsAndCheckCapsForShader(
const Shader &shader,
const Context *context,
Shader *shader,
GLuint maxUniformComponents,
GLuint maxTextureImageUnits,
const std::string &componentsErrorMessage,
......@@ -328,7 +331,7 @@ bool UniformLinker::flattenUniformsAndCheckCapsForShader(
InfoLog &infoLog)
{
VectorAndSamplerCount vasCount;
for (const sh::Uniform &uniform : shader.getUniforms())
for (const sh::Uniform &uniform : shader->getUniforms(context))
{
vasCount += flattenUniform(uniform, &samplerUniforms);
}
......@@ -348,17 +351,19 @@ bool UniformLinker::flattenUniformsAndCheckCapsForShader(
return true;
}
bool UniformLinker::flattenUniformsAndCheckCaps(const Caps &caps, InfoLog &infoLog)
bool UniformLinker::flattenUniformsAndCheckCaps(const Context *context, InfoLog &infoLog)
{
std::vector<LinkedUniform> samplerUniforms;
const Caps &caps = context->getCaps();
if (mState.getAttachedComputeShader())
{
const Shader *computeShader = mState.getAttachedComputeShader();
Shader *computeShader = mState.getAttachedComputeShader();
// TODO (mradev): check whether we need finer-grained component counting
if (!flattenUniformsAndCheckCapsForShader(
*computeShader, caps.maxComputeUniformComponents / 4,
context, computeShader, caps.maxComputeUniformComponents / 4,
caps.maxComputeTextureImageUnits,
"Compute shader active uniforms exceed MAX_COMPUTE_UNIFORM_COMPONENTS (",
"Compute shader sampler count exceeds MAX_COMPUTE_TEXTURE_IMAGE_UNITS (",
......@@ -369,20 +374,22 @@ bool UniformLinker::flattenUniformsAndCheckCaps(const Caps &caps, InfoLog &infoL
}
else
{
const Shader *vertexShader = mState.getAttachedVertexShader();
Shader *vertexShader = mState.getAttachedVertexShader();
if (!flattenUniformsAndCheckCapsForShader(
*vertexShader, caps.maxVertexUniformVectors, caps.maxVertexTextureImageUnits,
context, vertexShader, caps.maxVertexUniformVectors,
caps.maxVertexTextureImageUnits,
"Vertex shader active uniforms exceed MAX_VERTEX_UNIFORM_VECTORS (",
"Vertex shader sampler count exceeds MAX_VERTEX_TEXTURE_IMAGE_UNITS (",
samplerUniforms, infoLog))
{
return false;
}
const Shader *fragmentShader = mState.getAttachedFragmentShader();
Shader *fragmentShader = mState.getAttachedFragmentShader();
if (!flattenUniformsAndCheckCapsForShader(
*fragmentShader, caps.maxFragmentUniformVectors, caps.maxTextureImageUnits,
context, fragmentShader, caps.maxFragmentUniformVectors, caps.maxTextureImageUnits,
"Fragment shader active uniforms exceed MAX_FRAGMENT_UNIFORM_VECTORS (",
"Fragment shader sampler count exceeds MAX_TEXTURE_IMAGE_UNITS (", samplerUniforms,
infoLog))
......
src/libANGLE/UniformLinker.h
......@@ -22,7 +22,9 @@ class UniformLinker
public:
UniformLinker(const ProgramState &state);
bool link(InfoLog &infoLog, const Caps &caps, const Program::Bindings &uniformLocationBindings);
bool link(const Context *context,
InfoLog &infoLog,
const Program::Bindings &uniformLocationBindings);
void getResults(std::vector<LinkedUniform> *uniforms,
std::vector<VariableLocation> *uniformLocations);
......@@ -45,21 +47,22 @@ class UniformLinker
unsigned int samplerCount;
};
bool validateVertexAndFragmentUniforms(InfoLog &infoLog) const;
bool validateVertexAndFragmentUniforms(const Context *context, InfoLog &infoLog) const;
static bool linkValidateUniforms(InfoLog &infoLog,
const std::string &uniformName,
const sh::Uniform &vertexUniform,
const sh::Uniform &fragmentUniform);
bool flattenUniformsAndCheckCapsForShader(const Shader &shader,
bool flattenUniformsAndCheckCapsForShader(const Context *context,
Shader *shader,
GLuint maxUniformComponents,
GLuint maxTextureImageUnits,
const std::string &componentsErrorMessage,
const std::string &samplerErrorMessage,
std::vector<LinkedUniform> &samplerUniforms,
InfoLog &infoLog);
bool flattenUniformsAndCheckCaps(const Caps &caps, InfoLog &infoLog);
bool flattenUniformsAndCheckCaps(const Context *context, InfoLog &infoLog);
VectorAndSamplerCount flattenUniform(const sh::Uniform &uniform,
std::vector<LinkedUniform> *samplerUniforms);
......
src/libANGLE/queryutils.cpp
......@@ -678,7 +678,7 @@ void QueryRenderbufferiv(const Context *context,
}
}
void QueryShaderiv(const Shader *shader, GLenum pname, GLint *params)
void QueryShaderiv(const Context *context, Shader *shader, GLenum pname, GLint *params)
{
ASSERT(shader != nullptr);
......@@ -691,16 +691,16 @@ void QueryShaderiv(const Shader *shader, GLenum pname, GLint *params)
*params = shader->isFlaggedForDeletion();
return;
case GL_COMPILE_STATUS:
*params = shader->isCompiled() ? GL_TRUE : GL_FALSE;
*params = shader->isCompiled(context) ? GL_TRUE : GL_FALSE;
return;
case GL_INFO_LOG_LENGTH:
*params = shader->getInfoLogLength();
*params = shader->getInfoLogLength(context);
return;
case GL_SHADER_SOURCE_LENGTH:
*params = shader->getSourceLength();
return;
case GL_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE:
*params = shader->getTranslatedSourceWithDebugInfoLength();
*params = shader->getTranslatedSourceWithDebugInfoLength(context);
return;
default:
UNREACHABLE();
......
src/libANGLE/queryutils.h
......@@ -44,7 +44,7 @@ void QueryRenderbufferiv(const Context *context,
const Renderbuffer *renderbuffer,
GLenum pname,
GLint *params);
void QueryShaderiv(const Shader *shader, GLenum pname, GLint *params);
void QueryShaderiv(const Context *context, Shader *shader, GLenum pname, GLint *params);
void QueryTexLevelParameterfv(const Texture *texture,
GLenum target,
GLint level,
......
src/libANGLE/renderer/d3d/DynamicHLSL.cpp
......@@ -10,13 +10,14 @@
#include "common/utilities.h"
#include "compiler/translator/blocklayoutHLSL.h"
#include "libANGLE/Context.h"
#include "libANGLE/Program.h"
#include "libANGLE/Shader.h"
#include "libANGLE/VaryingPacking.h"
#include "libANGLE/formatutils.h"
#include "libANGLE/renderer/d3d/ProgramD3D.h"
#include "libANGLE/renderer/d3d/RendererD3D.h"
#include "libANGLE/renderer/d3d/ShaderD3D.h"
#include "libANGLE/VaryingPacking.h"
using namespace gl;
......@@ -392,7 +393,7 @@ void DynamicHLSL::generateVaryingLinkHLSL(const VaryingPacking &varyingPacking,
hlslStream << "};\n";
}
void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
void DynamicHLSL::generateShaderLinkHLSL(const gl::Context *context,
const gl::ProgramState &programData,
const ProgramD3DMetadata &programMetadata,
const VaryingPacking &varyingPacking,
......@@ -402,8 +403,9 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
{
ASSERT(pixelHLSL->empty() && vertexHLSL->empty());
const gl::Shader *vertexShaderGL = programData.getAttachedVertexShader();
const gl::Shader *fragmentShaderGL = programData.getAttachedFragmentShader();
const auto &data = context->getContextState();
gl::Shader *vertexShaderGL = programData.getAttachedVertexShader();
gl::Shader *fragmentShaderGL = programData.getAttachedFragmentShader();
const ShaderD3D *fragmentShader = GetImplAs<ShaderD3D>(fragmentShaderGL);
const int shaderModel = mRenderer->getMajorShaderModel();
......@@ -418,7 +420,7 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
ASSERT(!fragmentShader->usesFragColor() || !fragmentShader->usesFragData());
std::stringstream vertexStream;
vertexStream << vertexShaderGL->getTranslatedSource();
vertexStream << vertexShaderGL->getTranslatedSource(context);
// Instanced PointSprite emulation requires additional entries originally generated in the
// GeometryShader HLSL. These include pointsize clamp values.
......@@ -586,7 +588,7 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
const auto &pixelBuiltins = builtinsD3D[SHADER_PIXEL];
std::stringstream pixelStream;
pixelStream << fragmentShaderGL->getTranslatedSource();
pixelStream << fragmentShaderGL->getTranslatedSource(context);
pixelStream << "struct PS_INPUT\n";
generateVaryingLinkHLSL(varyingPacking, pixelBuiltins, builtinsD3D.usesPointSize(),
pixelStream);
......@@ -769,11 +771,12 @@ void DynamicHLSL::generateShaderLinkHLSL(const gl::ContextState &data,
*pixelHLSL = pixelStream.str();
}
std::string DynamicHLSL::generateComputeShaderLinkHLSL(const gl::ProgramState &programData) const
std::string DynamicHLSL::generateComputeShaderLinkHLSL(const gl::Context *context,
const gl::ProgramState &programData) const
{
const gl::Shader *computeShaderGL = programData.getAttachedComputeShader();
gl::Shader *computeShaderGL = programData.getAttachedComputeShader();
std::stringstream computeStream;
std::string translatedSource = computeShaderGL->getTranslatedSource();
std::string translatedSource = computeShaderGL->getTranslatedSource(context);
computeStream << translatedSource;
bool usesWorkGroupID = translatedSource.find("GL_USES_WORK_GROUP_ID") != std::string::npos;
......@@ -811,7 +814,7 @@ std::string DynamicHLSL::generateComputeShaderLinkHLSL(const gl::ProgramState &p
computeStream << "};\n\n";
const sh::WorkGroupSize &localSize = computeShaderGL->getWorkGroupSize();
const sh::WorkGroupSize &localSize = computeShaderGL->getWorkGroupSize(context);
computeStream << "[numthreads(" << localSize[0] << ", " << localSize[1] << ", " << localSize[2]
<< ")]\n";
......
src/libANGLE/renderer/d3d/DynamicHLSL.h
......@@ -117,14 +117,15 @@ class DynamicHLSL : angle::NonCopyable
const std::vector<PixelShaderOutputVariable> &outputVariables,
bool usesFragDepth,
const std::vector<GLenum> &outputLayout) const;
void generateShaderLinkHLSL(const gl::ContextState &data,
void generateShaderLinkHLSL(const gl::Context *context,
const gl::ProgramState &programData,
const ProgramD3DMetadata &programMetadata,
const gl::VaryingPacking &varyingPacking,
const BuiltinVaryingsD3D &builtinsD3D,
std::string *pixelHLSL,
std::string *vertexHLSL) const;
std::string generateComputeShaderLinkHLSL(const gl::ProgramState &programData) const;
std::string generateComputeShaderLinkHLSL(const gl::Context *context,
const gl::ProgramState &programData) const;
std::string generateGeometryShaderPreamble(const gl::VaryingPacking &varyingPacking,
const BuiltinVaryingsD3D &builtinsD3D) const;
......
src/libANGLE/renderer/d3d/ProgramD3D.cpp
......@@ -34,10 +34,11 @@ namespace rx
namespace
{
gl::InputLayout GetDefaultInputLayoutFromShader(const gl::Shader *vertexShader)
gl::InputLayout GetDefaultInputLayoutFromShader(const gl::Context *context,
gl::Shader *vertexShader)
{
gl::InputLayout defaultLayout;
for (const sh::Attribute &shaderAttr : vertexShader->getActiveAttributes())
for (const sh::Attribute &shaderAttr : vertexShader->getActiveAttributes(context))
{
if (shaderAttr.type != GL_NONE)
{
......@@ -1331,17 +1332,23 @@ class ProgramD3D::GetExecutableTask : public Closure
class ProgramD3D::GetVertexExecutableTask : public ProgramD3D::GetExecutableTask
{
public:
GetVertexExecutableTask(ProgramD3D *program) : GetExecutableTask(program) {}
GetVertexExecutableTask(ProgramD3D *program, const gl::Context *context)
: GetExecutableTask(program), mContext(context)
{
}
gl::Error run() override
{
const auto &defaultInputLayout =
GetDefaultInputLayoutFromShader(mProgram->mState.getAttachedVertexShader());
GetDefaultInputLayoutFromShader(mContext, mProgram->mState.getAttachedVertexShader());
ANGLE_TRY(
mProgram->getVertexExecutableForInputLayout(defaultInputLayout, &mResult, &mInfoLog));
return gl::NoError();
}
private:
const gl::Context *mContext;
};
class ProgramD3D::GetPixelExecutableTask : public ProgramD3D::GetExecutableTask
......@@ -1395,17 +1402,16 @@ gl::Error ProgramD3D::getComputeExecutable(ShaderExecutableD3D **outExecutable)
return gl::NoError();
}
LinkResult ProgramD3D::compileProgramExecutables(const gl::ContextState &contextState,
gl::InfoLog &infoLog)
LinkResult ProgramD3D::compileProgramExecutables(const gl::Context *context, gl::InfoLog &infoLog)
{
// Ensure the compiler is initialized to avoid race conditions.
ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized());
WorkerThreadPool *workerPool = mRenderer->getWorkerThreadPool();
GetVertexExecutableTask vertexTask(this);
GetVertexExecutableTask vertexTask(this, context);
GetPixelExecutableTask pixelTask(this);
GetGeometryExecutableTask geometryTask(this, contextState);
GetGeometryExecutableTask geometryTask(this, context->getContextState());
std::array<WaitableEvent, 3> waitEvents = {{workerPool->postWorkerTask(&vertexTask),
workerPool->postWorkerTask(&pixelTask),
......@@ -1453,12 +1459,12 @@ LinkResult ProgramD3D::compileProgramExecutables(const gl::ContextState &context
(!usesGeometryShader(GL_POINTS) || pointGS));
}
LinkResult ProgramD3D::compileComputeExecutable(gl::InfoLog &infoLog)
LinkResult ProgramD3D::compileComputeExecutable(const gl::Context *context, gl::InfoLog &infoLog)
{
// Ensure the compiler is initialized to avoid race conditions.
ANGLE_TRY(mRenderer->ensureHLSLCompilerInitialized());
std::string computeShader = mDynamicHLSL->generateComputeShaderLinkHLSL(mState);
std::string computeShader = mDynamicHLSL->generateComputeShaderLinkHLSL(context, mState);
ShaderExecutableD3D *computeExecutable = nullptr;
ANGLE_TRY(mRenderer->compileToExecutable(infoLog, computeShader, SHADER_COMPUTE,
......@@ -1488,14 +1494,14 @@ LinkResult ProgramD3D::link(const gl::Context *context,
reset();
const gl::Shader *computeShader = mState.getAttachedComputeShader();
gl::Shader *computeShader = mState.getAttachedComputeShader();
if (computeShader)
{
mSamplersCS.resize(data.getCaps().maxComputeTextureImageUnits);
defineUniformsAndAssignRegisters();
defineUniformsAndAssignRegisters(context);
LinkResult result = compileComputeExecutable(infoLog);
LinkResult result = compileComputeExecutable(context, infoLog);
if (result.isError())
{
infoLog << result.getError().getMessage();
......@@ -1507,12 +1513,12 @@ LinkResult ProgramD3D::link(const gl::Context *context,
return result;
}
initUniformBlockInfo(computeShader);
initUniformBlockInfo(context, computeShader);
}
else
{
const gl::Shader *vertexShader = mState.getAttachedVertexShader();
const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
gl::Shader *vertexShader = mState.getAttachedVertexShader();
gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(vertexShader);
const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(fragmentShader);
......@@ -1545,16 +1551,17 @@ LinkResult ProgramD3D::link(const gl::Context *context,
ProgramD3DMetadata metadata(mRenderer, vertexShaderD3D, fragmentShaderD3D);
BuiltinVaryingsD3D builtins(metadata, packing);
mDynamicHLSL->generateShaderLinkHLSL(data, mState, metadata, packing, builtins, &mPixelHLSL,
&mVertexHLSL);
mDynamicHLSL->generateShaderLinkHLSL(context, mState, metadata, packing, builtins,
&mPixelHLSL, &mVertexHLSL);
mUsesPointSize = vertexShaderD3D->usesPointSize();
mDynamicHLSL->getPixelShaderOutputKey(data, mState, metadata, &mPixelShaderKey);
mUsesFragDepth = metadata.usesFragDepth();
// Cache if we use flat shading
mUsesFlatInterpolation = (FindFlatInterpolationVarying(fragmentShader->getVaryings()) ||
FindFlatInterpolationVarying(vertexShader->getVaryings()));
mUsesFlatInterpolation =
(FindFlatInterpolationVarying(fragmentShader->getVaryings(context)) ||
FindFlatInterpolationVarying(vertexShader->getVaryings(context)));
if (mRenderer->getMajorShaderModel() >= 4)
{
......@@ -1562,13 +1569,13 @@ LinkResult ProgramD3D::link(const gl::Context *context,
mDynamicHLSL->generateGeometryShaderPreamble(packing, builtins);
}
initAttribLocationsToD3DSemantic();
initAttribLocationsToD3DSemantic(context);
defineUniformsAndAssignRegisters();
defineUniformsAndAssignRegisters(context);
gatherTransformFeedbackVaryings(packing, builtins[SHADER_VERTEX]);
LinkResult result = compileProgramExecutables(data, infoLog);
LinkResult result = compileProgramExecutables(context, infoLog);
if (result.isError())
{
infoLog << result.getError().getMessage();
......@@ -1580,8 +1587,8 @@ LinkResult ProgramD3D::link(const gl::Context *context,
return result;
}
initUniformBlockInfo(vertexShader);
initUniformBlockInfo(fragmentShader);
initUniformBlockInfo(context, vertexShader);
initUniformBlockInfo(context, fragmentShader);
}
return true;
......@@ -1593,9 +1600,9 @@ GLboolean ProgramD3D::validate(const gl::Caps & /*caps*/, gl::InfoLog * /*infoLo
return GL_TRUE;
}
void ProgramD3D::initUniformBlockInfo(const gl::Shader *shader)
void ProgramD3D::initUniformBlockInfo(const gl::Context *context, gl::Shader *shader)
{
for (const sh::InterfaceBlock &interfaceBlock : shader->getInterfaceBlocks())
for (const sh::InterfaceBlock &interfaceBlock : shader->getInterfaceBlocks(context))
{
if (!interfaceBlock.staticUse && interfaceBlock.layout == sh::BLOCKLAYOUT_PACKED)
continue;
......@@ -1923,13 +1930,13 @@ void ProgramD3D::setUniformBlockBinding(GLuint /*uniformBlockIndex*/,
{
}
void ProgramD3D::defineUniformsAndAssignRegisters()
void ProgramD3D::defineUniformsAndAssignRegisters(const gl::Context *context)
{
D3DUniformMap uniformMap;
const gl::Shader *computeShader = mState.getAttachedComputeShader();
gl::Shader *computeShader = mState.getAttachedComputeShader();
if (computeShader)
{
for (const sh::Uniform &computeUniform : computeShader->getUniforms())
for (const sh::Uniform &computeUniform : computeShader->getUniforms(context))
{
if (computeUniform.staticUse)
{
......@@ -1939,8 +1946,8 @@ void ProgramD3D::defineUniformsAndAssignRegisters()
}
else
{
const gl::Shader *vertexShader = mState.getAttachedVertexShader();
for (const sh::Uniform &vertexUniform : vertexShader->getUniforms())
gl::Shader *vertexShader = mState.getAttachedVertexShader();
for (const sh::Uniform &vertexUniform : vertexShader->getUniforms(context))
{
if (vertexUniform.staticUse)
{
......@@ -1948,8 +1955,8 @@ void ProgramD3D::defineUniformsAndAssignRegisters()
}
}
const gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms())
gl::Shader *fragmentShader = mState.getAttachedFragmentShader();
for (const sh::Uniform &fragmentUniform : fragmentShader->getUniforms(context))
{
if (fragmentUniform.staticUse)
{
......@@ -2360,15 +2367,15 @@ unsigned int ProgramD3D::issueSerial()
return mCurrentSerial++;
}
void ProgramD3D::initAttribLocationsToD3DSemantic()
void ProgramD3D::initAttribLocationsToD3DSemantic(const gl::Context *context)
{
const gl::Shader *vertexShader = mState.getAttachedVertexShader();
gl::Shader *vertexShader = mState.getAttachedVertexShader();
ASSERT(vertexShader != nullptr);
// Init semantic index
for (const sh::Attribute &attribute : mState.getAttributes())
{
int d3dSemantic = vertexShader->getSemanticIndex(attribute.name);
int d3dSemantic = vertexShader->getSemanticIndex(context, attribute.name);
int regCount = gl::VariableRegisterCount(attribute.type);
for (int reg = 0; reg < regCount; ++reg)
......
src/libANGLE/renderer/d3d/ProgramD3D.h
......@@ -336,7 +336,7 @@ class ProgramD3D : public ProgramImpl
typedef std::map<std::string, D3DUniform *> D3DUniformMap;
void defineUniformsAndAssignRegisters();
void defineUniformsAndAssignRegisters(const gl::Context *context);
void defineUniformBase(const gl::Shader *shader,
const sh::Uniform &uniform,
D3DUniformMap *uniformMap);
......@@ -364,20 +364,20 @@ class ProgramD3D : public ProgramImpl
const GLfloat *value,
GLenum targetUniformType);
LinkResult compileProgramExecutables(const gl::ContextState &data, gl::InfoLog &infoLog);
LinkResult compileComputeExecutable(gl::InfoLog &infoLog);
LinkResult compileProgramExecutables(const gl::Context *context, gl::InfoLog &infoLog);
LinkResult compileComputeExecutable(const gl::Context *context, gl::InfoLog &infoLog);
void gatherTransformFeedbackVaryings(const gl::VaryingPacking &varyings,
const BuiltinInfo &builtins);
D3DUniform *getD3DUniformByName(const std::string &name);
D3DUniform *getD3DUniformFromLocation(GLint location);
void initAttribLocationsToD3DSemantic();
void initAttribLocationsToD3DSemantic(const gl::Context *context);
void reset();
void ensureUniformBlocksInitialized();
void initUniformBlockInfo(const gl::Shader *shader);
void initUniformBlockInfo(const gl::Context *context, gl::Shader *shader);
size_t getUniformBlockInfo(const sh::InterfaceBlock &interfaceBlock);
RendererD3D *mRenderer;
......
src/libANGLE/renderer/vulkan/ProgramVk.cpp
......@@ -67,8 +67,10 @@ LinkResult ProgramVk::link(const gl::Context *glContext,
RendererVk *renderer = context->getRenderer();
GlslangWrapper *glslangWrapper = renderer->getGlslangWrapper();
const std::string &vertexSource = mState.getAttachedVertexShader()->getTranslatedSource();
const std::string &fragmentSource = mState.getAttachedFragmentShader()->getTranslatedSource();
const std::string &vertexSource =
mState.getAttachedVertexShader()->getTranslatedSource(glContext);
const std::string &fragmentSource =
mState.getAttachedFragmentShader()->getTranslatedSource(glContext);
std::vector<uint32_t> vertexCode;
std::vector<uint32_t> fragmentCode;
......
src/libANGLE/validationES2.cpp
......@@ -3527,7 +3527,7 @@ bool ValidateProgramPathFragmentInputGen(Context *context,
if (location == -1)
return true;
const auto &binding = programObject->getFragmentInputBindingInfo(location);
const auto &binding = programObject->getFragmentInputBindingInfo(context, location);
if (!binding.valid)
{
......
src/libGLESv2/entry_points_gles_2_0_ext.cpp
......@@ -452,7 +452,7 @@ void GL_APIENTRY GetTranslatedShaderSourceANGLE(GLuint shader,
return;
}
shaderObject->getTranslatedSourceWithDebugInfo(bufsize, length, source);
shaderObject->getTranslatedSourceWithDebugInfo(context, bufsize, length, source);
}
}
......@@ -2230,7 +2230,7 @@ GetShaderivRobustANGLE(GLuint shader, GLenum pname, GLsizei bufSize, GLsizei *le
}
Shader *shaderObject = context->getShader(shader);
QueryShaderiv(shaderObject, pname, params);
QueryShaderiv(context, shaderObject, pname, params);
SetRobustLengthParam(length, numParams);
}
}
......
src/tests/test_utils/ANGLETest.cpp
......@@ -506,7 +506,7 @@ GLuint ANGLETest::compileShader(GLenum type, const std::string &source)
std::vector<GLchar> infoLog(infoLogLength);
glGetShaderInfoLog(shader, static_cast<GLsizei>(infoLog.size()), nullptr, &infoLog[0]);
std::cerr << "shader compilation failed: " << &infoLog[0];
std::cerr << "shader compilation failed: " << &infoLog[0] << std::endl;
}
glDeleteShader(shader);
......
util/shader_utils.cpp
......@@ -59,6 +59,8 @@ GLuint CompileShader(GLenum type, const std::string &source)
std::cerr << "shader compilation failed. <Empty log message>";
}
std::cerr << std::endl;
glDeleteShader(shader);
shader = 0;
}
......
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