DNA_node_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 "DNA_ID.h"
#include "DNA_listBase.h"
#include "DNA_node_tree_interface_types.h"
#include "DNA_scene_types.h" /* for #ImageFormatData */
#include "DNA_vec_types.h"   /* for #rctf */
 
#ifdef __cplusplus
#  include <BLI_vector.hh>
#  include <string>
 
namespace blender {
template<typename T> class Span;
template<typename T> class MutableSpan;
class IndexRange;
class StringRef;
class StringRefNull;
}  // namespace blender
namespace blender::nodes {
class NodeDeclaration;
class SocketDeclaration;
}  // namespace blender::nodes
namespace blender::bke {
class bNodeTreeRuntime;
class bNodeRuntime;
class bNodeSocketRuntime;
}  // namespace blender::bke
namespace blender::bke {
class bNodeTreeZones;
class bNodeTreeZone;
struct bNodeInstanceHash;
struct bNodeTreeType;
struct bNodeType;
struct bNodeSocketType;
}  // namespace blender::bke
namespace blender::bke {
struct RuntimeNodeEnumItems;
}  // namespace blender::bke
using bNodeTreeRuntimeHandle = blender::bke::bNodeTreeRuntime;
using bNodeRuntimeHandle = blender::bke::bNodeRuntime;
using bNodeSocketRuntimeHandle = blender::bke::bNodeSocketRuntime;
using RuntimeNodeEnumItemsHandle = blender::bke::RuntimeNodeEnumItems;
using NodeInstanceHashHandle = blender::bke::bNodeInstanceHash;
using bNodeTreeTypeHandle = blender::bke::bNodeTreeType;
using bNodeTypeHandle = blender::bke::bNodeType;
using bNodeSocketTypeHandle = blender::bke::bNodeSocketType;
#else
typedef struct bNodeTreeRuntimeHandle bNodeTreeRuntimeHandle;
typedef struct bNodeRuntimeHandle bNodeRuntimeHandle;
typedef struct bNodeSocketRuntimeHandle bNodeSocketRuntimeHandle;
typedef struct RuntimeNodeEnumItemsHandle RuntimeNodeEnumItemsHandle;
typedef struct NodeInstanceHashHandle NodeInstanceHashHandle;
typedef struct bNodeTreeTypeHandle bNodeTreeTypeHandle;
typedef struct bNodeTypeHandle bNodeTypeHandle;
typedef struct bNodeSocketTypeHandle bNodeSocketTypeHandle;
#endif
 
struct AnimData;
struct Collection;
struct GeometryNodeAssetTraits;
struct ID;
struct Image;
struct ImBuf;
struct ListBase;
struct Material;
struct PreviewImage;
struct Tex;
struct bGPdata;
struct bNodeLink;
struct bNodePreview;
struct bNode;
struct NodeEnumDefinition;
 
#define NODE_MAXSTR 64
 
typedef struct bNodeStack {
  float vec[4];
  float min, max;
  void *data;
  short hasinput;
  short hasoutput;
  short datatype;
  short sockettype;
  short is_copy;
  short external;
  char _pad[4];
} bNodeStack;
 
enum {
  NS_OSA_VECTORS = 1,
  NS_OSA_VALUES = 2,
};
 
/* node socket/node socket type -b conversion rules */
enum {
  NS_CR_CENTER = 0,
  NS_CR_NONE = 1,
  NS_CR_FIT_WIDTH = 2,
  NS_CR_FIT_HEIGHT = 3,
  NS_CR_FIT = 4,
  NS_CR_STRETCH = 5,
};
 
typedef struct bNodeSocket {
  struct bNodeSocket *next, *prev;
 
  IDProperty *prop;
 
  char identifier[64];
 
  char name[64];
 
  void *storage;
 
  short type;
  short flag;
  short limit;
  short in_out;
  bNodeSocketTypeHandle *typeinfo;
  char idname[64];
 
  void *default_value;
 
  short stack_index;
  char display_shape;
 
  /* #AttrDomain used when the geometry nodes modifier creates an attribute for a group
   * output. */
  char attribute_domain;
 
  char _pad[4];
 
  char label[64];
  char short_label[64];
  char description[64];
 
  char *default_attribute_name;
 
  /* internal data to retrieve relations and groups
   * DEPRECATED, now uses the generic identifier string instead
   */
  int own_index DNA_DEPRECATED;
  /* XXX deprecated, only used for restoring old group node links */
  int to_index DNA_DEPRECATED;
 
  struct bNodeLink *link;
 
  /* XXX deprecated, socket input values are stored in default_value now.
   * kept for forward compatibility */
  bNodeStack ns DNA_DEPRECATED;
 
  bNodeSocketRuntimeHandle *runtime;
 
#ifdef __cplusplus
  bool is_hidden() const;
  bool is_available() const;
  bool is_panel_collapsed() const;
  bool is_visible() const;
  bool is_multi_input() const;
  bool is_input() const;
  bool is_output() const;
 
  template<typename T> T *default_value_typed();
  template<typename T> const T *default_value_typed() const;
 
  /* The following methods are only available when #bNodeTree.ensure_topology_cache has been
   * called. */
 
  int index() const;
  int index_in_tree() const;
  int index_in_all_inputs() const;
  int index_in_all_outputs() const;
  bNode &owner_node();
  const bNode &owner_node() const;
  bNodeTree &owner_tree();
  const bNodeTree &owner_tree() const;
 
  blender::Span<bNodeLink *> directly_linked_links();
  blender::Span<const bNodeLink *> directly_linked_links() const;
  blender::Span<bNodeSocket *> directly_linked_sockets();
  blender::Span<const bNodeSocket *> directly_linked_sockets() const;
  bool is_directly_linked() const;
  blender::Span<const bNodeSocket *> logically_linked_sockets() const;
  bool is_logically_linked() const;
 
  const bNodeSocket *internal_link_input() const;
 
#endif
} bNodeSocket;
 
typedef enum eNodeSocketDatatype {
  SOCK_CUSTOM = -1, /* socket has no integer type */
  SOCK_FLOAT = 0,
  SOCK_VECTOR = 1,
  SOCK_RGBA = 2,
  SOCK_SHADER = 3,
  SOCK_BOOLEAN = 4,
  SOCK_INT = 6,
  SOCK_STRING = 7,
  SOCK_OBJECT = 8,
  SOCK_IMAGE = 9,
  SOCK_GEOMETRY = 10,
  SOCK_COLLECTION = 11,
  SOCK_TEXTURE = 12,
  SOCK_MATERIAL = 13,
  SOCK_ROTATION = 14,
  SOCK_MENU = 15,
  SOCK_MATRIX = 16,
} eNodeSocketDatatype;
 
typedef enum eNodeSocketDisplayShape {
  SOCK_DISPLAY_SHAPE_CIRCLE = 0,
  SOCK_DISPLAY_SHAPE_SQUARE = 1,
  SOCK_DISPLAY_SHAPE_DIAMOND = 2,
  SOCK_DISPLAY_SHAPE_CIRCLE_DOT = 3,
  SOCK_DISPLAY_SHAPE_SQUARE_DOT = 4,
  SOCK_DISPLAY_SHAPE_DIAMOND_DOT = 5,
} eNodeSocketDisplayShape;
 
typedef enum eNodeSocketInOut {
  SOCK_IN = 1 << 0,
  SOCK_OUT = 1 << 1,
} eNodeSocketInOut;
ENUM_OPERATORS(eNodeSocketInOut, SOCK_OUT);
 
typedef enum eNodeSocketFlag {
  SOCK_HIDDEN = (1 << 1),
  SOCK_IS_LINKED = (1 << 2),
  SOCK_UNAVAIL = (1 << 3),
  SOCK_GIZMO_PIN = (1 << 4),
  // /** DEPRECATED  group socket should not be exposed */
  // SOCK_INTERNAL = (1 << 5),
  SOCK_COLLAPSED = (1 << 6),
  SOCK_HIDE_VALUE = (1 << 7),
  SOCK_AUTO_HIDDEN__DEPRECATED = (1 << 8),
  SOCK_NO_INTERNAL_LINK = (1 << 9),
  SOCK_COMPACT = (1 << 10),
  SOCK_MULTI_INPUT = (1 << 11),
  SOCK_HIDE_LABEL = (1 << 12),
  SOCK_HIDE_IN_MODIFIER = (1 << 13),
  SOCK_PANEL_COLLAPSED = (1 << 14),
} eNodeSocketFlag;
 
typedef enum eNodePanelFlag {
  /* Panel is collapsed (user setting). */
  NODE_PANEL_COLLAPSED = (1 << 0),
  /* The parent panel is collapsed. */
  NODE_PANEL_PARENT_COLLAPSED = (1 << 1),
  /* The panel has visible content. */
  NODE_PANEL_CONTENT_VISIBLE = (1 << 2),
} eNodePanelFlag;
 
typedef struct bNodePanelState {
  /* Unique identifier for validating state against panels in node declaration. */
  int identifier;
  /* eNodePanelFlag */
  char flag;
  char _pad[3];
 
#ifdef __cplusplus
  bool is_collapsed() const;
  bool is_parent_collapsed() const;
  bool has_visible_content() const;
#endif
} bNodePanelState;
 
typedef enum NodeWarningPropagation {
  NODE_WARNING_PROPAGATION_ALL = 0,
  NODE_WARNING_PROPAGATION_NONE = 1,
  NODE_WARNING_PROPAGATION_ONLY_ERRORS = 2,
  NODE_WARNING_PROPAGATION_ONLY_ERRORS_AND_WARNINGS = 3,
} NodeWarningPropagation;
 
typedef struct bNode {
  struct bNode *next, *prev;
 
  /* Input and output #bNodeSocket. */
  ListBase inputs, outputs;
 
  char name[64];
 
  int32_t identifier;
 
  int flag;
 
  char idname[64];
 
  bNodeTypeHandle *typeinfo;
 
  int16_t type;
 
  int16_t ui_order;
 
  int16_t custom1, custom2;
  float custom3, custom4;
 
  int8_t warning_propagation;
  char _pad[7];
 
  struct ID *id;
 
  void *storage;
 
  IDProperty *prop;
 
  struct bNode *parent;
 
  float locx, locy;
  float width, height;
  float offsetx, offsety;
 
  char label[64];
 
  float color[3];
 
  int num_panel_states;
  bNodePanelState *panel_states_array;
 
  bNodeRuntimeHandle *runtime;
 
#ifdef __cplusplus
  int index() const;
  blender::StringRefNull label_or_name() const;
  bool is_muted() const;
  bool is_reroute() const;
  bool is_frame() const;
  bool is_group() const;
  bool is_group_input() const;
  bool is_group_output() const;
  const blender::nodes::NodeDeclaration *declaration() const;
  blender::Span<bNodeLink> internal_links() const;
 
  /* This node is reroute which is not logically connected to any source of value. */
  bool is_dangling_reroute() const;
 
  /* True if the socket is visible and has a valid location. The icon may not be visible. */
  bool is_socket_drawn(const bNodeSocket &socket) const;
  /* True if the socket is drawn and the icon is visible. */
  bool is_socket_icon_drawn(const bNodeSocket &socket) const;
 
  /* The following methods are only available when #bNodeTree.ensure_topology_cache has been
   * called. */
 
  blender::Span<bNodeSocket *> input_sockets();
  blender::Span<const bNodeSocket *> input_sockets() const;
  blender::Span<bNodeSocket *> output_sockets();
  blender::Span<const bNodeSocket *> output_sockets() const;
  bNodeSocket &input_socket(int index);
  const bNodeSocket &input_socket(int index) const;
  bNodeSocket &output_socket(int index);
  const bNodeSocket &output_socket(int index) const;
  const bNodeSocket &input_by_identifier(blender::StringRef identifier) const;
  const bNodeSocket &output_by_identifier(blender::StringRef identifier) const;
  bNodeSocket &input_by_identifier(blender::StringRef identifier);
  bNodeSocket &output_by_identifier(blender::StringRef identifier);
  blender::Span<bNode *> direct_children_in_frame() const;
  blender::Span<bNodePanelState> panel_states() const;
  blender::MutableSpan<bNodePanelState> panel_states();
  const bNodeTree &owner_tree() const;
  bNodeTree &owner_tree();
#endif
} bNode;
 
enum {
  NODE_SELECT = 1 << 0,
  NODE_OPTIONS = 1 << 1,
  NODE_PREVIEW = 1 << 2,
  NODE_HIDDEN = 1 << 3,
  NODE_ACTIVE = 1 << 4,
  // NODE_ACTIVE_ID = 1 << 5, /* Deprecated. */
  NODE_DO_OUTPUT = 1 << 6,
  // NODE_GROUP_EDIT = 1 << 7, /* Deprecated, dirty. */
  NODE_TEST = 1 << 8,
  NODE_MUTED = 1 << 9,
  // NODE_CUSTOM_NAME = 1 << 10, /* Deprecated, dirty. */
  // NODE_CONST_OUTPUT = 1 << 11, /* Deprecated, dirty. */
  NODE_BACKGROUND = 1 << 12,
  // NODE_TRANSFORM = 1 << 13, /* Deprecated, dirty. */
 
  NODE_ACTIVE_TEXTURE = 1 << 14,
  NODE_CUSTOM_COLOR = 1 << 15,
  NODE_INIT = 1 << 16,
  NODE_DO_OUTPUT_RECALC = 1 << 17,
  // NODE_ACTIVE_PREVIEW = 1 << 18, /* deprecated */
  NODE_ACTIVE_PAINT_CANVAS = 1 << 19,
};
 
enum {
  NODE_UPDATE_ID = 1,
};
 
typedef struct bNodeInstanceKey {
  unsigned int value;
 
#ifdef __cplusplus
  inline bool operator==(const bNodeInstanceKey &other) const
  {
    return value == other.value;
  }
  inline bool operator!=(const bNodeInstanceKey &other) const
  {
    return !(*this == other);
  }
 
  inline uint64_t hash() const
  {
    return value;
  }
#endif
} bNodeInstanceKey;
 
#
#
typedef struct bNodeInstanceHashEntry {
  bNodeInstanceKey key;
 
  short tag;
} bNodeInstanceHashEntry;
 
#
#
typedef struct bNodePreview {
  bNodeInstanceHashEntry hash_entry;
 
  struct ImBuf *ibuf;
} bNodePreview;
 
typedef struct bNodeLink {
  struct bNodeLink *next, *prev;
 
  bNode *fromnode, *tonode;
  bNodeSocket *fromsock, *tosock;
 
  int flag;
  int multi_input_sort_id;
 
#ifdef __cplusplus
  bool is_muted() const;
  bool is_available() const;
  bool is_used() const;
#endif
 
} bNodeLink;
 
enum {
  NODE_LINK_INSERT_TARGET = 1 << 0,
  NODE_LINK_VALID = 1 << 1,
  NODE_LINK_TEST = 1 << 2,
  NODE_LINK_TEMP_HIGHLIGHT = 1 << 3,
  NODE_LINK_MUTED = 1 << 4,
  NODE_LINK_INSERT_TARGET_INVALID = 1 << 5,
};
 
typedef struct bNestedNodePath {
  int32_t node_id;
  int32_t id_in_node;
 
#ifdef __cplusplus
  uint64_t hash() const;
  friend bool operator==(const bNestedNodePath &a, const bNestedNodePath &b);
#endif
} bNestedNodePath;
 
typedef struct bNestedNodeRef {
  int32_t id;
  char _pad[4];
  bNestedNodePath path;
} bNestedNodeRef;
 
typedef struct bNodeTree {
  ID id;
  struct AnimData *adt;
 
  ID *owner_id;
 
  bNodeTreeTypeHandle *typeinfo;
  char idname[64];
  char *description;
 
  struct bGPdata *gpd;
  float view_center[2];
 
  ListBase nodes, links;
 
  int type;
 
  int cur_index;
  int flag;
 
  int chunksize DNA_DEPRECATED;
  int execution_mode DNA_DEPRECATED;
  int precision DNA_DEPRECATED;
 
  int color_tag;
 
  int default_group_node_width;
 
  rctf viewer_border;
 
  ListBase inputs_legacy DNA_DEPRECATED, outputs_legacy DNA_DEPRECATED;
 
  bNodeTreeInterface tree_interface;
 
  NodeInstanceHashHandle *previews;
  bNodeInstanceKey active_viewer_key;
 
  int nested_node_refs_num;
  bNestedNodeRef *nested_node_refs;
 
  struct GeometryNodeAssetTraits *geometry_node_asset_traits;
 
  struct PreviewImage *preview;
 
  bNodeTreeRuntimeHandle *runtime;
 
#ifdef __cplusplus
 
  blender::Span<bNode *> all_nodes();
  blender::Span<const bNode *> all_nodes() const;
 
  struct bNode *node_by_id(int32_t identifier);
  const struct bNode *node_by_id(int32_t identifier) const;
 
  blender::MutableSpan<bNestedNodeRef> nested_node_refs_span();
  blender::Span<bNestedNodeRef> nested_node_refs_span() const;
 
  const bNestedNodeRef *find_nested_node_ref(int32_t nested_node_id) const;
  const bNestedNodeRef *nested_node_ref_from_node_id_path(blender::Span<int> node_ids) const;
  [[nodiscard]] bool node_id_path_from_nested_node_ref(const int32_t nested_node_id,
                                                       blender::Vector<int32_t> &r_node_ids) const;
  const bNode *find_nested_node(int32_t nested_node_id, const bNodeTree **r_tree = nullptr) const;
 
  void ensure_topology_cache() const;
 
  /* The following methods are only available when #bNodeTree.ensure_topology_cache has been
   * called. */
 
  blender::Span<bNode *> group_nodes();
  blender::Span<const bNode *> group_nodes() const;
  blender::Span<bNodeSocket *> all_input_sockets();
  blender::Span<const bNodeSocket *> all_input_sockets() const;
  blender::Span<bNodeSocket *> all_output_sockets();
  blender::Span<const bNodeSocket *> all_output_sockets() const;
  blender::Span<bNodeSocket *> all_sockets();
  blender::Span<const bNodeSocket *> all_sockets() const;
  blender::Span<bNode *> nodes_by_type(blender::StringRefNull type_idname);
  blender::Span<const bNode *> nodes_by_type(blender::StringRefNull type_idname) const;
  blender::Span<bNode *> root_frames() const;
  blender::Span<bNodeLink *> all_links();
  blender::Span<const bNodeLink *> all_links() const;
  blender::Span<bNode *> toposort_left_to_right();
  blender::Span<const bNode *> toposort_left_to_right() const;
  blender::Span<bNode *> toposort_right_to_left();
  blender::Span<const bNode *> toposort_right_to_left() const;
  bool has_available_link_cycle() const;
  bool has_undefined_nodes_or_sockets() const;
  bNode *group_output_node();
  const bNode *group_output_node() const;
  blender::Span<bNode *> group_input_nodes();
  blender::Span<const bNode *> group_input_nodes() const;
 
  const blender::bke::bNodeTreeZones *zones() const;
 
  void ensure_interface_cache() const;
 
  /* Cached interface item lists. */
  blender::Span<bNodeTreeInterfaceSocket *> interface_inputs();
  blender::Span<const bNodeTreeInterfaceSocket *> interface_inputs() const;
  blender::Span<bNodeTreeInterfaceSocket *> interface_outputs();
  blender::Span<const bNodeTreeInterfaceSocket *> interface_outputs() const;
  blender::Span<bNodeTreeInterfaceItem *> interface_items();
  blender::Span<const bNodeTreeInterfaceItem *> interface_items() const;
#endif
} bNodeTree;
 
enum {
  NTREE_UNDEFINED = -2,
  NTREE_CUSTOM = -1,
  NTREE_SHADER = 0,
  NTREE_COMPOSIT = 1,
  NTREE_TEXTURE = 2,
  NTREE_GEOMETRY = 3,
};
 
enum {
  NTREE_DS_EXPAND = 1 << 0,
  NTREE_UNUSED_2 = 1 << 2, /* cleared */
  NTREE_VIEWER_BORDER = 1 << 4,
  // NTREE_IS_LOCALIZED = 1 << 5,
};
 
typedef enum eNodeTreeRuntimeFlag {
  NTREE_RUNTIME_FLAG_HAS_IMAGE_ANIMATION = 1 << 0,
  NTREE_RUNTIME_FLAG_HAS_MATERIAL_OUTPUT = 1 << 1,
  NTREE_RUNTIME_FLAG_HAS_SIMULATION_ZONE = 1 << 2,
} eNodeTreeRuntimeFlag;
 
/* socket value structs for input buttons
 * DEPRECATED now using ID properties
 */
 
typedef struct bNodeSocketValueInt {
  int subtype;
  int value;
  int min, max;
} bNodeSocketValueInt;
 
typedef struct bNodeSocketValueFloat {
  int subtype;
  float value;
  float min, max;
} bNodeSocketValueFloat;
 
typedef struct bNodeSocketValueBoolean {
  char value;
} bNodeSocketValueBoolean;
 
typedef struct bNodeSocketValueVector {
  int subtype;
  float value[3];
  float min, max;
} bNodeSocketValueVector;
 
typedef struct bNodeSocketValueRotation {
  float value_euler[3];
} bNodeSocketValueRotation;
 
typedef struct bNodeSocketValueRGBA {
  float value[4];
} bNodeSocketValueRGBA;
 
typedef struct bNodeSocketValueString {
  int subtype;
  char _pad[4];
  char value[1024];
} bNodeSocketValueString;
 
typedef struct bNodeSocketValueObject {
  struct Object *value;
} bNodeSocketValueObject;
 
typedef struct bNodeSocketValueImage {
  struct Image *value;
} bNodeSocketValueImage;
 
typedef struct bNodeSocketValueCollection {
  struct Collection *value;
} bNodeSocketValueCollection;
 
typedef struct bNodeSocketValueTexture {
  struct Tex *value;
} bNodeSocketValueTexture;
 
typedef struct bNodeSocketValueMaterial {
  struct Material *value;
} bNodeSocketValueMaterial;
 
typedef struct bNodeSocketValueMenu {
  /* Default input enum identifier. */
  int value;
  /* #NodeSocketValueMenuRuntimeFlag */
  int runtime_flag;
  /* Immutable runtime enum definition. */
  const RuntimeNodeEnumItemsHandle *enum_items;
 
#ifdef __cplusplus
  bool has_conflict() const;
#endif
} bNodeSocketValueMenu;
 
typedef struct GeometryNodeAssetTraits {
  int flag;
} GeometryNodeAssetTraits;
 
typedef enum GeometryNodeAssetTraitFlag {
  GEO_NODE_ASSET_TOOL = (1 << 0),
  GEO_NODE_ASSET_EDIT = (1 << 1),
  GEO_NODE_ASSET_SCULPT = (1 << 2),
  GEO_NODE_ASSET_MESH = (1 << 3),
  GEO_NODE_ASSET_CURVE = (1 << 4),
  GEO_NODE_ASSET_POINT_CLOUD = (1 << 5),
  GEO_NODE_ASSET_MODIFIER = (1 << 6),
  GEO_NODE_ASSET_OBJECT = (1 << 7),
  GEO_NODE_ASSET_WAIT_FOR_CURSOR = (1 << 8),
} GeometryNodeAssetTraitFlag;
ENUM_OPERATORS(GeometryNodeAssetTraitFlag, GEO_NODE_ASSET_WAIT_FOR_CURSOR);
 
/* Data structs, for `node->storage`. */
 
typedef enum CMPNodeMaskType {
  CMP_NODE_MASKTYPE_ADD = 0,
  CMP_NODE_MASKTYPE_SUBTRACT = 1,
  CMP_NODE_MASKTYPE_MULTIPLY = 2,
  CMP_NODE_MASKTYPE_NOT = 3,
} CMPNodeMaskType;
 
typedef enum CMPNodeDilateErodeMethod {
  CMP_NODE_DILATE_ERODE_STEP = 0,
  CMP_NODE_DILATE_ERODE_DISTANCE_THRESHOLD = 1,
  CMP_NODE_DILATE_ERODE_DISTANCE = 2,
  CMP_NODE_DILATE_ERODE_DISTANCE_FEATHER = 3,
} CMPNodeDilateErodeMethod;
 
enum {
  CMP_NODE_INPAINT_SIMPLE = 0,
};
 
typedef enum CMPNodeMaskFlags {
  /* CMP_NODEFLAG_MASK_AA          = (1 << 0), */ /* DEPRECATED */
  CMP_NODE_MASK_FLAG_NO_FEATHER = (1 << 1),
  CMP_NODE_MASK_FLAG_MOTION_BLUR = (1 << 2),
 
  CMP_NODE_MASK_FLAG_SIZE_FIXED = (1 << 8),
  CMP_NODE_MASK_FLAG_SIZE_FIXED_SCENE = (1 << 9),
} CMPNodeMaskFlags;
 
enum {
  CMP_NODEFLAG_BLUR_VARIABLE_SIZE = (1 << 0),
  CMP_NODEFLAG_BLUR_EXTEND_BOUNDS = (1 << 1),
};
 
typedef struct NodeFrame {
  short flag;
  short label_size;
} NodeFrame;
 
typedef struct NodeReroute {
  char type_idname[64];
 
} NodeReroute;
 
typedef struct NodeImageAnim {
  int frames DNA_DEPRECATED;
  int sfra DNA_DEPRECATED;
  int nr DNA_DEPRECATED;
  char cyclic DNA_DEPRECATED;
  char movie DNA_DEPRECATED;
  char _pad[2];
} NodeImageAnim;
 
typedef struct ColorCorrectionData {
  float saturation;
  float contrast;
  float gamma;
  float gain;
  float lift;
  char _pad[4];
} ColorCorrectionData;
 
typedef struct NodeColorCorrection {
  ColorCorrectionData master;
  ColorCorrectionData shadows;
  ColorCorrectionData midtones;
  ColorCorrectionData highlights;
  float startmidtones;
  float endmidtones;
} NodeColorCorrection;
 
typedef struct NodeBokehImage {
  float angle;
  int flaps;
  float rounding;
  float catadioptric;
  float lensshift;
} NodeBokehImage;
 
typedef struct NodeBoxMask {
  float x;
  float y;
  float rotation;
  float height;
  float width;
  char _pad[4];
} NodeBoxMask;
 
typedef struct NodeEllipseMask {
  float x;
  float y;
  float rotation;
  float height;
  float width;
  char _pad[4];
} NodeEllipseMask;
 
typedef struct NodeImageLayer {
  int pass_index DNA_DEPRECATED;
  /* render pass name */
  char pass_name[64];
} NodeImageLayer;
 
typedef struct NodeBlurData {
  short sizex, sizey;
  short samples, maxspeed, minspeed, relative, aspect;
  short curved;
  float fac, percentx, percenty;
  short filtertype;
  char bokeh, gamma;
  int image_in_width, image_in_height;
} NodeBlurData;
 
typedef struct NodeDBlurData {
  float center_x, center_y, distance, angle, spin, zoom;
  short iter;
  char _pad[2];
} NodeDBlurData;
 
typedef struct NodeBilateralBlurData {
  float sigma_color, sigma_space;
  short iter;
  char _pad[2];
} NodeBilateralBlurData;
 
typedef struct NodeKuwaharaData {
  short size DNA_DEPRECATED;
  short variation;
  int uniformity;
  float sharpness;
  float eccentricity;
  char high_precision;
  char _pad[3];
} NodeKuwaharaData;
 
typedef struct NodeAntiAliasingData {
  float threshold;
  float contrast_limit;
  float corner_rounding;
} NodeAntiAliasingData;
 
typedef struct NodeHueSat {
  float hue, sat, val;
} NodeHueSat;
 
typedef struct NodeImageFile {
  char name[1024];
  struct ImageFormatData im_format;
  int sfra, efra;
} NodeImageFile;
 
typedef struct NodeImageMultiFile {
  char base_path[1024];
  ImageFormatData format;
  int sfra DNA_DEPRECATED, efra DNA_DEPRECATED;
  int active_input;
  char save_as_render;
  char _pad[3];
} NodeImageMultiFile;
typedef struct NodeImageMultiFileSocket {
  /* single layer file output */
  short use_render_format DNA_DEPRECATED;
  short use_node_format;
  char save_as_render;
  char _pad1[3];
  char path[1024];
  ImageFormatData format;
 
  /* Multi-layer output. */
  char layer[30];
  char _pad2[2];
} NodeImageMultiFileSocket;
 
typedef struct NodeChroma {
  float t1, t2, t3;
  float fsize, fstrength, falpha;
  float key[4];
  short algorithm, channel;
} NodeChroma;
 
typedef struct NodeTwoXYs {
  short x1, x2, y1, y2;
  float fac_x1, fac_x2, fac_y1, fac_y2;
} NodeTwoXYs;
 
typedef struct NodeTwoFloats {
  float x, y;
} NodeTwoFloats;
 
typedef struct NodeVertexCol {
  char name[64];
} NodeVertexCol;
 
typedef struct NodeCMPCombSepColor {
  /* CMPNodeCombSepColorMode */
  uint8_t mode;
  uint8_t ycc_mode;
} NodeCMPCombSepColor;
 
typedef struct NodeDefocus {
  char bktype, _pad0, preview, gamco;
  short samples, no_zbuf;
  float fstop, maxblur, bthresh, scale;
  float rotation;
  char _pad1[4];
} NodeDefocus;
 
typedef struct NodeScriptDict {
  void *dict;
  void *node;
} NodeScriptDict;
 
typedef struct NodeGlare {
  char quality, type, iter;
  /* XXX angle is only kept for backward/forward compatibility,
   * was used for two different things, see #50736. */
  char angle DNA_DEPRECATED, _pad0, size, star_45, streaks;
  float colmod, mix, threshold, fade;
  float angle_ofs;
  char _pad1[4];
} NodeGlare;
 
typedef struct NodeTonemap {
  float key, offset, gamma;
  float f, m, a, c;
  int type;
} NodeTonemap;
 
typedef struct NodeLensDist {
  short jit, proj, fit;
  char _pad[2];
} NodeLensDist;
 
typedef struct NodeColorBalance {
  /* ASC CDL parameters. */
  float slope[3];
  float offset[3];
  float power[3];
  float offset_basis;
  char _pad[4];
 
  /* LGG parameters. */
  float lift[3];
  float gamma[3];
  float gain[3];
 
  /* White-point parameters. */
  float input_temperature;
  float input_tint;
  float output_temperature;
  float output_tint;
} NodeColorBalance;
 
typedef struct NodeColorspill {
  short limchan, unspill;
  float limscale;
  float uspillr, uspillg, uspillb;
} NodeColorspill;
 
typedef struct NodeConvertColorSpace {
  char from_color_space[64];
  char to_color_space[64];
} NodeConvertColorSpace;
 
typedef struct NodeDilateErode {
  char falloff;
} NodeDilateErode;
 
typedef struct NodeMask {
  int size_x, size_y;
} NodeMask;
 
typedef struct NodeSetAlpha {
  char mode;
} NodeSetAlpha;
 
typedef struct NodeTexBase {
  TexMapping tex_mapping;
  ColorMapping color_mapping;
} NodeTexBase;
 
typedef struct NodeTexSky {
  NodeTexBase base;
  int sky_model;
  float sun_direction[3];
  float turbidity;
  float ground_albedo;
  float sun_size;
  float sun_intensity;
  float sun_elevation;
  float sun_rotation;
  float altitude;
  float air_density;
  float dust_density;
  float ozone_density;
  char sun_disc;
  char _pad[7];
} NodeTexSky;
 
typedef struct NodeTexImage {
  NodeTexBase base;
  ImageUser iuser;
  int color_space DNA_DEPRECATED;
  int projection;
  float projection_blend;
  int interpolation;
  int extension;
  char _pad[4];
} NodeTexImage;
 
typedef struct NodeTexChecker {
  NodeTexBase base;
} NodeTexChecker;
 
typedef struct NodeTexBrick {
  NodeTexBase base;
  int offset_freq, squash_freq;
  float offset, squash;
} NodeTexBrick;
 
typedef struct NodeTexEnvironment {
  NodeTexBase base;
  ImageUser iuser;
  int color_space DNA_DEPRECATED;
  int projection;
  int interpolation;
  char _pad[4];
} NodeTexEnvironment;
 
typedef struct NodeTexGabor {
  NodeTexBase base;
  /* Stores NodeGaborType. */
  char type;
  char _pad[7];
} NodeTexGabor;
 
typedef struct NodeTexGradient {
  NodeTexBase base;
  int gradient_type;
  char _pad[4];
} NodeTexGradient;
 
typedef struct NodeTexNoise {
  NodeTexBase base;
  int dimensions;
  uint8_t type;
  uint8_t normalize;
  char _pad[2];
} NodeTexNoise;
 
typedef struct NodeTexVoronoi {
  NodeTexBase base;
  int dimensions;
  int feature;
  int distance;
  int normalize;
  int coloring DNA_DEPRECATED;
  char _pad[4];
} NodeTexVoronoi;
 
typedef struct NodeTexMusgrave {
  NodeTexBase base DNA_DEPRECATED;
  int musgrave_type DNA_DEPRECATED;
  int dimensions DNA_DEPRECATED;
} NodeTexMusgrave;
 
typedef struct NodeTexWave {
  NodeTexBase base;
  int wave_type;
  int bands_direction;
  int rings_direction;
  int wave_profile;
} NodeTexWave;
 
typedef struct NodeTexMagic {
  NodeTexBase base;
  int depth;
  char _pad[4];
} NodeTexMagic;
 
typedef struct NodeShaderAttribute {
  char name[256];
  int type;
  char _pad[4];
} NodeShaderAttribute;
 
typedef struct NodeShaderVectTransform {
  int type;
  int convert_from, convert_to;
  char _pad[4];
} NodeShaderVectTransform;
 
typedef struct NodeShaderTexPointDensity {
  NodeTexBase base;
  short point_source;
  char _pad[2];
  int particle_system;
  float radius;
  int resolution;
  short space;
  short interpolation;
  short color_source;
  short ob_color_source;
  PointDensity pd;
  int cached_resolution;
  char vertex_attribute_name[68];
} NodeShaderTexPointDensity;
 
typedef struct NodeShaderPrincipled {
  char use_subsurface_auto_radius;
  char _pad[3];
} NodeShaderPrincipled;
 
typedef struct NodeShaderHairPrincipled {
  short model;
  short parametrization;
  char _pad[4];
} NodeShaderHairPrincipled;
 
typedef struct TexNodeOutput {
  char name[64];
} TexNodeOutput;
 
typedef struct NodeKeyingScreenData {
  char tracking_object[64];
  float smoothness;
} NodeKeyingScreenData;
 
typedef struct NodeKeyingData {
  float screen_balance;
  float despill_factor;
  float despill_balance;
  int edge_kernel_radius;
  float edge_kernel_tolerance;
  float clip_black, clip_white;
  int dilate_distance;
  int feather_distance;
  int feather_falloff;
  int blur_pre, blur_post;
} NodeKeyingData;
 
typedef struct NodeTrackPosData {
  char tracking_object[64];
  char track_name[64];
} NodeTrackPosData;
 
typedef struct NodeTranslateData {
  char wrap_axis;
  char relative;
  short interpolation;
} NodeTranslateData;
 
typedef struct NodePlaneTrackDeformData {
  char tracking_object[64];
  char plane_track_name[64];
  char flag;
  char motion_blur_samples;
  char _pad[2];
  float motion_blur_shutter;
} NodePlaneTrackDeformData;
 
typedef struct NodeShaderScript {
  int mode;
  int flag;
 
  char filepath[1024];
 
  char bytecode_hash[64];
  char *bytecode;
} NodeShaderScript;
 
typedef struct NodeShaderTangent {
  int direction_type;
  int axis;
  char uv_map[64];
} NodeShaderTangent;
 
typedef struct NodeShaderNormalMap {
  int space;
  char uv_map[64];
} NodeShaderNormalMap;
 
typedef struct NodeShaderUVMap {
  char uv_map[64];
} NodeShaderUVMap;
 
typedef struct NodeShaderVertexColor {
  char layer_name[64];
} NodeShaderVertexColor;
 
typedef struct NodeShaderTexIES {
  int mode;
 
  char filepath[1024];
} NodeShaderTexIES;
 
typedef struct NodeShaderOutputAOV {
  char name[64];
} NodeShaderOutputAOV;
 
typedef struct NodeSunBeams {
  float source[2];
 
  float ray_length;
} NodeSunBeams;
 
typedef struct CryptomatteEntry {
  struct CryptomatteEntry *next, *prev;
  float encoded_hash;
  char name[64];
  char _pad[4];
} CryptomatteEntry;
 
typedef struct CryptomatteLayer {
  struct CryptomatteEntry *next, *prev;
  char name[64];
} CryptomatteLayer;
 
typedef struct NodeCryptomatte_Runtime {
  ListBase layers;
  float add[3];
  float remove[3];
} NodeCryptomatte_Runtime;
 
typedef struct NodeCryptomatte {
  ImageUser iuser;
 
  ListBase entries;
 
  /* MAX_NAME */
  char layer_name[64];
  char *matte_id;
 
  /* Legacy attributes. */
  int inputs_num;
 
  char _pad[4];
  NodeCryptomatte_Runtime runtime;
} NodeCryptomatte;
 
typedef struct NodeDenoise {
  char hdr;
  char prefilter;
} NodeDenoise;
 
typedef struct NodeMapRange {
  uint8_t data_type;
 
  uint8_t interpolation_type;
  uint8_t clamp;
  char _pad[5];
} NodeMapRange;
 
typedef struct NodeRandomValue {
  uint8_t data_type;
} NodeRandomValue;
 
typedef struct NodeAccumulateField {
  uint8_t data_type;
  uint8_t domain;
} NodeAccumulateField;
 
typedef struct NodeInputBool {
  uint8_t boolean;
} NodeInputBool;
 
typedef struct NodeInputInt {
  int integer;
} NodeInputInt;
 
typedef struct NodeInputRotation {
  float rotation_euler[3];
} NodeInputRotation;
 
typedef struct NodeInputVector {
  float vector[3];
} NodeInputVector;
 
typedef struct NodeInputColor {
  float color[4];
} NodeInputColor;
 
typedef struct NodeInputString {
  char *string;
} NodeInputString;
 
typedef struct NodeGeometryExtrudeMesh {
  uint8_t mode;
} NodeGeometryExtrudeMesh;
 
typedef struct NodeGeometryObjectInfo {
  uint8_t transform_space;
} NodeGeometryObjectInfo;
 
typedef struct NodeGeometryPointsToVolume {
  uint8_t resolution_mode;
  uint8_t input_type_radius;
} NodeGeometryPointsToVolume;
 
typedef struct NodeGeometryCollectionInfo {
  uint8_t transform_space;
} NodeGeometryCollectionInfo;
 
typedef struct NodeGeometryProximity {
  uint8_t target_element;
} NodeGeometryProximity;
 
typedef struct NodeGeometryVolumeToMesh {
  uint8_t resolution_mode;
} NodeGeometryVolumeToMesh;
 
typedef struct NodeGeometryMeshToVolume {
  uint8_t resolution_mode;
} NodeGeometryMeshToVolume;
 
typedef struct NodeGeometrySubdivisionSurface {
  uint8_t uv_smooth;
  uint8_t boundary_smooth;
} NodeGeometrySubdivisionSurface;
 
typedef struct NodeGeometryMeshCircle {
  uint8_t fill_type;
} NodeGeometryMeshCircle;
 
typedef struct NodeGeometryMeshCylinder {
  uint8_t fill_type;
} NodeGeometryMeshCylinder;
 
typedef struct NodeGeometryMeshCone {
  uint8_t fill_type;
} NodeGeometryMeshCone;
 
typedef struct NodeGeometryMergeByDistance {
  uint8_t mode;
} NodeGeometryMergeByDistance;
 
typedef struct NodeGeometryMeshLine {
  uint8_t mode;
  uint8_t count_mode;
} NodeGeometryMeshLine;
 
typedef struct NodeSwitch {
  uint8_t input_type;
} NodeSwitch;
 
typedef struct NodeEnumItem {
  char *name;
  char *description;
  /* Immutable unique identifier. */
  int32_t identifier;
  char _pad[4];
} NodeEnumItem;
 
typedef struct NodeEnumDefinition {
  /* User-defined enum items owned and managed by this node. */
  NodeEnumItem *items_array;
  int items_num;
  int active_index;
  uint32_t next_identifier;
  char _pad[4];
 
#ifdef __cplusplus
  blender::Span<NodeEnumItem> items() const;
  blender::MutableSpan<NodeEnumItem> items();
#endif
} NodeEnumDefinition;
 
typedef struct NodeMenuSwitch {
  NodeEnumDefinition enum_definition;
 
  uint8_t data_type;
  char _pad[7];
} NodeMenuSwitch;
 
typedef struct NodeGeometryCurveSplineType {
  uint8_t spline_type;
} NodeGeometryCurveSplineType;
 
typedef struct NodeGeometrySetCurveHandlePositions {
  uint8_t mode;
} NodeGeometrySetCurveHandlePositions;
 
typedef struct NodeGeometryCurveSetHandles {
  uint8_t handle_type;
  uint8_t mode;
} NodeGeometryCurveSetHandles;
 
typedef struct NodeGeometryCurveSelectHandles {
  uint8_t handle_type;
  uint8_t mode;
} NodeGeometryCurveSelectHandles;
 
typedef struct NodeGeometryCurvePrimitiveArc {
  uint8_t mode;
} NodeGeometryCurvePrimitiveArc;
 
typedef struct NodeGeometryCurvePrimitiveLine {
  uint8_t mode;
} NodeGeometryCurvePrimitiveLine;
 
typedef struct NodeGeometryCurvePrimitiveBezierSegment {
  uint8_t mode;
} NodeGeometryCurvePrimitiveBezierSegment;
 
typedef struct NodeGeometryCurvePrimitiveCircle {
  uint8_t mode;
} NodeGeometryCurvePrimitiveCircle;
 
typedef struct NodeGeometryCurvePrimitiveQuad {
  uint8_t mode;
} NodeGeometryCurvePrimitiveQuad;
 
typedef struct NodeGeometryCurveResample {
  uint8_t mode;
} NodeGeometryCurveResample;
 
typedef struct NodeGeometryCurveFillet {
  uint8_t mode;
} NodeGeometryCurveFillet;
 
typedef struct NodeGeometryCurveTrim {
  uint8_t mode;
} NodeGeometryCurveTrim;
 
typedef struct NodeGeometryCurveToPoints {
  uint8_t mode;
} NodeGeometryCurveToPoints;
 
typedef struct NodeGeometryCurveSample {
  uint8_t mode;
  int8_t use_all_curves;
  int8_t data_type;
  char _pad[1];
} NodeGeometryCurveSample;
 
typedef struct NodeGeometryTransferAttribute {
  int8_t data_type;
  int8_t domain;
  uint8_t mode;
  char _pad[1];
} NodeGeometryTransferAttribute;
 
typedef struct NodeGeometrySampleIndex {
  int8_t data_type;
  int8_t domain;
  int8_t clamp;
  char _pad[1];
} NodeGeometrySampleIndex;
 
typedef struct NodeGeometryRaycast {
  uint8_t mapping;
 
  int8_t data_type;
} NodeGeometryRaycast;
 
typedef struct NodeGeometryCurveFill {
  uint8_t mode;
} NodeGeometryCurveFill;
 
typedef struct NodeGeometryMeshToPoints {
  uint8_t mode;
} NodeGeometryMeshToPoints;
 
typedef struct NodeGeometryAttributeCaptureItem {
  int8_t data_type;
  char _pad[3];
  int identifier;
  char *name;
} NodeGeometryAttributeCaptureItem;
 
typedef struct NodeGeometryAttributeCapture {
  int8_t data_type_legacy;
  int8_t domain;
  char _pad[2];
  int next_identifier;
  NodeGeometryAttributeCaptureItem *capture_items;
  int capture_items_num;
  int active_index;
} NodeGeometryAttributeCapture;
 
typedef struct NodeGeometryStoreNamedAttribute {
  int8_t data_type;
  int8_t domain;
} NodeGeometryStoreNamedAttribute;
 
typedef struct NodeGeometryInputNamedAttribute {
  int8_t data_type;
} NodeGeometryInputNamedAttribute;
 
typedef struct NodeGeometryStringToCurves {
  uint8_t overflow;
  uint8_t align_x;
  uint8_t align_y;
  uint8_t pivot_mode;
} NodeGeometryStringToCurves;
 
typedef struct NodeGeometryDeleteGeometry {
  int8_t domain;
  int8_t mode;
} NodeGeometryDeleteGeometry;
 
typedef struct NodeGeometryDuplicateElements {
  int8_t domain;
} NodeGeometryDuplicateElements;
 
typedef struct NodeGeometryMergeLayers {
  int8_t mode;
} NodeGeometryMergeLayers;
 
typedef struct NodeGeometrySeparateGeometry {
  int8_t domain;
} NodeGeometrySeparateGeometry;
 
typedef struct NodeGeometryImageTexture {
  int8_t interpolation;
  int8_t extension;
} NodeGeometryImageTexture;
 
typedef struct NodeGeometryViewer {
  int8_t data_type;
  int8_t domain;
} NodeGeometryViewer;
 
typedef struct NodeGeometryUVUnwrap {
  uint8_t method;
} NodeGeometryUVUnwrap;
 
typedef struct NodeSimulationItem {
  char *name;
  short socket_type;
  short attribute_domain;
  int identifier;
} NodeSimulationItem;
 
typedef struct NodeGeometrySimulationInput {
  int32_t output_node_id;
} NodeGeometrySimulationInput;
 
typedef struct NodeGeometrySimulationOutput {
  NodeSimulationItem *items;
  int items_num;
  int active_index;
  int next_identifier;
  int _pad;
 
#ifdef __cplusplus
  blender::Span<NodeSimulationItem> items_span() const;
  blender::MutableSpan<NodeSimulationItem> items_span();
#endif
} NodeGeometrySimulationOutput;
 
typedef struct NodeRepeatItem {
  char *name;
  short socket_type;
  char _pad[2];
  int identifier;
} NodeRepeatItem;
 
typedef struct NodeGeometryRepeatInput {
  int32_t output_node_id;
} NodeGeometryRepeatInput;
 
typedef struct NodeGeometryRepeatOutput {
  NodeRepeatItem *items;
  int items_num;
  int active_index;
  int next_identifier;
  int inspection_index;
 
#ifdef __cplusplus
  blender::Span<NodeRepeatItem> items_span() const;
  blender::MutableSpan<NodeRepeatItem> items_span();
#endif
} NodeGeometryRepeatOutput;
 
typedef struct NodeGeometryForeachGeometryElementInput {
  int32_t output_node_id;
} NodeGeometryForeachGeometryElementInput;
 
typedef struct NodeForeachGeometryElementInputItem {
  char *name;
  short socket_type;
  char _pad[2];
  int identifier;
} NodeForeachGeometryElementInputItem;
 
typedef struct NodeForeachGeometryElementMainItem {
  char *name;
  short socket_type;
  char _pad[2];
  int identifier;
} NodeForeachGeometryElementMainItem;
 
typedef struct NodeForeachGeometryElementGenerationItem {
  char *name;
  short socket_type;
  uint8_t domain;
  char _pad[1];
  int identifier;
} NodeForeachGeometryElementGenerationItem;
 
typedef struct NodeForeachGeometryElementInputItems {
  NodeForeachGeometryElementInputItem *items;
  int items_num;
  int active_index;
  int next_identifier;
  char _pad[4];
} NodeForeachGeometryElementInputItems;
 
typedef struct NodeForeachGeometryElementMainItems {
  NodeForeachGeometryElementMainItem *items;
  int items_num;
  int active_index;
  int next_identifier;
  char _pad[4];
} NodeForeachGeometryElementMainItems;
 
typedef struct NodeForeachGeometryElementGenerationItems {
  NodeForeachGeometryElementGenerationItem *items;
  int items_num;
  int active_index;
  int next_identifier;
  char _pad[4];
} NodeForeachGeometryElementGenerationItems;
 
typedef struct NodeGeometryForeachGeometryElementOutput {
  NodeForeachGeometryElementInputItems input_items;
  NodeForeachGeometryElementMainItems main_items;
  NodeForeachGeometryElementGenerationItems generation_items;
  int inspection_index;
  uint8_t domain;
  char _pad[3];
} NodeGeometryForeachGeometryElementOutput;
 
typedef struct IndexSwitchItem {
  int identifier;
} IndexSwitchItem;
 
typedef struct NodeIndexSwitch {
  IndexSwitchItem *items;
  int items_num;
 
  /* #eNodeSocketDataType. */
  int data_type;
  int next_identifier;
 
  char _pad[4];
#ifdef __cplusplus
  blender::Span<IndexSwitchItem> items_span() const;
  blender::MutableSpan<IndexSwitchItem> items_span();
#endif
} NodeIndexSwitch;
 
typedef struct NodeGeometryDistributePointsInVolume {
  uint8_t mode;
} NodeGeometryDistributePointsInVolume;
 
typedef struct NodeFunctionCompare {
  int8_t operation;
  int8_t data_type;
  int8_t mode;
  char _pad[1];
} NodeFunctionCompare;
 
typedef struct NodeCombSepColor {
  int8_t mode;
} NodeCombSepColor;
 
typedef struct NodeShaderMix {
  int8_t data_type;
  int8_t factor_mode;
  int8_t clamp_factor;
  int8_t clamp_result;
  int8_t blend_type;
  char _pad[3];
} NodeShaderMix;
 
typedef struct NodeGeometryLinearGizmo {
  int color_id;
  int draw_style;
} NodeGeometryLinearGizmo;
 
typedef struct NodeGeometryDialGizmo {
  int color_id;
} NodeGeometryDialGizmo;
 
typedef struct NodeGeometryTransformGizmo {
  uint32_t flag;
} NodeGeometryTransformGizmo;
 
typedef enum NodeGeometryTransformGizmoFlag {
  GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_X = 1 << 0,
  GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_Y = 1 << 1,
  GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_Z = 1 << 2,
  GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_X = 1 << 3,
  GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_Y = 1 << 4,
  GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_Z = 1 << 5,
  GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_X = 1 << 6,
  GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_Y = 1 << 7,
  GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_Z = 1 << 8,
} NodeGeometryTransformGizmoFlag;
 
#define GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_ALL \
  (GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_X | GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_Y | \
   GEO_NODE_TRANSFORM_GIZMO_USE_TRANSLATION_Z)
 
#define GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_ALL \
  (GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_X | GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_Y | \
   GEO_NODE_TRANSFORM_GIZMO_USE_ROTATION_Z)
 
#define GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_ALL \
  (GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_X | GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_Y | \
   GEO_NODE_TRANSFORM_GIZMO_USE_SCALE_Z)
 
typedef struct NodeGeometryBakeItem {
  char *name;
  int16_t socket_type;
  int16_t attribute_domain;
  int identifier;
  int32_t flag;
  char _pad[4];
} NodeGeometryBakeItem;
 
typedef enum NodeGeometryBakeItemFlag {
  GEO_NODE_BAKE_ITEM_IS_ATTRIBUTE = (1 << 0),
} NodeGeometryBakeItemFlag;
 
typedef struct NodeGeometryBake {
  NodeGeometryBakeItem *items;
  int items_num;
  int next_identifier;
  int active_index;
  char _pad[4];
} NodeGeometryBake;
 
/* script node mode */
enum {
  NODE_SCRIPT_INTERNAL = 0,
  NODE_SCRIPT_EXTERNAL = 1,
};
 
/* script node flag */
enum {
  NODE_SCRIPT_AUTO_UPDATE = 1,
};
 
/* IES node mode. */
enum {
  NODE_IES_INTERNAL = 0,
  NODE_IES_EXTERNAL = 1,
};
 
/* Frame node flags. */
 
enum {
  NODE_FRAME_SHRINK = 1,
  NODE_FRAME_RESIZEABLE = 2,
};
 
/* Proxy node flags. */
 
enum {
  NODE_PROXY_AUTOTYPE = 1,
};
 
/* Comp channel matte. */
 
enum {
  CMP_NODE_CHANNEL_MATTE_CS_RGB = 1,
  CMP_NODE_CHANNEL_MATTE_CS_HSV = 2,
  CMP_NODE_CHANNEL_MATTE_CS_YUV = 3,
  CMP_NODE_CHANNEL_MATTE_CS_YCC = 4,
};
 
/* Conductive fresnel types */
enum {
  SHD_PHYSICAL_CONDUCTOR = 0,
  SHD_CONDUCTOR_F82 = 1,
};
 
/* glossy distributions */
enum {
  SHD_GLOSSY_BECKMANN = 0,
  SHD_GLOSSY_SHARP_DEPRECATED = 1, /* deprecated */
  SHD_GLOSSY_GGX = 2,
  SHD_GLOSSY_ASHIKHMIN_SHIRLEY = 3,
  SHD_GLOSSY_MULTI_GGX = 4,
};
 
/* sheen distributions */
#define SHD_SHEEN_ASHIKHMIN 0
#define SHD_SHEEN_MICROFIBER 1
 
/* vector transform */
enum {
  SHD_VECT_TRANSFORM_TYPE_VECTOR = 0,
  SHD_VECT_TRANSFORM_TYPE_POINT = 1,
  SHD_VECT_TRANSFORM_TYPE_NORMAL = 2,
};
 
enum {
  SHD_VECT_TRANSFORM_SPACE_WORLD = 0,
  SHD_VECT_TRANSFORM_SPACE_OBJECT = 1,
  SHD_VECT_TRANSFORM_SPACE_CAMERA = 2,
};
 
enum {
  SHD_ATTRIBUTE_GEOMETRY = 0,
  SHD_ATTRIBUTE_OBJECT = 1,
  SHD_ATTRIBUTE_INSTANCER = 2,
  SHD_ATTRIBUTE_VIEW_LAYER = 3,
};
 
/* toon modes */
enum {
  SHD_TOON_DIFFUSE = 0,
  SHD_TOON_GLOSSY = 1,
};
 
/* hair components */
enum {
  SHD_HAIR_REFLECTION = 0,
  SHD_HAIR_TRANSMISSION = 1,
};
 
/* principled hair models */
enum {
  SHD_PRINCIPLED_HAIR_CHIANG = 0,
  SHD_PRINCIPLED_HAIR_HUANG = 1,
};
 
/* principled hair color parametrization */
enum {
  SHD_PRINCIPLED_HAIR_REFLECTANCE = 0,
  SHD_PRINCIPLED_HAIR_PIGMENT_CONCENTRATION = 1,
  SHD_PRINCIPLED_HAIR_DIRECT_ABSORPTION = 2,
};
 
/* blend texture */
enum {
  SHD_BLEND_LINEAR = 0,
  SHD_BLEND_QUADRATIC = 1,
  SHD_BLEND_EASING = 2,
  SHD_BLEND_DIAGONAL = 3,
  SHD_BLEND_RADIAL = 4,
  SHD_BLEND_QUADRATIC_SPHERE = 5,
  SHD_BLEND_SPHERICAL = 6,
};
 
/* noise basis for textures */
enum {
  SHD_NOISE_PERLIN = 0,
  SHD_NOISE_VORONOI_F1 = 1,
  SHD_NOISE_VORONOI_F2 = 2,
  SHD_NOISE_VORONOI_F3 = 3,
  SHD_NOISE_VORONOI_F4 = 4,
  SHD_NOISE_VORONOI_F2_F1 = 5,
  SHD_NOISE_VORONOI_CRACKLE = 6,
  SHD_NOISE_CELL_NOISE = 7,
};
 
enum {
  SHD_NOISE_SOFT = 0,
  SHD_NOISE_HARD = 1,
};
 
/* Voronoi Texture */
 
enum {
  SHD_VORONOI_EUCLIDEAN = 0,
  SHD_VORONOI_MANHATTAN = 1,
  SHD_VORONOI_CHEBYCHEV = 2,
  SHD_VORONOI_MINKOWSKI = 3,
};
 
enum {
  SHD_VORONOI_F1 = 0,
  SHD_VORONOI_F2 = 1,
  SHD_VORONOI_SMOOTH_F1 = 2,
  SHD_VORONOI_DISTANCE_TO_EDGE = 3,
  SHD_VORONOI_N_SPHERE_RADIUS = 4,
};
 
/* Deprecated Musgrave Texture. Keep for Versioning */
enum {
  SHD_MUSGRAVE_MULTIFRACTAL = 0,
  SHD_MUSGRAVE_FBM = 1,
  SHD_MUSGRAVE_HYBRID_MULTIFRACTAL = 2,
  SHD_MUSGRAVE_RIDGED_MULTIFRACTAL = 3,
  SHD_MUSGRAVE_HETERO_TERRAIN = 4,
};
 
/* Noise Texture */
enum {
  SHD_NOISE_MULTIFRACTAL = 0,
  SHD_NOISE_FBM = 1,
  SHD_NOISE_HYBRID_MULTIFRACTAL = 2,
  SHD_NOISE_RIDGED_MULTIFRACTAL = 3,
  SHD_NOISE_HETERO_TERRAIN = 4,
};
 
/* wave texture */
enum {
  SHD_WAVE_BANDS = 0,
  SHD_WAVE_RINGS = 1,
};
 
enum {
  SHD_WAVE_BANDS_DIRECTION_X = 0,
  SHD_WAVE_BANDS_DIRECTION_Y = 1,
  SHD_WAVE_BANDS_DIRECTION_Z = 2,
  SHD_WAVE_BANDS_DIRECTION_DIAGONAL = 3,
};
 
enum {
  SHD_WAVE_RINGS_DIRECTION_X = 0,
  SHD_WAVE_RINGS_DIRECTION_Y = 1,
  SHD_WAVE_RINGS_DIRECTION_Z = 2,
  SHD_WAVE_RINGS_DIRECTION_SPHERICAL = 3,
};
 
enum {
  SHD_WAVE_PROFILE_SIN = 0,
  SHD_WAVE_PROFILE_SAW = 1,
  SHD_WAVE_PROFILE_TRI = 2,
};
 
/* sky texture */
enum {
  SHD_SKY_PREETHAM = 0,
  SHD_SKY_HOSEK = 1,
  SHD_SKY_NISHITA = 2,
};
 
/* environment texture */
enum {
  SHD_PROJ_EQUIRECTANGULAR = 0,
  SHD_PROJ_MIRROR_BALL = 1,
};
 
typedef enum NodeGaborType {
  SHD_GABOR_TYPE_2D = 0,
  SHD_GABOR_TYPE_3D = 1,
} NodeGaborType;
 
enum {
  SHD_IMAGE_EXTENSION_REPEAT = 0,
  SHD_IMAGE_EXTENSION_EXTEND = 1,
  SHD_IMAGE_EXTENSION_CLIP = 2,
  SHD_IMAGE_EXTENSION_MIRROR = 3,
};
 
/* image texture */
enum {
  SHD_PROJ_FLAT = 0,
  SHD_PROJ_BOX = 1,
  SHD_PROJ_SPHERE = 2,
  SHD_PROJ_TUBE = 3,
};
 
/* image texture interpolation */
enum {
  SHD_INTERP_LINEAR = 0,
  SHD_INTERP_CLOSEST = 1,
  SHD_INTERP_CUBIC = 2,
  SHD_INTERP_SMART = 3,
};
 
/* tangent */
enum {
  SHD_TANGENT_RADIAL = 0,
  SHD_TANGENT_UVMAP = 1,
};
 
/* tangent */
enum {
  SHD_TANGENT_AXIS_X = 0,
  SHD_TANGENT_AXIS_Y = 1,
  SHD_TANGENT_AXIS_Z = 2,
};
 
/* normal map, displacement space */
enum {
  SHD_SPACE_TANGENT = 0,
  SHD_SPACE_OBJECT = 1,
  SHD_SPACE_WORLD = 2,
  SHD_SPACE_BLENDER_OBJECT = 3,
  SHD_SPACE_BLENDER_WORLD = 4,
};
 
enum {
  SHD_AO_INSIDE = 1,
  SHD_AO_LOCAL = 2,
};
 
enum {
  NODE_MAPPING_TYPE_POINT = 0,
  NODE_MAPPING_TYPE_TEXTURE = 1,
  NODE_MAPPING_TYPE_VECTOR = 2,
  NODE_MAPPING_TYPE_NORMAL = 3,
};
 
enum {
  NODE_VECTOR_ROTATE_TYPE_AXIS = 0,
  NODE_VECTOR_ROTATE_TYPE_AXIS_X = 1,
  NODE_VECTOR_ROTATE_TYPE_AXIS_Y = 2,
  NODE_VECTOR_ROTATE_TYPE_AXIS_Z = 3,
  NODE_VECTOR_ROTATE_TYPE_EULER_XYZ = 4,
};
 
/* math node clamp */
enum {
  SHD_MATH_CLAMP = 1,
};
 
typedef enum NodeMathOperation {
  NODE_MATH_ADD = 0,
  NODE_MATH_SUBTRACT = 1,
  NODE_MATH_MULTIPLY = 2,
  NODE_MATH_DIVIDE = 3,
  NODE_MATH_SINE = 4,
  NODE_MATH_COSINE = 5,
  NODE_MATH_TANGENT = 6,
  NODE_MATH_ARCSINE = 7,
  NODE_MATH_ARCCOSINE = 8,
  NODE_MATH_ARCTANGENT = 9,
  NODE_MATH_POWER = 10,
  NODE_MATH_LOGARITHM = 11,
  NODE_MATH_MINIMUM = 12,
  NODE_MATH_MAXIMUM = 13,
  NODE_MATH_ROUND = 14,
  NODE_MATH_LESS_THAN = 15,
  NODE_MATH_GREATER_THAN = 16,
  NODE_MATH_MODULO = 17,
  NODE_MATH_ABSOLUTE = 18,
  NODE_MATH_ARCTAN2 = 19,
  NODE_MATH_FLOOR = 20,
  NODE_MATH_CEIL = 21,
  NODE_MATH_FRACTION = 22,
  NODE_MATH_SQRT = 23,
  NODE_MATH_INV_SQRT = 24,
  NODE_MATH_SIGN = 25,
  NODE_MATH_EXPONENT = 26,
  NODE_MATH_RADIANS = 27,
  NODE_MATH_DEGREES = 28,
  NODE_MATH_SINH = 29,
  NODE_MATH_COSH = 30,
  NODE_MATH_TANH = 31,
  NODE_MATH_TRUNC = 32,
  NODE_MATH_SNAP = 33,
  NODE_MATH_WRAP = 34,
  NODE_MATH_COMPARE = 35,
  NODE_MATH_MULTIPLY_ADD = 36,
  NODE_MATH_PINGPONG = 37,
  NODE_MATH_SMOOTH_MIN = 38,
  NODE_MATH_SMOOTH_MAX = 39,
  NODE_MATH_FLOORED_MODULO = 40,
} NodeMathOperation;
 
typedef enum NodeVectorMathOperation {
  NODE_VECTOR_MATH_ADD = 0,
  NODE_VECTOR_MATH_SUBTRACT = 1,
  NODE_VECTOR_MATH_MULTIPLY = 2,
  NODE_VECTOR_MATH_DIVIDE = 3,
 
  NODE_VECTOR_MATH_CROSS_PRODUCT = 4,
  NODE_VECTOR_MATH_PROJECT = 5,
  NODE_VECTOR_MATH_REFLECT = 6,
  NODE_VECTOR_MATH_DOT_PRODUCT = 7,
 
  NODE_VECTOR_MATH_DISTANCE = 8,
  NODE_VECTOR_MATH_LENGTH = 9,
  NODE_VECTOR_MATH_SCALE = 10,
  NODE_VECTOR_MATH_NORMALIZE = 11,
 
  NODE_VECTOR_MATH_SNAP = 12,
  NODE_VECTOR_MATH_FLOOR = 13,
  NODE_VECTOR_MATH_CEIL = 14,
  NODE_VECTOR_MATH_MODULO = 15,
  NODE_VECTOR_MATH_FRACTION = 16,
  NODE_VECTOR_MATH_ABSOLUTE = 17,
  NODE_VECTOR_MATH_MINIMUM = 18,
  NODE_VECTOR_MATH_MAXIMUM = 19,
  NODE_VECTOR_MATH_WRAP = 20,
  NODE_VECTOR_MATH_SINE = 21,
  NODE_VECTOR_MATH_COSINE = 22,
  NODE_VECTOR_MATH_TANGENT = 23,
  NODE_VECTOR_MATH_REFRACT = 24,
  NODE_VECTOR_MATH_FACEFORWARD = 25,
  NODE_VECTOR_MATH_MULTIPLY_ADD = 26,
} NodeVectorMathOperation;
 
typedef enum NodeBooleanMathOperation {
  NODE_BOOLEAN_MATH_AND = 0,
  NODE_BOOLEAN_MATH_OR = 1,
  NODE_BOOLEAN_MATH_NOT = 2,
 
  NODE_BOOLEAN_MATH_NAND = 3,
  NODE_BOOLEAN_MATH_NOR = 4,
  NODE_BOOLEAN_MATH_XNOR = 5,
  NODE_BOOLEAN_MATH_XOR = 6,
 
  NODE_BOOLEAN_MATH_IMPLY = 7,
  NODE_BOOLEAN_MATH_NIMPLY = 8,
} NodeBooleanMathOperation;
 
typedef enum NodeShaderMixMode {
  NODE_MIX_MODE_UNIFORM = 0,
  NODE_MIX_MODE_NON_UNIFORM = 1,
} NodeShaderMixMode;
 
typedef enum NodeCompareMode {
  NODE_COMPARE_MODE_ELEMENT = 0,
  NODE_COMPARE_MODE_LENGTH = 1,
  NODE_COMPARE_MODE_AVERAGE = 2,
  NODE_COMPARE_MODE_DOT_PRODUCT = 3,
  NODE_COMPARE_MODE_DIRECTION = 4
} NodeCompareMode;
 
typedef enum NodeCompareOperation {
  NODE_COMPARE_LESS_THAN = 0,
  NODE_COMPARE_LESS_EQUAL = 1,
  NODE_COMPARE_GREATER_THAN = 2,
  NODE_COMPARE_GREATER_EQUAL = 3,
  NODE_COMPARE_EQUAL = 4,
  NODE_COMPARE_NOT_EQUAL = 5,
  NODE_COMPARE_COLOR_BRIGHTER = 6,
  NODE_COMPARE_COLOR_DARKER = 7,
} NodeCompareOperation;
 
typedef enum NodeIntegerMathOperation {
  NODE_INTEGER_MATH_ADD = 0,
  NODE_INTEGER_MATH_SUBTRACT = 1,
  NODE_INTEGER_MATH_MULTIPLY = 2,
  NODE_INTEGER_MATH_DIVIDE = 3,
  NODE_INTEGER_MATH_MULTIPLY_ADD = 4,
  NODE_INTEGER_MATH_POWER = 5,
  NODE_INTEGER_MATH_FLOORED_MODULO = 6,
  NODE_INTEGER_MATH_ABSOLUTE = 7,
  NODE_INTEGER_MATH_MINIMUM = 8,
  NODE_INTEGER_MATH_MAXIMUM = 9,
  NODE_INTEGER_MATH_GCD = 10,
  NODE_INTEGER_MATH_LCM = 11,
  NODE_INTEGER_MATH_NEGATE = 12,
  NODE_INTEGER_MATH_SIGN = 13,
  NODE_INTEGER_MATH_DIVIDE_FLOOR = 14,
  NODE_INTEGER_MATH_DIVIDE_CEIL = 15,
  NODE_INTEGER_MATH_DIVIDE_ROUND = 16,
  NODE_INTEGER_MATH_MODULO = 17,
} NodeIntegerMathOperation;
 
typedef enum FloatToIntRoundingMode {
  FN_NODE_FLOAT_TO_INT_ROUND = 0,
  FN_NODE_FLOAT_TO_INT_FLOOR = 1,
  FN_NODE_FLOAT_TO_INT_CEIL = 2,
  FN_NODE_FLOAT_TO_INT_TRUNCATE = 3,
} FloatToIntRoundingMode;
 
enum {
  NODE_CLAMP_MINMAX = 0,
  NODE_CLAMP_RANGE = 1,
};
 
enum {
  NODE_MAP_RANGE_LINEAR = 0,
  NODE_MAP_RANGE_STEPPED = 1,
  NODE_MAP_RANGE_SMOOTHSTEP = 2,
  NODE_MAP_RANGE_SMOOTHERSTEP = 3,
};
 
/* mix rgb node flags */
enum {
  SHD_MIXRGB_USE_ALPHA = 1,
  SHD_MIXRGB_CLAMP = 2,
};
 
/* Subsurface. */
 
enum {
#ifdef DNA_DEPRECATED_ALLOW
  SHD_SUBSURFACE_COMPATIBLE = 0, /* Deprecated */
  SHD_SUBSURFACE_CUBIC = 1,
  SHD_SUBSURFACE_GAUSSIAN = 2,
#endif
  SHD_SUBSURFACE_BURLEY = 3,
  SHD_SUBSURFACE_RANDOM_WALK = 4,
  SHD_SUBSURFACE_RANDOM_WALK_SKIN = 5,
};
 
/* blur node */
enum {
  CMP_NODE_BLUR_ASPECT_NONE = 0,
  CMP_NODE_BLUR_ASPECT_Y = 1,
  CMP_NODE_BLUR_ASPECT_X = 2,
};
 
/* wrapping */
enum {
  CMP_NODE_WRAP_NONE = 0,
  CMP_NODE_WRAP_X = 1,
  CMP_NODE_WRAP_Y = 2,
  CMP_NODE_WRAP_XY = 3,
};
 
#define CMP_NODE_MASK_MBLUR_SAMPLES_MAX 64
 
/* image */
enum {
  CMP_NODE_IMAGE_USE_STRAIGHT_OUTPUT = 1,
};
 
/* viewer and composite output. */
enum {
  CMP_NODE_OUTPUT_IGNORE_ALPHA = 1,
};
 
typedef enum CMPNodeSplitAxis {
  CMP_NODE_SPLIT_HORIZONTAL = 0,
  CMP_NODE_SPLIT_VERTICAL = 1,
} CMPNodeSplitAxis;
 
typedef enum CMPNodeColorBalanceMethod {
  CMP_NODE_COLOR_BALANCE_LGG = 0,
  CMP_NODE_COLOR_BALANCE_ASC_CDL = 1,
  CMP_NODE_COLOR_BALANCE_WHITEPOINT = 2,
} CMPNodeColorBalanceMethod;
 
typedef enum CMPNodeAlphaConvertMode {
  CMP_NODE_ALPHA_CONVERT_PREMULTIPLY = 0,
  CMP_NODE_ALPHA_CONVERT_UNPREMULTIPLY = 1,
} CMPNodeAlphaConvertMode;
 
typedef enum CMPNodeDistanceMatteColorSpace {
  CMP_NODE_DISTANCE_MATTE_COLOR_SPACE_YCCA = 0,
  CMP_NODE_DISTANCE_MATTE_COLOR_SPACE_RGBA = 1,
} CMPNodeDistanceMatteColorSpace;
 
typedef enum CMPNodeColorSpillLimitAlgorithm {
  CMP_NODE_COLOR_SPILL_LIMIT_ALGORITHM_SINGLE = 0,
  CMP_NODE_COLOR_SPILL_LIMIT_ALGORITHM_AVERAGE = 1,
} CMPNodeColorSpillLimitAlgorithm;
 
typedef enum CMPNodeChannelMatteLimitAlgorithm {
  CMP_NODE_CHANNEL_MATTE_LIMIT_ALGORITHM_SINGLE = 0,
  CMP_NODE_CHANNEL_MATTE_LIMIT_ALGORITHM_MAX = 1,
} CMPNodeChannelMatteLimitAlgorithm;
 
/* Flip Node. Stored in custom1. */
typedef enum CMPNodeFlipMode {
  CMP_NODE_FLIP_X = 0,
  CMP_NODE_FLIP_Y = 1,
  CMP_NODE_FLIP_X_Y = 2,
} CMPNodeFlipMode;
 
/* Scale Node. Stored in custom1. */
typedef enum CMPNodeScaleMethod {
  CMP_NODE_SCALE_RELATIVE = 0,
  CMP_NODE_SCALE_ABSOLUTE = 1,
  CMP_NODE_SCALE_RENDER_PERCENT = 2,
  CMP_NODE_SCALE_RENDER_SIZE = 3,
} CMPNodeScaleMethod;
 
/* Scale Node. Stored in custom2. */
typedef enum CMPNodeScaleRenderSizeMethod {
  CMP_NODE_SCALE_RENDER_SIZE_STRETCH = 0,
  CMP_NODE_SCALE_RENDER_SIZE_FIT = 1,
  CMP_NODE_SCALE_RENDER_SIZE_CROP = 2,
} CMPNodeScaleRenderSizeMethod;
 
/* Filter Node. Stored in custom1. */
typedef enum CMPNodeFilterMethod {
  CMP_NODE_FILTER_SOFT = 0,
  CMP_NODE_FILTER_SHARP_BOX = 1,
  CMP_NODE_FILTER_LAPLACE = 2,
  CMP_NODE_FILTER_SOBEL = 3,
  CMP_NODE_FILTER_PREWITT = 4,
  CMP_NODE_FILTER_KIRSCH = 5,
  CMP_NODE_FILTER_SHADOW = 6,
  CMP_NODE_FILTER_SHARP_DIAMOND = 7,
} CMPNodeFilterMethod;
 
/* Levels Node. Stored in custom1. */
typedef enum CMPNodeLevelsChannel {
  CMP_NODE_LEVLES_LUMINANCE = 1,
  CMP_NODE_LEVLES_RED = 2,
  CMP_NODE_LEVLES_GREEN = 3,
  CMP_NODE_LEVLES_BLUE = 4,
  CMP_NODE_LEVLES_LUMINANCE_BT709 = 5,
} CMPNodeLevelsChannel;
 
/* Tone Map Node. Stored in NodeTonemap.type. */
typedef enum CMPNodeToneMapType {
  CMP_NODE_TONE_MAP_SIMPLE = 0,
  CMP_NODE_TONE_MAP_PHOTORECEPTOR = 1,
} CMPNodeToneMapType;
 
/* Track Position Node. Stored in custom1. */
typedef enum CMPNodeTrackPositionMode {
  CMP_NODE_TRACK_POSITION_ABSOLUTE = 0,
  CMP_NODE_TRACK_POSITION_RELATIVE_START = 1,
  CMP_NODE_TRACK_POSITION_RELATIVE_FRAME = 2,
  CMP_NODE_TRACK_POSITION_ABSOLUTE_FRAME = 3,
} CMPNodeTrackPositionMode;
 
/* Glare Node. Stored in NodeGlare.type. */
typedef enum CMPNodeGlareType {
  CMP_NODE_GLARE_SIMPLE_STAR = 0,
  CMP_NODE_GLARE_FOG_GLOW = 1,
  CMP_NODE_GLARE_STREAKS = 2,
  CMP_NODE_GLARE_GHOST = 3,
  CMP_NODE_GLARE_BLOOM = 4,
} CMPNodeGlareType;
 
/* Kuwahara Node. Stored in variation */
typedef enum CMPNodeKuwahara {
  CMP_NODE_KUWAHARA_CLASSIC = 0,
  CMP_NODE_KUWAHARA_ANISOTROPIC = 1,
} CMPNodeKuwahara;
 
/* Stabilize 2D node. Stored in custom1 for Stabilize 2D node and in interpolation for Translate
 * node. */
typedef enum CMPNodeInterpolation {
  CMP_NODE_INTERPOLATION_NEAREST = 0,
  CMP_NODE_INTERPOLATION_BILINEAR = 1,
  CMP_NODE_INTERPOLATION_BICUBIC = 2,
} CMPNodeInterpolation;
 
/* Stabilize 2D node. Stored in custom2. */
typedef enum CMPNodeStabilizeInverse {
  CMP_NODE_STABILIZE_FLAG_INVERSE = 1,
} CMPNodeStabilizeInverse;
 
#define CMP_NODE_PLANE_TRACK_DEFORM_MOTION_BLUR_SAMPLES_MAX 64
 
/* Plane track deform node. */
typedef enum CMPNodePlaneTrackDeformFlags {
  CMP_NODE_PLANE_TRACK_DEFORM_FLAG_MOTION_BLUR = 1,
} CMPNodePlaneTrackDeformFlags;
 
/* Set Alpha Node. */
 
typedef enum CMPNodeSetAlphaMode {
  CMP_NODE_SETALPHA_MODE_APPLY = 0,
  CMP_NODE_SETALPHA_MODE_REPLACE_ALPHA = 1,
} CMPNodeSetAlphaMode;
 
/* Denoise Node. */
 
typedef enum CMPNodeDenoisePrefilter {
  CMP_NODE_DENOISE_PREFILTER_FAST = 0,
  CMP_NODE_DENOISE_PREFILTER_NONE = 1,
  CMP_NODE_DENOISE_PREFILTER_ACCURATE = 2
} CMPNodeDenoisePrefilter;
 
/* Color combine/separate modes */
 
typedef enum CMPNodeCombSepColorMode {
  CMP_NODE_COMBSEP_COLOR_RGB = 0,
  CMP_NODE_COMBSEP_COLOR_HSV = 1,
  CMP_NODE_COMBSEP_COLOR_HSL = 2,
  CMP_NODE_COMBSEP_COLOR_YCC = 3,
  CMP_NODE_COMBSEP_COLOR_YUV = 4,
} CMPNodeCombSepColorMode;
 
/* Filtering modes Compositor MapUV node, stored in custom2. */
typedef enum CMPNodeMapUVFiltering {
  CMP_NODE_MAP_UV_FILTERING_NEAREST = 0,
  CMP_NODE_MAP_UV_FILTERING_BILINEAR = 1,
  CMP_NODE_MAP_UV_FILTERING_BICUBIC = 2,
  CMP_NODE_MAP_UV_FILTERING_ANISOTROPIC = 3,
} CMPNodeMapUVFiltering;
 
/* Cryptomatte node source. */
typedef enum CMPNodeCryptomatteSource {
  CMP_NODE_CRYPTOMATTE_SOURCE_RENDER = 0,
  CMP_NODE_CRYPTOMATTE_SOURCE_IMAGE = 1,
} CMPNodeCryptomatteSource;
 
/* Point Density shader node */
 
enum {
  SHD_POINTDENSITY_SOURCE_PSYS = 0,
  SHD_POINTDENSITY_SOURCE_OBJECT = 1,
};
 
enum {
  SHD_POINTDENSITY_SPACE_OBJECT = 0,
  SHD_POINTDENSITY_SPACE_WORLD = 1,
};
 
enum {
  SHD_POINTDENSITY_COLOR_PARTAGE = 1,
  SHD_POINTDENSITY_COLOR_PARTSPEED = 2,
  SHD_POINTDENSITY_COLOR_PARTVEL = 3,
};
 
enum {
  SHD_POINTDENSITY_COLOR_VERTCOL = 0,
  SHD_POINTDENSITY_COLOR_VERTWEIGHT = 1,
  SHD_POINTDENSITY_COLOR_VERTNOR = 2,
};
 
/* Scattering phase functions */
enum {
  SHD_PHASE_HENYEY_GREENSTEIN = 0,
  SHD_PHASE_FOURNIER_FORAND = 1,
  SHD_PHASE_DRAINE = 2,
  SHD_PHASE_RAYLEIGH = 3,
  SHD_PHASE_MIE = 4,
};
 
/* Output shader node */
 
typedef enum NodeShaderOutputTarget {
  SHD_OUTPUT_ALL = 0,
  SHD_OUTPUT_EEVEE = 1,
  SHD_OUTPUT_CYCLES = 2,
} NodeShaderOutputTarget;
 
/* Geometry Nodes */
 
typedef enum GeometryNodeProximityTargetType {
  GEO_NODE_PROX_TARGET_POINTS = 0,
  GEO_NODE_PROX_TARGET_EDGES = 1,
  GEO_NODE_PROX_TARGET_FACES = 2,
} GeometryNodeProximityTargetType;
 
typedef enum GeometryNodeCurvePrimitiveCircleMode {
  GEO_NODE_CURVE_PRIMITIVE_CIRCLE_TYPE_POINTS = 0,
  GEO_NODE_CURVE_PRIMITIVE_CIRCLE_TYPE_RADIUS = 1
} GeometryNodeCurvePrimitiveCircleMode;
 
typedef enum GeometryNodeCurveHandleType {
  GEO_NODE_CURVE_HANDLE_FREE = 0,
  GEO_NODE_CURVE_HANDLE_AUTO = 1,
  GEO_NODE_CURVE_HANDLE_VECTOR = 2,
  GEO_NODE_CURVE_HANDLE_ALIGN = 3
} GeometryNodeCurveHandleType;
 
typedef enum GeometryNodeCurveHandleMode {
  GEO_NODE_CURVE_HANDLE_LEFT = (1 << 0),
  GEO_NODE_CURVE_HANDLE_RIGHT = (1 << 1)
} GeometryNodeCurveHandleMode;
 
typedef enum GeometryNodeTriangulateNGons {
  GEO_NODE_TRIANGULATE_NGON_BEAUTY = 0,
  GEO_NODE_TRIANGULATE_NGON_EARCLIP = 1,
} GeometryNodeTriangulateNGons;
 
typedef enum GeometryNodeTriangulateQuads {
  GEO_NODE_TRIANGULATE_QUAD_BEAUTY = 0,
  GEO_NODE_TRIANGULATE_QUAD_FIXED = 1,
  GEO_NODE_TRIANGULATE_QUAD_ALTERNATE = 2,
  GEO_NODE_TRIANGULATE_QUAD_SHORTEDGE = 3,
  GEO_NODE_TRIANGULATE_QUAD_LONGEDGE = 4,
} GeometryNodeTriangulateQuads;
 
typedef enum GeometryNodeDistributePointsInVolumeMode {
  GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME_DENSITY_RANDOM = 0,
  GEO_NODE_DISTRIBUTE_POINTS_IN_VOLUME_DENSITY_GRID = 1,
} GeometryNodeDistributePointsInVolumeMode;
 
typedef enum GeometryNodeDistributePointsOnFacesMode {
  GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_RANDOM = 0,
  GEO_NODE_POINT_DISTRIBUTE_POINTS_ON_FACES_POISSON = 1,
} GeometryNodeDistributePointsOnFacesMode;
 
typedef enum GeometryNodeExtrudeMeshMode {
  GEO_NODE_EXTRUDE_MESH_VERTICES = 0,
  GEO_NODE_EXTRUDE_MESH_EDGES = 1,
  GEO_NODE_EXTRUDE_MESH_FACES = 2,
} GeometryNodeExtrudeMeshMode;
 
typedef enum FunctionNodeRotateEulerType {
  FN_NODE_ROTATE_EULER_TYPE_EULER = 0,
  FN_NODE_ROTATE_EULER_TYPE_AXIS_ANGLE = 1,
} FunctionNodeRotateEulerType;
 
typedef enum FunctionNodeRotateEulerSpace {
  FN_NODE_ROTATE_EULER_SPACE_OBJECT = 0,
  FN_NODE_ROTATE_EULER_SPACE_LOCAL = 1,
} FunctionNodeRotateEulerSpace;
 
typedef enum NodeAlignEulerToVectorAxis {
  FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_X = 0,
  FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_Y = 1,
  FN_NODE_ALIGN_EULER_TO_VECTOR_AXIS_Z = 2,
} NodeAlignEulerToVectorAxis;
 
typedef enum NodeAlignEulerToVectorPivotAxis {
  FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_AUTO = 0,
  FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_X = 1,
  FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Y = 2,
  FN_NODE_ALIGN_EULER_TO_VECTOR_PIVOT_AXIS_Z = 3,
} NodeAlignEulerToVectorPivotAxis;
 
typedef enum GeometryNodeTransformSpace {
  GEO_NODE_TRANSFORM_SPACE_ORIGINAL = 0,
  GEO_NODE_TRANSFORM_SPACE_RELATIVE = 1,
} GeometryNodeTransformSpace;
 
typedef enum GeometryNodePointsToVolumeResolutionMode {
  GEO_NODE_POINTS_TO_VOLUME_RESOLUTION_MODE_AMOUNT = 0,
  GEO_NODE_POINTS_TO_VOLUME_RESOLUTION_MODE_SIZE = 1,
} GeometryNodePointsToVolumeResolutionMode;
 
typedef enum GeometryNodeMeshCircleFillType {
  GEO_NODE_MESH_CIRCLE_FILL_NONE = 0,
  GEO_NODE_MESH_CIRCLE_FILL_NGON = 1,
  GEO_NODE_MESH_CIRCLE_FILL_TRIANGLE_FAN = 2,
} GeometryNodeMeshCircleFillType;
 
typedef enum GeometryNodeMergeByDistanceMode {
  GEO_NODE_MERGE_BY_DISTANCE_MODE_ALL = 0,
  GEO_NODE_MERGE_BY_DISTANCE_MODE_CONNECTED = 1,
} GeometryNodeMergeByDistanceMode;
 
typedef enum GeometryNodeUVUnwrapMethod {
  GEO_NODE_UV_UNWRAP_METHOD_ANGLE_BASED = 0,
  GEO_NODE_UV_UNWRAP_METHOD_CONFORMAL = 1,
} GeometryNodeUVUnwrapMethod;
 
typedef enum GeometryNodeMeshLineMode {
  GEO_NODE_MESH_LINE_MODE_END_POINTS = 0,
  GEO_NODE_MESH_LINE_MODE_OFFSET = 1,
} GeometryNodeMeshLineMode;
 
typedef enum GeometryNodeMeshLineCountMode {
  GEO_NODE_MESH_LINE_COUNT_TOTAL = 0,
  GEO_NODE_MESH_LINE_COUNT_RESOLUTION = 1,
} GeometryNodeMeshLineCountMode;
 
typedef enum GeometryNodeCurvePrimitiveArcMode {
  GEO_NODE_CURVE_PRIMITIVE_ARC_TYPE_POINTS = 0,
  GEO_NODE_CURVE_PRIMITIVE_ARC_TYPE_RADIUS = 1,
} GeometryNodeCurvePrimitiveArcMode;
 
typedef enum GeometryNodeCurvePrimitiveLineMode {
  GEO_NODE_CURVE_PRIMITIVE_LINE_MODE_POINTS = 0,
  GEO_NODE_CURVE_PRIMITIVE_LINE_MODE_DIRECTION = 1
} GeometryNodeCurvePrimitiveLineMode;
 
typedef enum GeometryNodeCurvePrimitiveQuadMode {
  GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_RECTANGLE = 0,
  GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_PARALLELOGRAM = 1,
  GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_TRAPEZOID = 2,
  GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_KITE = 3,
  GEO_NODE_CURVE_PRIMITIVE_QUAD_MODE_POINTS = 4,
} GeometryNodeCurvePrimitiveQuadMode;
 
typedef enum GeometryNodeCurvePrimitiveBezierSegmentMode {
  GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT_POSITION = 0,
  GEO_NODE_CURVE_PRIMITIVE_BEZIER_SEGMENT_OFFSET = 1,
} GeometryNodeCurvePrimitiveBezierSegmentMode;
 
typedef enum GeometryNodeCurveResampleMode {
  GEO_NODE_CURVE_RESAMPLE_COUNT = 0,
  GEO_NODE_CURVE_RESAMPLE_LENGTH = 1,
  GEO_NODE_CURVE_RESAMPLE_EVALUATED = 2,
} GeometryNodeCurveResampleMode;
 
typedef enum GeometryNodeCurveSampleMode {
  GEO_NODE_CURVE_SAMPLE_FACTOR = 0,
  GEO_NODE_CURVE_SAMPLE_LENGTH = 1,
} GeometryNodeCurveSampleMode;
 
typedef enum GeometryNodeCurveFilletMode {
  GEO_NODE_CURVE_FILLET_BEZIER = 0,
  GEO_NODE_CURVE_FILLET_POLY = 1,
} GeometryNodeCurveFilletMode;
 
typedef enum GeometryNodeAttributeTransferMode {
  GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST_FACE_INTERPOLATED = 0,
  GEO_NODE_ATTRIBUTE_TRANSFER_NEAREST = 1,
  GEO_NODE_ATTRIBUTE_TRANSFER_INDEX = 2,
} GeometryNodeAttributeTransferMode;
 
typedef enum GeometryNodeRaycastMapMode {
  GEO_NODE_RAYCAST_INTERPOLATED = 0,
  GEO_NODE_RAYCAST_NEAREST = 1,
} GeometryNodeRaycastMapMode;
 
typedef enum GeometryNodeCurveFillMode {
  GEO_NODE_CURVE_FILL_MODE_TRIANGULATED = 0,
  GEO_NODE_CURVE_FILL_MODE_NGONS = 1,
} GeometryNodeCurveFillMode;
 
typedef enum GeometryNodeMeshToPointsMode {
  GEO_NODE_MESH_TO_POINTS_VERTICES = 0,
  GEO_NODE_MESH_TO_POINTS_EDGES = 1,
  GEO_NODE_MESH_TO_POINTS_FACES = 2,
  GEO_NODE_MESH_TO_POINTS_CORNERS = 3,
} GeometryNodeMeshToPointsMode;
 
typedef enum GeometryNodeStringToCurvesOverflowMode {
  GEO_NODE_STRING_TO_CURVES_MODE_OVERFLOW = 0,
  GEO_NODE_STRING_TO_CURVES_MODE_SCALE_TO_FIT = 1,
  GEO_NODE_STRING_TO_CURVES_MODE_TRUNCATE = 2,
} GeometryNodeStringToCurvesOverflowMode;
 
typedef enum GeometryNodeStringToCurvesAlignXMode {
  GEO_NODE_STRING_TO_CURVES_ALIGN_X_LEFT = 0,
  GEO_NODE_STRING_TO_CURVES_ALIGN_X_CENTER = 1,
  GEO_NODE_STRING_TO_CURVES_ALIGN_X_RIGHT = 2,
  GEO_NODE_STRING_TO_CURVES_ALIGN_X_JUSTIFY = 3,
  GEO_NODE_STRING_TO_CURVES_ALIGN_X_FLUSH = 4,
} GeometryNodeStringToCurvesAlignXMode;
 
typedef enum GeometryNodeStringToCurvesAlignYMode {
  GEO_NODE_STRING_TO_CURVES_ALIGN_Y_TOP_BASELINE = 0,
  GEO_NODE_STRING_TO_CURVES_ALIGN_Y_TOP = 1,
  GEO_NODE_STRING_TO_CURVES_ALIGN_Y_MIDDLE = 2,
  GEO_NODE_STRING_TO_CURVES_ALIGN_Y_BOTTOM_BASELINE = 3,
  GEO_NODE_STRING_TO_CURVES_ALIGN_Y_BOTTOM = 4,
} GeometryNodeStringToCurvesAlignYMode;
 
typedef enum GeometryNodeStringToCurvesPivotMode {
  GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_MIDPOINT = 0,
  GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_LEFT = 1,
  GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_CENTER = 2,
  GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_TOP_RIGHT = 3,
  GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_LEFT = 4,
  GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_CENTER = 5,
  GEO_NODE_STRING_TO_CURVES_PIVOT_MODE_BOTTOM_RIGHT = 6,
} GeometryNodeStringToCurvesPivotMode;
 
typedef enum GeometryNodeDeleteGeometryMode {
  GEO_NODE_DELETE_GEOMETRY_MODE_ALL = 0,
  GEO_NODE_DELETE_GEOMETRY_MODE_EDGE_FACE = 1,
  GEO_NODE_DELETE_GEOMETRY_MODE_ONLY_FACE = 2,
} GeometryNodeDeleteGeometryMode;
 
typedef enum GeometryNodeScaleElementsMode {
  GEO_NODE_SCALE_ELEMENTS_UNIFORM = 0,
  GEO_NODE_SCALE_ELEMENTS_SINGLE_AXIS = 1,
} GeometryNodeScaleElementsMode;
 
typedef enum NodeCombSepColorMode {
  NODE_COMBSEP_COLOR_RGB = 0,
  NODE_COMBSEP_COLOR_HSV = 1,
  NODE_COMBSEP_COLOR_HSL = 2,
} NodeCombSepColorMode;
 
typedef enum GeometryNodeGizmoColor {
  GEO_NODE_GIZMO_COLOR_PRIMARY = 0,
  GEO_NODE_GIZMO_COLOR_SECONDARY = 1,
  GEO_NODE_GIZMO_COLOR_X = 2,
  GEO_NODE_GIZMO_COLOR_Y = 3,
  GEO_NODE_GIZMO_COLOR_Z = 4,
} GeometryNodeGizmoColor;
 
typedef enum GeometryNodeLinearGizmoDrawStyle {
  GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_ARROW = 0,
  GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_CROSS = 1,
  GEO_NODE_LINEAR_GIZMO_DRAW_STYLE_BOX = 2,
} GeometryNodeLinearGizmoDrawStyle;
 
typedef enum NodeGeometryTransformMode {
  GEO_NODE_TRANSFORM_MODE_COMPONENTS = 0,
  GEO_NODE_TRANSFORM_MODE_MATRIX = 1,
} NodeGeometryTransformMode;