{"id":1530,"date":"2025-05-08T12:10:17","date_gmt":"2025-05-08T12:10:17","guid":{"rendered":"https:\/\/www.portalsunited.com:443\/?post_type=docs&p=1530"},"modified":"2025-06-10T14:20:30","modified_gmt":"2025-06-10T14:20:30","password":"","slug":"custom-nodes-tutorial-guide","status":"publish","type":"docs","link":"https:\/\/www.portalsunited.com:443\/docs\/custom-nodes-tutorial-guide\/","title":{"rendered":"World Builder – Custom Nodes Tutorial Guide"},"content":{"rendered":"\n

1. MyDebugNode Tutorial<\/h1>\n\n\n\n

The Debug Node lets you print messages to the Unity console \u2013 perfect for tracking values and debugging your node graphs during runtime!<\/p>\n\n\n\n

You can find all of our currently implemented Nodes here<\/a>.<\/p>\n\n\n\n

Purpose<\/h3>\n\n\n\n

This node takes a string input and logs it to the Unity console, making it easy to debug values and track execution flow in your node-based applications.<\/p>\n\n\n\n

Step-by-Step Tutorial<\/h3>\n\n\n\n

1. Create the Node Script<\/h4>\n\n\n\n
using<\/span> System;\nusing<\/span> System.Collections.Generic;\nusing<\/span> UnityEngine;\nusing<\/span> WorldBuilder.Nodes;\nusing<\/span> Worldbuilder.Nodes.FileIO;\nusing<\/span> WorldBuilder.Nodes.IO;\n\nnamespace<\/span> MyNodes<\/span>\n{\n    public<\/span> class<\/span> MyDebugNode<\/span> : NodeBase<\/span>\n    {\n        public<\/span> static<\/span> string<\/span> NODE_GUID => \"b4fc3090-faf0-4417-88b9-92c04a986117\"<\/span>;\n        public<\/span> static<\/span> string<\/span> NODE_CLASS_NAME => \"MyDebugNode\"<\/span>;\n\n        public<\/span> override<\/span> Guid NodeClassGuid => Guid.Parse(NODE_GUID);\n        public<\/span> override<\/span> string<\/span> NodeClassName => NODE_CLASS_NAME;\n\n        public<\/span> static<\/span> List<NodeFactory.VarType> InputTypes => m_InputTypes;\n        public<\/span> static<\/span> List<NodeFactory.VarType> OutputTypes => m_OutputTypes;\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_InputTypes =\n            new<\/span> List<NodeFactory.VarType> { NodeFactory.VarType.Flow, NodeFactory.VarType.String };\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_OutputTypes =\n            new<\/span> List<NodeFactory.VarType> { NodeFactory.VarType.Flow };\n\n        private<\/span> InputBase m_StringInput;\n\n        public<\/span> MyDebugNode<\/span>(NodeTree nodeTree, Guid nodeInstanceGuid<\/span>) :\n            base<\/span>(nodeTree, nodeInstanceGuid, null<\/span>, m_InputTypes, m_OutputTypes<\/span>)\n        <\/span>{\n        }\n\n        public<\/span> MyDebugNode<\/span>(NodeTree nodeTree, NodeFile nodeFile, NodeFileEntry nodeFileEntry<\/span>) \n            : base<\/span>(nodeTree, nodeFileEntry.Identity, nodeFileEntry, m_InputTypes, m_OutputTypes<\/span>)\n        <\/span>{\n        }\n\n        protected<\/span> override<\/span> void<\/span> MakeIO<\/span>(NodeFileEntry nodeFileEntry<\/span>)\n        <\/span>{\n            Inputs[0<\/span>].RunAction = RunAction;\n            m_StringInput = Inputs[1<\/span>];\n        }\n\n        public<\/span> void<\/span> RunAction<\/span>(<\/span>)\n        <\/span>{\n            string<\/span> text = m_StringInput.GetString();\n            Debug.Log(\"MyDebugNode: \"<\/span> + text);\n\n            Run();\n        }\n    }\n}\n<\/code><\/pre>\n\n\n\n
How It Works<\/h3>\n\n\n\n
Node Properties:<\/h4>\n\n\n\n
    \n
  • Flow Input<\/strong>: Triggers the node execution<\/li>\n\n\n\n
  • String Input<\/strong>: The message to be logged to the console<\/li>\n\n\n\n
  • Flow Output<\/strong>: Continues execution to the next node<\/li>\n<\/ul>\n\n\n\n
    Implementation Details:<\/h4>\n\n\n\n
      \n
    • Uses Unity’s Debug.Log()<\/code> method to output messages to the console<\/li>\n\n\n\n
    • Prefixes messages with “MyDebugNode:” for easy identification<\/li>\n\n\n\n
    • Calls Run()<\/code> to continue execution to the next node in the sequence<\/li>\n<\/ul>\n\n\n\n
      Runtime Behavior:<\/h4>\n\n\n\n
        \n
      • When the flow input is triggered, the node gets the current string value<\/li>\n\n\n\n
      • Logs the string to the Unity console<\/li>\n\n\n\n
      • Continues execution flow to any connected node<\/li>\n<\/ul>\n\n\n\n
        Using the Node<\/h3>\n\n\n\n
          \n
        1. Add the MyDebugNode to your node graph<\/li>\n\n\n\n
        2. Connect the flow execution from a previous node to its input<\/li>\n\n\n\n
        3. Connect a string value to the string input, or manually enter text<\/li>\n\n\n\n
        4. Connect the flow output to any subsequent nodes<\/li>\n\n\n\n
        5. When executed, the node will print your string to the console and continue execution<\/li>\n<\/ol>\n\n\n\n
          2. MyLerpFloat Tutorial<\/h2>\n\n\n\n
          The Lerp Float Node performs linear interpolation between two values \u2013 perfect for creating smooth transitions and animations in your node-based applications!<\/p>\n\n\n\n
          Purpose<\/h3>\n\n\n\n
          This node takes two float values (x and y) and a t parameter (0-1), then performs linear interpolation to calculate a value between them.<\/p>\n\n\n\n
          Step-by-Step Tutorial<\/h3>\n\n\n\n
          1. Create the Node Script<\/h4>\n\n\n\n
          using<\/span> System;\nusing<\/span> System.Collections.Generic;\nusing<\/span> WorldBuilder.Nodes.IO;\nusing<\/span> UnityEngine;\nusing<\/span> Worldbuilder.Nodes.FileIO;\n\nnamespace<\/span> WorldBuilder<\/span>.Nodes<\/span>\n<\/span>{\n    public<\/span> class<\/span> MyLerpFloat<\/span> : NodeBase<\/span>, INodeBase<\/span>\n    <\/span>{\n        public<\/span> static<\/span> string<\/span> NODE_GUID => \"69eaba67-8d94-476b-9ec1-9f2b6643b650\"<\/span>;\n        public<\/span> static<\/span> string<\/span> NODE_CLASS_NAME => \"My Lerp (x,y,t)\"<\/span>;\n\n        public<\/span> override<\/span> Guid NodeClassGuid => Guid.Parse(NODE_GUID);\n        public<\/span> override<\/span> string<\/span> NodeClassName => NODE_CLASS_NAME;\n\n        public<\/span> static<\/span> List<NodeFactory.VarType> InputTypes => m_InputTypes;\n        public<\/span> static<\/span> List<NodeFactory.VarType> OutputTypes => m_OutputTypes;\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_InputTypes = new<\/span> List<NodeFactory.VarType> { \n            NodeFactory.VarType.Float, \n            NodeFactory.VarType.Float, \n            NodeFactory.VarType.Float \n        };\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_OutputTypes = new<\/span> List<NodeFactory.VarType> { \n            NodeFactory.VarType.Float \n        };\n\n        private<\/span> InputBase m_ValueA;\n        private<\/span> InputBase m_ValueB;\n        private<\/span> InputBase m_Scalar;\n\n        private<\/span> FloatOutput m_ResultOutput;\n\n        public<\/span> MyLerpFloat(NodeTree nodeTree, Guid nodeInstanceGuid) :\n            base(nodeTree, nodeInstanceGuid, null<\/span>, m_InputTypes, m_OutputTypes)\n        {\n        }\n\n        public<\/span> MyLerpFloat(NodeTree nodeTree, NodeFile nodeFile, NodeFileEntry nodeFileEntry) :\n            base(nodeTree, nodeFileEntry.Identity, nodeFileEntry, m_InputTypes, m_OutputTypes)\n        {\n        }\n\n        protected<\/span> override<\/span> void<\/span> MakeIO(NodeFileEntry nodeFileEntry)\n        {\n            m_ValueA = Inputs[0<\/span>];\n            m_ValueA.DisplayName = \"x\"<\/span>;\n\n            m_ValueB = Inputs[1<\/span>];\n            m_ValueB.DisplayName = \"y\"<\/span>;\n\n            m_Scalar = Inputs[2<\/span>];\n            m_Scalar.DisplayName = \"t\"<\/span>;\n\n            m_ResultOutput = Outputs[0<\/span>] as FloatOutput;\n            m_ResultOutput.DisplayName = \"result\"<\/span>;\n            m_ResultOutput.SetGetValueFunc(Calc);\n        }\n\n        private<\/span> float<\/span> Calc()\n        {\n            float<\/span> scalar = Math.Clamp(m_Scalar.GetFloat(), 0.0<\/span>f, 1.0<\/span>f);\n\n            float<\/span> a = m_ValueA.GetFloat();\n            float<\/span> b = m_ValueB.GetFloat();\n            return<\/span> Mathf.Lerp(a, b, scalar);\n        }\n    }\n}\n<\/code><\/pre>\n\n\n\n
          How It Works<\/h3>\n\n\n\n
          Node Properties:<\/h4>\n\n\n\n
            \n
          • x Input<\/strong>: The starting value<\/li>\n\n\n\n
          • y Input<\/strong>: The ending value<\/li>\n\n\n\n
          • t Input<\/strong>: The interpolation parameter (0-1)<\/li>\n\n\n\n
          • result Output<\/strong>: The interpolated value<\/li>\n<\/ul>\n\n\n\n
            The Math Behind It:<\/h4>\n\n\n\n
              \n
            • Linear interpolation calculates a point between two values<\/li>\n\n\n\n
            • When t=0, the result equals x<\/li>\n\n\n\n
            • When t=1, the result equals y<\/li>\n\n\n\n
            • When t is between 0 and 1, the result is proportionally between x and y<\/li>\n\n\n\n
            • The formula is: result = x + (y – x) * t<\/li>\n<\/ul>\n\n\n\n
              Implementation Details:<\/h4>\n\n\n\n
                \n
              • Uses Unity’s Mathf.Lerp()<\/code> function for the actual calculation<\/li>\n\n\n\n
              • Clamps the t parameter between 0 and 1 to ensure valid results<\/li>\n\n\n\n
              • Returns the interpolated value through the output<\/li>\n<\/ul>\n\n\n\n
                Using the Node<\/h3>\n\n\n\n
                  \n
                1. Add the MyLerpFloat node to your graph<\/li>\n\n\n\n
                2. Connect float values to the x and y inputs<\/li>\n\n\n\n
                3. Connect a value between 0-1 to the t input<\/li>\n\n\n\n
                4. Use the result output anywhere you need the interpolated value<\/li>\n\n\n\n
                5. For animation, try connecting a time-based value to t<\/li>\n<\/ol>\n\n\n\n
                  3. MyRoundToFloat Tutorial<\/h2>\n\n\n\n
                  The Round To Float Node rounds decimal values to a specified precision \u2013 perfect for cleaning up calculations and displaying user-friendly numbers!<\/p>\n\n\n\n
                  Purpose<\/h3>\n\n\n\n
                  This node takes a float value and rounds it to a specified number of decimal places, making it ideal for formatting numbers for display or ensuring consistent precision.<\/p>\n\n\n\n
                  Step-by-Step Tutorial<\/h3>\n\n\n\n
                  1. Create the Node Script<\/h4>\n\n\n\n
                  using<\/span> System;\nusing<\/span> System.Collections.Generic;\nusing<\/span> Worldbuilder.Nodes.FileIO;\nusing<\/span> WorldBuilder.Nodes.IO;\n\nnamespace<\/span> WorldBuilder.Nodes<\/span>\n{\n    public<\/span> class<\/span> MyRoundToFloatNode<\/span> : NodeBase<\/span>\n    {\n        public<\/span> static<\/span> string<\/span> NODE_GUID => \"04a383f8-03df-46d4-b336-dfd4ed1685c6\"<\/span>;\n\n        public<\/span> static<\/span> string<\/span> NODE_CLASS_NAME => \"My Round To Float\"<\/span>;\n\n        public<\/span> override<\/span> Guid NodeClassGuid => Guid.Parse(NODE_GUID);\n\n        public<\/span> override<\/span> string<\/span> NodeClassName => NODE_CLASS_NAME;\n\n        public<\/span> static<\/span> List<NodeFactory.VarType> InputTypes => m_InputTypes;\n        public<\/span> static<\/span> List<NodeFactory.VarType> OutputTypes => m_OutputTypes;\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_InputTypes = new<\/span> List<NodeFactory.VarType> { \n            NodeFactory.VarType.Float, \n            NodeFactory.VarType.Int \n        };\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_OutputTypes = new<\/span> List<NodeFactory.VarType> { \n            NodeFactory.VarType.Float \n        };\n\n        private<\/span> InputBase m_ValueInput;\n        private<\/span> InputBase m_NrOfDecimalsInput;\n        private<\/span> FloatOutput m_ResultOutput;\n\n        public<\/span> MyRoundToFloatNode<\/span>(NodeTree nodeTree, Guid nodeInstanceGuid<\/span>) :\n            base<\/span>(nodeTree, nodeInstanceGuid, null<\/span>, m_InputTypes, m_OutputTypes<\/span>)\n        <\/span>{\n        }\n\n        public<\/span> MyRoundToFloatNode<\/span>(NodeTree nodeTree, NodeFile nodeFile, NodeFileEntry nodeFileEntry<\/span>) :\n            base<\/span>(nodeTree, nodeFileEntry.Identity, nodeFileEntry, m_InputTypes, m_OutputTypes<\/span>)\n        <\/span>{\n        }\n\n        protected<\/span> override<\/span> void<\/span> MakeIO<\/span>(NodeFileEntry nodeFileEntry<\/span>)\n        <\/span>{\n            m_ValueInput = Inputs[0<\/span>];\n            m_ValueInput.DisplayName = \"Value\"<\/span>;\n\n            m_NrOfDecimalsInput = Inputs[1<\/span>];\n            m_NrOfDecimalsInput.DisplayName = \"Decimal places\"<\/span>;\n\n            m_ResultOutput = Outputs[0<\/span>] as<\/span> FloatOutput;\n            m_ResultOutput.DisplayName = \"Rounded Value\"<\/span>;\n            m_ResultOutput.SetGetValueFunc(() => RoundWithDecimalPlaces(m_NrOfDecimalsInput.GetInt()));\n        }\n\n        private<\/span> float<\/span> RoundWithDecimalPlaces<\/span>(int<\/span> nrOfDecimalPlaces<\/span>) <\/span>=> \n            (float<\/span>)Math.Round(m_ValueInput.GetFloat(), nrOfDecimalPlaces);\n    }\n}\n<\/code><\/pre>\n\n\n\n
                  How It Works<\/h3>\n\n\n\n
                  Node Properties:<\/h4>\n\n\n\n
                    \n
                  • Value Input<\/strong>: The float value to be rounded<\/li>\n\n\n\n
                  • Decimal places Input<\/strong>: Integer specifying how many decimal places to keep<\/li>\n\n\n\n
                  • Rounded Value Output<\/strong>: The result after rounding<\/li>\n<\/ul>\n\n\n\n
                    Implementation Details:<\/h4>\n\n\n\n
                      \n
                    • Uses the Math.Round()<\/code> method to perform precision rounding<\/li>\n\n\n\n
                    • Takes an integer parameter to specify the number of decimal places<\/li>\n\n\n\n
                    • Returns the rounded value as a float<\/li>\n\n\n\n
                    • Uses a lambda expression to connect the rounding function to the output<\/li>\n<\/ul>\n\n\n\n
                      Runtime Behavior:<\/h4>\n\n\n\n
                        \n
                      • When the output value is requested, the node reads both inputs<\/li>\n\n\n\n
                      • Applies the Math.Round function with the specified precision<\/li>\n\n\n\n
                      • Returns the rounded float value through the output<\/li>\n<\/ul>\n\n\n\n
                        Using the Node<\/h3>\n\n\n\n
                          \n
                        1. Add the MyRoundToFloatNode to your graph<\/li>\n\n\n\n
                        2. Connect a float value to the Value input<\/li>\n\n\n\n
                        3. Set the Decimal places input (e.g., 2 for two decimal places)<\/li>\n\n\n\n
                        4. Use the Rounded Value output anywhere you need the formatted number<\/li>\n\n\n\n
                        5. Perfect for display values, currency, or measurements<\/li>\n<\/ol>\n\n\n\n
                          4. MyVideoPlayerNode Tutorial<\/h2>\n\n\n\n
                          The Video Player Node controls video playback within your application \u2013 perfect for creating interactive media experiences and presentations!<\/p>\n\n\n\n
                          Purpose<\/h3>\n\n\n\n
                          This advanced node allows you to play, stop, and control video playback on GameObjects with video components, supporting both asset-based videos and URL streams.<\/p>\n\n\n\n
                          Step-by-Step Tutorial<\/h3>\n\n\n\n
                          1. Create the Node Script<\/h4>\n\n\n\n
                          \/\/ This is a complex node, so I'll provide a simplified version of the key parts<\/span>\npublic<\/span> class<\/span> MyVideoPlayerNode<\/span> : NodeBase<\/span>, INodeBase<\/span>\n<\/span>{\n    public<\/span> class<\/span> VideoSourceData<\/span>\n    <\/span>{\n        public<\/span> string<\/span> AssetGuidString = null<\/span>;\n        public<\/span> string<\/span> VideoUrl = null<\/span>;\n    }\n\n    public<\/span> static<\/span> string<\/span> NODE_GUID => \"c9cfd216-9103-471c-8642-fe07c025e350\"<\/span>;\n    public<\/span> static<\/span> string<\/span> NODE_CLASS_NAME => \"My Video Player\"<\/span>;\n\n    \/\/ Input\/Output definitions with five inputs and two outputs<\/span>\n    private<\/span> static<\/span> List<NodeFactory.VarType> m_InputTypes = new<\/span> List<NodeFactory.VarType> \n    { \n        NodeFactory.VarType.Flow,  \/\/ Play flow<\/span>\n        NodeFactory.VarType.Flow,  \/\/ Stop flow<\/span>\n        NodeFactory.VarType.Flow,  \/\/ Set Time flow<\/span>\n        NodeFactory.VarType.Float, \/\/ Time value<\/span>\n        NodeFactory.VarType.GameObject \/\/ Target object<\/span>\n    };\n\n    private<\/span> static<\/span> List<NodeFactory.VarType> m_OutputTypes = new<\/span> List<NodeFactory.VarType> \n    { \n        NodeFactory.VarType.Flow,  \/\/ Execution flow output<\/span>\n        NodeFactory.VarType.Bool   \/\/ Is Playing status<\/span>\n    };\n\n    \/\/ Input\/Output references<\/span>\n    private<\/span> InputBase m_PlayFlowIn;\n    private<\/span> InputBase m_StopFlowIn;\n    private<\/span> InputBase m_SetTimeFlowIn;\n    private<\/span> InputBase m_TimeFloatIn;\n    private<\/span> InputBase m_GameObjectIn;\n    private<\/span> BoolOutput m_IsPlayingOutput;\n\n    private<\/span> VideoSourceData m_VideoSourceData = new<\/span>();\n\n    \/\/ MakeIO method connects the inputs and outputs<\/span>\n    protected<\/span> override<\/span> void<\/span> MakeIO(NodeFileEntry nodeFileEntry)\n    {\n        \/\/ Set up flow inputs with their actions<\/span>\n        m_PlayFlowIn = Inputs[0<\/span>];\n        m_PlayFlowIn.DisplayName = \"Play\"<\/span>;\n        m_PlayFlowIn.RunAction = () => Play();\n\n        m_StopFlowIn = Inputs[1<\/span>];\n        m_StopFlowIn.DisplayName = \"Stop\"<\/span>;\n        m_StopFlowIn.RunAction = () => Stop();\n\n        m_SetTimeFlowIn = Inputs[2<\/span>];\n        m_SetTimeFlowIn.DisplayName = \"Set Time\"<\/span>;\n        m_SetTimeFlowIn.RunAction = () => ChangeTime();\n\n        \/\/ Set up value inputs<\/span>\n        m_TimeFloatIn = Inputs[3<\/span>];\n        m_TimeFloatIn.DisplayName = \"time\"<\/span>;\n\n        m_GameObjectIn = Inputs[4<\/span>];\n        m_GameObjectIn.DisplayName = \"object\"<\/span>;\n\n        \/\/ Set up outputs<\/span>\n        OutputBase flowOutput = Outputs[0<\/span>];\n        flowOutput.DisplayName = \"Run\"<\/span>;\n\n        m_IsPlayingOutput = Outputs[1<\/span>] as BoolOutput;\n        m_IsPlayingOutput.DisplayName = \"Is Playing\"<\/span>;\n    }\n\n    \/\/ Action implementations<\/span>\n    private<\/span> void<\/span> Play()\n    {\n        \/\/ Play video on the target object<\/span>\n        \/\/ [Implementation details omitted for brevity]<\/span>\n\n        Run(); \/\/ Continue execution flow<\/span>\n    }\n\n    private<\/span> void<\/span> Stop()\n    {\n        \/\/ Stop video on the target object<\/span>\n    }\n\n    private<\/span> void<\/span> ChangeTime()\n    {\n        \/\/ Change playback time to the specified value<\/span>\n    }\n}\n<\/code><\/pre>\n\n\n\n
                          How It Works<\/h3>\n\n\n\n
                          Node Properties:<\/h4>\n\n\n\n
                            \n
                          • Play Input (Flow)<\/strong>: Begins video playback<\/li>\n\n\n\n
                          • Stop Input (Flow)<\/strong>: Stops video playback<\/li>\n\n\n\n
                          • Set Time Input (Flow)<\/strong>: Sets the playback position<\/li>\n\n\n\n
                          • Time Input (Float)<\/strong>: The timestamp to seek to (in seconds)<\/li>\n\n\n\n
                          • Object Input (GameObject)<\/strong>: The GameObject containing the video player<\/li>\n\n\n\n
                          • Run Output (Flow)<\/strong>: Continues execution flow after playback control<\/li>\n\n\n\n
                          • Is Playing Output (Bool)<\/strong>: Indicates if the video is currently playing<\/li>\n<\/ul>\n\n\n\n
                            Implementation Details:<\/h4>\n\n\n\n
                              \n
                            • Supports both asset-based videos (from your project) and URL-based streaming<\/li>\n\n\n\n
                            • Stores video source data that persists when saving the node graph<\/li>\n\n\n\n
                            • Connects to Unity’s VideoPlayer component to control playback<\/li>\n\n\n\n
                            • Provides custom UI elements in the node editor for setting video sources<\/li>\n<\/ul>\n\n\n\n
                              Advanced Features:<\/h4>\n\n\n\n
                                \n
                              • Provides IsPlaying status output for conditional logic<\/li>\n\n\n\n
                              • Maintains state information even when playback was triggered elsewhere<\/li>\n\n\n\n
                              • Has UI in the editor for selecting video assets or entering URLs<\/li>\n<\/ul>\n\n\n\n
                                Using the Node<\/h3>\n\n\n\n
                                  \n
                                1. Add the MyVideoPlayerNode to your graph<\/li>\n\n\n\n
                                2. Connect the “object” input to a GameObject that has a VideoPlayer component<\/li>\n\n\n\n
                                3. In the node editor, select a video asset or enter a URL<\/li>\n\n\n\n
                                4. Connect the appropriate flow inputs:\n
                                    \n
                                  • Use “Play” to start playback<\/li>\n\n\n\n
                                  • Use “Stop” to end playback<\/li>\n\n\n\n
                                  • Use “Set Time” to jump to a specific timestamp<\/li>\n<\/ul>\n<\/li>\n\n\n\n
                                  • Connect the “Run” output to any nodes that should execute after video control<\/li>\n\n\n\n
                                  • Use the “Is Playing” boolean output for conditional logic<\/li>\n<\/ol>\n\n\n\n
                                    Creating Your Own Custom Nodes<\/h2>\n\n\n\n
                                    Now that you’ve seen several examples, let’s go through the process of creating your own custom node:<\/p>\n\n\n\n
                                    Step 1: Plan Your Node’s Functionality<\/h3>\n\n\n\n
                                      \n
                                    • Determine what your node will do<\/li>\n\n\n\n
                                    • Decide what inputs and outputs it needs<\/li>\n\n\n\n
                                    • Consider any special data it might need to store<\/li>\n<\/ul>\n\n\n\n
                                      Step 2: Generate a Unique GUID<\/h3>\n\n\n\n
                                      Every node needs a unique identifier. Generate a GUID using one of these methods:<\/p>\n\n\n\n
                                        \n
                                      • Use Visual Studio’s Tools > Create GUID<\/li>\n\n\n\n
                                      • Use an online GUID generator<\/li>\n\n\n\n
                                      • Execute Guid.NewGuid().ToString()<\/code> in C#<\/li>\n<\/ul>\n\n\n\n
                                        Step 3: Create the Node Class<\/h3>\n\n\n\n
                                        Create a new C# file named after your node (e.g., MyCustomNode.cs<\/code>) with this structure:<\/p>\n\n\n\n
                                        using<\/span> System;\nusing<\/span> System.Collections.Generic;\nusing<\/span> WorldBuilder.Nodes;\nusing<\/span> WorldBuilder.Nodes.IO;\nusing<\/span> Worldbuilder.Nodes.FileIO;\n\nnamespace<\/span> MyNodes<\/span>\n{\n    public<\/span> class<\/span> MyCustomNode<\/span> : NodeBase<\/span>\n    {\n        \/\/ 1. Define the unique GUID and name<\/span>\n        public<\/span> static<\/span> string<\/span> NODE_GUID => \"your-generated-guid-here\"<\/span>;\n        public<\/span> static<\/span> string<\/span> NODE_CLASS_NAME => \"My Custom Node\"<\/span>;\n\n        public<\/span> override<\/span> Guid NodeClassGuid => Guid.Parse(NODE_GUID);\n        public<\/span> override<\/span> string<\/span> NodeClassName => NODE_CLASS_NAME;\n\n        \/\/ 2. Define inputs and outputs<\/span>\n        public<\/span> static<\/span> List<NodeFactory.VarType> InputTypes => m_InputTypes;\n        public<\/span> static<\/span> List<NodeFactory.VarType> OutputTypes => m_OutputTypes;\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_InputTypes = new<\/span> List<NodeFactory.VarType> {\n            \/\/ List your input types here<\/span>\n        };\n\n        private<\/span> static<\/span> List<NodeFactory.VarType> m_OutputTypes = new<\/span> List<NodeFactory.VarType> {\n            \/\/ List your output types here<\/span>\n        };\n\n        \/\/ 3. Create references to inputs and outputs<\/span>\n        private<\/span> InputBase m_SomeInput;\n        private<\/span> FloatOutput m_SomeOutput;\n\n        \/\/ 4. Create constructors<\/span>\n        public<\/span> MyCustomNode<\/span>(NodeTree nodeTree, Guid nodeInstanceGuid<\/span>) :\n            base<\/span>(nodeTree, nodeInstanceGuid, null<\/span>, m_InputTypes, m_OutputTypes<\/span>)\n        <\/span>{\n        }\n\n        public<\/span> MyCustomNode<\/span>(NodeTree nodeTree, NodeFile nodeFile, NodeFileEntry nodeFileEntry<\/span>) :\n            base<\/span>(nodeTree, nodeFileEntry.Identity, nodeFileEntry, m_InputTypes, m_OutputTypes<\/span>)\n        <\/span>{\n            \/\/ Load any saved data if needed<\/span>\n        }\n\n        \/\/ 5. Configure inputs and outputs<\/span>\n        protected<\/span> override<\/span> void<\/span> MakeIO<\/span>(NodeFileEntry nodeFileEntry<\/span>)\n        <\/span>{\n            \/\/ Configure inputs<\/span>\n            m_SomeInput = Inputs[0<\/span>];\n            m_SomeInput.DisplayName = \"My Input\"<\/span>;\n\n            \/\/ For flow inputs, assign the action<\/span>\n            if<\/span> (InputTypes[0<\/span>] == NodeFactory.VarType.Flow)\n                Inputs[0<\/span>].RunAction = MyAction;\n\n            \/\/ Configure outputs<\/span>\n            m_SomeOutput = Outputs[0<\/span>] as<\/span> FloatOutput;\n            m_SomeOutput.DisplayName = \"My Output\"<\/span>;\n            m_SomeOutput.SetGetValueFunc(CalculateOutput);\n        }\n\n        \/\/ 6. Implement node functionality<\/span>\n        private<\/span> void<\/span> MyAction<\/span>(<\/span>)\n        <\/span>{\n            \/\/ Your node's action logic here<\/span>\n\n            \/\/ Continue execution flow<\/span>\n            Run();\n        }\n\n        private<\/span> float<\/span> CalculateOutput<\/span>(<\/span>)\n        <\/span>{\n            \/\/ Your calculation logic here<\/span>\n            return<\/span> 0.0<\/span>f;\n        }\n    }\n}\n<\/code><\/pre>\n\n\n\n
                                        Step 4: Test Your Node<\/h3>\n\n\n\n
                                          \n
                                        1. Add your new node to your project<\/li>\n\n\n\n
                                        2. Use it in a node graph<\/li>\n\n\n\n
                                        3. Test all inputs and outputs to verify functionality<\/li>\n\n\n\n
                                        4. Debug any issues using Unity’s console<\/li>\n<\/ol>\n\n\n\n
                                          Best Practices for Custom Nodes<\/h2>\n\n\n\n
                                          1. Keep It Simple<\/h3>\n\n\n\n
                                            \n
                                          • Focus each node on a specific, well-defined task<\/li>\n\n\n\n
                                          • Avoid creating “super nodes” that try to do too many things<\/li>\n<\/ul>\n\n\n\n
                                            2. Use Descriptive Names<\/h3>\n\n\n\n
                                              \n
                                            • Give your node a clear, descriptive name<\/li>\n\n\n\n
                                            • Use display names that explain what each input and output does<\/li>\n<\/ul>\n\n\n\n
                                              3. Handle Edge Cases<\/h3>\n\n\n\n
                                                \n
                                              • Check for null values and other potential errors<\/li>\n\n\n\n
                                              • Provide sensible defaults when inputs are not connected<\/li>\n<\/ul>\n\n\n\n
                                                4. Document Your Nodes<\/h3>\n\n\n\n
                                                  \n
                                                • Add comments explaining complex logic<\/li>\n\n\n\n
                                                • Consider creating a README for your custom node library<\/li>\n<\/ul>\n\n\n\n
                                                  5. Optimize Performance<\/h3>\n\n\n\n
                                                    \n
                                                  • Avoid expensive operations in frequently called methods<\/li>\n\n\n\n
                                                  • Cache results when appropriate to avoid redundant calculations<\/li>\n<\/ul>\n\n\n\n
                                                    Conclusion<\/h2>\n\n\n\n
                                                    Custom nodes are a powerful way to extend your node-based application with new functionality. By following the patterns shown in these examples, you can create your own nodes that integrate seamlessly with the existing system.<\/p>\n\n\n\n
                                                    Remember that the key elements of any node are:<\/p>\n\n\n\n
                                                      \n
                                                    1. A unique GUID to identify the node type<\/li>\n\n\n\n
                                                    2. Clearly defined inputs and outputs<\/li>\n\n\n\n
                                                    3. Well-implemented functionality<\/li>\n\n\n\n
                                                    4. Proper execution flow management<\/li>\n<\/ol>\n\n\n\n
                                                      Happy node creating!<\/p>\n","protected":false},"excerpt":{"rendered":"
                                                      1. MyDebugNode Tutorial The Debug Node lets you print messages to the Unity console \u2013 perfect for tracking values and debugging your node graphs during runtime! You can find all of our currently implemented Nodes here. Purpose This node takes a string input and logs it to the Unity console, making it easy to debug…<\/p>\n","protected":false},"author":5,"featured_media":0,"comment_status":"open","ping_status":"closed","template":"","meta":{"_bbp_topic_count":0,"_bbp_reply_count":0,"_bbp_total_topic_count":0,"_bbp_total_reply_count":0,"_bbp_voice_count":0,"_bbp_anonymous_reply_count":0,"_bbp_topic_count_hidden":0,"_bbp_reply_count_hidden":0,"_bbp_forum_subforum_count":0,"_kad_post_transparent":"","_kad_post_title":"","_kad_post_layout":"","_kad_post_sidebar_id":"","_kad_post_content_style":"","_kad_post_vertical_padding":"","_kad_post_feature":"","_kad_post_feature_position":"","_kad_post_header":false,"_kad_post_footer":false,"footnotes":""},"doc_category":[16],"doc_tag":[],"class_list":["post-1530","docs","type-docs","status-publish","hentry","doc_category-world-builder-extensions"],"year_month":"2025-08","word_count":2400,"total_views":0,"reactions":{"happy":0,"normal":0,"sad":0},"author_info":{"name":"maximilian.winter","author_nicename":"maximilian-winter","author_url":"https:\/\/www.portalsunited.com:443\/author\/maximilian-winter\/"},"doc_category_info":[{"term_name":"World Builder - Extensions","term_url":"https:\/\/www.portalsunited.com:443\/docs-category\/world-builder-extensions\/"}],"doc_tag_info":[],"_links":{"self":[{"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/docs\/1530","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/docs"}],"about":[{"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/types\/docs"}],"author":[{"embeddable":true,"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/users\/5"}],"replies":[{"embeddable":true,"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/comments?post=1530"}],"version-history":[{"count":3,"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/docs\/1530\/revisions"}],"predecessor-version":[{"id":1685,"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/docs\/1530\/revisions\/1685"}],"wp:attachment":[{"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/media?parent=1530"}],"wp:term":[{"taxonomy":"doc_category","embeddable":true,"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/doc_category?post=1530"},{"taxonomy":"doc_tag","embeddable":true,"href":"https:\/\/www.portalsunited.com:443\/wp-json\/wp\/v2\/doc_tag?post=1530"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}