DNA_node_tree_interface_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2005 Blender Authors
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "BLI_utildefines.h"
 
#ifdef __cplusplus
#  include "BLI_color.hh"
#  include "BLI_function_ref.hh"
#  include "BLI_span.hh"
#  include "BLI_string_ref.hh"
 
#  include <memory>
#endif
 
#ifdef __cplusplus
namespace blender::bke {
class bNodeTreeInterfaceRuntime;
struct bNodeSocketType;
}  // namespace blender::bke
using bNodeTreeInterfaceRuntimeHandle = blender::bke::bNodeTreeInterfaceRuntime;
using bNodeSocketTypeHandle = blender::bke::bNodeSocketType;
#else
typedef struct bNodeTreeInterfaceRuntimeHandle bNodeTreeInterfaceRuntimeHandle;
typedef struct bNodeSocketTypeHandle bNodeSocketTypeHandle;
#endif
 
struct bNodeSocket;
struct bNodeTreeInterfaceItem;
struct bNodeTreeInterfacePanel;
struct bNodeTreeInterfaceSocket;
struct ID;
struct IDProperty;
struct LibraryForeachIDData;
struct BlendWriter;
struct BlendDataReader;

typedef enum NodeTreeInterfaceItemType {
  NODE_INTERFACE_PANEL = 0,
  NODE_INTERFACE_SOCKET = 1,
} eNodeTreeInterfaceItemType;

typedef struct bNodeTreeInterfaceItem {
  /* eNodeTreeInterfaceItemType */
  char item_type;
  char _pad[7];
} bNodeTreeInterfaceItem;
 
/* Socket interface flags */
typedef enum NodeTreeInterfaceSocketFlag {
  NODE_INTERFACE_SOCKET_INPUT = 1 << 0,
  NODE_INTERFACE_SOCKET_OUTPUT = 1 << 1,
  NODE_INTERFACE_SOCKET_HIDE_VALUE = 1 << 2,
  NODE_INTERFACE_SOCKET_HIDE_IN_MODIFIER = 1 << 3,
  NODE_INTERFACE_SOCKET_COMPACT = 1 << 4,
  /* To be deprecated when structure types are moved out of experimental. */
  NODE_INTERFACE_SOCKET_SINGLE_VALUE_ONLY_LEGACY = 1 << 5,
  NODE_INTERFACE_SOCKET_LAYER_SELECTION = 1 << 6,
  /* INSPECT is used by Connect to Output operator to ensure socket that exits from node group. */
  NODE_INTERFACE_SOCKET_INSPECT = 1 << 7,
  /* Socket is used in the panel header as a toggle. */
  NODE_INTERFACE_SOCKET_PANEL_TOGGLE = 1 << 8,
  /* Menu socket should be drawn expanded instead of as drop-down menu. */
  NODE_INTERFACE_SOCKET_MENU_EXPANDED = 1 << 9,
} NodeTreeInterfaceSocketFlag;
ENUM_OPERATORS(NodeTreeInterfaceSocketFlag, NODE_INTERFACE_SOCKET_MENU_EXPANDED);
 
typedef enum NodeSocketInterfaceStructureType {
  NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_AUTO = 0,
  NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_SINGLE = 1,
  NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_DYNAMIC = 2,
  NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_FIELD = 3,
  NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_GRID = 4,
} NodeSocketInterfaceStructureType;
 
// TODO: Move out of DNA.
#ifdef __cplusplus
namespace blender::nodes {
enum class StructureType : int8_t {
  Single = NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_SINGLE,
  Dynamic = NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_DYNAMIC,
  Field = NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_FIELD,
  Grid = NODE_INTERFACE_SOCKET_STRUCTURE_TYPE_GRID,
};
}
#endif
 
typedef struct bNodeTreeInterfaceSocket {
  bNodeTreeInterfaceItem item;
 
  /* UI name of the socket. */
  char *name;
  char *description;
  /* Type idname of the socket to generate, e.g. "NodeSocketFloat". */
  char *socket_type;
  /* NodeTreeInterfaceSocketFlag */
  int flag;
 
  /* AttrDomain */
  int16_t attribute_domain;
  int16_t default_input;
  char *default_attribute_name;
 
  /* Unique identifier for generated sockets. */
  char *identifier;
  /* Socket default value and associated data, e.g. bNodeSocketValueFloat. */
  void *socket_data;
 
  struct IDProperty *properties;

  int8_t structure_type;
  char _pad[7];
 
#ifdef __cplusplus
  bNodeSocketTypeHandle *socket_typeinfo() const;
  blender::ColorGeometry4f socket_color() const;

  bool set_socket_type(blender::StringRef new_socket_type);

  void init_from_socket_instance(const bNodeSocket *socket);
#endif
} bNodeTreeInterfaceSocket;
 
/* Panel interface flags */
typedef enum NodeTreeInterfacePanelFlag {
  /* Panel starts closed on new node instances. */
  NODE_INTERFACE_PANEL_DEFAULT_CLOSED = 1 << 0,
  /* In the past, not all panels allowed child panels. Now all allow them. */
  NODE_INTERFACE_PANEL_ALLOW_CHILD_PANELS_LEGACY = 1 << 1,
  /* Allow adding sockets after panels. */
  NODE_INTERFACE_PANEL_ALLOW_SOCKETS_AFTER_PANELS = 1 << 2,
} NodeTreeInterfacePanelFlag;
ENUM_OPERATORS(NodeTreeInterfacePanelFlag, NODE_INTERFACE_PANEL_DEFAULT_CLOSED);
 
typedef enum NodeDefaultInputType {
  NODE_DEFAULT_INPUT_VALUE = 0,
  NODE_DEFAULT_INPUT_INDEX_FIELD = 1,
  NODE_DEFAULT_INPUT_ID_INDEX_FIELD = 2,
  NODE_DEFAULT_INPUT_NORMAL_FIELD = 3,
  NODE_DEFAULT_INPUT_POSITION_FIELD = 4,
  NODE_DEFAULT_INPUT_INSTANCE_TRANSFORM_FIELD = 5,
  NODE_DEFAULT_INPUT_HANDLE_LEFT_FIELD = 6,
  NODE_DEFAULT_INPUT_HANDLE_RIGHT_FIELD = 7,
} NodeDefaultInputType;
 
typedef struct bNodeTreeInterfacePanel {
  bNodeTreeInterfaceItem item;
 
  /* UI name of the panel. */
  char *name;
  char *description;
  /* NodeTreeInterfacePanelFlag */
  int flag;
  char _pad[4];
 
  bNodeTreeInterfaceItem **items_array;
  int items_num;
 
  /* Internal unique identifier for validating panel states. */
  int identifier;
 
#ifdef __cplusplus
  blender::IndexRange items_range() const;
  blender::Span<const bNodeTreeInterfaceItem *> items() const;
  blender::MutableSpan<bNodeTreeInterfaceItem *> items();

  bool contains(const bNodeTreeInterfaceItem &item) const;
  bool contains_recursive(const bNodeTreeInterfaceItem &item) const;
  int item_position(const bNodeTreeInterfaceItem &item) const;
  int item_index(const bNodeTreeInterfaceItem &item) const;
  const bNodeTreeInterfaceItem *item_at_index(int index) const;
  bNodeTreeInterfacePanel *find_parent_recursive(const bNodeTreeInterfaceItem &item);

  void clear(bool do_id_user);

  void add_item(bNodeTreeInterfaceItem &item);
  void insert_item(bNodeTreeInterfaceItem &item, int position);
  bool remove_item(bNodeTreeInterfaceItem &item, bool free);
  bool move_item(bNodeTreeInterfaceItem &item, int new_position);

  void foreach_item(blender::FunctionRef<bool(bNodeTreeInterfaceItem &item)> fn,
                    bool include_self = false);
  void foreach_item(blender::FunctionRef<bool(const bNodeTreeInterfaceItem &item)> fn,
                    bool include_self = false) const;

  const bNodeTreeInterfaceSocket *header_toggle_socket() const;
  bNodeTreeInterfaceSocket *header_toggle_socket();
 
 private:
  int find_valid_insert_position_for_item(const bNodeTreeInterfaceItem &item,
                                          int initial_position) const;
#endif
} bNodeTreeInterfacePanel;
 
typedef struct bNodeTreeInterface {
  bNodeTreeInterfacePanel root_panel;
 
  /* Global index of the active item. */
  int active_index;
  int next_uid;
 
  bNodeTreeInterfaceRuntimeHandle *runtime;
 
#ifdef __cplusplus

  void init_data();
  void copy_data(const bNodeTreeInterface &src, int flag);
  void free_data();

  void write(BlendWriter *writer);
  void read_data(BlendDataReader *reader);
 
  bNodeTreeInterfaceItem *active_item();
  const bNodeTreeInterfaceItem *active_item() const;
  void active_item_set(bNodeTreeInterfaceItem *item);

  int find_item_position(const bNodeTreeInterfaceItem &item) const
  {
    /* const_cast to avoid a const version of #find_parent_recursive. */
    const bNodeTreeInterfacePanel *parent =
        const_cast<bNodeTreeInterfacePanel &>(root_panel).find_parent_recursive(item);
    if (parent == nullptr || parent == &root_panel) {
      /* Panel is the root panel. */
      return root_panel.item_position(item);
    }
    return parent->item_position(item);
  }
  int find_item_index(const bNodeTreeInterfaceItem &item) const
  {
    return root_panel.item_index(item);
  }
  bool find_item(const bNodeTreeInterfaceItem &item) const
  {
    return root_panel.contains_recursive(item);
  }
  const bNodeTreeInterfaceItem *get_item_at_index(int index) const
  {
    return root_panel.item_at_index(index);
  }
  bNodeTreeInterfacePanel *find_item_parent(const bNodeTreeInterfaceItem &item,
                                            bool include_root = false)
  {
    bNodeTreeInterfacePanel *parent = root_panel.find_parent_recursive(item);
    /* Return nullptr instead the root panel. */
    if (!include_root && parent == &root_panel) {
      return nullptr;
    }
    return parent;
  }

  bNodeTreeInterfaceSocket *add_socket(blender::StringRef name,
                                       blender::StringRef description,
                                       blender::StringRef socket_type,
                                       NodeTreeInterfaceSocketFlag flag,
                                       bNodeTreeInterfacePanel *parent);
  bNodeTreeInterfaceSocket *insert_socket(blender::StringRef name,
                                          blender::StringRef description,
                                          blender::StringRef socket_type,
                                          NodeTreeInterfaceSocketFlag flag,
                                          bNodeTreeInterfacePanel *parent,
                                          int position);

  bNodeTreeInterfacePanel *add_panel(blender::StringRef name,
                                     blender::StringRef description,
                                     NodeTreeInterfacePanelFlag flag,
                                     bNodeTreeInterfacePanel *parent);
  bNodeTreeInterfacePanel *insert_panel(blender::StringRef name,
                                        blender::StringRef description,
                                        NodeTreeInterfacePanelFlag flag,
                                        bNodeTreeInterfacePanel *parent,
                                        int position);

  bNodeTreeInterfaceItem *add_item_copy(const bNodeTreeInterfaceItem &item,
                                        bNodeTreeInterfacePanel *parent);
  bNodeTreeInterfaceItem *insert_item_copy(const bNodeTreeInterfaceItem &item,
                                           bNodeTreeInterfacePanel *parent,
                                           int position);

  bool remove_item(bNodeTreeInterfaceItem &item, bool move_content_to_parent = true);
  void clear_items();

  bool move_item(bNodeTreeInterfaceItem &item, int new_position);
  bool move_item_to_parent(bNodeTreeInterfaceItem &item,
                           bNodeTreeInterfacePanel *new_parent,
                           int new_position);

  void foreach_item(blender::FunctionRef<bool(bNodeTreeInterfaceItem &item)> fn,
                    bool include_root = false)
  {
    root_panel.foreach_item(fn, /*include_self=*/include_root);
  }
  void foreach_item(blender::FunctionRef<bool(const bNodeTreeInterfaceItem &item)> fn,
                    bool include_root = false) const
  {
    root_panel.foreach_item(fn, /*include_self=*/include_root);
  }

  void foreach_id(LibraryForeachIDData *cb);

  bool items_cache_is_available() const;

  void ensure_items_cache() const;

  bool requires_dependent_tree_updates() const;

  void tag_items_changed();
  void tag_items_changed_generic();
  void tag_item_property_changed();

  void reset_interface_changed();
 
 private:
  void tag_interface_changed();
  void tag_missing_runtime_data();
 
#endif
} bNodeTreeInterface;