Runtime token support

source/MaterialXRuntime/Private/PvtPort.cpp

@@ -39,6 +39,12 @@ PvtInput::PvtInput(const RtIdentifier& name, const RtIdentifier& type, uint32_t
 
 bool PvtInput::isConnectable(const PvtOutput* output) const
 {
+    // TODO : Tokens are not connectable for now.
+    if (isToken() || output->isToken())
+    {
+        return false;
+    }
+
     // We cannot connect to ourselves.
     if (_parent == output->_parent)
     {

source/MaterialXRuntime/Private/PvtPort.h

@@ -13,6 +13,7 @@
 #include <MaterialXRuntime/RtValue.h>
 #include <MaterialXRuntime/RtTypeDef.h>
 #include <MaterialXRuntime/RtTraversal.h>
+#include <MaterialXRuntime/Identifiers.h>
 
 /// @file
 /// TODO: Docs
@@ -106,6 +107,23 @@ class PvtPort : public PvtObject
         attr->asIdentifier() = unit;
     }
 
+    bool isToken() const
+    {
+        return (_flags & RtPortFlag::TOKEN) != 0;
+    }
+
+    void setIsToken(bool val)
+    {
+        if (val)
+        {
+            _flags |= RtPortFlag::TOKEN;
+        }
+        else
+        {
+            _flags &= ~RtPortFlag::TOKEN;
+        }
+    }
+
     static const RtIdentifier DEFAULT_OUTPUT_NAME;
     static const RtIdentifier COLOR_SPACE;
     static const RtIdentifier UNIT;
@@ -148,6 +166,24 @@ class PvtInput : public PvtPort
         }
     }
 
+    bool isUIVisible() const
+    {
+        // For now since connections require ports to be created and hence visible
+        // always assume a connection means visible.
+        if (isConnected())
+        {
+            return true;
+        }
+        const RtTypedValue* attr = getAttribute(Identifiers::UIVISIBLE, RtType::BOOLEAN);
+        return attr ? attr->asBool() : true;
+    }
+
+    void setIsUIVisible(bool val)
+    {
+        RtTypedValue* attr = createAttribute(Identifiers::UIVISIBLE, RtType::BOOLEAN);
+        attr->asBool() = val;
+    }
+
     bool isConnected() const
     {
         return _connection != nullptr;

source/MaterialXRuntime/RtConnectableApi.cpp

@@ -16,6 +16,12 @@ namespace
 
 bool RtConnectableApi::acceptConnection(const RtInput& input, const RtOutput& output) const
 {
+    // TODO: Tokens are not currently considered to be connectable
+    if (input.isToken())
+    {
+        return false;
+    }
+
     // Default implementation checks if the types are matching.
     //
     // TODO: Check if the data types are compatible/castable

source/MaterialXRuntime/RtFileIo.cpp

@@ -200,6 +200,11 @@ namespace
                 const uint32_t flags = elem->asA<Input>()->getIsUniform() ? RtPortFlag::UNIFORM : 0;
                 port = schema.createInput(portName, portType, flags);
             }
+            else if (elem->isA<Token>())
+            {
+                const uint32_t flags = RtPortFlag::UNIFORM | RtPortFlag::TOKEN;
+                port = schema.createInput(portName, portType, flags);
+            }
 
             if (port)
             {
@@ -487,7 +492,17 @@ namespace
                         if (!socket)
                         {
                             const RtIdentifier inputType(elem->getType());
-                            RtInput input = nodegraph.createInput(socketName, inputType);
+
+                            RtInput input = RtInput();
+                            if (elem->isA<Token>())
+                            {
+                                const uint32_t flags = RtPortFlag::UNIFORM | RtPortFlag::TOKEN;
+                                input = nodegraph.createInput(socketName, inputType, flags);
+                            }
+                            else
+                            {
+                                input = nodegraph.createInput(socketName, inputType);
+                            }
                             socket = nodegraph.getInputSocket(input.getName());
 
                             // Set the input value
@@ -901,7 +916,16 @@ namespace
         for (PvtObject* obj : src->getInputs())
         {
             const PvtInput* input = obj->asA<PvtInput>();
-            ValueElementPtr destPort = destNodeDef->addInput(input->getName().str(), input->getType().str());
+            ValueElementPtr destPort = nullptr;
+            if (input->isToken())
+            {
+                destPort = destNodeDef->addToken(input->getName().str());
+                destPort->setType(input->getType().str());
+            }
+            else
+            {
+                destPort = destNodeDef->addInput(input->getName().str(), input->getType().str());
+            }
             if (input->isUniform())
             {
                 destPort->setIsUniform(true);
@@ -941,10 +965,8 @@ namespace
             RtInput input = node.getInput(i);
             if (input)
             {
-                const RtTypedValue* uiVisible1 = input.getAttribute(Identifiers::UIVISIBLE, RtType::BOOLEAN);
-                const RtTypedValue* uiVisible2 = nodedefInput.getAttribute(Identifiers::UIVISIBLE, RtType::BOOLEAN);
-                const bool uiHidden1 = uiVisible1 && !uiVisible1->asBool();
-                const bool uiHidden2 = uiVisible2 && !uiVisible2->asBool();
+                const bool uiHidden1 = input.isUIVisible();
+                const bool uiHidden2 = nodedefInput.isUIVisible();
                 const bool writeUiVisibleData = uiHidden1 != uiHidden2;
 
                 // Write input if it's connected or different from default value.
@@ -955,7 +977,15 @@ namespace
                     ValueElementPtr valueElem;
                     if (input.isUniform())
                     {
-                        valueElem = destNode->addInput(input.getName().str(), input.getType().str());
+                        if (input.isToken())
+                        {
+                            valueElem = destNode->addToken(input.getName().str());
+                            valueElem->setType(input.getType().str());
+                        }
+                        else
+                        {
+                            valueElem = destNode->addInput(input.getName().str(), input.getType().str());
+                        }
                         valueElem->setIsUniform(true);
                         if (input.isConnected())
                         {
@@ -1049,7 +1079,15 @@ namespace
                 ValueElementPtr v = nullptr;
                 if (nodegraphInput.isUniform())
                 {
-                    v = destNodeGraph->addInput(nodegraphInput.getName().str(), nodegraphInput.getType().str());
+                    if (nodegraphInput.isToken())
+                    {
+                        v = destNodeGraph->addToken(nodegraphInput.getName().str());
+                        v->setType(nodegraphInput.getType().str());
+                    }
+                    else
+                    {
+                        v = destNodeGraph->addInput(nodegraphInput.getName().str(), nodegraphInput.getType().str());
+                    }
                     v->setIsUniform(true);
                 }
                 else

source/MaterialXRuntime/RtPort.cpp

@@ -78,6 +78,16 @@ void RtPort::setUnitType(const RtIdentifier& unit)
     return hnd()->asA<PvtPort>()->setUnitType(unit);
 }
 
+bool RtPort::isToken() const
+{
+    return hnd()->asA<PvtPort>()->isToken();
+}
+
+void RtPort::setIsToken(bool uniform)
+{
+    hnd()->asA<PvtPort>()->setIsToken(uniform);
+}
+
 
 RT_DEFINE_RUNTIME_OBJECT(RtInput, RtObjType::INPUT, "RtInput")
 
@@ -96,6 +106,16 @@ void RtInput::setUniform(bool uniform)
     hnd()->asA<PvtInput>()->setUniform(uniform);
 }
 
+bool RtInput::isUIVisible() const
+{
+    return hnd()->asA<PvtInput>()->isUIVisible();
+}
+
+void RtInput::setIsUIVisible(bool val)
+{
+    hnd()->asA<PvtInput>()->setIsUIVisible(val);
+}
+
 bool RtInput::isConnected() const
 {
     return hnd()->asA<PvtInput>()->isConnected();

source/MaterialXRuntime/RtPort.h

@@ -29,6 +29,9 @@ class RtPortFlag
 
     /// Port is a nodegraph internal socket.
     static const uint32_t SOCKET      = 0x00000002;
+
+    /// Port holds a token
+    static const uint32_t TOKEN       = 0x00000004;
 };
 
 /// @class RtPort
@@ -80,6 +83,12 @@ class RtPort : public RtObject
 
     /// Set the unit type for this port.
     void setUnitType(const RtIdentifier& unit);
+
+    /// Return true if this input is a token.
+    bool isToken() const;
+
+    /// Sets the input to be a token or not a token
+    void setIsToken(bool val);
 };
 
 
@@ -103,6 +112,12 @@ class RtInput : public RtPort
     /// Sets the input to be a uniform or not a uniform
     void setUniform(bool uniform);
 
+    /// Return true if this input should be visible in the UI.
+    bool isUIVisible() const;
+
+    /// Sets the input's visibilit in the UI.
+    void setIsUIVisible(bool val);
+
     /// Return true if this input is connected.
     bool isConnected() const;
 

source/MaterialXRuntime/RtStage.cpp

@@ -189,12 +189,17 @@ RtPrim RtStage::createNodeDef(RtPrim nodegraphPrim,
     for (RtInput input : nodegraph.getInputs())
     {
         RtInput nodedefInput = nodedef.createInput(input.getName(), input.getType());
-        nodedefInput.setUniform(input.isUniform());
+        PvtObject *src = PvtObject::cast(input);
+        for (const RtIdentifier& name : src->getAttributeNames())
+        {
+            const RtTypedValue* srcAttr = src->getAttribute(name);
+            RtTypedValue* destAttr = nodedefInput.createAttribute(name, srcAttr->getType());
+            RtValue::copy(srcAttr->getType(), srcAttr->getValue(), destAttr->getValue());
+        }
+        nodedefInput.setIsToken(input.isToken());
         RtValue::copy(input.getType(), input.getValue(), nodedefInput.getValue());
     }
 
-    // TODO : Add support for tokens
-
     // Add an output per nodegraph output
     for (RtOutput output : nodegraph.getOutputs())
     {

source/MaterialXTest/MaterialXRuntime/Runtime.cpp

@@ -80,7 +80,7 @@ namespace
         }
     };
 
-    // Commonly used tokens.
+    // Commonly used identifiers.
     const mx::RtIdentifier X("x");
     const mx::RtIdentifier Y("y");
     const mx::RtIdentifier Z("z");
@@ -95,6 +95,7 @@ namespace
     const mx::RtIdentifier IN3("in3");
     const mx::RtIdentifier OUT("out");
     const mx::RtIdentifier IN("in");
+    const mx::RtIdentifier TOKEN1("token1");
     const mx::RtIdentifier REFLECTIVITY("reflectivity");
     const mx::RtIdentifier SURFACESHADER("surfaceshader");
     const mx::RtIdentifier UIFOLDER("uifolder");
@@ -156,7 +157,7 @@ TEST_CASE("Runtime: Material Element Upgrade", "[runtime]")
     }
 }
 
-TEST_CASE("Runtime: Token", "[runtime]")
+TEST_CASE("Runtime: Identifiers", "[runtime]")
 {
     mx::RtIdentifier tok1("hej");
     mx::RtIdentifier tok2("hey");
@@ -1299,20 +1300,36 @@ TEST_CASE("Runtime: FileIo NodeGraph", "[runtime]")
     // Create a nodegraph.
     mx::RtNodeGraph graph = stage->createPrim(mx::RtNodeGraph::typeName());
     graph.createInput(IN, mx::RtType::FLOAT);
+    graph.createInput(TOKEN1, mx::RtType::FLOAT, mx::RtPortFlag::UNIFORM | mx::RtPortFlag::TOKEN);
     graph.createOutput(OUT, mx::RtType::FLOAT);
     mx::RtInput graphIn = graph.getInput(IN);
+    REQUIRE(graphIn.isUIVisible());
+    graphIn.setIsUIVisible(false);
+    REQUIRE(!graphIn.isUIVisible());
+    mx::RtInput graphToken = graph.getInput(TOKEN1);
+    REQUIRE(graphToken.isUniform());
     mx::RtOutput graphOut = graph.getOutput(OUT);
     mx::RtOutput graphInSocket = graph.getInputSocket(IN);
+    mx::RtOutput graphTokenSocket = graph.getInputSocket(TOKEN1);
     mx::RtInput graphOutSocket = graph.getOutputSocket(OUT);
     REQUIRE(graphIn);
+    REQUIRE(graphToken);
     REQUIRE(graphOut);
     REQUIRE(graphInSocket);
+    REQUIRE(graphTokenSocket);
     REQUIRE(graphOutSocket);
 
     // Add nodes to the graph.
     const mx::RtIdentifier ADD_FLOAT_NODEDEF("ND_add_float");
     mx::RtNode add1 = stage->createPrim(graph.getPath(), NONAME, ADD_FLOAT_NODEDEF);
     mx::RtNode add2 = stage->createPrim(graph.getPath(), NONAME, ADD_FLOAT_NODEDEF);
+    try {
+        graphTokenSocket.connect(add1.getInput(IN1));
+    }
+    catch (mx::Exception&)
+    {
+    }
+    REQUIRE(!graphTokenSocket.isConnected());
     graphInSocket.connect(add1.getInput(IN1));
     add1.getOutput(OUT).connect(add2.getInput(IN1));
     add2.getOutput(OUT).connect(graphOutSocket);