DNA_anim_types.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
 * All rights reserved.
 */
 
#pragma once
 
#include "DNA_ID.h"
#include "DNA_action_types.h"
#include "DNA_curve_types.h"
#include "DNA_listBase.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/* ************************************************ */
/* F-Curve DataTypes */
 
/* Modifiers -------------------------------------- */
 
typedef struct FModifier {
  struct FModifier *next, *prev;
 
  struct FCurve *curve;
  void *data;
 
  char name[64];
  short type;
  short flag;
  short ui_expand_flag;
 
  char _pad[6];
 
  float influence;
 
  float sfra;
  float efra;
  float blendin;
  float blendout;
} FModifier;
 
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,
  FMODIFIER_TYPE_PYTHON = 7,
  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 modifier data */
typedef struct FMod_Generator {
  /* general generator information */
  float *coefficients;
  unsigned int arraysize;
 
  int poly_order;
  int mode;
 
  int flag;
} FMod_Generator;
 
/* 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;
 
typedef struct FMod_FunctionGenerator {
  float amplitude;
  float phase_multiplier;
  float phase_offset;
  float value_offset;
 
  /* flags */
  int type;
  int flag;
} FMod_FunctionGenerator;
 
/* '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;
 
/* 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;
 
/* cycling modes */
typedef enum eFMod_Cycling_Modes {
  FCM_EXTRAPOLATE_NONE = 0,
  FCM_EXTRAPOLATE_CYCLIC,
  FCM_EXTRAPOLATE_CYCLIC_OFFSET,
  FCM_EXTRAPOLATE_MIRROR,
} eFMod_Cycling_Modes;
 
/* Python-script modifier data */
typedef struct FMod_Python {
  struct Text *script;
  IDProperty *prop;
} FMod_Python;
 
/* limits modifier data */
typedef struct FMod_Limits {
  rctf rect;
  int flag;
  char _pad[4];
} FMod_Limits;
 
/* 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;
 
/* noise modifier data */
typedef struct FMod_Noise {
  float size;
  float strength;
  float phase;
  float offset;
 
  short depth;
  short modification;
} FMod_Noise;
 
/* 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 data */
typedef struct FMod_Stepped {
  float step_size;
  float offset;
 
  float start_frame;
  float end_frame;
 
  int flag;
} FMod_Stepped;
 
/* 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 -------------------------------------- */
 
/* Driver Target (dtar)
 *
 * Defines how to access a dependency needed for a driver variable.
 */
typedef struct DriverTarget {
  ID *id;
 
  char *rna_path;
 
  char pchan_name[64];
  short transChan;
 
  char rotation_mode;
  char _pad[7];
 
  short flag;
  int idtype;
} DriverTarget;
 
typedef enum eDriverTarget_Flag {
  DTAR_FLAG_STRUCT_REF = (1 << 0),
  DTAR_FLAG_ID_OB_ONLY = (1 << 1),
 
  /* "localspace" flags */
  DTAR_FLAG_LOCALSPACE = (1 << 2),
  DTAR_FLAG_LOCAL_CONSTS = (1 << 3),
 
  DTAR_FLAG_INVALID = (1 << 4),
} 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;
 
/* --- */
 
/* maximum number of driver targets per variable */
#define MAX_DRIVER_TARGETS 8
 
typedef struct DriverVar {
  struct DriverVar *next, *prev;
 
  char name[64];
 
  DriverTarget targets[8];
 
  char num_targets;
  char type;
 
  short flag;
  float curval;
} DriverVar;
 
typedef enum eDriverVar_Types {
  DVAR_TYPE_SINGLE_PROP = 0,
  DVAR_TYPE_ROT_DIFF,
  DVAR_TYPE_LOC_DIFF,
  DVAR_TYPE_TRANSFORM_CHAN,
 
  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;
 
/* All invalid dvar name 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 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;
 
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),
  // DRIVER_FLAG_UNUSED_5 = (1 << 5),
  DRIVER_FLAG_USE_SELF = (1 << 6),
} eDriver_Flags;
 
/* F-Curves -------------------------------------- */
 
#define FCURVE_ACTIVE_KEYFRAME_NONE -1
 
typedef struct FPoint {
  float vec[2];
  int flag;
  char _pad[4];
} FPoint;
 
/* 'Function-Curve' - defines values over time for a given setting (fcu) */
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;
 
/* 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),
 
  // DEPRECATED
  FCURVE_AUTO_HANDLES = (1 << 5),
  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;
 
/* 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' Datatypes */
 
/* 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;
 /* TODO: move out? */
  ListBase fcurves;
  ListBase modifiers;
 
  char 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;
 
/* 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_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 ------------------------------------- */
 
typedef struct NlaTrack {
  struct NlaTrack *next, *prev;
 
  ListBase strips;
 
  int flag;
  int index;
 
  char name[64];
} NlaTrack;
 
/* 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_OVERRIDELIBRARY_LOCAL = 1 << 16,
} eNlaTrack_Flag;
 
/* ************************************ */
/* KeyingSet Datatypes */
 
typedef struct KS_Path {
  struct KS_Path *next, *prev;
 
  ID *id;
  char group[64];
 
  int idtype;
 
  short groupmode;
  short flag;
 
  char *rna_path;
  int array_index;
 
  short keyingflag;
  short keyingoverride;
} KS_Path;
 
/* 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;
 
/* ---------------- */
 
typedef struct KeyingSet {
  struct KeyingSet *next, *prev;
 
  ListBase paths;
 
  char idname[64];
  char name[64];
  char description[240];
  char typeinfo[64];
 
  int active_path;
 
  short flag;
 
  short keyingflag;
  short keyingoverride;
 
  char _pad[6];
} KeyingSet;
 
/* KeyingSet settings */
typedef enum eKS_Settings {
  /* KEYINGSET_BUILTIN = (1 << 0), */ /* UNUSED */
  KEYINGSET_ABSOLUTE = (1 << 1),
} eKS_Settings;
 
/* 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_XYZ2RGB = (1 << 5),
  INSERTKEY_NO_USERPREF = (1 << 6),
  INSERTKEY_OVERWRITE_FULL = (1 << 7),
  INSERTKEY_DRIVER = (1 << 8),
  INSERTKEY_CYCLE_AWARE = (1 << 9),
  INSERTKEY_AVAILABLE = (1 << 10),
} eInsertKeyFlags;
 
/* ************************************************ */
/* 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;
 
  bAction *tmpact;
 
  /* 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;
  char _pad[4];
 
  /* settings for active action evaluation (based on NLA strip settings) */
  short act_blendmode;
  short act_extendmode;
  float act_influence;
} 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),
 
  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),
} eAnimData_Flag;
 
/* Base Struct for Anim ------------------------------------- */
 
typedef struct IdAdtTemplate {
  ID id;
  AnimData *adt;
} IdAdtTemplate;
 
/* ************************************************ */
 
#ifdef __cplusplus
};
#endif