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,
  NODE_INTERFACE_SOCKET_SINGLE_VALUE_ONLY = 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,
} NodeTreeInterfaceSocketFlag;
ENUM_OPERATORS(NodeTreeInterfaceSocketFlag, NODE_INTERFACE_SOCKET_INSPECT);
 
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;
 
  IDProperty *properties;
 
#ifdef __cplusplus
  bNodeSocketTypeHandle *socket_typeinfo() const;
  blender::ColorGeometry4f socket_color() const;
 
  bool set_socket_type(const char *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,
  /* Allow child panels inside this panel. */
  NODE_INTERFACE_PANEL_ALLOW_CHILD_PANELS = 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);
 
#define NODE_INPUT_DEFAULT_VALUE 0
 
typedef enum GeometryNodeDefaultInputType {
  GEO_NODE_DEFAULT_INPUT_VALUE = NODE_INPUT_DEFAULT_VALUE,
  GEO_NODE_DEFAULT_FIELD_INPUT_INDEX_FIELD = 1,
  GEO_NODE_DEFAULT_FIELD_INPUT_ID_INDEX_FIELD = 2,
  GEO_NODE_DEFAULT_FIELD_INPUT_NORMAL_FIELD = 3,
  GEO_NODE_DEFAULT_FIELD_INPUT_POSITION_FIELD = 4,
  GEO_NODE_DEFAULT_FIELD_INPUT_INSTANCE_TRANSFORM_FIELD = 5,
} GeometryNodeDefaultInputType;
 
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;
 
 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 is_changed() const;
 
  void tag_items_changed();
 
  void reset_changed_flags();
 
 private:
  void tag_missing_runtime_data();
 
#endif
} bNodeTreeInterface;