Warning fixes, one actual bug found in sequencer sound wave drawing. Also
[blender-staging.git] / source / blender / blenkernel / BKE_fcurve.h
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2009 Blender Foundation, Joshua Leung
21  * All rights reserved.
22  *
23  * Contributor(s): Joshua Leung (full recode)
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 #ifndef BKE_FCURVE_H
29 #define BKE_FCURVE_H
30
31 struct FCurve;
32 struct FModifier;
33 struct ChannelDriver;
34 struct DriverVar;
35 struct DriverTarget;
36
37 struct bAction;
38 struct BezTriple;
39 struct StructRNA;
40 struct PointerRNA;
41 struct PropertyRNA;
42
43 #include "DNA_curve_types.h"
44
45 /* ************** Keyframe Tools ***************** */
46
47 typedef struct CfraElem {
48         struct CfraElem *next, *prev;
49         float cfra;
50         int sel;
51 } CfraElem;
52
53 void bezt_add_to_cfra_elem(ListBase *lb, struct BezTriple *bezt);
54
55 /* ************** F-Curve Drivers ***************** */
56
57 /* With these iterators for convenience, the variables "tarIndex" and "dtar" can be 
58  * accessed directly from the code using them, but it is not recommended that their
59  * values be changed to point at other slots...
60  */
61
62 /* convenience looper over ALL driver targets for a given variable (even the unused ones) */
63 #define DRIVER_TARGETS_LOOPER(dvar) \
64         { \
65                 DriverTarget *dtar= &dvar->targets[0]; \
66                 int tarIndex= 0; \
67                 for (; tarIndex < MAX_DRIVER_TARGETS; tarIndex++, dtar++)
68                  
69 /* convenience looper over USED driver targets only */
70 #define DRIVER_TARGETS_USED_LOOPER(dvar) \
71         { \
72                 DriverTarget *dtar= &dvar->targets[0]; \
73                 int tarIndex= 0; \
74                 for (; tarIndex < dvar->num_targets; tarIndex++, dtar++)
75                 
76 /* tidy up for driver targets loopers */
77 #define DRIVER_TARGETS_LOOPER_END \
78         }
79
80 /* ---------------------- */
81
82 void fcurve_free_driver(struct FCurve *fcu);
83 struct ChannelDriver *fcurve_copy_driver(struct ChannelDriver *driver);
84
85 void driver_free_variable(struct ChannelDriver *driver, struct DriverVar *dvar);
86 void driver_change_variable_type(struct DriverVar *dvar, int type);
87 struct DriverVar *driver_add_new_variable(struct ChannelDriver *driver);
88
89 float driver_get_variable_value (struct ChannelDriver *driver, struct DriverVar *dvar);
90
91 /* ************** F-Curve Modifiers *************** */
92
93 /* F-Curve Modifier Type-Info (fmi):
94  *  This struct provides function pointers for runtime, so that functions can be
95  *  written more generally (with fewer/no special exceptions for various modifiers).
96  *
97  *  Callers of these functions must check that they actually point to something useful,
98  *  as some constraints don't define some of these.
99  *
100  *  Warning: it is not too advisable to reorder order of members of this struct,
101  *                      as you'll have to edit quite a few ($FMODIFIER_NUM_TYPES) of these
102  *                      structs.
103  */
104 typedef struct FModifierTypeInfo {
105         /* admin/ident */
106         short type;                             /* FMODIFIER_TYPE_### */
107         short size;                             /* size in bytes of the struct */
108         short acttype;                  /* eFMI_Action_Types */
109         short requires;                 /* eFMI_Requirement_Flags */
110         char name[64];                  /* name of modifier in interface */
111         char structName[64];    /* name of struct for SDNA */
112         
113         /* data management function pointers - special handling */
114                 /* free any data that is allocated separately (optional) */
115         void (*free_data)(struct FModifier *fcm);
116                 /* copy any special data that is allocated separately (optional) */
117         void (*copy_data)(struct FModifier *fcm, struct FModifier *src);
118                 /* set settings for data that will be used for FCuModifier.data (memory already allocated using MEM_callocN) */
119         void (*new_data)(void *mdata);
120                 /* verifies that the modifier settings are valid */
121         void (*verify_data)(struct FModifier *fcm);
122         
123         /* evaluation */
124                 /* evaluate time that the modifier requires the F-Curve to be evaluated at */
125         float (*evaluate_modifier_time)(struct FCurve *fcu, struct FModifier *fcm, float cvalue, float evaltime);
126                 /* evaluate the modifier for the given time and 'accumulated' value */
127         void (*evaluate_modifier)(struct FCurve *fcu, struct FModifier *fcm, float *cvalue, float evaltime);
128 } FModifierTypeInfo;
129
130 /* Values which describe the behaviour of a FModifier Type */
131 typedef enum eFMI_Action_Types {
132                 /* modifier only modifies values outside of data range */
133         FMI_TYPE_EXTRAPOLATION = 0,
134                 /* modifier leaves data-points alone, but adjusts the interpolation between and around them */
135         FMI_TYPE_INTERPOLATION,
136                 /* modifier only modifies the values of points (but times stay the same) */
137         FMI_TYPE_REPLACE_VALUES,
138                 /* modifier generates a curve regardless of what came before */
139         FMI_TYPE_GENERATE_CURVE,
140 } eFMI_Action_Types;
141
142 /* Flags for the requirements of a FModifier Type */
143 typedef enum eFMI_Requirement_Flags {
144                 /* modifier requires original data-points (kindof beats the purpose of a modifier stack?) */
145         FMI_REQUIRES_ORIGINAL_DATA              = (1<<0),
146                 /* modifier doesn't require on any preceeding data (i.e. it will generate a curve). 
147                  * Use in conjunction with FMI_TYPE_GENRATE_CURVE 
148                  */
149         FMI_REQUIRES_NOTHING                    = (1<<1),
150                 /* refer to modifier instance */
151         FMI_REQUIRES_RUNTIME_CHECK              = (1<<2),
152 } eFMI_Requirement_Flags;
153
154 /* Function Prototypes for FModifierTypeInfo's */
155 FModifierTypeInfo *fmodifier_get_typeinfo(struct FModifier *fcm);
156 FModifierTypeInfo *get_fmodifier_typeinfo(int type);
157
158 /* ---------------------- */
159
160 struct FModifier *add_fmodifier(ListBase *modifiers, int type);
161 void copy_fmodifiers(ListBase *dst, ListBase *src);
162 int remove_fmodifier(ListBase *modifiers, struct FModifier *fcm);
163 int remove_fmodifier_index(ListBase *modifiers, int index);
164 void free_fmodifiers(ListBase *modifiers);
165
166 struct FModifier *find_active_fmodifier(ListBase *modifiers);
167 void set_active_fmodifier(ListBase *modifiers, struct FModifier *fcm);
168
169 short list_has_suitable_fmodifier(ListBase *modifiers, int mtype, short acttype);
170
171 float evaluate_time_fmodifiers(ListBase *modifiers, struct FCurve *fcu, float cvalue, float evaltime);
172 void evaluate_value_fmodifiers(ListBase *modifiers, struct FCurve *fcu, float *cvalue, float evaltime);
173
174 void fcurve_bake_modifiers(struct FCurve *fcu, int start, int end);
175
176 /* ************** F-Curves API ******************** */
177
178 /* -------- Data Managemnt  --------  */
179
180 void free_fcurve(struct FCurve *fcu);
181 struct FCurve *copy_fcurve(struct FCurve *fcu);
182
183 void free_fcurves(ListBase *list);
184 void copy_fcurves(ListBase *dst, ListBase *src);
185
186 /* find matching F-Curve in the given list of F-Curves */
187 struct FCurve *list_find_fcurve(ListBase *list, const char rna_path[], const int array_index);
188
189 /* high level function to get an fcurve from C without having the rna */
190 struct FCurve *id_data_find_fcurve(ID *id, void *data, struct StructRNA *type, char *prop_name, int index);
191
192 /* Get list of LinkData's containing pointers to the F-Curves which control the types of data indicated 
193  *      e.g.  numMatches = list_find_data_fcurves(matches, &act->curves, "pose.bones[", "MyFancyBone");
194  */
195 int list_find_data_fcurves(ListBase *dst, ListBase *src, const char *dataPrefix, const char *dataName);
196
197 /* find an f-curve based on an rna property */
198 struct FCurve *rna_get_fcurve(struct PointerRNA *ptr, struct PropertyRNA *prop, int rnaindex, struct bAction **action, int *driven);
199
200 /* Binary search algorithm for finding where to 'insert' BezTriple with given frame number.
201  * Returns the index to insert at (data already at that index will be offset if replace is 0)
202  */
203 int binarysearch_bezt_index(struct BezTriple array[], float frame, int arraylen, short *replace);
204
205 /* get the time extents for F-Curve */
206 void calc_fcurve_range(struct FCurve *fcu, float *min, float *max);
207
208 /* get the bounding-box extents for F-Curve */
209 void calc_fcurve_bounds(struct FCurve *fcu, float *xmin, float *xmax, float *ymin, float *ymax);
210
211 /* -------- Curve Sanity --------  */
212
213 void calchandles_fcurve(struct FCurve *fcu);
214 void testhandles_fcurve(struct FCurve *fcu);
215 void sort_time_fcurve(struct FCurve *fcu);
216 short test_time_fcurve(struct FCurve *fcu);
217
218 void correct_bezpart(float *v1, float *v2, float *v3, float *v4);
219
220 /* -------- Evaluation --------  */
221
222 /* evaluate fcurve */
223 float evaluate_fcurve(struct FCurve *fcu, float evaltime);
224 /* evaluate fcurve and store value */
225 void calculate_fcurve(struct FCurve *fcu, float ctime);
226
227 /* ************* F-Curve Samples API ******************** */
228
229 /* -------- Defines --------  */
230
231 /* Basic signature for F-Curve sample-creation function 
232  *      - fcu: the F-Curve being operated on
233  *      - data: pointer to some specific data that may be used by one of the callbacks
234  */
235 typedef float (*FcuSampleFunc)(struct FCurve *fcu, void *data, float evaltime);
236
237 /* ----- Sampling Callbacks ------  */
238
239 /* Basic sampling callback which acts as a wrapper for evaluate_fcurve() */
240 float fcurve_samplingcb_evalcurve(struct FCurve *fcu, void *data, float evaltime);
241
242 /* -------- Main Methods --------  */
243
244 /* Main API function for creating a set of sampled curve data, given some callback function 
245  * used to retrieve the values to store.
246  */
247 void fcurve_store_samples(struct FCurve *fcu, void *data, int start, int end, FcuSampleFunc sample_cb);
248
249 #endif /* BKE_FCURVE_H*/