Skip to content

A
angle
Commit 4cff2477 by Jamie Madill
Options

Make PackedVarying a D3D-only type.

The register assignment stuff only applies to the D3D back-end. Cleans up the GL back-ends use of PackedVarying, and will lead to future cleanups relating to packing varyings. BUG=angleproject:1123 Change-Id: Iaaa5fc03577e5b61ea6ae76ee1e15ad608037f34 Reviewed-on: https://chromium-review.googlesource.com/295190Reviewed-by: 's avatarCorentin Wallez <cwallez@chromium.org> Reviewed-by: 's avatarGeoff Lang <geofflang@chromium.org> Tested-by: 's avatarJamie Madill <jmadill@chromium.org>
parent 401d9fe6
Showing with 251 additions and 218 deletions
src/libANGLE/Program.cpp
......@@ -1204,10 +1204,10 @@ bool Program::linkVaryings(InfoLog &infoLog,
const Shader *vertexShader,
const Shader *fragmentShader)
{
const std::vector<PackedVarying> &vertexVaryings = vertexShader->getVaryings();
const std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
const std::vector<sh::Varying> &vertexVaryings = vertexShader->getVaryings();
const std::vector<sh::Varying> &fragmentVaryings = fragmentShader->getVaryings();
for (const PackedVarying &output : fragmentVaryings)
for (const sh::Varying &output : fragmentVaryings)
{
bool matched = false;
......@@ -1217,7 +1217,7 @@ bool Program::linkVaryings(InfoLog &infoLog,
continue;
}
for (const PackedVarying &input : vertexVaryings)
for (const sh::Varying &input : vertexVaryings)
{
if (output.name == input.name)
{
......
src/libANGLE/Shader.cpp
......@@ -174,7 +174,7 @@ int Shader::getShaderVersion() const
return mShader->getShaderVersion();
}
const std::vector<gl::PackedVarying> &Shader::getVaryings() const
const std::vector<sh::Varying> &Shader::getVaryings() const
{
return mShader->getVaryings();
}
......@@ -199,7 +199,7 @@ const std::vector<sh::Attribute> &Shader::getActiveOutputVariables() const
return mShader->getActiveOutputVariables();
}
std::vector<gl::PackedVarying> &Shader::getVaryings()
std::vector<sh::Varying> &Shader::getVaryings()
{
return mShader->getVaryings();
}
......
src/libANGLE/Shader.h
......@@ -33,26 +33,6 @@ class Compiler;
class ResourceManager;
struct Data;
struct PackedVarying : public sh::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
PackedVarying(const sh::Varying &varying)
: sh::Varying(varying),
registerIndex(GL_INVALID_INDEX),
columnIndex(0)
{}
bool registerAssigned() const { return registerIndex != GL_INVALID_INDEX; }
void resetRegisterAssignment()
{
registerIndex = GL_INVALID_INDEX;
}
};
class Shader : angle::NonCopyable
{
public:
......@@ -87,13 +67,13 @@ class Shader : angle::NonCopyable
int getShaderVersion() const;
const std::vector<gl::PackedVarying> &getVaryings() const;
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::Attribute> &getActiveOutputVariables() const;
std::vector<gl::PackedVarying> &getVaryings();
std::vector<sh::Varying> &getVaryings();
std::vector<sh::Uniform> &getUniforms();
std::vector<sh::InterfaceBlock> &getInterfaceBlocks();
std::vector<sh::Attribute> &getActiveAttributes();
......
src/libANGLE/renderer/ShaderImpl.h
......@@ -31,13 +31,13 @@ class ShaderImpl : angle::NonCopyable
int getShaderVersion() const { return mShaderVersion; }
const std::vector<gl::PackedVarying> &getVaryings() const { return mVaryings; }
const std::vector<sh::Varying> &getVaryings() const { return mVaryings; }
const std::vector<sh::Uniform> &getUniforms() const { return mUniforms; }
const std::vector<sh::InterfaceBlock> &getInterfaceBlocks() const { return mInterfaceBlocks; }
const std::vector<sh::Attribute> &getActiveAttributes() const { return mActiveAttributes; }
const std::vector<sh::Attribute> &getActiveOutputVariables() const { return mActiveOutputVariables; }
std::vector<gl::PackedVarying> &getVaryings() { return mVaryings; }
std::vector<sh::Varying> &getVaryings() { return mVaryings; }
std::vector<sh::Uniform> &getUniforms() { return mUniforms; }
std::vector<sh::InterfaceBlock> &getInterfaceBlocks() { return mInterfaceBlocks; }
std::vector<sh::Attribute> &getActiveAttributes() { return mActiveAttributes; }
......@@ -50,7 +50,7 @@ class ShaderImpl : angle::NonCopyable
// TODO(jmadill): make part of shared non-Impl state
int mShaderVersion;
std::vector<gl::PackedVarying> mVaryings;
std::vector<sh::Varying> mVaryings;
std::vector<sh::Uniform> mUniforms;
std::vector<sh::InterfaceBlock> mInterfaceBlocks;
std::vector<sh::Attribute> mActiveAttributes;
......
src/libANGLE/renderer/d3d/DynamicHLSL.cpp
......@@ -86,31 +86,25 @@ const PixelShaderOutputVariable *FindOutputAtLocation(const std::vector<PixelSha
return NULL;
}
const std::string VERTEX_ATTRIBUTE_STUB_STRING = "@@ VERTEX ATTRIBUTES @@";
const std::string PIXEL_OUTPUT_STUB_STRING = "@@ PIXEL OUTPUT @@";
}
DynamicHLSL::DynamicHLSL(RendererD3D *const renderer)
: mRenderer(renderer)
{
}
typedef const PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
static bool packVarying(PackedVarying *varying, const int maxVaryingVectors, VaryingPacking packing)
bool PackVarying(PackedVarying *packedVarying, const int maxVaryingVectors, VaryingPacking &packing)
{
// Make sure we use transposed matrix types to count registers correctly.
int registers = 0;
int elements = 0;
if (varying->isStruct())
const sh::Varying &varying = *packedVarying->varying;
if (varying.isStruct())
{
registers = HLSLVariableRegisterCount(*varying, true) * varying->elementCount();
registers = HLSLVariableRegisterCount(varying, true) * varying.elementCount();
elements = 4;
}
else
{
GLenum transposedType = TransposeMatrixType(varying->type);
registers = VariableRowCount(transposedType) * varying->elementCount();
GLenum transposedType = TransposeMatrixType(varying.type);
registers = VariableRowCount(transposedType) * varying.elementCount();
elements = VariableColumnCount(transposedType);
}
......@@ -133,14 +127,14 @@ static bool packVarying(PackedVarying *varying, const int maxVaryingVectors, Var
if (available)
{
varying->registerIndex = r;
varying->columnIndex = 0;
packedVarying->registerIndex = r;
packedVarying->columnIndex = 0;
for (int y = 0; y < registers; y++)
{
for (int x = 0; x < elements; x++)
{
packing[r + y][x] = &*varying;
packing[r + y][x] = packedVarying;
}
}
......@@ -167,14 +161,14 @@ static bool packVarying(PackedVarying *varying, const int maxVaryingVectors, Var
if (available)
{
varying->registerIndex = r;
varying->columnIndex = 2;
packedVarying->registerIndex = r;
packedVarying->columnIndex = 2;
for (int y = 0; y < registers; y++)
{
for (int x = 2; x < 4; x++)
{
packing[r + y][x] = &*varying;
packing[r + y][x] = packedVarying;
}
}
......@@ -211,12 +205,12 @@ static bool packVarying(PackedVarying *varying, const int maxVaryingVectors, Var
{
if (!packing[r][column])
{
varying->registerIndex = r;
varying->columnIndex = column;
packedVarying->registerIndex = r;
packedVarying->columnIndex = column;
for (int y = r; y < r + registers; y++)
{
packing[y][column] = &*varying;
packing[y][column] = packedVarying;
}
break;
......@@ -231,38 +225,51 @@ static bool packVarying(PackedVarying *varying, const int maxVaryingVectors, Var
return false;
}
const std::string VERTEX_ATTRIBUTE_STUB_STRING = "@@ VERTEX ATTRIBUTES @@";
const std::string PIXEL_OUTPUT_STUB_STRING = "@@ PIXEL OUTPUT @@";
}
DynamicHLSL::DynamicHLSL(RendererD3D *const renderer) : mRenderer(renderer)
{
}
// Packs varyings into generic varying registers, using the algorithm from [OpenGL ES Shading Language 1.00 rev. 17] appendix A section 7 page 111
// Returns the number of used varying registers, or -1 if unsuccesful
int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, ShaderD3D *fragmentShader,
ShaderD3D *vertexShader, const std::vector<std::string> &transformFeedbackVaryings)
int DynamicHLSL::packVaryings(InfoLog &infoLog,
ShaderD3D *fragmentShader,
ShaderD3D *vertexShader,
const std::vector<std::string> &transformFeedbackVaryings)
{
// TODO (geofflang): Use context's caps
const int maxVaryingVectors = mRenderer->getRendererCaps().maxVaryingVectors;
VaryingPacking packing = {};
vertexShader->resetVaryingsRegisterAssignment();
fragmentShader->resetVaryingsRegisterAssignment();
std::set<std::string> packedVaryings;
std::vector<gl::PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
std::vector<gl::PackedVarying> &vertexVaryings = vertexShader->getVaryings();
std::vector<PackedVarying> &vertexVaryings = vertexShader->getPackedVaryings();
std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getPackedVaryings();
for (unsigned int varyingIndex = 0; varyingIndex < fragmentVaryings.size(); varyingIndex++)
{
PackedVarying *varying = &fragmentVaryings[varyingIndex];
PackedVarying *packedVarying = &fragmentVaryings[varyingIndex];
const sh::Varying &varying = *packedVarying->varying;
// Do not assign registers to built-in or unreferenced varyings
if (varying->isBuiltIn() || !varying->staticUse)
if (varying.isBuiltIn() || !varying.staticUse)
{
continue;
}
if (packVarying(varying, maxVaryingVectors, packing))
if (PackVarying(packedVarying, maxVaryingVectors, packing))
{
packedVaryings.insert(varying->name);
packedVaryings.insert(varying.name);
}
else
{
infoLog << "Could not pack varying " << varying->name;
infoLog << "Could not pack varying " << varying.name;
return -1;
}
}
......@@ -282,12 +289,13 @@ int DynamicHLSL::packVaryings(InfoLog &infoLog, VaryingPacking packing, ShaderD3
bool found = false;
for (unsigned int varyingIndex = 0; varyingIndex < vertexVaryings.size(); varyingIndex++)
{
PackedVarying *varying = &vertexVaryings[varyingIndex];
if (transformFeedbackVarying == varying->name)
PackedVarying *packedVarying = &vertexVaryings[varyingIndex];
const sh::Varying &varying = *packedVarying->varying;
if (transformFeedbackVarying == varying.name)
{
if (!packVarying(varying, maxVaryingVectors, packing))
if (!PackVarying(packedVarying, maxVaryingVectors, packing))
{
infoLog << "Could not pack varying " << varying->name;
infoLog << "Could not pack varying " << varying.name;
return -1;
}
......@@ -325,53 +333,67 @@ std::string DynamicHLSL::generateVaryingHLSL(const ShaderD3D *shader) const
std::string varyingSemantic = getVaryingSemantic(shader->mUsesPointSize);
std::string varyingHLSL;
const std::vector<gl::PackedVarying> &varyings = shader->getVaryings();
const std::vector<PackedVarying> &varyings = shader->getPackedVaryings();
for (unsigned int varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
for (const PackedVarying &packedVarying : varyings)
{
const PackedVarying &varying = varyings[varyingIndex];
if (varying.registerAssigned())
if (!packedVarying.registerAssigned())
{
ASSERT(!varying.isBuiltIn());
GLenum transposedType = TransposeMatrixType(varying.type);
int variableRows = (varying.isStruct() ? 1 : VariableRowCount(transposedType));
continue;
}
const sh::Varying &varying = *packedVarying.varying;
ASSERT(!varying.isBuiltIn());
GLenum transposedType = TransposeMatrixType(varying.type);
int variableRows = (varying.isStruct() ? 1 : VariableRowCount(transposedType));
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
{
for (int row = 0; row < variableRows; row++)
{
for (int row = 0; row < variableRows; row++)
// TODO: Add checks to ensure D3D interpolation modifiers don't result in too many
// registers being used.
// For example, if there are N registers, and we have N vec3 varyings and 1 float
// varying, then D3D will pack them into N registers.
// If the float varying has the 'nointerpolation' modifier on it then we would need
// N + 1 registers, and D3D compilation will fail.
switch (varying.interpolation)
{
// TODO: Add checks to ensure D3D interpolation modifiers don't result in too many registers being used.
// For example, if there are N registers, and we have N vec3 varyings and 1 float varying, then D3D will pack them into N registers.
// If the float varying has the 'nointerpolation' modifier on it then we would need N + 1 registers, and D3D compilation will fail.
switch (varying.interpolation)
{
case sh::INTERPOLATION_SMOOTH: varyingHLSL += " "; break;
case sh::INTERPOLATION_FLAT: varyingHLSL += " nointerpolation "; break;
case sh::INTERPOLATION_CENTROID: varyingHLSL += " centroid "; break;
default: UNREACHABLE();
}
case sh::INTERPOLATION_SMOOTH:
varyingHLSL += " ";
break;
case sh::INTERPOLATION_FLAT:
varyingHLSL += " nointerpolation ";
break;
case sh::INTERPOLATION_CENTROID:
varyingHLSL += " centroid ";
break;
default:
UNREACHABLE();
}
unsigned int semanticIndex = elementIndex * variableRows +
varying.columnIndex * mRenderer->getRendererCaps().maxVaryingVectors +
varying.registerIndex + row;
std::string n = Str(semanticIndex);
unsigned int semanticIndex =
elementIndex * variableRows +
packedVarying.columnIndex * mRenderer->getRendererCaps().maxVaryingVectors +
packedVarying.registerIndex + row;
std::string n = Str(semanticIndex);
std::string typeString;
std::string typeString;
if (varying.isStruct())
{
// TODO(jmadill): pass back translated name from the shader translator
typeString = decorateVariable(varying.structName);
}
else
{
GLenum componentType = VariableComponentType(transposedType);
int columnCount = VariableColumnCount(transposedType);
typeString = HLSLComponentTypeString(componentType, columnCount);
}
varyingHLSL += typeString + " v" + n + " : " + varyingSemantic + n + ";\n";
if (varying.isStruct())
{
// TODO(jmadill): pass back translated name from the shader translator
typeString = decorateVariable(varying.structName);
}
else
{
GLenum componentType = VariableComponentType(transposedType);
int columnCount = VariableColumnCount(transposedType);
typeString = HLSLComponentTypeString(componentType, columnCount);
}
varyingHLSL += typeString + " v" + n + " : " + varyingSemantic + n + ";\n";
}
}
}
......@@ -717,21 +739,20 @@ void DynamicHLSL::storeUserLinkedVaryings(const ShaderD3D *vertexShader,
std::vector<LinkedVarying> *linkedVaryings) const
{
const std::string &varyingSemantic = getVaryingSemantic(vertexShader->mUsesPointSize);
const std::vector<PackedVarying> &varyings = vertexShader->getVaryings();
for (unsigned int varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
for (const PackedVarying &packedVarying : vertexShader->getPackedVaryings())
{
const PackedVarying &varying = varyings[varyingIndex];
if (varying.registerAssigned())
if (packedVarying.registerAssigned())
{
const sh::Varying &varying = *packedVarying.varying;
ASSERT(!varying.isBuiltIn());
GLenum transposedType = TransposeMatrixType(varying.type);
int variableRows = (varying.isStruct() ? 1 : VariableRowCount(transposedType));
linkedVaryings->push_back(LinkedVarying(varying.name, varying.type, varying.elementCount(),
varyingSemantic, varying.registerIndex,
variableRows * varying.elementCount()));
linkedVaryings->push_back(
LinkedVarying(varying.name, varying.type, varying.elementCount(), varyingSemantic,
packedVarying.registerIndex, variableRows * varying.elementCount()));
}
}
}
......@@ -740,7 +761,6 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
const gl::Program::Data &programData,
InfoLog &infoLog,
int registers,
const VaryingPacking packing,
std::string &pixelHLSL,
std::string &vertexHLSL,
std::vector<LinkedVarying> *linkedVaryings,
......@@ -861,35 +881,41 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
vertexHLSL += " output.gl_FragCoord = gl_Position;\n";
}
const std::vector<PackedVarying> &vertexVaryings = vertexShader->getVaryings();
for (unsigned int vertVaryingIndex = 0; vertVaryingIndex < vertexVaryings.size(); vertVaryingIndex++)
const std::vector<PackedVarying> &vertexVaryings = vertexShader->getPackedVaryings();
for (const PackedVarying &packedVarying : vertexVaryings)
{
const PackedVarying &varying = vertexVaryings[vertVaryingIndex];
if (varying.registerAssigned())
if (!packedVarying.registerAssigned())
{
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
{
int variableRows = (varying.isStruct() ? 1 : VariableRowCount(TransposeMatrixType(varying.type)));
continue;
}
for (int row = 0; row < variableRows; row++)
{
int r = varying.registerIndex + varying.columnIndex * data.caps->maxVaryingVectors + elementIndex * variableRows + row;
vertexHLSL += " output.v" + Str(r);
const sh::Varying &varying = *packedVarying.varying;
vertexHLSL += " = _" + varying.name;
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
{
int variableRows =
(varying.isStruct() ? 1 : VariableRowCount(TransposeMatrixType(varying.type)));
if (varying.isArray())
{
vertexHLSL += ArrayString(elementIndex);
}
for (int row = 0; row < variableRows; row++)
{
int r = packedVarying.registerIndex +
packedVarying.columnIndex * data.caps->maxVaryingVectors +
elementIndex * variableRows + row;
vertexHLSL += " output.v" + Str(r);
if (variableRows > 1)
{
vertexHLSL += ArrayString(row);
}
vertexHLSL += " = _" + varying.name;
vertexHLSL += ";\n";
if (varying.isArray())
{
vertexHLSL += ArrayString(elementIndex);
}
if (variableRows > 1)
{
vertexHLSL += ArrayString(row);
}
vertexHLSL += ";\n";
}
}
}
......@@ -1025,54 +1051,66 @@ bool DynamicHLSL::generateShaderLinkHLSL(const gl::Data &data,
}
}
const std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getVaryings();
for (unsigned int varyingIndex = 0; varyingIndex < fragmentVaryings.size(); varyingIndex++)
const std::vector<PackedVarying> &fragmentVaryings = fragmentShader->getPackedVaryings();
for (const PackedVarying &packedVarying : fragmentVaryings)
{
const PackedVarying &varying = fragmentVaryings[varyingIndex];
if (varying.registerAssigned())
const sh::Varying &varying = *packedVarying.varying;
if (!packedVarying.registerAssigned())
{
ASSERT(!varying.isBuiltIn());
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
ASSERT(varying.isBuiltIn() || !varying.staticUse);
continue;
}
ASSERT(!varying.isBuiltIn());
for (unsigned int elementIndex = 0; elementIndex < varying.elementCount(); elementIndex++)
{
GLenum transposedType = TransposeMatrixType(varying.type);
int variableRows = (varying.isStruct() ? 1 : VariableRowCount(transposedType));
for (int row = 0; row < variableRows; row++)
{
GLenum transposedType = TransposeMatrixType(varying.type);
int variableRows = (varying.isStruct() ? 1 : VariableRowCount(transposedType));
for (int row = 0; row < variableRows; row++)
{
std::string n = Str(varying.registerIndex + varying.columnIndex * data.caps->maxVaryingVectors + elementIndex * variableRows + row);
pixelHLSL += " _" + varying.name;
std::string n = Str(packedVarying.registerIndex +
packedVarying.columnIndex * data.caps->maxVaryingVectors +
elementIndex * variableRows + row);
pixelHLSL += " _" + varying.name;
if (varying.isArray())
{
pixelHLSL += ArrayString(elementIndex);
}
if (varying.isArray())
{
pixelHLSL += ArrayString(elementIndex);
}
if (variableRows > 1)
{
pixelHLSL += ArrayString(row);
}
if (variableRows > 1)
{
pixelHLSL += ArrayString(row);
}
if (varying.isStruct())
{
pixelHLSL += " = input.v" + n + ";\n"; break;
}
else
if (varying.isStruct())
{
pixelHLSL += " = input.v" + n + ";\n";
break;
}
else
{
switch (VariableColumnCount(transposedType))
{
switch (VariableColumnCount(transposedType))
{
case 1: pixelHLSL += " = input.v" + n + ".x;\n"; break;
case 2: pixelHLSL += " = input.v" + n + ".xy;\n"; break;
case 3: pixelHLSL += " = input.v" + n + ".xyz;\n"; break;
case 4: pixelHLSL += " = input.v" + n + ";\n"; break;
default: UNREACHABLE();
}
case 1:
pixelHLSL += " = input.v" + n + ".x;\n";
break;
case 2:
pixelHLSL += " = input.v" + n + ".xy;\n";
break;
case 3:
pixelHLSL += " = input.v" + n + ".xyz;\n";
break;
case 4:
pixelHLSL += " = input.v" + n + ";\n";
break;
default:
UNREACHABLE();
}
}
}
}
else
{
ASSERT(varying.isBuiltIn() || !varying.staticUse);
}
}
if (fragmentShader->usesDeferredInit())
......
src/libANGLE/renderer/d3d/DynamicHLSL.h
......@@ -30,7 +30,6 @@ class InfoLog;
struct VariableLocation;
struct LinkedVarying;
struct VertexAttribute;
struct PackedVarying;
struct Data;
}
......@@ -39,8 +38,6 @@ namespace rx
class RendererD3D;
class ShaderD3D;
typedef const gl::PackedVarying *VaryingPacking[gl::IMPLEMENTATION_MAX_VARYING_VECTORS][4];
struct PixelShaderOutputVariable
{
GLenum type;
......@@ -54,8 +51,10 @@ class DynamicHLSL : angle::NonCopyable
public:
explicit DynamicHLSL(RendererD3D *const renderer);
int packVaryings(gl::InfoLog &infoLog, VaryingPacking packing, ShaderD3D *fragmentShader,
ShaderD3D *vertexShader, const std::vector<std::string>& transformFeedbackVaryings);
int packVaryings(gl::InfoLog &infoLog,
ShaderD3D *fragmentShader,
ShaderD3D *vertexShader,
const std::vector<std::string> &transformFeedbackVaryings);
std::string generateVertexShaderForInputLayout(const std::string &sourceShader,
const gl::InputLayout &inputLayout,
const std::vector<sh::Attribute> &shaderAttributes) const;
......@@ -65,7 +64,6 @@ class DynamicHLSL : angle::NonCopyable
const gl::Program::Data &programData,
gl::InfoLog &infoLog,
int registers,
const VaryingPacking packing,
std::string &pixelHLSL,
std::string &vertexHLSL,
std::vector<gl::LinkedVarying> *linkedVaryings,
......
src/libANGLE/renderer/d3d/ProgramD3D.cpp
......@@ -131,19 +131,19 @@ bool LinkVaryingRegisters(gl::InfoLog &infoLog,
ShaderD3D *vertexShaderD3D,
ShaderD3D *fragmentShaderD3D)
{
for (gl::PackedVarying &input : fragmentShaderD3D->getVaryings())
for (PackedVarying &input : fragmentShaderD3D->getPackedVaryings())
{
bool matched = false;
// Built-in varyings obey special rules
if (input.isBuiltIn())
if (input.varying->isBuiltIn())
{
continue;
}
for (gl::PackedVarying &output : vertexShaderD3D->getVaryings())
for (PackedVarying &output : vertexShaderD3D->getPackedVaryings())
{
if (output.name == input.name)
if (output.varying->name == input.varying->name)
{
output.registerIndex = input.registerIndex;
output.columnIndex = input.columnIndex;
......@@ -154,7 +154,7 @@ bool LinkVaryingRegisters(gl::InfoLog &infoLog,
}
// We permit unmatched, unreferenced varyings
ASSERT(matched || !input.staticUse);
ASSERT(matched || !input.varying->staticUse);
}
return true;
......@@ -1137,8 +1137,7 @@ LinkResult ProgramD3D::link(const gl::Data &data,
}
// Map the varyings to the register file
VaryingPacking packing = {};
int registers = mDynamicHLSL->packVaryings(infoLog, packing, fragmentShaderD3D, vertexShaderD3D,
int registers = mDynamicHLSL->packVaryings(infoLog, fragmentShaderD3D, vertexShaderD3D,
mData.getTransformFeedbackVaryingNames());
if (registers < 0)
......@@ -1149,7 +1148,7 @@ LinkResult ProgramD3D::link(const gl::Data &data,
LinkVaryingRegisters(infoLog, vertexShaderD3D, fragmentShaderD3D);
std::vector<gl::LinkedVarying> linkedVaryings;
if (!mDynamicHLSL->generateShaderLinkHLSL(data, mData, infoLog, registers, packing, mPixelHLSL,
if (!mDynamicHLSL->generateShaderLinkHLSL(data, mData, infoLog, registers, mPixelHLSL,
mVertexHLSL, &linkedVaryings, &mPixelShaderKey,
&mUsesFragDepth))
{
......
src/libANGLE/renderer/d3d/ShaderD3D.cpp
......@@ -35,6 +35,27 @@ const char *GetShaderTypeString(GLenum type)
}
}
// true if varying x has a higher priority in packing than y
bool CompareVarying(const sh::Varying &x, const sh::Varying &y)
{
if (x.type == y.type)
{
return x.arraySize > y.arraySize;
}
// Special case for handling structs: we sort these to the end of the list
if (x.type == GL_STRUCT_ANGLEX)
{
return false;
}
if (y.type == GL_STRUCT_ANGLEX)
{
return true;
}
return gl::VariableSortOrder(x.type) < gl::VariableSortOrder(y.type);
}
}
namespace rx
......@@ -87,9 +108,11 @@ void ShaderD3D::parseVaryings(ShHandle compiler)
const std::vector<sh::Varying> *varyings = ShGetVaryings(compiler);
ASSERT(varyings);
mVaryings = *varyings;
for (size_t varyingIndex = 0; varyingIndex < varyings->size(); varyingIndex++)
{
mVaryings.push_back(gl::PackedVarying((*varyings)[varyingIndex]));
mPackedVaryings.push_back(PackedVarying(mVaryings[varyingIndex]));
}
mUsesMultipleRenderTargets = mTranslatedSource.find("GL_USES_MRT") != std::string::npos;
......@@ -112,7 +135,7 @@ void ShaderD3D::resetVaryingsRegisterAssignment()
{
for (size_t varyingIndex = 0; varyingIndex < mVaryings.size(); varyingIndex++)
{
mVaryings[varyingIndex].resetRegisterAssignment();
mPackedVaryings[varyingIndex].resetRegisterAssignment();
}
}
......@@ -285,28 +308,6 @@ void ShaderD3D::generateWorkarounds(D3DCompilerWorkarounds *workarounds) const
}
}
// true if varying x has a higher priority in packing than y
bool ShaderD3D::compareVarying(const gl::PackedVarying &x, const gl::PackedVarying &y)
{
if (x.type == y.type)
{
return x.arraySize > y.arraySize;
}
// Special case for handling structs: we sort these to the end of the list
if (x.type == GL_STRUCT_ANGLEX)
{
return false;
}
if (y.type == GL_STRUCT_ANGLEX)
{
return true;
}
return gl::VariableSortOrder(x.type) < gl::VariableSortOrder(y.type);
}
unsigned int ShaderD3D::getUniformRegister(const std::string &uniformName) const
{
ASSERT(mUniformRegisterMap.count(uniformName) > 0);
......@@ -349,7 +350,7 @@ bool ShaderD3D::compile(gl::Compiler *compiler, const std::string &source)
if (mShaderType == GL_FRAGMENT_SHADER)
{
std::sort(mVaryings.begin(), mVaryings.end(), compareVarying);
std::sort(mVaryings.begin(), mVaryings.end(), CompareVarying);
const std::string &hlsl = getTranslatedSource();
if (!hlsl.empty())
......
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;
......@@ -50,14 +68,17 @@ 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);
void parseAttributes(ShHandle compiler);
static bool compareVarying(const gl::PackedVarying &x, const gl::PackedVarying &y);
GLenum mShaderType;
bool mUsesMultipleRenderTargets;
......@@ -79,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/libANGLE/renderer/gl/ShaderGL.cpp
......@@ -123,12 +123,7 @@ bool ShaderGL::compile(gl::Compiler *compiler, const std::string &source)
mActiveAttributes = GetFilteredShaderVariables(ShGetAttributes(compilerHandle));
}
const std::vector<sh::Varying> &varyings = GetShaderVariables(ShGetVaryings(compilerHandle));
for (size_t varyingIndex = 0; varyingIndex < varyings.size(); varyingIndex++)
{
mVaryings.push_back(gl::PackedVarying(varyings[varyingIndex]));
}
mVaryings = GetShaderVariables(ShGetVaryings(compilerHandle));
mUniforms = GetShaderVariables(ShGetUniforms(compilerHandle));
mInterfaceBlocks = GetShaderVariables(ShGetInterfaceBlocks(compilerHandle));
......
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