DNA_action_types.h

Go to the documentation of this file.

/* SPDX-FileCopyrightText: 2001-2002 NaN Holding BV. All rights reserved.
 *
 * SPDX-License-Identifier: GPL-2.0-or-later */

 
#pragma once
 
#include "DNA_ID.h"
#include "DNA_armature_types.h"
#include "DNA_listBase.h"
#include "DNA_session_uid_types.h"
#include "DNA_userdef_types.h" /* ThemeWireColor */
#include "DNA_vec_types.h"
#include "DNA_view2d_types.h"
 
#ifdef __cplusplus
#  include <type_traits>
#endif
 
struct AnimData;
struct Collection;
struct FCurve;
struct GHash;
struct Object;
struct SpaceLink;
#ifdef __cplusplus
namespace blender::gpu {
class VertBuf;
class Batch;
}  // namespace blender::gpu
using GPUBatchHandle = blender::gpu::Batch;
using GPUVertBufHandle = blender::gpu::VertBuf;
#else
typedef struct GPUBatchHandle GPUBatchHandle;
typedef struct GPUVertBufHandle GPUVertBufHandle;
#endif
 
/* Forward declarations so the actual declarations can happen top-down. */
struct ActionLayer;
struct ActionSlot;
struct ActionStrip;
struct ActionChannelbag;
 
/* Declarations of the C++ wrappers. */
#ifdef __cplusplus
namespace blender::animrig {
class Action;
class Slot;
class SlotRuntime;
class Channelbag;
class ChannelGroup;
class Layer;
class Strip;
class StripKeyframeData;
}  // namespace blender::animrig
using ActionSlotRuntimeHandle = blender::animrig::SlotRuntime;
#else
typedef struct ActionSlotRuntimeHandle ActionSlotRuntimeHandle;
#endif
 
/* ************************************************ */
/* Visualization */
 
/* Motion Paths ------------------------------------ */
/* (used for Pose Channels and Objects) */

typedef struct bMotionPathVert {
  float co[3];
  int flag;
} bMotionPathVert;

typedef enum eMotionPathVert_Flag {
  /* vert is selected */
  MOTIONPATH_VERT_SEL = (1 << 0),
  MOTIONPATH_VERT_KEY = (1 << 1),
} eMotionPathVert_Flag;
 
/* ........ */
 
/* Motion Path data cache (mpath)
 * - for elements providing transforms (i.e. Objects or PoseChannels)
 */
typedef struct bMotionPath {
  bMotionPathVert *points;
  int length;

  int start_frame;
  int end_frame;

  float color[3];
  float color_post[3];
  int line_thickness;
  int flag;
 
  char _pad2[4];
  /* Used for drawing. */
  GPUVertBufHandle *points_vbo;
  GPUBatchHandle *batch_line;
  GPUBatchHandle *batch_points;
  void *_pad;
} bMotionPath;
 
/* bMotionPath->flag */
typedef enum eMotionPath_Flag {
  /* (for bones) path represents the head of the bone */
  MOTIONPATH_FLAG_BHEAD = (1 << 0),
  /* motion path is being edited */
  MOTIONPATH_FLAG_EDIT = (1 << 1),
  /* Custom colors */
  MOTIONPATH_FLAG_CUSTOM = (1 << 2),
  /* Draw lines or only points */
  MOTIONPATH_FLAG_LINES = (1 << 3),
  /* Bake to scene camera. */
  MOTIONPATH_FLAG_BAKE_CAMERA = (1 << 4),
} eMotionPath_Flag;
 
/* Visualization General --------------------------- */
/* for Objects or Poses (but NOT PoseChannels) */
 
/* Animation Visualization Settings (avs) */
typedef struct bAnimVizSettings {
  /* General Settings ------------------------ */
  short recalc;
 
  /* Motion Path Settings ------------------- */
  short path_type;
  short path_step;
  short path_range;

  short path_viewflag;
  short path_bakeflag;
  char _pad[4];

  int path_sf, path_ef;
  int path_bc, path_ac;
} bAnimVizSettings;
 
/* bAnimVizSettings->recalc */
typedef enum eAnimViz_RecalcFlags {
  /* Motion-paths need recalculating. */
  ANIMVIZ_RECALC_PATHS = (1 << 0),
} eAnimViz_RecalcFlags;
 
/* bAnimVizSettings->path_type */
typedef enum eMotionPaths_Types {
  /* show the paths along their entire ranges */
  MOTIONPATH_TYPE_RANGE = 0,
  /* only show the parts of the paths around the current frame */
  MOTIONPATH_TYPE_ACFRA = 1,
} eMotionPath_Types;
 
/* bAnimVizSettings->path_range */
typedef enum eMotionPath_Ranges {
  /* Default is scene */
  MOTIONPATH_RANGE_SCENE = 0,
  MOTIONPATH_RANGE_KEYS_SELECTED = 1,
  MOTIONPATH_RANGE_KEYS_ALL = 2,
  MOTIONPATH_RANGE_MANUAL = 3,
} eMotionPath_Ranges;
 
/* bAnimVizSettings->path_viewflag */
typedef enum eMotionPaths_ViewFlag {
  /* show frames on path */
  MOTIONPATH_VIEW_FNUMS = (1 << 0),
  /* show keyframes on path */
  MOTIONPATH_VIEW_KFRAS = (1 << 1),
  /* show keyframe/frame numbers */
  MOTIONPATH_VIEW_KFNOS = (1 << 2),
  /* find keyframes in whole action (instead of just in matching group name) */
  MOTIONPATH_VIEW_KFACT = (1 << 3),
  /* draw lines on path */
  /* MOTIONPATH_VIEW_LINES = (1 << 4), */ /* UNUSED */
} eMotionPath_ViewFlag;
 
/* bAnimVizSettings->path_bakeflag */
typedef enum eMotionPaths_BakeFlag {
  /* MOTIONPATH_BAKE_NEEDS_RECALC = (1 << 0), */ /* UNUSED */
  MOTIONPATH_BAKE_HEADS = (1 << 1),
  MOTIONPATH_BAKE_HAS_PATHS = (1 << 2),
  /* Bake the path in camera space. */
  MOTIONPATH_BAKE_CAMERA_SPACE = (1 << 3),
} eMotionPath_BakeFlag;
 
/* runtime */
#
#
typedef struct bPoseChannelDrawData {
  float solid_color[4];
  float wire_color[4];
 
  int bbone_matrix_len;
  /* keep last */
  float bbone_matrix[0][4][4];
} bPoseChannelDrawData;
 
struct DualQuat;
struct Mat4;
 
/* Describes a plane in pose space that delimits B-Bone segments. */
typedef struct bPoseChannel_BBoneSegmentBoundary {
  /* Boundary data in pose space. */
  float point[3];
  float plane_normal[3];
  /* Dot product of point and plane_normal to speed up distance computation. */
  float plane_offset;

  float depth_scale;
} bPoseChannel_BBoneSegmentBoundary;

typedef enum bPoseChannelRuntimeFlag {
  POSE_RUNTIME_TRANSFORM = (1 << 0),
  POSE_RUNTIME_HINGE_CHILD_TRANSFORM = (1 << 1),
  POSE_RUNTIME_TRANSFORM_CHILD = (1 << 2),
  /* Set on bones during selection to tell following code that this bone should be operated on. */
  POSE_RUNTIME_IN_SELECTION_AREA = (1 << 3),
} bPoseChannelRuntimeFlag;
 
typedef struct bPoseChannel_Runtime {
  SessionUID session_uid;
 
  /* Cached dual quaternion for deformation. */
  struct DualQuat deform_dual_quat;
 
  /* B-Bone shape data: copy of the segment count for validation. */
  int bbone_segments;
 
  /* Inverse of the total length of the segment polyline. */
  float bbone_arc_length_reciprocal;
  /* bPoseChannelRuntimeFlag */
  uint8_t flag;
  char _pad1[3];
 
  /* Rest and posed matrices for segments. */
  struct Mat4 *bbone_rest_mats;
  struct Mat4 *bbone_pose_mats;
 
  /* Delta from rest to pose in matrix and DualQuat form. */
  struct Mat4 *bbone_deform_mats;
  struct DualQuat *bbone_dual_quats;
 
  /* Segment boundaries for curved mode. */
  struct bPoseChannel_BBoneSegmentBoundary *bbone_segment_boundaries;
  void *_pad;
} bPoseChannel_Runtime;
 
/* ************************************************ */
/* Poses */
 
/* PoseChannel ------------------------------------ */

typedef struct bPoseChannel {
  DNA_DEFINE_CXX_METHODS(bPoseChannel)
 
  struct bPoseChannel *next, *prev;

  IDProperty *prop;

  IDProperty *system_properties;

  ListBase constraints;
  char name[/*MAXBONENAME*/ 64];

  short flag;
  short ikflag;
  short protectflag;
  short agrp_index;
  char constflag;
  char selectflag DNA_DEPRECATED;
  char drawflag;
  char bboneflag DNA_DEPRECATED;
  char _pad0[4];

  struct Bone *bone;
  struct bPoseChannel *parent;
  struct bPoseChannel *child;

  struct ListBase iktree;
  struct ListBase siktree;

  bMotionPath *mpath;
  struct Object *custom;
  struct bPoseChannel *custom_tx;
  float custom_scale; /* Deprecated */
  float custom_scale_xyz[3];
  float custom_translation[3];
  float custom_rotation_euler[3];
  float custom_shape_wire_width;

  float loc[3];
  float scale[3];

  float eul[3];
  float quat[4];
  float rotAxis[3], rotAngle;
  short rotmode;
  char _pad[6];

  float chan_mat[4][4];
  float pose_mat[4][4];
  float disp_mat[4][4];
  float disp_tail_mat[4][4];
  float constinv[4][4];

  float pose_head[3];
  float pose_tail[3];

  float limitmin[3], limitmax[3];
  float stiffness[3];
  float ikstretch;
  float ikrotweight;
  float iklinweight;

  float roll1, roll2;
  float curve_in_x, curve_in_z;
  float curve_out_x, curve_out_z;
  float ease1, ease2;
  float scale_in_x DNA_DEPRECATED, scale_in_z DNA_DEPRECATED;
  float scale_out_x DNA_DEPRECATED, scale_out_z DNA_DEPRECATED;
  float scale_in[3], scale_out[3];

  struct bPoseChannel *bbone_prev;
  struct bPoseChannel *bbone_next;

  void *temp;
  bPoseChannelDrawData *draw_data;

  struct bPoseChannel *orig_pchan;
 
  BoneColor color; /* MUST be named the same as in Bone and EditBone structs. */
 
  void *_pad2;

  struct bPoseChannel_Runtime runtime;
} bPoseChannel;
 
/* PoseChannel (transform) flags */
typedef enum ePchan_Flag {
  /* has transforms */
  POSE_LOC = (1 << 0),
  POSE_ROT = (1 << 1),
  POSE_SCALE = (1 << 2),
 
  /* old IK/cache stuff
   * - used to be here from (1 << 3) to (1 << 8)
   *   but has been repurposed since 2.77.2
   *   as they haven't been used in over 10 years
   */
 
  /* has BBone deforms */
  POSE_BBONE_SHAPE = (1 << 3),
  /* When set and bPoseChan.custom_tx is not a nullptr, the gizmo will be drawn at the location and
     orientation of the custom_tx instead of this bone. */
  POSE_TRANSFORM_AT_CUSTOM_TX = (1 << 4),
  /* When set, transformations will modify the bone as if it was a child of the
     bPoseChan.custom_tx. The flag only has an effect when `POSE_TRANSFORM_AT_CUSTOM_TX` and
     `custom_tx` are set. This can be useful for rigs where the deformation is coming from
     blendshapes in addition to the armature. */
  POSE_TRANSFORM_AROUND_CUSTOM_TX = (1 << 5),
  POSE_SELECTED = (1 << 6),
 
  /* IK/Pose solving */
  POSE_CHAIN = (1 << 9),
  POSE_DONE = (1 << 10),
  /* POSE_KEY = (1 << 11) */     /* UNUSED */
  /* POSE_STRIDE = (1 << 12), */ /* UNUSED */
  /* standard IK solving */
  POSE_IKTREE = (1 << 13),
#if 0
  /* has Spline IK */
  POSE_HAS_IKS = (1 << 14),
#endif
  /* spline IK solving */
  POSE_IKSPLINE = (1 << 15),
} ePchan_Flag;
 
/* PoseChannel constflag (constraint detection) */
typedef enum ePchan_ConstFlag {
  PCHAN_HAS_IK = (1 << 0),           /* Has IK constraint. */
  PCHAN_HAS_CONST = (1 << 1),        /* Has any constraint. */
  /* PCHAN_HAS_ACTION = (1 << 2), */ /* UNUSED */
  PCHAN_HAS_NO_TARGET = (1 << 3),    /* Has (spline) IK constraint but no target is set. */
  /* PCHAN_HAS_STRIDE = (1 << 4), */ /* UNUSED */
  PCHAN_HAS_SPLINEIK = (1 << 5),     /* Has Spline IK constraint. */
  PCHAN_INFLUENCED_BY_IK = (1 << 6), /* Is part of a (non-spline) IK chain. */
} ePchan_ConstFlag;
ENUM_OPERATORS(ePchan_ConstFlag, PCHAN_INFLUENCED_BY_IK);
 
/* PoseChannel->ikflag */
typedef enum ePchan_IkFlag {
  BONE_IK_NO_XDOF = (1 << 0),
  BONE_IK_NO_YDOF = (1 << 1),
  BONE_IK_NO_ZDOF = (1 << 2),
 
  BONE_IK_XLIMIT = (1 << 3),
  BONE_IK_YLIMIT = (1 << 4),
  BONE_IK_ZLIMIT = (1 << 5),
 
  BONE_IK_ROTCTL = (1 << 6),
  BONE_IK_LINCTL = (1 << 7),
 
  BONE_IK_NO_XDOF_TEMP = (1 << 10),
  BONE_IK_NO_YDOF_TEMP = (1 << 11),
  BONE_IK_NO_ZDOF_TEMP = (1 << 12),
} ePchan_IkFlag;
 
/* PoseChannel->drawflag */
typedef enum ePchan_DrawFlag {
  PCHAN_DRAW_NO_CUSTOM_BONE_SIZE = (1 << 0),
  PCHAN_DRAW_HIDDEN = (1 << 1),
} ePchan_DrawFlag;
 
/* NOTE: It doesn't take custom_scale_xyz into account. */
#define PCHAN_CUSTOM_BONE_LENGTH(pchan) \
  (((pchan)->drawflag & PCHAN_DRAW_NO_CUSTOM_BONE_SIZE) ? 1.0f : (pchan)->bone->length)
 
#ifdef DNA_DEPRECATED_ALLOW
/* PoseChannel->bboneflag */
typedef enum ePchan_BBoneFlag {
  /* Use custom reference bones (for roll and handle alignment), instead of immediate neighbors */
  PCHAN_BBONE_CUSTOM_HANDLES = (1 << 1),
  /* Evaluate start handle as being "relative" */
  PCHAN_BBONE_CUSTOM_START_REL = (1 << 2),
  /* Evaluate end handle as being "relative" */
  PCHAN_BBONE_CUSTOM_END_REL = (1 << 3),
} ePchan_BBoneFlag;
#endif
 
/* PoseChannel->rotmode and Object->rotmode */
typedef enum eRotationModes {
  /* quaternion rotations (default, and for older Blender versions) */
  ROT_MODE_QUAT = 0,
  /* euler rotations - keep in sync with enum in BLI_math_rotation.h */
  ROT_MODE_EUL = 1,
  ROT_MODE_XYZ = 1,
  ROT_MODE_XZY = 2,
  ROT_MODE_YXZ = 3,
  ROT_MODE_YZX = 4,
  ROT_MODE_ZXY = 5,
  ROT_MODE_ZYX = 6,
  /* NOTE: space is reserved here for 18 other possible
   * euler rotation orders not implemented
   */
  /* axis angle rotations */
  ROT_MODE_AXISANGLE = -1,
 
  ROT_MODE_MIN = ROT_MODE_AXISANGLE, /* sentinel for Py API */
  ROT_MODE_MAX = ROT_MODE_ZYX,
} eRotationModes;
 
/* Pose ------------------------------------ */
 
/* Pose-Object.
 *
 * It is only found under ob->pose. It is not library data, even
 * though there is a define for it (hack for the outliner).
 */
typedef struct bPose {
  ListBase chanbase;
  struct GHash *chanhash;
 
  /* Flat array of pose channels. It references pointers from
   * chanbase. Used for quick pose channel lookup from an index.
   */
  bPoseChannel **chan_array;
 
  short flag;
  char _pad[2];

  float ctime;
  float stride_offset[3];
  float cyclic_offset[3];

  ListBase agroups;

  int active_group;
  int iksolver;
  void *ikdata;
  void *ikparam;

  bAnimVizSettings avs;
} bPose;
 
/* Pose->flag */
typedef enum ePose_Flags {
  /* results in BKE_pose_rebuild being called */
  POSE_RECALC = (1 << 0),
  /* prevents any channel from getting overridden by anim from IPO */
  POSE_LOCKED = (1 << 1),
  /* clears the POSE_LOCKED flag for the next time the pose is evaluated */
  POSE_DO_UNLOCK = (1 << 2),
  /* pose has constraints which depend on time (used when depsgraph updates for a new frame) */
  POSE_CONSTRAINTS_TIMEDEPEND = (1 << 3),
  /* recalculate bone paths */
  /* POSE_RECALCPATHS = (1 << 4), */ /* UNUSED */
  /* set by BKE_pose_rebuild to give a chance to the IK solver to rebuild IK tree */
  POSE_WAS_REBUILT = (1 << 5),
  POSE_FLAG_DEPRECATED = (1 << 6), /* deprecated. */
  /* pose constraint flags needs to be updated */
  POSE_CONSTRAINTS_NEED_UPDATE_FLAGS = (1 << 7),
  /* Use auto IK in pose mode */
  POSE_AUTO_IK = (1 << 8),
  /* Use x-axis mirror in pose mode */
  POSE_MIRROR_EDIT = (1 << 9),
  /* Use relative mirroring in mirror mode */
  POSE_MIRROR_RELATIVE = (1 << 10),
} ePose_Flags;
 
/* IK Solvers ------------------------------------ */
 
/* bPose->iksolver and bPose->ikparam->iksolver */
typedef enum ePose_IKSolverType {
  IKSOLVER_STANDARD = 0,
  IKSOLVER_ITASC = 1,
} ePose_IKSolverType;
 
/* header for all bPose->ikparam structures */
typedef struct bIKParam {
  int iksolver;
} bIKParam;
 
/* bPose->ikparam when bPose->iksolver=1 */
typedef struct bItasc {
  int iksolver;
  float precision;
  short numiter;
  short numstep;
  float minstep;
  float maxstep;
  short solver;
  short flag;
  float feedback;
  float maxvel;
  float dampmax;
  float dampeps;
} bItasc;
 
/* bItasc->flag */
typedef enum eItasc_Flags {
  ITASC_AUTO_STEP = (1 << 0),
  ITASC_INITIAL_REITERATION = (1 << 1),
  ITASC_REITERATION = (1 << 2),
  ITASC_SIMULATION = (1 << 3),
  ITASC_TRANSLATE_ROOT_BONES = (1 << 4),
} eItasc_Flags;
 
/* bItasc->solver */
typedef enum eItasc_Solver {
  ITASC_SOLVER_SDLS = 0, /* selective damped least square, suitable for CopyPose constraint */
  ITASC_SOLVER_DLS = 1,  /* damped least square with numerical filtering of damping */
} eItasc_Solver;
 
/* ************************************************ */
/* Action */
 
/* Groups -------------------------------------- */

typedef struct bActionGroup {
  struct bActionGroup *next, *prev;

  ListBase channels;

  int fcurve_range_start;
  int fcurve_range_length;

  struct ActionChannelbag *channelbag;

  int flag;
  int customCol;
  char name[64];

  ThemeWireColor cs;
 
#ifdef __cplusplus
  blender::animrig::ChannelGroup &wrap();
  const blender::animrig::ChannelGroup &wrap() const;
#endif
} bActionGroup;
 
/* Action Group flags */
typedef enum eActionGroup_Flag {
  /* group is selected */
  AGRP_SELECTED = (1 << 0),
  /* group is 'active' / last selected one */
  AGRP_ACTIVE = (1 << 1),
  /* keyframes/channels belonging to it cannot be edited */
  AGRP_PROTECTED = (1 << 2),
  /* for UI (DopeSheet), sub-channels are shown */
  AGRP_EXPANDED = (1 << 3),
  /* sub-channels are not evaluated */
  AGRP_MUTED = (1 << 4),
  /* sub-channels are not visible in Graph Editor */
  AGRP_NOTVISIBLE = (1 << 5),
  /* for UI (Graph Editor), sub-channels are shown */
  AGRP_EXPANDED_G = (1 << 6),
 
  /* sub channel modifiers off */
  AGRP_MODIFIERS_OFF = (1 << 7),
 
  AGRP_TEMP = (1 << 30),
  AGRP_MOVED = (1u << 31),
} eActionGroup_Flag;
 
/* Actions -------------------------------------- */

typedef struct bAction {
#ifdef __cplusplus
  static constexpr ID_Type id_type = ID_AC;
#endif

  ID id;

  struct ActionLayer **layer_array;
  int layer_array_num;
  int layer_active_index; /* Index into layer_array, -1 means 'no active'. */

  struct ActionSlot **slot_array;
  int slot_array_num;
  int32_t last_slot_handle;
 
  /* Storage for the underlying data of strips. Each strip type has its own
   * array, and strips reference this data with an enum indicating the strip
   * type and an int containing the index in the array to use.
   *
   * NOTE: when adding new strip data arrays, also update `duplicate_slot()`. */
  struct ActionStripKeyframeData **strip_keyframe_data_array;
  int strip_keyframe_data_array_num;
 
  char _pad0[4];
 
  /* Note about legacy animation data:
   *
   * Blender 2.5 introduced a new animation system 'Animato'. This replaced the
   * IPO ('interpolation') curves with F-Curves. Both are considered 'legacy' at
   * different levels:
   *
   * - Actions with F-Curves in `curves`, as introduced in Blender 2.5, are
   *   considered 'legacy' but still functional in current Blender.
   * - Pre-2.5 data are deprecated and old files are automatically converted to
   *   the post-2.5 data model.
   */

  ListBase curves;
  ListBase groups;

  ListBase markers;

  int flag;
  int active_marker;

  int idroot;
  char _pad1[4];

  float frame_start, frame_end;
 
  PreviewImage *preview;
 
#ifdef __cplusplus
  blender::animrig::Action &wrap();
  const blender::animrig::Action &wrap() const;
#endif
} bAction;

typedef enum eAction_Flags {
  /* flags for displaying in UI */
  ACT_COLLAPSED = (1 << 0),
  ACT_SELECTED = (1 << 1),
 
  /* flags for evaluation/editing */
  ACT_MUTED = (1 << 9),
  /* ACT_PROTECTED = (1 << 10), */ /* UNUSED */
  /* ACT_DISABLED = (1 << 11), */  /* UNUSED */
  ACT_FRAME_RANGE = (1 << 12),
  ACT_CYCLIC = (1 << 13),
} eAction_Flags;
 
/* ************************************************ */
/* Action/Dope-sheet Editor */

typedef struct bDopeSheet {
  ID *source; /* XXX not used! */
  ListBase chanbase;

  struct Collection *filter_grp;
  char searchstr[64];

  int filterflag;
  int filterflag2;
  int flag;

  int renameIndex;
} bDopeSheet;

typedef enum eDopeSheet_FilterFlag {
  /* general filtering */
  ADS_FILTER_ONLYSEL = (1 << 0),
 
  /* temporary filters */
  ADS_FILTER_ONLYDRIVERS = (1 << 1),
  ADS_FILTER_ONLYNLA = (1 << 2),
  ADS_FILTER_SELEDIT = (1 << 3),
 
  /* general filtering */
  ADS_FILTER_SUMMARY = (1 << 4),

  ADS_FILTER_ONLY_SLOTS_OF_ACTIVE = (1 << 5),
 
  /* datatype-based filtering */
  ADS_FILTER_NOSHAPEKEYS = (1 << 6),
  ADS_FILTER_NOMESH = (1 << 7),
  ADS_FILTER_NOOBJ = (1 << 8),
  ADS_FILTER_NOLAT = (1 << 9),
  ADS_FILTER_NOCAM = (1 << 10),
  ADS_FILTER_NOMAT = (1 << 11),
  ADS_FILTER_NOLAM = (1 << 12),
  ADS_FILTER_NOCUR = (1 << 13),
  ADS_FILTER_NOWOR = (1 << 14),
  ADS_FILTER_NOSCE = (1 << 15),
  ADS_FILTER_NOPART = (1 << 16),
  ADS_FILTER_NOMBA = (1 << 17),
  ADS_FILTER_NOARM = (1 << 18),
  ADS_FILTER_NONTREE = (1 << 19),
  ADS_FILTER_NOTEX = (1 << 20),
  ADS_FILTER_NOSPK = (1 << 21),
  ADS_FILTER_NOLINESTYLE = (1 << 22),
  ADS_FILTER_NOMODIFIERS = (1 << 23),
  ADS_FILTER_NOGPENCIL = (1 << 24),
  /* NOTE: all new datablock filters will have to go in filterflag2 (see below) */
 
  /* NLA-specific filters */
  ADS_FILTER_NLA_NOACT = (1 << 25),
 
  /* general filtering 3 */
  ADS_FILTER_INCL_HIDDEN = (1 << 26),
  ADS_FILTER_ONLY_ERRORS = (1 << 28),
 
#if 0
  ADS_FILTER_NOOBDATA = (ADS_FILTER_NOCAM | ADS_FILTER_NOMAT | ADS_FILTER_NOLAM |
                         ADS_FILTER_NOCUR | ADS_FILTER_NOPART | ADS_FILTER_NOARM |
                         ADS_FILTER_NOSPK | ADS_FILTER_NOMODIFIERS),
#endif
} eDopeSheet_FilterFlag;
ENUM_OPERATORS(eDopeSheet_FilterFlag, ADS_FILTER_ONLY_ERRORS);
 
/* DopeSheet filter-flags - Overflow (filterflag2) */
typedef enum eDopeSheet_FilterFlag2 {
  ADS_FILTER_NOCACHEFILES = (1 << 1),
  ADS_FILTER_NOMOVIECLIPS = (1 << 2),
  ADS_FILTER_NOHAIR = (1 << 3),
  ADS_FILTER_NOPOINTCLOUD = (1 << 4),
  ADS_FILTER_NOVOLUME = (1 << 5),

  ADS_FILTER_DRIVER_FALLBACK_AS_ERROR = (1 << 6),
 
  ADS_FILTER_NOLIGHTPROBE = (1 << 7),
} eDopeSheet_FilterFlag2;
ENUM_OPERATORS(eDopeSheet_FilterFlag2, ADS_FILTER_NOLIGHTPROBE);
 
/* DopeSheet general flags */
typedef enum eDopeSheet_Flag {
  ADS_FLAG_SUMMARY_COLLAPSED = (1 << 0),
  ADS_FLAG_SHOW_DBFILTERS = (1 << 1),

  ADS_FLAG_FUZZY_NAMES = (1 << 2),
  ADS_FLAG_NO_DB_SORT = (1 << 3),
  ADS_FLAG_INVERT_FILTER = (1 << 4),
} eDopeSheet_Flag;
 
typedef struct SpaceAction_Runtime {
  char flag;
  char _pad0[7];
} SpaceAction_Runtime;
 
typedef enum SpaceActionOverlays_Flag {
  ADS_OVERLAY_SHOW_OVERLAYS = (1 << 0),
  ADS_SHOW_SCENE_STRIP_FRAME_RANGE = (1 << 1)
} SpaceActionOverlays_Flag;
 
typedef struct SpaceActionOverlays {
  int flag;
  char _pad0[4];
} SpaceActionOverlays;
 
/* Action Editor Space. This is defined here instead of in DNA_space_types.h */
typedef struct SpaceAction {
  struct SpaceLink *next, *prev;
  ListBase regionbase;
  char spacetype;
  char link_flag;
  char _pad0[6];
  /* End 'SpaceLink' header. */

  View2D v2d DNA_DEPRECATED;

  bAction *action DNA_DEPRECATED;

  bDopeSheet ads;

  float timeslide;
 
  short flag;
  /* Editing context */
  char mode;
  /* Storage for sub-space types. */
  char mode_prev;
  /* Snapping now lives on the Scene. */
  char autosnap DNA_DEPRECATED;
  char cache_display;
  char _pad1[6];
 
  SpaceActionOverlays overlays;
 
  SpaceAction_Runtime runtime;
} SpaceAction;
 
/* SpaceAction flag */
typedef enum eSAction_Flag {
  /* during transform (only set for TimeSlide) */
  SACTION_MOVING = (1 << 0),
  /* show sliders */
  SACTION_SLIDERS = (1 << 1),
  /* draw time in seconds instead of time in frames */
  SACTION_DRAWTIME = (1 << 2),
  /* don't filter action channels according to visibility */
  // SACTION_NOHIDE = (1 << 3), /* Deprecated, old animation systems. */
  /* don't kill overlapping keyframes after transform */
  SACTION_NOTRANSKEYCULL = (1 << 4),
  /* don't include keyframes that are out of view */
  // SACTION_HORIZOPTIMISEON = (1 << 5), /* Deprecated, old irrelevant trick. */
  /* show pose-markers (local to action) in Action Editor mode. */
  SACTION_POSEMARKERS_SHOW = (1 << 6),
  /* don't draw action channels using group colors (where applicable) */
  /* SACTION_NODRAWGCOLORS = (1 << 7), DEPRECATED */
  /* SACTION_NODRAWCFRANUM = (1 << 8), DEPRECATED */
  /* don't perform realtime updates */
  SACTION_NOREALTIMEUPDATES = (1 << 10),
  /* move markers as well as keyframes */
  SACTION_MARKERS_MOVE = (1 << 11),
  /* show interpolation type */
  SACTION_SHOW_INTERPOLATION = (1 << 12),
  /* show extremes */
  SACTION_SHOW_EXTREMES = (1 << 13),
  /* show markers region */
  SACTION_SHOW_MARKERS = (1 << 14),
} eSAction_Flag;

typedef enum eSAction_Runtime_Flag {
  SACTION_RUNTIME_FLAG_NEED_CHAN_SYNC = (1 << 0),
} eSAction_Runtime_Flag;

typedef enum eAnimEdit_Context {
  SACTCONT_ACTION = 0,
  SACTCONT_SHAPEKEY = 1,
  SACTCONT_GPENCIL = 2,
  SACTCONT_DOPESHEET = 3,
  SACTCONT_MASK = 4,
  SACTCONT_CACHEFILE = 5,
  SACTCONT_TIMELINE = 6,
} eAnimEdit_Context;
 
/* Old snapping enum that is only needed because of the versioning code. */
typedef enum eAnimEdit_AutoSnap {
  /* snap to 1.0 frame/second intervals */
  SACTSNAP_STEP = 1,
  /* snap to actual frames/seconds (nla-action time) */
  SACTSNAP_FRAME = 2,
  /* snap to nearest marker */
  SACTSNAP_MARKER = 3,
  /* snap to actual seconds (nla-action time) */
  SACTSNAP_SECOND = 4,
  /* snap to 1.0 second increments */
  SACTSNAP_TSTEP = 5,
} eAnimEdit_AutoSnap DNA_DEPRECATED;
 
/* SAction->cache_display */
typedef enum eTimeline_Cache_Flag {
  TIME_CACHE_DISPLAY = (1 << 0),
  TIME_CACHE_SOFTBODY = (1 << 1),
  TIME_CACHE_PARTICLES = (1 << 2),
  TIME_CACHE_CLOTH = (1 << 3),
  TIME_CACHE_SMOKE = (1 << 4),
  TIME_CACHE_DYNAMICPAINT = (1 << 5),
  TIME_CACHE_RIGIDBODY = (1 << 6),
  TIME_CACHE_SIMULATION_NODES = (1 << 7),
} eTimeline_Cache_Flag;
 
/* ************************************************ */
/* Layered Animation data-types. */

typedef struct ActionLayer {
  char name[/*MAX_NAME*/ 64];
 
  float influence; /* [0-1] */

  uint8_t layer_flags;

  int8_t layer_mix_mode;
 
  uint8_t _pad0[2];

  struct ActionStrip **strip_array; /* Array of 'strip_array_num' strips. */
  int strip_array_num;
 
  uint8_t _pad1[4];
 
#ifdef __cplusplus
  blender::animrig::Layer &wrap();
  const blender::animrig::Layer &wrap() const;
#endif
} ActionLayer;

typedef struct ActionSlot {
  char identifier[/*MAX_ID_NAME*/ 258];

  int16_t idtype;

  int32_t handle;

  int8_t slot_flags;
  uint8_t _pad1[7];

  ActionSlotRuntimeHandle *runtime;
 
#ifdef __cplusplus
  blender::animrig::Slot &wrap();
  const blender::animrig::Slot &wrap() const;
#endif
} ActionSlot;

typedef struct ActionStrip {
  int8_t strip_type;
  uint8_t _pad0[3];

  int data_index;
 
  float frame_start; 
  float frame_end;   

  float frame_offset;
 
  uint8_t _pad1[4];
 
#ifdef __cplusplus
  blender::animrig::Strip &wrap();
  const blender::animrig::Strip &wrap() const;
#endif
} ActionStrip;

typedef struct ActionStripKeyframeData {
  struct ActionChannelbag **channelbag_array;
  int channelbag_array_num;
 
  uint8_t _pad[4];
 
#ifdef __cplusplus
  blender::animrig::StripKeyframeData &wrap();
  const blender::animrig::StripKeyframeData &wrap() const;
#endif
} ActionStripKeyframeData;

typedef struct ActionChannelbag {
  int32_t slot_handle;
 
  /* Channel groups. These index into the `fcurve_array` below to specify group
   * membership of the fcurves.
   *
   * Note that although the fcurves also have pointers back to the groups they
   * belong to, those pointers are not the source of truth. The source of truth
   * for membership is the information in the channel groups here.
   *
   * Invariants:
   * 1. The groups are sorted by their `fcurve_range_start` field. In other
   *    words, they are in the same order as their starting positions in the
   *    fcurve array.
   * 2. The grouped fcurves are tightly packed, starting at the first fcurve and
   *    having no gaps of ungrouped fcurves between them. Ungrouped fcurves come
   *    at the end, after all of the grouped fcurves. */
  int group_array_num;
  struct bActionGroup **group_array;
 
  uint8_t _pad[4];
 
  int fcurve_array_num;
  struct FCurve **fcurve_array; /* Array of 'fcurve_array_num' FCurves. */
 
  /* TODO: Design & implement a way to integrate other channel types as well,
   * and still have them map to a certain slot */
#ifdef __cplusplus
  blender::animrig::Channelbag &wrap();
  const blender::animrig::Channelbag &wrap() const;
#endif
} ActionChannelbag;
 
#ifdef __cplusplus
/* Some static assertions that things that should have the same type actually do. */
static_assert(std::is_same_v<decltype(ActionSlot::handle), decltype(bAction::last_slot_handle)>);
static_assert(
    std::is_same_v<decltype(ActionSlot::handle), decltype(ActionChannelbag::slot_handle)>);
#endif