DNA_anim_types.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"
 
#include "DNA_ID.h"
#include "DNA_action_types.h"
#include "DNA_anim_enums.h"
#include "DNA_curve_types.h"
#include "DNA_listBase.h"
 
#ifdef __cplusplus
#  include "BLI_span.hh"
 
#  include <type_traits>
#endif
 
/* ************************************************ */
/* F-Curve DataTypes */
 
/* Modifiers -------------------------------------- */

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

  struct FCurve *curve;
  void *data;

  char name[/*MAX_NAME*/ 64];
  short type;
  short flag;
  short ui_expand_flag;
 
  char _pad[6];

  float influence;

  float sfra;
  float efra;
  float blendin;
  float blendout;
} FModifier;
 
/* --- */
 
/* Generator modifier data */
typedef struct FMod_Generator {
  /* general generator information */
  float *coefficients;
  unsigned int arraysize;

  int poly_order;
  int mode;

  int flag;
} FMod_Generator;

typedef struct FMod_FunctionGenerator {
  float amplitude;
  float phase_multiplier;
  float phase_offset;
  float value_offset;
 
  /* flags */
  int type;
  int flag;
} FMod_FunctionGenerator;
 
/* envelope modifier - envelope data */
typedef struct FCM_EnvelopeData {
  float min, max;
  float time;

  short f1;
  short f2;
} FCM_EnvelopeData;
 
/* envelope-like adjustment to values (for fade in/out) */
typedef struct FMod_Envelope {
  FCM_EnvelopeData *data;
  int totvert;

  float midval;
  float min, max;
} FMod_Envelope;
 
/* cycling/repetition modifier data */
/* TODO: we can only do complete cycles. */
typedef struct FMod_Cycles {
  short before_mode;
  short after_mode;
  short before_cycles;
  short after_cycles;
} FMod_Cycles;
 
/* limits modifier data */
typedef struct FMod_Limits {
  rctf rect;
  int flag;
  char _pad[4];
} FMod_Limits;
 
/* noise modifier data */
typedef struct FMod_Noise {
  float size;
  float strength;
  float phase;
  float offset;
  float roughness;
  float lacunarity;
 
  short depth;
  short modification;
  char legacy_noise;
  char _pad[3];
} FMod_Noise;
 
/* stepped modifier data */
typedef struct FMod_Stepped {
  float step_size;
  float offset;

  float start_frame;
  float end_frame;

  int flag;
} FMod_Stepped;
 
/* Drivers -------------------------------------- */

typedef struct DriverTarget {
  ID *id;

  char *rna_path;

  char pchan_name[/*MAX_NAME*/ 64];
  short transChan;

  char rotation_mode;
  char _pad[5];

  short flag;
  short options;
  int idtype;
 
  /* Context-dependent property of a "Context Property" type target.
   * The `rna_path` of this property is used as a target.
   * This is a value of enumerator #eDriverTarget_ContextProperty. */
  int context_property;
 
  /* Fall back value to use with DTAR_OPTION_USE_FALLBACK. */
  float fallback_value;
} DriverTarget;
 
/* --- */

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

  char name[/*MAX_NAME*/ 64];

  DriverTarget targets[8];

  char num_targets;
  char type;

  short flag;
  float curval;
} DriverVar;
 
/* --- */

typedef struct ChannelDriver {
  ListBase variables;
 
  /* python expression to execute (may call functions defined in an accessory file)
   * which relates the target 'variables' in some way to yield a single usable value
   */
  char expression[256];
  void *expr_comp;

  struct ExprPyLike_Parsed *expr_simple;

  float curval;
  /* XXX to be implemented... this is like the constraint influence setting. */
  float influence;
 
  /* general settings */
  int type;
  int flag;
} ChannelDriver;
 
/* F-Curves -------------------------------------- */

typedef struct FPoint {
  float vec[2];
  int flag;
  char _pad[4];
} FPoint;

typedef struct FCurve {
  struct FCurve *next, *prev;
 
  /* group */
  bActionGroup *grp;
 
  /* driver settings */
  ChannelDriver *driver;
  /* evaluation settings */
  ListBase modifiers;
 
  /* motion data */
  BezTriple *bezt;
  FPoint *fpt;
  unsigned int totvert;

  int active_keyframe_index;
 
  /* value cache + settings */
  float curval;
  short flag;
  short extend;
  char auto_smoothing;
 
  char _pad[3];
 
  /* RNA - data link */
  int array_index;
  char *rna_path;
 
  /* curve coloring (for editor) */
  int color_mode;
  float color[3];
 
  float prev_norm_factor, prev_offset;
} FCurve;
 
/* ************************************************ */
/* '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 ------------------------------------- */

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

  ListBase strips;
  bAction *act;

  int32_t action_slot_handle;
  char last_slot_identifier[/*MAX_ID_NAME*/ 258];
  char _pad0[2];
 /* TODO: move out? */
  ListBase fcurves;
  ListBase modifiers;

  char name[/*MAX_NAME*/ 64];

  float influence;
  float strip_time;

  float start, end;
  float actstart, actend;

  float repeat;
  float scale;

  float blendin, blendout;
  short blendmode;

  short extendmode;
  char _pad1[2];

  short type;

  void *speaker_handle;

  int flag;
  char _pad2[4];
 
  /* Pointer to an original NLA strip. */
  struct NlaStrip *orig_strip;
 
  void *_pad3;
} NlaStrip;
 
#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(NlaStrip::action_slot_handle)>);
#endif
 
/* NLA Tracks ------------------------------------- */

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

  ListBase strips;

  int flag;
  int index;

  char name[/*MAX_NAME*/ 64];
} NlaTrack;
 
/* ************************************ */
/* KeyingSet Data-types */

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

  ID *id;
  char group[/*MAX_NAME*/ 64];

  int idtype;

  short groupmode;
  short flag;

  char *rna_path;
  int array_index;

  short keyingflag;
  short keyingoverride;
} KS_Path;
 
/* ---------------- */

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

  ListBase paths;

  char idname[/*MAX_NAME*/ 64];
  char name[/*MAX_NAME*/ 64];
  char description[1024];
  char typeinfo[/*MAX_NAME*/ 64];

  int active_path;

  short flag;

  short keyingflag;
  short keyingoverride;
 
  char _pad[6];
} KeyingSet;
 
/* ************************************************ */
/* Animation Data */
 
/* AnimOverride ------------------------------------- */

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

  char *rna_path;
  int array_index;

  float value;
} AnimOverride;
 
/* AnimData ------------------------------------- */

typedef struct AnimData {
  bAction *action;

  int32_t slot_handle;
  char last_slot_identifier[/*MAX_ID_NAME*/ 258];
  uint8_t _pad0[2];

  bAction *tmpact;
  int32_t tmp_slot_handle;
  char tmp_last_slot_identifier[/*MAX_ID_NAME*/ 258];
  uint8_t _pad1[2];
 
  /* nla-tracks */
  ListBase nla_tracks;
  NlaTrack *act_track;
  NlaStrip *actstrip;
 
  /* 'drivers' for this ID-block's settings - FCurves, but are completely
   * separate from those for animation data
   */
  ListBase drivers;
  ListBase overrides;

  FCurve **driver_array;
 
  /* settings for animation evaluation */
  int flag;
 
  /* settings for active action evaluation (based on NLA strip settings) */
  short act_blendmode;
  short act_extendmode;
  float act_influence;
 
  uint8_t _pad2[4];
} AnimData;
 
#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(AnimData::slot_handle)>);
static_assert(
    std::is_same_v<decltype(ActionSlot::identifier), decltype(AnimData::last_slot_identifier)>);
#endif
 
/* Base Struct for Anim ------------------------------------- */

typedef struct IdAdtTemplate {
  ID id;
  AnimData *adt;
} IdAdtTemplate;