diff options
Diffstat (limited to 'src/3rdparty/angle/src/compiler/translator/StructureHLSL.cpp')
-rw-r--r-- | src/3rdparty/angle/src/compiler/translator/StructureHLSL.cpp | 594 |
1 files changed, 0 insertions, 594 deletions
diff --git a/src/3rdparty/angle/src/compiler/translator/StructureHLSL.cpp b/src/3rdparty/angle/src/compiler/translator/StructureHLSL.cpp deleted file mode 100644 index 61a9431ceb..0000000000 --- a/src/3rdparty/angle/src/compiler/translator/StructureHLSL.cpp +++ /dev/null @@ -1,594 +0,0 @@ -// -// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved. -// Use of this source code is governed by a BSD-style license that can be -// found in the LICENSE file. -// -// StructureHLSL.cpp: -// HLSL translation of GLSL constructors and structures. -// - -#include "compiler/translator/StructureHLSL.h" -#include "common/utilities.h" -#include "compiler/translator/OutputHLSL.h" -#include "compiler/translator/Types.h" -#include "compiler/translator/util.h" -#include "compiler/translator/UtilsHLSL.h" - -namespace sh -{ - -namespace -{ - -TString Define(const TStructure &structure, - bool useHLSLRowMajorPacking, - bool useStd140Packing, - Std140PaddingHelper *padHelper) -{ - const TFieldList &fields = structure.fields(); - const bool isNameless = (structure.name() == ""); - const TString &structName = - QualifiedStructNameString(structure, useHLSLRowMajorPacking, useStd140Packing); - const TString declareString = (isNameless ? "struct" : "struct " + structName); - - TString string; - string += declareString + - "\n" - "{\n"; - - for (const TField *field : fields) - { - const TType &fieldType = *field->type(); - if (!IsSampler(fieldType.getBasicType())) - { - const TStructure *fieldStruct = fieldType.getStruct(); - const TString &fieldTypeString = - fieldStruct ? QualifiedStructNameString(*fieldStruct, useHLSLRowMajorPacking, - useStd140Packing) - : TypeString(fieldType); - - if (padHelper) - { - string += padHelper->prePaddingString(fieldType); - } - - string += " " + fieldTypeString + " " + DecorateField(field->name(), structure) + - ArrayString(fieldType) + ";\n"; - - if (padHelper) - { - string += padHelper->postPaddingString(fieldType, useHLSLRowMajorPacking); - } - } - } - - // Nameless structs do not finish with a semicolon and newline, to leave room for an instance - // variable - string += (isNameless ? "} " : "};\n"); - - return string; -} - -TString WriteParameterList(const std::vector<TType> ¶meters) -{ - TString parameterList; - for (size_t parameter = 0u; parameter < parameters.size(); parameter++) - { - const TType ¶mType = parameters[parameter]; - - parameterList += TypeString(paramType) + " x" + str(parameter) + ArrayString(paramType); - - if (parameter < parameters.size() - 1u) - { - parameterList += ", "; - } - } - return parameterList; -} - -} // anonymous namespace - -Std140PaddingHelper::Std140PaddingHelper(const std::map<TString, int> &structElementIndexes, - unsigned *uniqueCounter) - : mPaddingCounter(uniqueCounter), mElementIndex(0), mStructElementIndexes(&structElementIndexes) -{ -} - -Std140PaddingHelper::Std140PaddingHelper(const Std140PaddingHelper &other) - : mPaddingCounter(other.mPaddingCounter), - mElementIndex(other.mElementIndex), - mStructElementIndexes(other.mStructElementIndexes) -{ -} - -Std140PaddingHelper &Std140PaddingHelper::operator=(const Std140PaddingHelper &other) -{ - mPaddingCounter = other.mPaddingCounter; - mElementIndex = other.mElementIndex; - mStructElementIndexes = other.mStructElementIndexes; - return *this; -} - -TString Std140PaddingHelper::next() -{ - unsigned value = (*mPaddingCounter)++; - return str(value); -} - -int Std140PaddingHelper::prePadding(const TType &type) -{ - if (type.getBasicType() == EbtStruct || type.isMatrix() || type.isArray()) - { - // no padding needed, HLSL will align the field to a new register - mElementIndex = 0; - return 0; - } - - const GLenum glType = GLVariableType(type); - const int numComponents = gl::VariableComponentCount(glType); - - if (numComponents >= 4) - { - // no padding needed, HLSL will align the field to a new register - mElementIndex = 0; - return 0; - } - - if (mElementIndex + numComponents > 4) - { - // no padding needed, HLSL will align the field to a new register - mElementIndex = numComponents; - return 0; - } - - const int alignment = numComponents == 3 ? 4 : numComponents; - const int paddingOffset = (mElementIndex % alignment); - const int paddingCount = (paddingOffset != 0 ? (alignment - paddingOffset) : 0); - - mElementIndex += paddingCount; - mElementIndex += numComponents; - mElementIndex %= 4; - - return paddingCount; -} - -TString Std140PaddingHelper::prePaddingString(const TType &type) -{ - int paddingCount = prePadding(type); - - TString padding; - - for (int paddingIndex = 0; paddingIndex < paddingCount; paddingIndex++) - { - padding += " float pad_" + next() + ";\n"; - } - - return padding; -} - -TString Std140PaddingHelper::postPaddingString(const TType &type, bool useHLSLRowMajorPacking) -{ - if (!type.isMatrix() && !type.isArray() && type.getBasicType() != EbtStruct) - { - return ""; - } - - int numComponents = 0; - const TStructure *structure = type.getStruct(); - - if (type.isMatrix()) - { - // This method can also be called from structureString, which does not use layout - // qualifiers. - // Thus, use the method parameter for determining the matrix packing. - // - // Note HLSL row major packing corresponds to GL API column-major, and vice-versa, since we - // wish to always transpose GL matrices to play well with HLSL's matrix array indexing. - // - const bool isRowMajorMatrix = !useHLSLRowMajorPacking; - const GLenum glType = GLVariableType(type); - numComponents = gl::MatrixComponentCount(glType, isRowMajorMatrix); - } - else if (structure) - { - const TString &structName = - QualifiedStructNameString(*structure, useHLSLRowMajorPacking, true); - numComponents = mStructElementIndexes->find(structName)->second; - - if (numComponents == 0) - { - return ""; - } - } - else - { - const GLenum glType = GLVariableType(type); - numComponents = gl::VariableComponentCount(glType); - } - - TString padding; - for (int paddingOffset = numComponents; paddingOffset < 4; paddingOffset++) - { - padding += " float pad_" + next() + ";\n"; - } - return padding; -} - -StructureHLSL::StructureHLSL() : mUniquePaddingCounter(0) -{ -} - -Std140PaddingHelper StructureHLSL::getPaddingHelper() -{ - return Std140PaddingHelper(mStd140StructElementIndexes, &mUniquePaddingCounter); -} - -TString StructureHLSL::defineQualified(const TStructure &structure, - bool useHLSLRowMajorPacking, - bool useStd140Packing) -{ - if (useStd140Packing) - { - Std140PaddingHelper padHelper = getPaddingHelper(); - return Define(structure, useHLSLRowMajorPacking, useStd140Packing, &padHelper); - } - else - { - return Define(structure, useHLSLRowMajorPacking, useStd140Packing, nullptr); - } -} - -TString StructureHLSL::defineNameless(const TStructure &structure) -{ - return Define(structure, false, false, nullptr); -} - -StructureHLSL::DefinedStructs::iterator StructureHLSL::defineVariants(const TStructure &structure, - const TString &name) -{ - ASSERT(mDefinedStructs.find(name) == mDefinedStructs.end()); - - for (const TField *field : structure.fields()) - { - const TType *fieldType = field->type(); - if (fieldType->getBasicType() == EbtStruct) - { - ensureStructDefined(*fieldType->getStruct()); - } - } - - DefinedStructs::iterator addedStruct = - mDefinedStructs.insert(std::make_pair(name, new TStructProperties())).first; - // Add element index - storeStd140ElementIndex(structure, false); - storeStd140ElementIndex(structure, true); - - const TString &structString = defineQualified(structure, false, false); - - ASSERT(std::find(mStructDeclarations.begin(), mStructDeclarations.end(), structString) == - mStructDeclarations.end()); - // Add row-major packed struct for interface blocks - TString rowMajorString = "#pragma pack_matrix(row_major)\n" + - defineQualified(structure, true, false) + - "#pragma pack_matrix(column_major)\n"; - - TString std140String = defineQualified(structure, false, true); - TString std140RowMajorString = "#pragma pack_matrix(row_major)\n" + - defineQualified(structure, true, true) + - "#pragma pack_matrix(column_major)\n"; - - mStructDeclarations.push_back(structString); - mStructDeclarations.push_back(rowMajorString); - mStructDeclarations.push_back(std140String); - mStructDeclarations.push_back(std140RowMajorString); - return addedStruct; -} - -void StructureHLSL::ensureStructDefined(const TStructure &structure) -{ - const TString name = StructNameString(structure); - if (name == "") - { - return; // Nameless structures are not defined - } - if (mDefinedStructs.find(name) == mDefinedStructs.end()) - { - defineVariants(structure, name); - } -} - -TString StructureHLSL::addStructConstructor(const TStructure &structure) -{ - const TString name = StructNameString(structure); - - if (name == "") - { - return TString(); // Nameless structures don't have constructors - } - - auto definedStruct = mDefinedStructs.find(name); - if (definedStruct == mDefinedStructs.end()) - { - definedStruct = defineVariants(structure, name); - } - const TString constructorFunctionName = TString(name) + "_ctor"; - TString *constructor = &definedStruct->second->constructor; - if (!constructor->empty()) - { - return constructorFunctionName; // Already added - } - *constructor += name + " " + constructorFunctionName + "("; - - std::vector<TType> ctorParameters; - const TFieldList &fields = structure.fields(); - for (const TField *field : fields) - { - const TType *fieldType = field->type(); - if (!IsSampler(fieldType->getBasicType())) - { - ctorParameters.push_back(*fieldType); - } - } - // Structs that have sampler members should not have constructor calls, and otherwise structs - // are guaranteed to be non-empty by the grammar. Structs can't contain empty declarations - // either. - ASSERT(!ctorParameters.empty()); - - *constructor += WriteParameterList(ctorParameters); - - *constructor += - ")\n" - "{\n" - " " + - name + " structure = { "; - - for (size_t parameterIndex = 0u; parameterIndex < ctorParameters.size(); ++parameterIndex) - { - *constructor += "x" + str(parameterIndex); - if (parameterIndex < ctorParameters.size() - 1u) - { - *constructor += ", "; - } - } - *constructor += - "};\n" - " return structure;\n" - "}\n"; - - return constructorFunctionName; -} - -TString StructureHLSL::addBuiltInConstructor(const TType &type, const TIntermSequence *parameters) -{ - ASSERT(!type.isArray()); - ASSERT(type.getStruct() == nullptr); - ASSERT(parameters); - - TType ctorType = type; - ctorType.setPrecision(EbpHigh); - ctorType.setQualifier(EvqTemporary); - - const TString constructorFunctionName = - TString(type.getBuiltInTypeNameString()) + "_ctor" + DisambiguateFunctionName(parameters); - TString constructor = TypeString(ctorType) + " " + constructorFunctionName + "("; - - std::vector<TType> ctorParameters; - for (auto parameter : *parameters) - { - const TType ¶mType = parameter->getAsTyped()->getType(); - ASSERT(!paramType.isArray()); - ctorParameters.push_back(paramType); - } - constructor += WriteParameterList(ctorParameters); - - constructor += - ")\n" - "{\n" - " return " + - TypeString(ctorType) + "("; - - if (ctorType.isMatrix() && ctorParameters.size() == 1) - { - int rows = ctorType.getRows(); - int cols = ctorType.getCols(); - const TType ¶meter = ctorParameters[0]; - - if (parameter.isScalar()) - { - for (int col = 0; col < cols; col++) - { - for (int row = 0; row < rows; row++) - { - constructor += TString((row == col) ? "x0" : "0.0"); - - if (row < rows - 1 || col < cols - 1) - { - constructor += ", "; - } - } - } - } - else if (parameter.isMatrix()) - { - for (int col = 0; col < cols; col++) - { - for (int row = 0; row < rows; row++) - { - if (row < parameter.getRows() && col < parameter.getCols()) - { - constructor += TString("x0") + "[" + str(col) + "][" + str(row) + "]"; - } - else - { - constructor += TString((row == col) ? "1.0" : "0.0"); - } - - if (row < rows - 1 || col < cols - 1) - { - constructor += ", "; - } - } - } - } - else - { - ASSERT(rows == 2 && cols == 2 && parameter.isVector() && - parameter.getNominalSize() == 4); - - constructor += "x0"; - } - } - else - { - size_t remainingComponents = ctorType.getObjectSize(); - size_t parameterIndex = 0; - - while (remainingComponents > 0) - { - const TType ¶meter = ctorParameters[parameterIndex]; - const size_t parameterSize = parameter.getObjectSize(); - bool moreParameters = parameterIndex + 1 < ctorParameters.size(); - - constructor += "x" + str(parameterIndex); - - if (parameter.isScalar()) - { - remainingComponents -= parameter.getObjectSize(); - } - else if (parameter.isVector()) - { - if (remainingComponents == parameterSize || moreParameters) - { - ASSERT(parameterSize <= remainingComponents); - remainingComponents -= parameterSize; - } - else if (remainingComponents < static_cast<size_t>(parameter.getNominalSize())) - { - switch (remainingComponents) - { - case 1: - constructor += ".x"; - break; - case 2: - constructor += ".xy"; - break; - case 3: - constructor += ".xyz"; - break; - case 4: - constructor += ".xyzw"; - break; - default: - UNREACHABLE(); - } - - remainingComponents = 0; - } - else - UNREACHABLE(); - } - else if (parameter.isMatrix()) - { - int column = 0; - while (remainingComponents > 0 && column < parameter.getCols()) - { - constructor += "[" + str(column) + "]"; - - if (remainingComponents < static_cast<size_t>(parameter.getRows())) - { - switch (remainingComponents) - { - case 1: - constructor += ".x"; - break; - case 2: - constructor += ".xy"; - break; - case 3: - constructor += ".xyz"; - break; - default: - UNREACHABLE(); - } - - remainingComponents = 0; - } - else - { - remainingComponents -= parameter.getRows(); - - if (remainingComponents > 0) - { - constructor += ", x" + str(parameterIndex); - } - } - - column++; - } - } - else - { - UNREACHABLE(); - } - - if (moreParameters) - { - parameterIndex++; - } - - if (remainingComponents) - { - constructor += ", "; - } - } - } - - constructor += - ");\n" - "}\n"; - - mBuiltInConstructors.insert(constructor); - - return constructorFunctionName; -} - -std::string StructureHLSL::structsHeader() const -{ - TInfoSinkBase out; - - for (auto &declaration : mStructDeclarations) - { - out << declaration; - } - - for (auto &structure : mDefinedStructs) - { - out << structure.second->constructor; - } - - for (auto &constructor : mBuiltInConstructors) - { - out << constructor; - } - - return out.str(); -} - -void StructureHLSL::storeStd140ElementIndex(const TStructure &structure, - bool useHLSLRowMajorPacking) -{ - Std140PaddingHelper padHelper = getPaddingHelper(); - const TFieldList &fields = structure.fields(); - - for (const TField *field : fields) - { - padHelper.prePadding(*field->type()); - } - - // Add remaining element index to the global map, for use with nested structs in standard - // layouts - const TString &structName = QualifiedStructNameString(structure, useHLSLRowMajorPacking, true); - mStd140StructElementIndexes[structName] = padHelper.elementIndex(); -} - -} // namespace sh |