Consolidate ClosureCompoundNode.cpp with CompoundNode.cpp, similar to the previous work done for SourceCodeNode.cpp. Also added an additional helper call to consolidate the logic.

Author: ld-kerley

source/MaterialXGenGlsl/GlslShaderGenerator.cpp

@@ -27,7 +27,6 @@
 #include <MaterialXGenShader/Nodes/HwBitangentNode.h>
 #include <MaterialXGenShader/Nodes/HwFrameNode.h>
 #include <MaterialXGenShader/Nodes/HwViewDirectionNode.h>
-#include <MaterialXGenShader/Nodes/ClosureCompoundNode.h>
 
 MATERIALX_NAMESPACE_BEGIN
 
@@ -740,10 +739,6 @@ ShaderNodeImplPtr GlslShaderGenerator::getImplementation(const NodeDef& nodedef,
         {
             impl = LightCompoundNodeGlsl::create();
         }
-        else if (outputType.isClosure())
-        {
-            impl = ClosureCompoundNode::create();
-        }
         else
         {
             impl = CompoundNode::create();

source/MaterialXGenMsl/MslShaderGenerator.cpp

@@ -27,7 +27,6 @@
 #include <MaterialXGenShader/Nodes/HwBitangentNode.h>
 #include <MaterialXGenShader/Nodes/HwFrameNode.h>
 #include <MaterialXGenShader/Nodes/HwViewDirectionNode.h>
-#include <MaterialXGenShader/Nodes/ClosureCompoundNode.h>
 
 #include "MslResourceBindingContext.h"
 
@@ -1255,10 +1254,6 @@ ShaderNodeImplPtr MslShaderGenerator::getImplementation(const NodeDef& nodedef,
         {
             impl = LightCompoundNodeMsl::create();
         }
-        else if (outputType.isClosure())
-        {
-            impl = ClosureCompoundNode::create();
-        }
         else
         {
             impl = CompoundNode::create();

source/MaterialXGenShader/Nodes/ClosureCompoundNode.cpp

@@ -19,6 +19,12 @@ ShaderNodeImplPtr CompoundNode::create()
     return std::make_shared<CompoundNode>();
 }
 
+void CompoundNode::addClassification(ShaderNode& node) const
+{
+    // Add classification from the graph implementation.
+    node.addClassification(_rootGraph->getClassification());
+}
+
 void CompoundNode::initialize(const InterfaceElement& element, GenContext& context)
 {
     ShaderNodeImpl::initialize(element, context);
@@ -54,7 +60,7 @@ void CompoundNode::createVariables(const ShaderNode&, GenContext& context, Shade
     }
 }
 
-void CompoundNode::emitFunctionDefinition(const ShaderNode&, GenContext& context, ShaderStage& stage) const
+void CompoundNode::emitFunctionDefinition(const ShaderNode& node, GenContext& context, ShaderStage& stage) const
 {
     DEFINE_SHADER_STAGE(stage, Stage::PIXEL)
     {
@@ -66,9 +72,14 @@ void CompoundNode::emitFunctionDefinition(const ShaderNode&, GenContext& context
 
         // Begin function signature.
         shadergen.emitLineBegin(stage);
-        shadergen.emitString("void " + _functionName + +"(", stage);
+        shadergen.emitString("void " + _functionName + "(", stage);
 
-        string delim = "";
+        if (context.getShaderGenerator().nodeNeedsClosureData(node))
+        {
+            shadergen.emitString(HW::CLOSURE_DATA_TYPE + " " + HW::CLOSURE_DATA_ARG + ", ", stage);
+        }
+
+        string delim;
 
         // Add all inputs
         for (ShaderGraphInputSocket* inputSocket : _rootGraph->getInputSockets())
@@ -90,7 +101,32 @@ void CompoundNode::emitFunctionDefinition(const ShaderNode&, GenContext& context
 
         // Begin function body.
         shadergen.emitFunctionBodyBegin(*_rootGraph, context, stage);
-        shadergen.emitFunctionCalls(*_rootGraph, context, stage);
+
+        if (nodeOutputIsClosure(node))
+        {
+            // Emit all texturing nodes. These are inputs to the
+            // closure nodes and need to be emitted first.
+            shadergen.emitFunctionCalls(*_rootGraph, context, stage, ShaderNode::Classification::TEXTURE);
+
+            // Emit function calls for internal closures nodes connected to the graph sockets.
+            // These will in turn emit function calls for any dependent closure nodes upstream.
+            for (ShaderGraphOutputSocket* outputSocket : _rootGraph->getOutputSockets())
+            {
+                if (outputSocket->getConnection())
+                {
+                    const ShaderNode* upstream = outputSocket->getConnection()->getNode();
+                    if (upstream->getParent() == _rootGraph.get() &&
+                        (upstream->hasClassification(ShaderNode::Classification::CLOSURE) || upstream->hasClassification(ShaderNode::Classification::SHADER)))
+                    {
+                        shadergen.emitFunctionCall(*upstream, context, stage);
+                    }
+                }
+            }
+        }
+        else
+        {
+            shadergen.emitFunctionCalls(*_rootGraph, context, stage);
+        }
 
         // Emit final results
         for (ShaderGraphOutputSocket* outputSocket : _rootGraph->getOutputSockets())
@@ -116,14 +152,26 @@ void CompoundNode::emitFunctionCall(const ShaderNode& node, GenContext& context,
 
     DEFINE_SHADER_STAGE(stage, Stage::PIXEL)
     {
+        if (nodeOutputIsClosure(node))
+        {
+            // Emit calls for any closure dependencies upstream from this nodedef
+            shadergen.emitDependentFunctionCalls(node, context, stage, ShaderNode::Classification::CLOSURE);
+        }
+
         // Declare the output variables.
         emitOutputVariables(node, context, stage);
 
         // Begin function call.
         shadergen.emitLineBegin(stage);
         shadergen.emitString(_functionName + "(", stage);
 
-        string delim = "";
+        // Check if we have a closure context to modify the function call.
+        if (context.getShaderGenerator().nodeNeedsClosureData(node))
+        {
+            shadergen.emitString(HW::CLOSURE_DATA_ARG + ", ", stage);
+        }
+
+        string delim;
 
         // Emit inputs.
         for (ShaderInput* input : node.getInputs())

source/MaterialXGenShader/Nodes/ClosureCompoundNode.h

@@ -6,6 +6,7 @@
 #ifndef MATERIALX_COMPOUNDNODE_H
 #define MATERIALX_COMPOUNDNODE_H
 
+#include <MaterialXGenShader/GenContext.h>
 #include <MaterialXGenShader/ShaderNodeImpl.h>
 #include <MaterialXGenShader/ShaderGraph.h>
 #include <MaterialXGenShader/Shader.h>
@@ -20,6 +21,8 @@ class MX_GENSHADER_API CompoundNode : public ShaderNodeImpl
 
     void initialize(const InterfaceElement& element, GenContext& context) override;
 
+    void addClassification(ShaderNode& node) const override;
+
     void createVariables(const ShaderNode& node, GenContext& context, Shader& shader) const override;
 
     void emitFunctionDefinition(const ShaderNode& node, GenContext& context, ShaderStage& stage) const override;

source/MaterialXGenShader/Nodes/CompoundNode.cpp

@@ -109,16 +109,7 @@ void SourceCodeNode::emitFunctionCall(const ShaderNode& node, GenContext& contex
     {
         const ShaderGenerator& shadergen = context.getShaderGenerator();
 
-        const auto& outputs = node.getOutputs();
-        if (outputs.empty())
-        {
-            // This should never happen as we auto populate the default 'out' output based on the
-            // node type if no output is present.
-            throw ExceptionShaderGenError("Node has no outputs defined'");
-        }
-
-        const TypeDesc outputType = outputs[0]->getType();
-        if (outputType.isClosure())
+        if (nodeOutputIsClosure(node))
         {
             // Emit calls for any closure dependencies upstream from this nodedef
             shadergen.emitDependentFunctionCalls(node, context, stage, ShaderNode::Classification::CLOSURE);

source/MaterialXGenShader/Nodes/CompoundNode.h

@@ -9,7 +9,6 @@
 #include <MaterialXGenShader/ShaderNodeImpl.h>
 #include <MaterialXGenShader/Nodes/CompoundNode.h>
 #include <MaterialXGenShader/Nodes/SourceCodeNode.h>
-#include <MaterialXGenShader/Nodes/ClosureCompoundNode.h>
 #include <MaterialXGenShader/Util.h>
 
 #include <MaterialXFormat/File.h>
@@ -290,25 +289,9 @@ ShaderNodeImplPtr ShaderGenerator::getImplementation(const NodeDef& nodedef, Gen
         return impl;
     }
 
-    vector<OutputPtr> outputs = nodedef.getActiveOutputs();
-    if (outputs.empty())
-    {
-        throw ExceptionShaderGenError("NodeDef '" + nodedef.getName() + "' has no outputs defined");
-    }
-
-    const TypeDesc outputType = _typeSystem->getType(outputs[0]->getType());
-
     if (implElement->isA<NodeGraph>())
     {
-        // Use a compound implementation.
-        if (outputType.isClosure())
-        {
-            impl = ClosureCompoundNode::create();
-        }
-        else
-        {
-            impl = CompoundNode::create();
-        }
+        impl = CompoundNode::create();
     }
     else if (implElement->isA<Implementation>())
     {