Support assigning array constructors in HLSL output

src/compiler/translator/OutputHLSL.cpp

@@ -353,6 +353,14 @@ void OutputHLSL::header(const BuiltInFunctionEmulator *builtInFunctionEmulator)
             out << assignmentFunction.functionDefinition << "\n";
         }
     }
+    if (!mArrayConstructIntoFunctions.empty())
+    {
+        out << "\n// Array constructor functions\n\n";
+        for (const auto &constructIntoFunction : mArrayConstructIntoFunctions)
+        {
+            out << constructIntoFunction.functionDefinition << "\n";
+        }
+    }
 
     if (mUsesDiscardRewriting)
     {
@@ -1451,8 +1459,26 @@ bool OutputHLSL::visitBinary(Visit visit, TIntermBinary *node)
       case EOpAssign:
         if (node->getLeft()->isArray())
         {
-            const TString &functionName = addArrayAssignmentFunction(node->getType());
-            outputTriplet(visit, (functionName + "(").c_str(), ", ", ")");
+            TIntermAggregate *rightAgg = node->getRight()->getAsAggregate();
+            if (rightAgg != nullptr && rightAgg->isConstructor())
+            {
+                const TString &functionName = addArrayConstructIntoFunction(node->getType());
+                out << functionName << "(";
+                node->getLeft()->traverse(this);
+                TIntermSequence *seq = rightAgg->getSequence();
+                for (auto &arrayElement : *seq)
+                {
+                    out << ", ";
+                    arrayElement->traverse(this);
+                }
+                out << ")";
+                return false;
+            }
+            else
+            {
+                const TString &functionName = addArrayAssignmentFunction(node->getType());
+                outputTriplet(visit, (functionName + "(").c_str(), ", ", ")");
+            }
         }
         else
         {
@@ -3116,4 +3142,48 @@ TString OutputHLSL::addArrayAssignmentFunction(const TType& type)
     return function.functionName;
 }
 
+TString OutputHLSL::addArrayConstructIntoFunction(const TType& type)
+{
+    for (const auto &constructIntoFunction : mArrayConstructIntoFunctions)
+    {
+        if (constructIntoFunction.type == type)
+        {
+            return constructIntoFunction.functionName;
+        }
+    }
+
+    const TString &typeName = TypeString(type);
+
+    ArrayHelperFunction function;
+    function.type = type;
+
+    TInfoSinkBase fnNameOut;
+    fnNameOut << "angle_construct_into_" << type.getArraySize() << "_" << typeName;
+    function.functionName = fnNameOut.c_str();
+
+    TInfoSinkBase fnOut;
+
+    fnOut << "void " << function.functionName << "(out "
+          << typeName << " a[" << type.getArraySize() << "]";
+    for (int i = 0; i < type.getArraySize(); ++i)
+    {
+        fnOut << ", " << typeName << " b" << i;
+    }
+    fnOut << ")\n"
+             "{\n";
+
+    for (int i = 0; i < type.getArraySize(); ++i)
+    {
+        fnOut << "    a[" << i << "] = b" << i << ";\n";
+    }
+    fnOut << "}\n";
+
+    function.functionDefinition = fnOut.c_str();
+
+    mArrayConstructIntoFunctions.push_back(function);
+
+    return function.functionName;
+}
+
+
 }

src/compiler/translator/OutputHLSL.h

@@ -90,6 +90,7 @@ class OutputHLSL : public TIntermTraverser
     TString addStructEqualityFunction(const TStructure &structure);
     TString addArrayEqualityFunction(const TType &type);
     TString addArrayAssignmentFunction(const TType &type);
+    TString addArrayConstructIntoFunction(const TType &type);
 
     sh::GLenum mShaderType;
     int mShaderVersion;
@@ -214,6 +215,11 @@ class OutputHLSL : public TIntermTraverser
     std::vector<ArrayHelperFunction*> mArrayEqualityFunctions;
 
     std::vector<ArrayHelperFunction> mArrayAssignmentFunctions;
+
+    // The construct-into functions are functions that fill an N-element array passed as an out parameter
+    // with the other N parameters of the function. This is used to work around that arrays can't be
+    // return values in HLSL.
+    std::vector<ArrayHelperFunction> mArrayConstructIntoFunctions;
 };
 
 }