Support token editing within GraphEditor UI

source/MaterialXGraphEditor/Graph.cpp

@@ -774,10 +774,7 @@ void Graph::updateMaterials(mx::InputPtr input /* = nullptr */, mx::ValuePtr val
     {
         if (!input)
         {
-            mx::ElementPtr elem = nullptr;
-            {
-                elem = _graphDoc->getDescendant(renderablePath);
-            }
+            const mx::ElementPtr elem = _graphDoc->getDescendant(renderablePath);
             mx::TypedElementPtr typedElem = elem ? elem->asA<mx::TypedElement>() : nullptr;
             _renderer->updateMaterials(typedElem);
         }
@@ -1086,6 +1083,8 @@ void Graph::showPropertyEditorValue(UiNodePtr node, mx::InputPtr input, const mx
                 nodeInput->setValueString(temp);
                 nodeInput->setValue(temp, nodeInput->getType());
                 updateMaterials();
+
+                _currUiNode->buildUiTokenMap(); // Re-build token map
             }
         }
     }
@@ -1139,16 +1138,16 @@ void Graph::setUiNodeInfo(UiNodePtr node, const std::string& type, const std::st
     }
     else
     {
-        if (node->getNode())
+        if (mx::ConstNodePtr mxNode = node->getNode())
         {
-            mx::NodeDefPtr nodeDef = node->getNode()->getNodeDef(node->getNode()->getName());
+            mx::NodeDefPtr nodeDef = mxNode->getNodeDef(mxNode->getName());
             if (nodeDef)
             {
                 for (mx::InputPtr input : nodeDef->getActiveInputs())
                 {
-                    if (node->getNode()->getInput(input->getName()))
+                    if (mxNode->getInput(input->getName()))
                     {
-                        input = node->getNode()->getInput(input->getName());
+                        input = mxNode->getInput(input->getName());
                     }
                     UiPinPtr inPin = std::make_shared<UiPin>(_state.nextUiId, node, ax::NodeEditor::PinKind::Input, input);
                     node->getInputPins().push_back(inPin);
@@ -1158,16 +1157,18 @@ void Graph::setUiNodeInfo(UiNodePtr node, const std::string& type, const std::st
 
                 for (mx::OutputPtr output : nodeDef->getActiveOutputs())
                 {
-                    if (node->getNode()->getOutput(output->getName()))
+                    if (mxNode->getOutput(output->getName()))
                     {
-                        output = node->getNode()->getOutput(output->getName());
+                        output = mxNode->getOutput(output->getName());
                     }
                     UiPinPtr outPin = std::make_shared<UiPin>(_state.nextUiId, node, ax::NodeEditor::PinKind::Output, output);
                     node->getOutputPins().push_back(outPin);
                     _state.pins.push_back(outPin);
                     ++_state.nextUiId;
                 }
             }
+
+            node->buildUiTokenMap(); // Build initial token map
         }
         else if (node->getInput())
         {
@@ -3778,40 +3779,62 @@ void Graph::propertyEditor()
             showPropertyEditorOutputConnections(_currUiNode);
         }
 
-        // Find tokens within currUiNode
-        mx::ConstNodePtr node = _currUiNode->getNode();
-        if (node != nullptr)
+        // Draw token table
+        if (const auto& currTokenMap = _currUiNode->getUiTokenMap(); !currTokenMap.empty())
         {
-            mx::StringResolverPtr resolver = node->createStringResolver();
-            const mx::StringMap& tokens = resolver->getFilenameSubstitutions();
+            ImGui::Text("Tokens");
+            ImGui::SameLine();
+            drawHelpMarker("All tokens that are within scope of the selected node. Token values will be string-substituted into listed 'Affected Inputs'.");
 
-            if (!tokens.empty())
+            int tokenCount = static_cast<int>(currTokenMap.size() + 1u); // Add 1 to account for header row
+            ImVec2 tableHeight(0.0f, TEXT_BASE_HEIGHT * std::min(SCROLL_LINE_COUNT, tokenCount));
+
+            // Use `ImGuiTableFlags_SizingFixedFit` to set default column width to fit content
+            if (ImGui::BeginTable("tokens_node_table", 4, tableFlags | ImGuiTableFlags_SizingFixedFit, tableHeight))
             {
-                ImGui::Text("Tokens");
+                ImGui::SetWindowFontScale(_fontScale);
 
-                ImVec2 tableSize(0.0f, TEXT_BASE_HEIGHT * std::min(SCROLL_LINE_COUNT, static_cast<int>(tokens.size())));
-                bool haveTable = ImGui::BeginTable("tokens_node_table", 2, tableFlags, tableSize);
-                if (haveTable)
-                {
-                    ImGui::SetWindowFontScale(_fontScale);
+                ImGui::TableSetupColumn("Name");
+                ImGui::TableSetupColumn("Value");
+                ImGui::TableSetupColumn("Source Element");
+                ImGui::TableSetupColumn("Affected Inputs");
 
-                    for (const auto& [token, value] : tokens)
-                    {
+                // Set tooltips for each of table's columns
+                constexpr std::array tableHeadersTooltips = { "", "Press <enter> to set token value.", "The graph element where the token is declared.", "Node inputs which reference the token." };
+                drawTableHeadersRowWithTooltips(tableHeadersTooltips);
 
-                        ImGui::TableNextRow();
-                        ImGui::TableNextColumn();
-                        ImGui::PushID(&token);
+                for (const auto& [tokenName, tokenPtr] : currTokenMap)
+                {
+                    ImGui::TableNextRow(); // Start new row
+                    ImGui::PushID(&tokenName);
 
-                        ImGui::Text("%s", token.c_str());
-                        ImGui::TableNextColumn();
-                        ImGui::Text("%s", value.c_str());
+                    // Name
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%s", tokenName.c_str());
 
-                        ImGui::PopID();
+                    // Value
+                    ImGui::TableNextColumn();
+                    std::string tokenValue = tokenPtr->getValue();
+
+                    if (ImGui::InputText("##token_value", &tokenValue, ImGuiInputTextFlags_EnterReturnsTrue))
+                    {
+                        tokenPtr->setValue(tokenValue);  // Write out new token value
+                        updateMaterials();               // Trigger update of material
                     }
 
-                    ImGui::EndTable();
-                    ImGui::SetWindowFontScale(1.0f);
+                    // Source Element
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%s", tokenPtr->getSourceElementString().c_str());
+
+                    // Affected Inputs
+                    ImGui::TableNextColumn();
+                    ImGui::Text("%s", tokenPtr->getAffectedInputsString().c_str());
+
+                    ImGui::PopID();
                 }
+
+                ImGui::EndTable();
+                ImGui::SetWindowFontScale(1.0f); // Restore font scale
             }
         }
 
@@ -3875,6 +3898,20 @@ void Graph::showHelp() const
         ImGui::BulletText("\"Node Info\" Will toggle showing node information.");
     }
 }
+void Graph::drawHelpMarker(const char* content)
+{
+    constexpr float WRAP_POSITION = 32.f; // Compile-time definition of text-wrap position
+
+    ImGui::TextDisabled(HELP_MARKER_TEXT); // Draw help marker
+    if (!ImGui::IsItemHovered())
+        return; // If help marker isn't hovered return early
+
+    ImGui::BeginTooltip();
+    ImGui::PushTextWrapPos(ImGui::GetFontSize() * WRAP_POSITION);
+    ImGui::TextUnformatted(content);
+    ImGui::PopTextWrapPos();
+    ImGui::EndTooltip();
+}
 
 void Graph::addNodePopup(bool cursor)
 {

source/MaterialXGraphEditor/Graph.h

@@ -298,6 +298,35 @@ class Graph
 
     void showHelp() const;
 
+    // A compile-time constant member variable that corresponds to the function below. Defined in header as visibility is desirable here.
+    static constexpr char HELP_MARKER_TEXT[] = "(?)";
+    // Static helper function to draw a marker via ImGui which shows a tooltip when hovered
+    static void drawHelpMarker(const char* content);
+
+    // Static helper function to display tooltips for headers in an ImGui table
+    template <std::size_t N> static void drawTableHeadersRowWithTooltips(const std::array<const char*, N>& tooltips)
+    {
+        const int columnCount = ImGui::TableGetColumnCount();
+        if (columnCount == 0 || columnCount != N)
+            return; // Given array size should match number of columns in table
+
+        ImGui::TableNextRow(ImGuiTableRowFlags_Headers);
+        for (int col = 0; col < columnCount; ++col)
+        {
+            if (!ImGui::TableSetColumnIndex(col))
+                continue;                                       // Do not draw if column is not visible
+            ImGui::TableHeader(ImGui::TableGetColumnName(col)); // Header name
+
+            std::string colTooltip = tooltips[col];
+            if (!colTooltip.empty() && ImGui::IsItemHovered())
+            {
+                ImGui::BeginTooltip();
+                ImGui::TextUnformatted(tooltips[col]);
+                ImGui::EndTooltip();
+            }
+        }
+    }
+
   private:
     mx::StringVec _geomFilter;
     mx::StringVec _mtlxFilter;
@@ -389,5 +418,4 @@ class Graph
     // Current height of the diagnostic panel; adjusted by the resize handle.
     float _diagPanelHeight = 120.f;
 };
-
 #endif

source/MaterialXGraphEditor/UiNode.cpp

@@ -95,6 +95,76 @@ mx::NodeGraphPtr UiNode::getNodeGraph() const
     return _element ? _element->asA<mx::NodeGraph>() : nullptr;
 }
 
+void UiNode::buildUiTokenMap()
+{
+    _uiTokenMap.clear(); // Assume we want clean slate
+
+    const mx::NodePtr node = getNode();
+    if (!node) return; // Early return as no further work is needed
+
+    mx::ElementPtr currElem = node->asA<mx::Element>(); // Explicit upcast
+    // Traverse upward using parent pointers to collect all active tokens in the current scope
+    while (currElem)
+    {
+        if (mx::ConstInterfaceElementPtr currInterfaceElem = currElem->asA<mx::InterfaceElement>())
+        {
+            UiToken::applyTokenMapping(&_uiTokenMap, currInterfaceElem, currElem);
+
+            // If the node is a nodegraph, check for tokens on corresponding nodedef
+            if (mx::ConstNodeGraphPtr currNodeGraph = currElem->asA<mx::NodeGraph>())
+            {
+                if (mx::NodeDefPtr currNodedef = currNodeGraph->getNodeDef())
+                {
+                    UiToken::applyTokenMapping(&_uiTokenMap, currNodedef, currNodedef);
+                }
+            }
+
+            // If the node is a custom node instance, check for tokens on corresponding nodedef
+            if (mx::NodePtr currNode = currElem->asA<mx::Node>())
+            {
+                if (mx::NodeDefPtr currNodedef = currNode->getNodeDef())
+                {
+                    UiToken::applyTokenMapping(&_uiTokenMap, currNodedef, currNodedef);
+                }
+            }
+        }
+        currElem = currElem->getParent();
+    }
+
+    // Traverse through inputs and determine which tokens their value depends on
+    for (const auto& input : node->getActiveInputs())
+    {
+        if (input->getType() != "filename")
+            continue;
+
+        mx::StringResolverPtr inputResolver = input->createStringResolver();
+        const mx::StringMap& inputTokens = inputResolver->getFilenameSubstitutions();
+
+        mx::StringMap inputTokensRenormalized;
+        for (const auto& entry : inputTokens)
+        {
+            // Store tokens without excess delimiters
+            inputTokensRenormalized[entry.first] = entry.first.substr(1, entry.first.size() - 2);
+        }
+
+        std::string inputValue = input->getValueString();
+        if (inputValue.empty() && input->hasInterfaceName())
+            inputValue = input->getInterfaceInput()->getValueString(); // Get value from referenced interface
+
+        for (const auto& entry : inputTokens)
+        {
+            if (inputValue.find(entry.first) != std::string::npos)
+            {
+                // Ensure that the token exists in the pre-built map
+                if (auto it = _uiTokenMap.find(inputTokensRenormalized[entry.first]); it != _uiTokenMap.end())
+                {
+                    it->second->addAffectedInput(input); // Append to affected inputs of corresponding entry in token map
+                }
+            }
+        }
+    }
+}
+
 // return the uiNode connected with input name
 UiNodePtr UiNode::getConnectedNode(const std::string& name)
 {