Documentation

Learn how to use NodeCanvas

  1. Getting Started
    1. Framework Concepts
    2. The GraphOwner Component
    3. The "Self" Parameter
    4. BBParameters
    5. Visual Debugging
  2. The Editor
    1. Controls & Shortcuts
    2. Assigning Tasks
    3. Canvas Groups
  3. The Blackboard
    1. Data Binding Variables
    2. Blackboard Parenting
    3. Global Variables
    4. Dynamic Variables
    5. Network Sync
    6. Save & Load
  4. Tasks (Actions & Conditions)
    1. Tasks Included
    2. The Reflection Tasks
    3. Using Task Lists
    4. Creating Custom Tasks
    5. Using Task Attributes
    6. Using BBParameters in Tasks
    7. Creating Generic Tasks
    8. Using FixedUpdate and OnGUI
  5. Behaviour Trees
    1. BT Nodes Reference
    2. Reactive Evaluation
    3. Creating Custom BT Nodes
  6. State Machines (FSM)
    1. FSM Nodes Reference
    2. FSM Callbacks
    3. Creating Custom FSM Nodes
  7. Dialogue Trees
    1. Dialogue Tree Nodes Reference
  8. Mapping Sub Graph Variables
  9. Using Graph Events
  10. Using Signal Events
  11. Working with Custom Types
  12. Working with AOT Platforms
  13. Using the Graph Console
  14. Using the Graph Refactor
  15. Using the Graph Explorer
  16. JSON Import/Export
  17. Scripting
    1. Interfacing with your code
    2. GraphOwner API
    3. Blackboard API
    4. Runtime Instantiation Tips
    5. Creating a Behaviour in Code
    6. Creating Custom Object Drawers
    7. Appending Custom AutoConverters
  18. FlowCanvas Integration
    1. Behaviour Tree -> FlowScript
    2. FSM -> FlowScript
    3. Dialogue Tree -> FlowScript
    4. FlowCanvas -> NodeCanvas
    5. Using Tasks in FlowScripts
  19. Full API

Creating Custom Object Drawers

Custom Object and Attribute Drawers work very similar to Unity’s Property Drawers feature and with it, it is possible to customize how a certain object (class/struct) appears in all NodeCanvas inspectors, as well as create GUI for custom attributes.

Object Drawers

Let’s suppose we have this example struct (it could also be a class of course).

To create a custom drawer for this object, you simply need to create a class and derive from the generic version of ObjectDrawer, then implement the OnGUI method. For example:

The instance parameter of the OnGUI method above is always of type T. By the end of the OnGUI method you must return the modified instance (this is why a struct was chosen for this example).

That’s it. The drawer will work exactly the same for fields of BBParameter<MyExampleStruct> as well. Both are shown below.

ObjectDrawer

Attribute Drawers

For this example, we are going to re-create a Range(min, max) attribute. So let’s first create the attribute, with the only requirement being that it has to derive from DrawerAttribute.

Then to create the actual GUI drawer for this attribute, in short, you need to create a class and derive from the generic version of AttributeDrawer. Much similar on how it was done before for ObjectDrawer. In this case, the T argument represents the type of the attribute we need to create the drawer for. The instance here is always of type object. The inherited ‘attribute’ property returns our attribute which we can use to fetch its meta data. No casting is required here since our attribute is of type T. It is always a good idea to check what type the field actually is by checking the inherited property ‘fieldInfo.FieldType’. Because multiple attributes may be used on the same field, it is advised to return MoveNextDrawer() by the end in case the attribute did not actually draw or returned anything. Following is how the drawer implementation of our MyRangeAttribute should ideally look like.

Finally, we simply add this new attribute above a float, or even a BBParameter<float>. It will work exactly the same. Both are shown below.

AttributeDrawer

Yes No Suggest edit
14 of 16 users found this section helpful
« Creating a Behaviour in CodeAppending Custom AutoConverters »
Suggest Edit