Skip to content

A
angle
Commit c437046f by Jamie Madill
Options

Revert "Compute packed varyings in ProgramD3D only."

Likely the cause of Windows bot failures. BUG=angleproject:1123 This reverts commit 532061bb. Change-Id: Ia4f0161b97bfbf2adb4cafaa5fa5484f04fad245 Reviewed-on: https://chromium-review.googlesource.com/296710Reviewed-by: 's avatarJamie Madill <jmadill@chromium.org> Tested-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 63069dfc
Showing with 118 additions and 219 deletions
src/libANGLE/renderer/d3d/DynamicHLSL.h
......@@ -46,36 +46,14 @@ struct PixelShaderOutputVariable
size_t outputIndex;
};
struct PackedVarying
{
PackedVarying(const sh::Varying &varyingIn)
: varying(&varyingIn), registerIndex(GL_INVALID_INDEX), columnIndex(0)
{
}
bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
void resetRegisterAssignment() { registerIndex = GL_INVALID_INDEX; }
const sh::Varying *varying;
// Assigned during link
unsigned int registerIndex;
// Assigned during link, Defaults to 0
unsigned int columnIndex;
// Transform feedback varyings can be only referenced in the VS.
bool vertexOnly;
};
class DynamicHLSL : angle::NonCopyable
{
public:
explicit DynamicHLSL(RendererD3D *const renderer);
int packVaryings(gl::InfoLog &infoLog,
std::vector<PackedVarying> *packedVaryings,
ShaderD3D *fragmentShader,
ShaderD3D *vertexShader,
const std::vector<std::string> &transformFeedbackVaryings);
std::string generateVertexShaderForInputLayout(const std::string &sourceShader,
const gl::InputLayout &inputLayout,
......@@ -88,14 +66,13 @@ class DynamicHLSL : angle::NonCopyable
int registers,
std::string &pixelHLSL,
std::string &vertexHLSL,
const std::vector<PackedVarying> &packedVaryings,
std::vector<gl::LinkedVarying> *linkedVaryings,
std::vector<PixelShaderOutputVariable> *outPixelShaderKey,
bool *outUsesFragDepth) const;
std::string generateGeometryShaderHLSL(int registers,
const ShaderD3D *fragmentShader,
const std::vector<PackedVarying> &packedVaryings) const;
const ShaderD3D *vertexShader) const;
private:
RendererD3D *const mRenderer;
......@@ -106,15 +83,12 @@ class DynamicHLSL : angle::NonCopyable
SemanticInfo getSemanticInfo(int startRegisters, bool position, bool fragCoord, bool pointCoord,
bool pointSize, bool pixelShader) const;
std::string generateVaryingLinkHLSL(const SemanticInfo &info, const std::string &varyingHLSL) const;
std::string generateVaryingHLSL(const std::vector<PackedVarying> &varyings,
bool shaderUsesPointSize) const;
void storeUserLinkedVaryings(const std::vector<PackedVarying> &packedVaryings,
bool shaderUsesPointSize,
std::vector<gl::LinkedVarying> *linkedVaryings) const;
std::string generateVaryingHLSL(const ShaderD3D *shader) const;
void storeUserLinkedVaryings(const ShaderD3D *vertexShader, std::vector<gl::LinkedVarying> *linkedVaryings) const;
void storeBuiltinLinkedVaryings(const SemanticInfo &info, std::vector<gl::LinkedVarying> *linkedVaryings) const;
std::string generatePointSpriteHLSL(int registers,
const ShaderD3D *fragmentShader,
const std::vector<PackedVarying> &packedVaryings) const;
const ShaderD3D *vertexShader) const;
// Prepend an underscore
static std::string decorateVariable(const std::string &name);
......
src/libANGLE/renderer/d3d/ProgramD3D.cpp
......@@ -127,52 +127,37 @@ struct AttributeSorter
const ProgramD3D::SemanticIndexArray *originalIndices;
};
std::vector<PackedVarying> MergeVaryings(const gl::Shader &vertexShader,
const gl::Shader &fragmentShader,
const std::vector<std::string> &tfVaryings)
bool LinkVaryingRegisters(gl::InfoLog &infoLog,
ShaderD3D *vertexShaderD3D,
ShaderD3D *fragmentShaderD3D)
{
std::vector<PackedVarying> packedVaryings;
for (const sh::Varying &output : vertexShader.getVaryings())
for (PackedVarying &input : fragmentShaderD3D->getPackedVaryings())
{
bool packed = false;
bool matched = false;
// Built-in varyings obey special rules
if (output.isBuiltIn())
if (input.varying->isBuiltIn())
{
continue;
}
for (const sh::Varying &input : fragmentShader.getVaryings())
for (PackedVarying &output : vertexShaderD3D->getPackedVaryings())
{
if (output.name == input.name)
if (output.varying->name == input.varying->name)
{
packedVaryings.push_back(PackedVarying(input));
packed = true;
break;
}
}
output.registerIndex = input.registerIndex;
output.columnIndex = input.columnIndex;
// Keep Transform FB varyings in the merged list always.
if (!packed)
{
for (const std::string &tfVarying : tfVaryings)
{
if (tfVarying == output.name)
{
packedVaryings.push_back(PackedVarying(output));
packedVaryings.back().vertexOnly = true;
packed = true;
break;
}
matched = true;
break;
}
}
// We permit unreferenced varyings
ASSERT(packed || !output.staticUse);
// We permit unmatched, unreferenced varyings
ASSERT(matched || !input.varying->staticUse);
}
return packedVaryings;
return true;
}
} // anonymous namespace
......@@ -1063,10 +1048,9 @@ gl::Error ProgramD3D::getVertexExecutableForInputLayout(const gl::InputLayout &i
return gl::Error(GL_NO_ERROR);
}
LinkResult ProgramD3D::compileProgramExecutables(gl::InfoLog &infoLog,
int registers,
const std::vector<PackedVarying> &packedVaryings)
LinkResult ProgramD3D::compileProgramExecutables(gl::InfoLog &infoLog, int registers)
{
const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(mData.getAttachedVertexShader());
const ShaderD3D *fragmentShaderD3D = GetImplAs<ShaderD3D>(mData.getAttachedFragmentShader());
const gl::InputLayout &defaultInputLayout =
......@@ -1088,8 +1072,7 @@ LinkResult ProgramD3D::compileProgramExecutables(gl::InfoLog &infoLog,
if (usesGeometryShader())
{
std::string geometryHLSL =
mDynamicHLSL->generateGeometryShaderHLSL(registers, fragmentShaderD3D, packedVaryings);
std::string geometryHLSL = mDynamicHLSL->generateGeometryShaderHLSL(registers, fragmentShaderD3D, vertexShaderD3D);
error = mRenderer->compileToExecutable(
infoLog, geometryHLSL, SHADER_GEOMETRY, mTransformFeedbackLinkedVaryings,
......@@ -1102,8 +1085,6 @@ LinkResult ProgramD3D::compileProgramExecutables(gl::InfoLog &infoLog,
}
#if ANGLE_SHADER_DEBUG_INFO == ANGLE_ENABLED
const ShaderD3D *vertexShaderD3D = GetImplAs<ShaderD3D>(mData.getAttachedVertexShader());
if (usesGeometryShader() && mGeometryExecutable)
{
// Geometry shaders are currently only used internally, so there is no corresponding shader object at the interface level
......@@ -1155,11 +1136,8 @@ LinkResult ProgramD3D::link(const gl::Data &data,
}
}
std::vector<PackedVarying> packedVaryings =
MergeVaryings(*vertexShader, *fragmentShader, mData.getTransformFeedbackVaryingNames());
// Map the varyings to the register file
int registers = mDynamicHLSL->packVaryings(infoLog, &packedVaryings,
int registers = mDynamicHLSL->packVaryings(infoLog, fragmentShaderD3D, vertexShaderD3D,
mData.getTransformFeedbackVaryingNames());
if (registers < 0)
......@@ -1167,10 +1145,12 @@ LinkResult ProgramD3D::link(const gl::Data &data,
return LinkResult(false, gl::Error(GL_NO_ERROR));
}
LinkVaryingRegisters(infoLog, vertexShaderD3D, fragmentShaderD3D);
std::vector<gl::LinkedVarying> linkedVaryings;
if (!mDynamicHLSL->generateShaderLinkHLSL(data, mData, infoLog, registers, mPixelHLSL,
mVertexHLSL, packedVaryings, &linkedVaryings,
&mPixelShaderKey, &mUsesFragDepth))
mVertexHLSL, &linkedVaryings, &mPixelShaderKey,
&mUsesFragDepth))
{
return LinkResult(false, gl::Error(GL_NO_ERROR));
}
......@@ -1188,7 +1168,7 @@ LinkResult ProgramD3D::link(const gl::Data &data,
gatherTransformFeedbackVaryings(linkedVaryings);
LinkResult result = compileProgramExecutables(infoLog, registers, packedVaryings);
LinkResult result = compileProgramExecutables(infoLog, registers);
if (result.error.isError() || !result.linkSuccess)
{
infoLog << "Failed to create D3D shaders.";
......
src/libANGLE/renderer/d3d/ProgramD3D.h
......@@ -207,9 +207,7 @@ class ProgramD3D : public ProgramImpl
sh::BlockLayoutEncoder *encoder, std::vector<unsigned int> *blockUniformIndexes,
bool inRowMajorLayout);
LinkResult compileProgramExecutables(gl::InfoLog &infoLog,
int registers,
const std::vector<PackedVarying> &packedVaryings);
LinkResult compileProgramExecutables(gl::InfoLog &infoLog, int registers);
void gatherTransformFeedbackVaryings(const std::vector<gl::LinkedVarying> &varyings);
......
src/libANGLE/renderer/d3d/ShaderD3D.cpp
......@@ -110,6 +110,11 @@ void ShaderD3D::parseVaryings(ShHandle compiler)
mVaryings = *varyings;
for (size_t varyingIndex = 0; varyingIndex < varyings->size(); varyingIndex++)
{
mPackedVaryings.push_back(PackedVarying(mVaryings[varyingIndex]));
}
mUsesMultipleRenderTargets = mTranslatedSource.find("GL_USES_MRT") != std::string::npos;
mUsesFragColor = mTranslatedSource.find("GL_USES_FRAG_COLOR") != std::string::npos;
mUsesFragData = mTranslatedSource.find("GL_USES_FRAG_DATA") != std::string::npos;
......@@ -126,6 +131,14 @@ void ShaderD3D::parseVaryings(ShHandle compiler)
}
}
void ShaderD3D::resetVaryingsRegisterAssignment()
{
for (size_t varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
{
mPackedVaryings[varyingIndex].resetRegisterAssignment();
}
}
// initialize/clean up previous state
void ShaderD3D::uncompile()
{
......
src/libANGLE/renderer/d3d/ShaderD3D.h
......@@ -20,6 +20,24 @@ namespace rx
class DynamicHLSL;
class RendererD3D;
struct PackedVarying
{
PackedVarying(const sh::Varying &varyingIn)
: varying(&varyingIn), registerIndex(GL_INVALID_INDEX), columnIndex(0)
{
}
bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
void resetRegisterAssignment() { registerIndex = GL_INVALID_INDEX; }
const sh::Varying *varying;
// TODO(jmadill): Make these D3D-only or otherwise clearly separate from GL.
unsigned int registerIndex; // Assigned during link
unsigned int columnIndex; // Assigned during link, defaults to 0
};
class ShaderD3D : public ShaderImpl
{
friend class DynamicHLSL;
......@@ -33,6 +51,7 @@ class ShaderD3D : public ShaderImpl
// D3D-specific methods
virtual void uncompile();
void resetVaryingsRegisterAssignment();
unsigned int getUniformRegister(const std::string &uniformName) const;
unsigned int getInterfaceBlockRegister(const std::string &blockName) const;
void appendDebugInfo(const std::string &info) { mDebugInfo += info; }
......@@ -49,6 +68,11 @@ class ShaderD3D : public ShaderImpl
virtual bool compile(gl::Compiler *compiler, const std::string &source);
const std::vector<PackedVarying> &getPackedVaryings() const { return mPackedVaryings; }
// TODO(jmadill): remove this
std::vector<PackedVarying> &getPackedVaryings() { return mPackedVaryings; }
private:
void compileToHLSL(ShHandle compiler, const std::string &source);
void parseVaryings(ShHandle compiler);
......@@ -76,6 +100,7 @@ class ShaderD3D : public ShaderImpl
std::map<std::string, unsigned int> mUniformRegisterMap;
std::map<std::string, unsigned int> mInterfaceBlockRegisterMap;
RendererD3D *mRenderer;
std::vector<PackedVarying> mPackedVaryings;
};
}
......
src/tests/gl_tests/TransformFeedbackTest.cpp
......@@ -264,71 +264,6 @@ TEST_P(TransformFeedbackTest, BufferBinding)
glDeleteBuffers(1, &scratchBuffer);
}
// Test that we can capture varyings only used in the vertex shader.
TEST_P(TransformFeedbackTest, VertexOnly)
{
const std::string &vertexShaderSource =
"#version 300 es\n"
"in vec2 position;\n"
"in float attrib;\n"
"out float varyingAttrib;\n"
"void main() {\n"
" gl_Position = vec4(position, 0, 1);\n"
" varyingAttrib = attrib;\n"
"}";
const std::string &fragmentShaderSource =
"#version 300 es\n"
"out mediump vec4 color;\n"
"void main() {\n"
" color = vec4(0.0, 1.0, 0.0, 1.0);\n"
"}";
std::vector<std::string> tfVaryings;
tfVaryings.push_back("varyingAttrib");
GLuint program = CompileProgramWithTransformFeedback(vertexShaderSource, fragmentShaderSource,
tfVaryings, GL_INTERLEAVED_ATTRIBS);
ASSERT_NE(0u, program);
GLuint transformFeedback;
glGenTransformFeedbacks(1, &transformFeedback);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, mTransformFeedbackBuffer);
std::vector<float> attribData;
for (unsigned int cnt = 0; cnt < 100; ++cnt)
{
attribData.push_back(static_cast<float>(cnt));
}
GLint attribLocation = glGetAttribLocation(program, "attrib");
ASSERT_NE(-1, attribLocation);
glVertexAttribPointer(attribLocation, 1, GL_FLOAT, GL_FALSE, 4, &attribData[0]);
glEnableVertexAttribArray(attribLocation);
glBeginTransformFeedback(GL_TRIANGLES);
drawQuad(program, "position", 0.5f);
glEndTransformFeedback();
ASSERT_GL_NO_ERROR();
GLvoid *mappedBuffer =
glMapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, sizeof(float) * 6, GL_MAP_READ_BIT);
ASSERT_NE(nullptr, mappedBuffer);
float *mappedFloats = static_cast<float *>(mappedBuffer);
for (unsigned int cnt = 0; cnt < 6; ++cnt)
{
EXPECT_EQ(attribData[cnt], mappedFloats[cnt]);
}
glDeleteTransformFeedbacks(1, &transformFeedback);
glDeleteProgram(program);
EXPECT_GL_NO_ERROR();
}
// Use this to select which configurations (e.g. which renderer, which GLES major version) these tests should be run against.
ANGLE_INSTANTIATE_TEST(TransformFeedbackTest, ES3_D3D11());
......
util/shader_utils.cpp
......@@ -69,11 +69,7 @@ GLuint CompileShaderFromFile(GLenum type, const std::string &sourcePath)
return CompileShader(type, source);
}
GLuint CompileProgramWithTransformFeedback(
const std::string &vsSource,
const std::string &fsSource,
const std::vector<std::string> &transformFeedbackVaryings,
GLenum bufferMode)
GLuint CompileProgram(const std::string &vsSource, const std::string &fsSource)
{
GLuint program = glCreateProgram();
......@@ -94,19 +90,6 @@ GLuint CompileProgramWithTransformFeedback(
glAttachShader(program, fs);
glDeleteShader(fs);
if (transformFeedbackVaryings.size() > 0)
{
std::vector<const char *> constCharTFVaryings;
for (const std::string &transformFeedbackVarying : transformFeedbackVaryings)
{
constCharTFVaryings.push_back(transformFeedbackVarying.c_str());
}
glTransformFeedbackVaryings(program, static_cast<GLsizei>(transformFeedbackVaryings.size()),
&constCharTFVaryings[0], bufferMode);
}
glLinkProgram(program);
GLint linkStatus;
......@@ -129,12 +112,6 @@ GLuint CompileProgramWithTransformFeedback(
return program;
}
GLuint CompileProgram(const std::string &vsSource, const std::string &fsSource)
{
std::vector<std::string> emptyVector;
return CompileProgramWithTransformFeedback(vsSource, fsSource, emptyVector, GL_NONE);
}
GLuint CompileProgramFromFiles(const std::string &vsPath, const std::string &fsPath)
{
std::string vsSource = ReadFileToString(vsPath);
......
util/shader_utils.h
......@@ -17,18 +17,12 @@
#include <EGL/eglext.h>
#include <string>
#include <vector>
#define SHADER_SOURCE(...) #__VA_ARGS__
GLuint CompileShader(GLenum type, const std::string &source);
GLuint CompileShaderFromFile(GLenum type, const std::string &sourcePath);
GLuint CompileProgramWithTransformFeedback(
const std::string &vsSource,
const std::string &fsSource,
const std::vector<std::string> &transformFeedbackVaryings,
GLenum bufferMode);
GLuint CompileProgram(const std::string &vsSource, const std::string &fsSource);
GLuint CompileProgramFromFiles(const std::string &vsPath, const std::string &fsPath);
......
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