DNA_anim_enums.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2009 Blender Authors, Joshua Leung. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "BLI_utildefines.h"
 
/* ************************************************ */
/* F-Curve DataTypes */
 
/* Modifiers -------------------------------------- */

typedef enum eFModifier_Types {
  FMODIFIER_TYPE_NULL = 0,
  FMODIFIER_TYPE_GENERATOR = 1,
  FMODIFIER_TYPE_FN_GENERATOR = 2,
  FMODIFIER_TYPE_ENVELOPE = 3,
  FMODIFIER_TYPE_CYCLES = 4,
  FMODIFIER_TYPE_NOISE = 5,
  FMODIFIER_TYPE_FILTER = 6, /* Was never implemented, removed in #123906. */
  FMODIFIER_TYPE_PYTHON = 7, /* Was never implemented, removed in #123906. */
  FMODIFIER_TYPE_LIMITS = 8,
  FMODIFIER_TYPE_STEPPED = 9,
 
  /* NOTE: all new modifiers must be added above this line */
  FMODIFIER_NUM_TYPES,
} eFModifier_Types;

typedef enum eFModifier_Flags {
  FMODIFIER_FLAG_DISABLED = (1 << 0),
#ifdef DNA_DEPRECATED_ALLOW
  FMODIFIER_FLAG_EXPANDED = (1 << 1),
#endif
  FMODIFIER_FLAG_ACTIVE = (1 << 2),
  FMODIFIER_FLAG_MUTED = (1 << 3),
  FMODIFIER_FLAG_RANGERESTRICT = (1 << 4),
  FMODIFIER_FLAG_USEINFLUENCE = (1 << 5),
} eFModifier_Flags;
 
/* --- */
 
/* generator modes */
typedef enum eFMod_Generator_Modes {
  FCM_GENERATOR_POLYNOMIAL = 0,
  FCM_GENERATOR_POLYNOMIAL_FACTORISED = 1,
} eFMod_Generator_Modes;
 
/* generator flags
 * - shared by Generator and Function Generator
 */
typedef enum eFMod_Generator_Flags {
  /* generator works in conjunction with other modifiers (i.e. doesn't replace those before it) */
  FCM_GENERATOR_ADDITIVE = (1 << 0),
} eFMod_Generator_Flags;
 
/* 'function' generator types */
typedef enum eFMod_Generator_Functions {
  FCM_GENERATOR_FN_SIN = 0,
  FCM_GENERATOR_FN_COS = 1,
  FCM_GENERATOR_FN_TAN = 2,
  FCM_GENERATOR_FN_SQRT = 3,
  FCM_GENERATOR_FN_LN = 4,
  FCM_GENERATOR_FN_SINC = 5,
} eFMod_Generator_Functions;
 
/* cycling modes */
typedef enum eFMod_Cycling_Modes {
  FCM_EXTRAPOLATE_NONE = 0,
  FCM_EXTRAPOLATE_CYCLIC,
  FCM_EXTRAPOLATE_CYCLIC_OFFSET,
  FCM_EXTRAPOLATE_MIRROR,
} eFMod_Cycling_Modes;
 
/* limiting flags */
typedef enum eFMod_Limit_Flags {
  FCM_LIMIT_XMIN = (1 << 0),
  FCM_LIMIT_XMAX = (1 << 1),
  FCM_LIMIT_YMIN = (1 << 2),
  FCM_LIMIT_YMAX = (1 << 3),
} eFMod_Limit_Flags;
 
/* modification modes */
typedef enum eFMod_Noise_Modifications {
  FCM_NOISE_MODIF_REPLACE = 0,
  FCM_NOISE_MODIF_ADD,
  FCM_NOISE_MODIF_SUBTRACT,
  FCM_NOISE_MODIF_MULTIPLY,
} eFMod_Noise_Modifications;
 
/* stepped modifier range flags */
typedef enum eFMod_Stepped_Flags {
  FCM_STEPPED_NO_BEFORE = (1 << 0),
  FCM_STEPPED_NO_AFTER = (1 << 1),
} eFMod_Stepped_Flags;
 
/* Drivers -------------------------------------- */

typedef enum eDriverTarget_Options {
  DTAR_OPTION_USE_FALLBACK = (1 << 0),
} eDriverTarget_Options;

typedef enum eDriverTarget_Flag {
  DTAR_FLAG_STRUCT_REF = (1 << 0),
  DTAR_FLAG_ID_OB_ONLY = (1 << 1),
 
  /* "local-space" flags. */
  DTAR_FLAG_LOCALSPACE = (1 << 2),
  DTAR_FLAG_LOCAL_CONSTS = (1 << 3),

  DTAR_FLAG_INVALID = (1 << 4),

  DTAR_FLAG_FALLBACK_USED = (1 << 5),
} eDriverTarget_Flag;
 
/* Transform Channels for Driver Targets */
typedef enum eDriverTarget_TransformChannels {
  DTAR_TRANSCHAN_LOCX = 0,
  DTAR_TRANSCHAN_LOCY,
  DTAR_TRANSCHAN_LOCZ,
  DTAR_TRANSCHAN_ROTX,
  DTAR_TRANSCHAN_ROTY,
  DTAR_TRANSCHAN_ROTZ,
  DTAR_TRANSCHAN_SCALEX,
  DTAR_TRANSCHAN_SCALEY,
  DTAR_TRANSCHAN_SCALEZ,
  DTAR_TRANSCHAN_SCALE_AVG,
  DTAR_TRANSCHAN_ROTW,
 
  MAX_DTAR_TRANSCHAN_TYPES,
} eDriverTarget_TransformChannels;
 
/* Rotation channel mode for Driver Targets */
typedef enum eDriverTarget_RotationMode {
  DTAR_ROTMODE_AUTO = 0,

  DTAR_ROTMODE_EULER_XYZ = 1,
  DTAR_ROTMODE_EULER_XZY,
  DTAR_ROTMODE_EULER_YXZ,
  DTAR_ROTMODE_EULER_YZX,
  DTAR_ROTMODE_EULER_ZXY,
  DTAR_ROTMODE_EULER_ZYX,
 
  DTAR_ROTMODE_QUATERNION,

  DTAR_ROTMODE_SWING_TWIST_X,
  DTAR_ROTMODE_SWING_TWIST_Y,
  DTAR_ROTMODE_SWING_TWIST_Z,
 
  DTAR_ROTMODE_EULER_MIN = DTAR_ROTMODE_EULER_XYZ,
  DTAR_ROTMODE_EULER_MAX = DTAR_ROTMODE_EULER_ZYX,
} eDriverTarget_RotationMode;
 
typedef enum eDriverTarget_ContextProperty {
  DTAR_CONTEXT_PROPERTY_ACTIVE_SCENE = 0,
  DTAR_CONTEXT_PROPERTY_ACTIVE_VIEW_LAYER = 1,
} eDriverTarget_ContextProperty;
 
/* --- */
 
/* maximum number of driver targets per variable */
#define MAX_DRIVER_TARGETS 8

typedef enum eDriverVar_Types {
  DVAR_TYPE_SINGLE_PROP = 0,
  DVAR_TYPE_ROT_DIFF,
  DVAR_TYPE_LOC_DIFF,
  DVAR_TYPE_TRANSFORM_CHAN,
  DVAR_TYPE_CONTEXT_PROP,

  MAX_DVAR_TYPES,
} eDriverVar_Types;
 
/* Driver Variable Flags */
typedef enum eDriverVar_Flags {
  /* variable is not set up correctly */
  DVAR_FLAG_ERROR = (1 << 0),
 
  /* variable name doesn't pass the validation tests */
  DVAR_FLAG_INVALID_NAME = (1 << 1),
  /* name starts with a number */
  DVAR_FLAG_INVALID_START_NUM = (1 << 2),
  /* name starts with a special character (!, $, @, #, _, etc.) */
  DVAR_FLAG_INVALID_START_CHAR = (1 << 3),
  /* name contains a space */
  DVAR_FLAG_INVALID_HAS_SPACE = (1 << 4),
  /* name contains a dot */
  DVAR_FLAG_INVALID_HAS_DOT = (1 << 5),
  /* name contains invalid chars */
  DVAR_FLAG_INVALID_HAS_SPECIAL = (1 << 6),
  /* name is a reserved keyword */
  DVAR_FLAG_INVALID_PY_KEYWORD = (1 << 7),
  /* name is zero-length */
  DVAR_FLAG_INVALID_EMPTY = (1 << 8),
} eDriverVar_Flags;

#define DVAR_ALL_INVALID_FLAGS \
  (DVAR_FLAG_INVALID_NAME | DVAR_FLAG_INVALID_START_NUM | DVAR_FLAG_INVALID_START_CHAR | \
   DVAR_FLAG_INVALID_HAS_SPACE | DVAR_FLAG_INVALID_HAS_DOT | DVAR_FLAG_INVALID_HAS_SPECIAL | \
   DVAR_FLAG_INVALID_PY_KEYWORD | DVAR_FLAG_INVALID_EMPTY)
 
/* --- */

typedef enum eDriver_Types {
  DRIVER_TYPE_AVERAGE = 0,
  DRIVER_TYPE_PYTHON,
  DRIVER_TYPE_SUM,
  DRIVER_TYPE_MIN,
  DRIVER_TYPE_MAX,
} eDriver_Types;

typedef enum eDriver_Flags {
  DRIVER_FLAG_INVALID = (1 << 0),
  DRIVER_FLAG_DEPRECATED = (1 << 1),
  /* TODO: this needs to be implemented at some stage or left out... */
  // DRIVER_FLAG_LAYERING  = (1 << 2),
  DRIVER_FLAG_RECOMPILE = (1 << 3),
  DRIVER_FLAG_RENAMEVAR = (1 << 4),
  /* Set if the driver cannot run because it uses Python which isn't allowed to execute. */
  DRIVER_FLAG_PYTHON_BLOCKED = (1 << 5),
  DRIVER_FLAG_USE_SELF = (1 << 6),
} eDriver_Flags;
 
/* F-Curves -------------------------------------- */

#define FCURVE_ACTIVE_KEYFRAME_NONE -1
 
/* user-editable flags/settings */
typedef enum eFCurve_Flags {
  FCURVE_VISIBLE = (1 << 0),
  FCURVE_SELECTED = (1 << 1),
  FCURVE_ACTIVE = (1 << 2),
  FCURVE_PROTECTED = (1 << 3),
  FCURVE_MUTED = (1 << 4),
 
#ifdef DNA_DEPRECATED_ALLOW
  FCURVE_AUTO_HANDLES = (1 << 5), /* Dirty. */
#endif
  FCURVE_MOD_OFF = (1 << 6),
  FCURVE_DISABLED = (1 << 10),
  FCURVE_INT_VALUES = (1 << 11),
  FCURVE_DISCRETE_VALUES = (1 << 12),

  FCURVE_TAGGED = (1 << 15),
} eFCurve_Flags;
ENUM_OPERATORS(eFCurve_Flags, FCURVE_TAGGED);
 
/* extrapolation modes (only simple value 'extending') */
typedef enum eFCurve_Extend {
  FCURVE_EXTRAPOLATE_CONSTANT = 0,
  FCURVE_EXTRAPOLATE_LINEAR,
} eFCurve_Extend;
 
/* curve coloring modes */
typedef enum eFCurve_Coloring {
  FCURVE_COLOR_AUTO_RAINBOW = 0,
  FCURVE_COLOR_AUTO_RGB = 1,
  FCURVE_COLOR_AUTO_YRGB = 3,
  FCURVE_COLOR_CUSTOM = 2,
} eFCurve_Coloring;
 
/* curve smoothing modes */
typedef enum eFCurve_Smoothing {
  FCURVE_SMOOTH_NONE = 0,
  FCURVE_SMOOTH_CONT_ACCEL = 1,
} eFCurve_Smoothing;
 
/* ************************************************ */
/* 'Action' Data-types */
 
/* NOTE: Although these are part of the Animation System,
 * they are not stored here, see `DNA_action_types.h` instead. */
 
/* ************************************************ */
/* NLA - Non-Linear Animation */
 
/* NLA Strips ------------------------------------- */
 
/* NLA Strip Blending Mode */
typedef enum eNlaStrip_Blend_Mode {
  NLASTRIP_MODE_REPLACE = 0,
  NLASTRIP_MODE_ADD,
  NLASTRIP_MODE_SUBTRACT,
  NLASTRIP_MODE_MULTIPLY,
  NLASTRIP_MODE_COMBINE,
} eNlaStrip_Blend_Mode;

typedef enum eNlaStrip_Extrapolate_Mode {
  /* extend before first frame if no previous strips in track,
   * and always hold+extend last frame */
  NLASTRIP_EXTEND_HOLD = 0,
  /* only hold+extend last frame */
  NLASTRIP_EXTEND_HOLD_FORWARD = 1,
  /* don't contribute at all */
  NLASTRIP_EXTEND_NOTHING = 2,
} eNlaStrip_Extrapolate_Mode;

typedef enum eNlaStrip_Flag {
  /* UI selection flags */
  NLASTRIP_FLAG_ACTIVE = (1 << 0),
  /* NLA strip is selected for editing */
  NLASTRIP_FLAG_SELECT = (1 << 1),
  // NLASTRIP_FLAG_SELECT_L      = (1 << 2),   /* left handle selected. */
  // NLASTRIP_FLAG_SELECT_R      = (1 << 3),   /* right handle selected. */

  NLASTRIP_FLAG_TWEAKUSER = (1 << 4),
 
  /* controls driven by local F-Curves */
  NLASTRIP_FLAG_USR_INFLUENCE = (1 << 5),
  NLASTRIP_FLAG_USR_TIME = (1 << 6),
  NLASTRIP_FLAG_USR_TIME_CYCLIC = (1 << 7),

  NLASTRIP_FLAG_SYNC_LENGTH = (1 << 9),
 
  /* playback flags (may be overridden by F-Curves) */
  NLASTRIP_FLAG_AUTO_BLENDS = (1 << 10),
  NLASTRIP_FLAG_REVERSE = (1 << 11),
  NLASTRIP_FLAG_MUTED = (1 << 12),
  /* NLASTRIP_FLAG_MIRROR = (1 << 13), */ /* UNUSED */
 
  /* temporary editing flags */

  NLASTRIP_FLAG_INVALID_LOCATION = (1 << 28),
  NLASTRIP_FLAG_NO_TIME_MAP = (1 << 29),
  NLASTRIP_FLAG_TEMP_META = (1 << 30),
  NLASTRIP_FLAG_EDIT_TOUCHED = (1u << 31),
} eNlaStrip_Flag;
 
/* NLA Strip Type */
typedef enum eNlaStrip_Type {
  /* 'clip' - references an Action */
  NLASTRIP_TYPE_CLIP = 0,
  /* 'transition' - blends between the adjacent strips */
  NLASTRIP_TYPE_TRANSITION,
  /* 'meta' - a strip which acts as a container for a few others */
  NLASTRIP_TYPE_META,
 
  /* 'emit sound' - a strip which is used for timing when speaker emits sounds */
  NLASTRIP_TYPE_SOUND,
} eNlaStrip_Type;
 
/* NLA Tracks ------------------------------------- */
 
/* settings for track */
typedef enum eNlaTrack_Flag {
  NLATRACK_ACTIVE = (1 << 0),
  NLATRACK_SELECTED = (1 << 1),
  NLATRACK_MUTED = (1 << 2),
  NLATRACK_SOLO = (1 << 3),
  NLATRACK_PROTECTED = (1 << 4),

  NLATRACK_DISABLED = (1 << 10),

  NLATRACK_TEMPORARILY_ADDED = (1 << 11),

  NLATRACK_OVERRIDELIBRARY_LOCAL = 1 << 16,
} eNlaTrack_Flag;
 
/* ************************************ */
/* KeyingSet Data-types */
 
/* KeyingSet settings */
typedef enum eKS_Settings {
  /* KEYINGSET_BUILTIN = (1 << 0), */ /* UNUSED */
  KEYINGSET_ABSOLUTE = (1 << 1),
} eKS_Settings;
ENUM_OPERATORS(eKS_Settings, KEYINGSET_ABSOLUTE)
 
/* Flags for use by keyframe creation/deletion calls */
typedef enum eInsertKeyFlags {
  INSERTKEY_NOFLAGS = 0,
  INSERTKEY_NEEDED = (1 << 0),
  INSERTKEY_MATRIX = (1 << 1),
  INSERTKEY_FAST = (1 << 2),
  /* INSERTKEY_FASTR = (1 << 3), */ /* UNUSED */
  INSERTKEY_REPLACE = (1 << 4),
  INSERTKEY_NO_USERPREF = (1 << 6),
  INSERTKEY_OVERWRITE_FULL = (1 << 7),
  INSERTKEY_CYCLE_AWARE = (1 << 9),
  INSERTKEY_AVAILABLE = (1 << 10),
} eInsertKeyFlags;
ENUM_OPERATORS(eInsertKeyFlags, INSERTKEY_AVAILABLE);
 
/* KS_Path->flag */
typedef enum eKSP_Settings {
  /* entire array (not just the specified index) gets keyframed */
  KSP_FLAG_WHOLE_ARRAY = (1 << 0),
} eKSP_Settings;
 
/* KS_Path->groupmode */
typedef enum eKSP_Grouping {
  KSP_GROUP_NAMED = 0,
  KSP_GROUP_NONE,
  KSP_GROUP_KSNAME,
  /* KSP_GROUP_TEMPLATE_ITEM, */ /* UNUSED */
} eKSP_Grouping;
 
/* ************************************************ */
/* Animation Data */
 
/* AnimData ------------------------------------- */
 
/* Animation Data settings (mostly for NLA) */
typedef enum eAnimData_Flag {
  ADT_NLA_SOLO_TRACK = (1 << 0),
  ADT_NLA_EVAL_OFF = (1 << 1),
  ADT_NLA_EDIT_ON = (1 << 2),
  ADT_NLA_EDIT_NOMAP = (1 << 3),
  ADT_NLA_SKEYS_COLLAPSED = (1 << 4),
  /* Evaluate tracks above tweaked strip. Only relevant in tweak mode. */
  ADT_NLA_EVAL_UPPER_TRACKS = (1 << 5),

  ADT_DRIVERS_COLLAPSED = (1 << 10),
  /* ADT_DRIVERS_DISABLED = (1 << 11), */ /* UNUSED */

  ADT_UI_SELECTED = (1 << 14),
  ADT_UI_ACTIVE = (1 << 15),

  ADT_CURVES_NOT_VISIBLE = (1 << 16),

  ADT_CURVES_ALWAYS_VISIBLE = (1 << 17),

  ADT_UI_EXPANDED = (1 << 18),
} eAnimData_Flag;
 
/* From: `DNA_object_types.h`, see its doc-string there. */
#define SELECT 1