NLA SoC: Current Frame can now be negative
[blender.git] / source / blender / makesrna / intern / rna_nla.c
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  * Contributor(s): Blender Foundation (2009), Joshua Leung
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 #include <stdlib.h>
26
27 #include "RNA_define.h"
28 #include "RNA_types.h"
29
30 #include "rna_internal.h"
31
32 #include "DNA_anim_types.h"
33 #include "DNA_action_types.h"
34 #include "DNA_scene_types.h"
35
36 #include "MEM_guardedalloc.h"
37
38 #ifdef RNA_RUNTIME
39
40 #include <stdio.h>
41 #include <math.h>
42
43 /* temp constant defined for these funcs only... */
44 #define NLASTRIP_MIN_LEN_THRESH         0.1f
45
46 static void rna_NlaStrip_start_frame_set(PointerRNA *ptr, float value)
47 {
48         NlaStrip *data= (NlaStrip*)ptr->data;
49         
50         /* clamp value to lie within valid limits 
51          *      - cannot start past the end of the strip + some flexibility threshold
52          *      - cannot start before the previous strip (if present) ends
53          *              -> but if it was a transition, we could go up to the start of the strip + some flexibility threshold
54          *              as long as we re-adjust the transition afterwards
55          *      - minimum frame is -MAXFRAME so that we don't get clipping on frame 0
56          */
57         if (data->prev) {
58                 if (data->prev->type == NLASTRIP_TYPE_TRANSITION) {
59                         CLAMP(value, data->prev->start+NLASTRIP_MIN_LEN_THRESH, data->end-NLASTRIP_MIN_LEN_THRESH);
60                         
61                         /* readjust the transition to stick to the endpoints of the action-clips */
62                         data->prev->end= value;
63                 }
64                 else {
65                         CLAMP(value, data->prev->end, data->end-NLASTRIP_MIN_LEN_THRESH);
66                 }
67         }
68         else {
69                 CLAMP(value, MINAFRAME, data->end);
70         }
71         data->start= value;
72 }
73
74 static void rna_NlaStrip_end_frame_set(PointerRNA *ptr, float value)
75 {
76         NlaStrip *data= (NlaStrip*)ptr->data;
77         
78         /* clamp value to lie within valid limits
79          *      - must not have zero or negative length strip, so cannot start before the first frame 
80          *        + some minimum-strip-length threshold
81          *      - cannot end later than the start of the next strip (if present)
82          *              -> but if it was a transition, we could go up to the start of the end - some flexibility threshold
83          *              as long as we re-adjust the transition afterwards
84          */
85         if (data->next) {
86                 if (data->next->type == NLASTRIP_TYPE_TRANSITION) {
87                         CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, data->next->end-NLASTRIP_MIN_LEN_THRESH);
88                         
89                         /* readjust the transition to stick to the endpoints of the action-clips */
90                         data->next->start= value;
91                 }
92                 else {
93                         CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, data->next->start);
94                 }
95         }
96         else {
97                 CLAMP(value, data->start+NLASTRIP_MIN_LEN_THRESH, MAXFRAME);
98         }
99         data->end= value;
100         
101         
102         /* calculate the lengths the strip and its action (if applicable) */
103         if (data->type == NLASTRIP_TYPE_CLIP) {
104                 float len, actlen;
105                 
106                 len= data->end - data->start;
107                 actlen= data->actend - data->actstart;
108                 if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
109                 
110                 /* now, adjust the 'scale' setting to reflect this (so that this change can be valid) */
111                 data->scale= len / ((actlen) * data->repeat);
112         }
113 }
114
115 static void rna_NlaStrip_scale_set(PointerRNA *ptr, float value)
116 {
117         NlaStrip *data= (NlaStrip*)ptr->data;
118         float actlen, mapping;
119         
120         /* set scale value */
121         CLAMP(value, 0.0001f, 1000.0f); /* NOTE: these need to be synced with the values in the property definition in rna_def_nlastrip() */
122         data->scale= value;
123         
124         /* calculate existing factors */
125         actlen= data->actend - data->actstart;
126         if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
127         mapping= data->scale * data->repeat;
128         
129         /* adjust endpoint of strip in response to this */
130         if (IS_EQ(mapping, 0.0f) == 0)
131                 data->end = (actlen * mapping) + data->start; 
132         else
133                 printf("NlaStrip Set Scale Error (in RNA): Scale = %0.4f, Repeat = %0.4f \n", data->scale, data->repeat);
134 }
135
136 static void rna_NlaStrip_repeat_set(PointerRNA *ptr, float value)
137 {
138         NlaStrip *data= (NlaStrip*)ptr->data;
139         float actlen, mapping;
140         
141         /* set scale value */
142         CLAMP(value, 0.01f, 1000.0f); /* NOTE: these need to be synced with the values in the property definition in rna_def_nlastrip() */
143         data->repeat= value;
144         
145         /* calculate existing factors */
146         actlen= data->actend - data->actstart;
147         if (IS_EQ(actlen, 0.0f)) actlen= 1.0f;
148         mapping= data->scale * data->repeat;
149         
150         /* adjust endpoint of strip in response to this */
151         if (IS_EQ(mapping, 0.0f) == 0)
152                 data->end = (actlen * mapping) + data->start; 
153         else
154                 printf("NlaStrip Set Repeat Error (in RNA): Scale = %0.4f, Repeat = %0.4f \n", data->scale, data->repeat);
155 }
156
157 static void rna_NlaStrip_blend_in_set(PointerRNA *ptr, float value)
158 {
159         NlaStrip *data= (NlaStrip*)ptr->data;
160         float len;
161         
162         /* blend-in is limited to the length of the strip, and also cannot overlap with blendout */
163         len= (data->end - data->start) - data->blendout;
164         CLAMP(value, 0, len);
165         
166         data->blendin= value;
167 }
168
169 static void rna_NlaStrip_blend_out_set(PointerRNA *ptr, float value)
170 {
171         NlaStrip *data= (NlaStrip*)ptr->data;
172         float len;
173         
174         /* blend-out is limited to the length of the strip */
175         len= (data->end - data->start);
176         CLAMP(value, 0, len);
177         
178         /* it also cannot overlap with blendin */
179         if ((len - value) < data->blendin)
180                 value= len - data->blendin;
181         
182         data->blendout= value;
183 }
184
185 static void rna_NlaStrip_action_start_frame_set(PointerRNA *ptr, float value)
186 {
187         NlaStrip *data= (NlaStrip*)ptr->data;
188         CLAMP(value, MINAFRAME, data->actend);
189         data->actstart= value;
190 }
191
192 static void rna_NlaStrip_action_end_frame_set(PointerRNA *ptr, float value)
193 {
194         NlaStrip *data= (NlaStrip*)ptr->data;
195         CLAMP(value, data->actstart, MAXFRAME);
196         data->actend= value;
197 }
198
199 #else
200
201 void rna_def_nlastrip(BlenderRNA *brna)
202 {
203         StructRNA *srna;
204         PropertyRNA *prop;
205         
206                 /* enum defs */
207         static EnumPropertyItem prop_type_items[] = {
208                 {NLASTRIP_TYPE_CLIP, "CLIP", 0, "Action Clip", "NLA Strip references some Action."},
209                 {NLASTRIP_TYPE_TRANSITION, "TRANSITION", 0, "Transition", "NLA Strip 'transitions' between adjacent strips."},
210                 {NLASTRIP_TYPE_META, "META", 0, "Meta", "NLA Strip acts as a container for adjacent strips."},
211                 {0, NULL, 0, NULL, NULL}};
212         static EnumPropertyItem prop_mode_blend_items[] = {
213                 {NLASTRIP_MODE_BLEND, "BLEND", 0, "Blend", "Results of strip and accumulated results are combined in ratio governed by influence."},
214                 {NLASTRIP_MODE_ADD, "ADD", 0, "Add", "Weighted result of strip is added to the accumlated results."},
215                 {NLASTRIP_MODE_SUBTRACT, "SUBTRACT", 0, "Subtract", "Weighted result of strip is removed from the accumlated results."},
216                 {NLASTRIP_MODE_MULTIPLY, "MULITPLY", 0, "Multiply", "Weighted result of strip is multiplied with the accumlated results."},
217                 {0, NULL, 0, NULL, NULL}};
218         static EnumPropertyItem prop_mode_extend_items[] = {
219                 {NLASTRIP_EXTEND_NOTHING, "NOTHING", 0, "Nothing", "Strip has no influence past its extents."},
220                 {NLASTRIP_EXTEND_HOLD, "HOLD", 0, "Hold", "Hold the first frame if no previous strips in track, and always hold last frame."},
221                 {NLASTRIP_EXTEND_HOLD_FORWARD, "HOLD_FORWARD", 0, "Hold Forward", "Only hold last frame."},
222                 {0, NULL, 0, NULL, NULL}};
223         
224         /* struct definition */
225         srna= RNA_def_struct(brna, "NlaStrip", NULL);
226         RNA_def_struct_ui_text(srna, "NLA Strip", "A container referencing an existing Action.");
227         RNA_def_struct_ui_icon(srna, ICON_NLA); // XXX
228         
229         /* Enums */
230         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
231         RNA_def_property_enum_sdna(prop, NULL, "type");
232         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // XXX for now, not editable, since this is dangerous
233         RNA_def_property_enum_items(prop, prop_type_items);
234         RNA_def_property_ui_text(prop, "Type", "Type of NLA Strip.");
235         
236         prop= RNA_def_property(srna, "extrapolation", PROP_ENUM, PROP_NONE);
237         RNA_def_property_enum_sdna(prop, NULL, "extendmode");
238         RNA_def_property_enum_items(prop, prop_mode_extend_items);
239         RNA_def_property_ui_text(prop, "Extrapolation", "Action to take for gaps past the strip extents.");
240         
241         prop= RNA_def_property(srna, "blending", PROP_ENUM, PROP_NONE);
242         RNA_def_property_enum_sdna(prop, NULL, "blendmode");
243         RNA_def_property_enum_items(prop, prop_mode_blend_items);
244         RNA_def_property_ui_text(prop, "Blending", "Method used for combining strip's result with accumulated result.");
245         
246         /* Strip extents */
247         prop= RNA_def_property(srna, "start_frame", PROP_FLOAT, PROP_NONE);
248         RNA_def_property_float_sdna(prop, NULL, "start");
249         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_start_frame_set", NULL);
250         RNA_def_property_ui_text(prop, "Start Frame", "");
251         
252         prop= RNA_def_property(srna, "end_frame", PROP_FLOAT, PROP_NONE);
253         RNA_def_property_float_sdna(prop, NULL, "end");
254         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_end_frame_set", NULL);
255         RNA_def_property_ui_text(prop, "End Frame", "");
256         
257         /* Blending */
258         prop= RNA_def_property(srna, "blend_in", PROP_FLOAT, PROP_NONE);
259         RNA_def_property_float_sdna(prop, NULL, "blendin");
260         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_blend_in_set", NULL);
261         RNA_def_property_ui_text(prop, "Blend In", "Number of frames at start of strip to fade in influence.");
262         
263         prop= RNA_def_property(srna, "blend_out", PROP_FLOAT, PROP_NONE);
264         RNA_def_property_float_sdna(prop, NULL, "blendout");
265         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_blend_out_set", NULL);
266         RNA_def_property_ui_text(prop, "Blend Out", "");
267         
268         prop= RNA_def_property(srna, "auto_blending", PROP_BOOLEAN, PROP_NONE);
269         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_AUTO_BLENDS);
270         RNA_def_property_ui_text(prop, "Auto Blend In/Out", "Number of frames for Blending In/Out is automatically determined from overlapping strips.");
271         
272         /* Action */
273         prop= RNA_def_property(srna, "action", PROP_POINTER, PROP_NONE);
274         RNA_def_property_pointer_sdna(prop, NULL, "act");
275         RNA_def_property_ui_text(prop, "Action", "Action referenced by this strip.");
276         
277         /* Action extents */
278         prop= RNA_def_property(srna, "action_start_frame", PROP_FLOAT, PROP_NONE);
279         RNA_def_property_float_sdna(prop, NULL, "actstart");
280         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_action_start_frame_set", NULL);
281         RNA_def_property_ui_text(prop, "Action Start Frame", "");
282         
283         prop= RNA_def_property(srna, "action_end_frame", PROP_FLOAT, PROP_NONE);
284         RNA_def_property_float_sdna(prop, NULL, "actend");
285         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_action_end_frame_set", NULL);
286         RNA_def_property_ui_text(prop, "Action End Frame", "");
287         
288         /* Action Reuse */
289         prop= RNA_def_property(srna, "repeat", PROP_FLOAT, PROP_NONE);
290         RNA_def_property_float_sdna(prop, NULL, "repeat"); 
291         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_repeat_set", NULL);
292         RNA_def_property_range(prop, 0.1f, 1000.0f); /* these limits have currently be chosen arbitarily, but could be extended (minimum should still be > 0 though) if needed... */
293         RNA_def_property_ui_text(prop, "Repeat", "Number of times to repeat the action range.");
294         
295         prop= RNA_def_property(srna, "scale", PROP_FLOAT, PROP_NONE);
296         RNA_def_property_float_sdna(prop, NULL, "scale"); 
297         RNA_def_property_float_funcs(prop, NULL, "rna_NlaStrip_scale_set", NULL);
298         RNA_def_property_range(prop, 0.0001f, 1000.0f); /* these limits can be extended, but beyond this, we can get some crazy+annoying bugs due to numeric errors */
299         RNA_def_property_ui_text(prop, "Scale", "Scaling factor for action.");
300         
301         /* Strip's F-Curves */
302         prop= RNA_def_property(srna, "fcurves", PROP_COLLECTION, PROP_NONE);
303         RNA_def_property_struct_type(prop, "FCurve");
304         RNA_def_property_ui_text(prop, "F-Curves", "F-Curves for controlling the strip's influence and timing.");
305         
306         /* Strip's F-Modifiers */
307         prop= RNA_def_property(srna, "modifiers", PROP_COLLECTION, PROP_NONE);
308         RNA_def_property_struct_type(prop, "FModifier");
309         RNA_def_property_ui_text(prop, "Modifiers", "Modifiers affecting all the F-Curves in the referenced Action.");
310         
311         /* Strip's Sub-Strips (for Meta-Strips) */
312         prop= RNA_def_property(srna, "strips", PROP_COLLECTION, PROP_NONE);
313         RNA_def_property_struct_type(prop, "NlaStrip");
314         RNA_def_property_ui_text(prop, "NLA Strips", "NLA Strips that this strip acts as a container for (if it is of type Meta).");
315         
316         /* Settings - Values necessary for evaluation */
317         prop= RNA_def_property(srna, "influence", PROP_FLOAT, PROP_NONE);
318         RNA_def_property_range(prop, 0.0f, 1.0f);
319         RNA_def_property_ui_text(prop, "Influence", "Amount the strip contributes to the current result.");
320         
321         prop= RNA_def_property(srna, "strip_time", PROP_FLOAT, PROP_NONE);
322         RNA_def_property_ui_text(prop, "Strip Time", "Frame of referenced Action to evaluate.");
323         
324         prop= RNA_def_property(srna, "animated_influence", PROP_BOOLEAN, PROP_NONE);
325         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // XXX for now, not editable
326         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_USR_INFLUENCE);
327         RNA_def_property_ui_text(prop, "Animated Influence", "Influence setting is controlled by an F-Curve rather than automatically determined.");
328         
329         prop= RNA_def_property(srna, "animated_time", PROP_BOOLEAN, PROP_NONE);
330         RNA_def_property_clear_flag(prop, PROP_EDITABLE); // XXX for now, not editable
331         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_USR_INFLUENCE);
332         RNA_def_property_ui_text(prop, "Animated Strip Time", "Strip time is controlled by an F-Curve rather than automatically determined.");
333         
334         /* settings */
335         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
336         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
337         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_ACTIVE);
338         RNA_def_property_ui_text(prop, "Active", "NLA Strip is active.");
339         
340         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
341         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_SELECT);
342         RNA_def_property_ui_text(prop, "Selected", "NLA Strip is selected.");
343         
344         prop= RNA_def_property(srna, "muted", PROP_BOOLEAN, PROP_NONE);
345         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_MUTED);
346         RNA_def_property_ui_text(prop, "Muted", "NLA Strip is not evaluated.");
347         
348         prop= RNA_def_property(srna, "reversed", PROP_BOOLEAN, PROP_NONE);
349         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLASTRIP_FLAG_REVERSE);
350         RNA_def_property_ui_text(prop, "Reversed", "NLA Strip is played back in reverse order (only when timing is automatically determined).");
351         
352         // TODO: 
353         // - sync length
354 }
355
356 void rna_def_nlatrack(BlenderRNA *brna)
357 {
358         StructRNA *srna;
359         PropertyRNA *prop;
360         
361         srna= RNA_def_struct(brna, "NlaTrack", NULL);
362         RNA_def_struct_ui_text(srna, "NLA Track", "A animation layer containing Actions referenced as NLA strips.");
363         RNA_def_struct_ui_icon(srna, ICON_NLA);
364         
365         /* strips collection */
366         prop= RNA_def_property(srna, "strips", PROP_COLLECTION, PROP_NONE);
367         RNA_def_property_struct_type(prop, "NlaStrip");
368         RNA_def_property_ui_text(prop, "NLA Strips", "NLA Strips on this NLA-track.");
369         
370         /* name property */
371         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
372         RNA_def_property_ui_text(prop, "Name", "");
373         RNA_def_struct_name_property(srna, prop);
374         
375         /* settings */
376         prop= RNA_def_property(srna, "active", PROP_BOOLEAN, PROP_NONE);
377         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
378         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_ACTIVE);
379         RNA_def_property_ui_text(prop, "Active", "NLA Track is active.");
380         
381         prop= RNA_def_property(srna, "solo", PROP_BOOLEAN, PROP_NONE);
382         RNA_def_property_clear_flag(prop, PROP_EDITABLE); /* can be made editable by hooking it up to the necessary NLA API methods */
383         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_SOLO);
384         RNA_def_property_ui_text(prop, "Solo", "NLA Track is evaluated itself (i.e. active Action and all other NLA Tracks in the same AnimData block are disabled).");
385         
386         prop= RNA_def_property(srna, "selected", PROP_BOOLEAN, PROP_NONE);
387         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_SELECTED);
388         RNA_def_property_ui_text(prop, "Selected", "NLA Track is selected.");
389         
390         prop= RNA_def_property(srna, "muted", PROP_BOOLEAN, PROP_NONE);
391         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_MUTED);
392         RNA_def_property_ui_text(prop, "Muted", "NLA Track is not evaluated.");
393
394         prop= RNA_def_property(srna, "locked", PROP_BOOLEAN, PROP_NONE);
395         RNA_def_property_boolean_sdna(prop, NULL, "flag", NLATRACK_PROTECTED);
396         RNA_def_property_ui_text(prop, "Locked", "NLA Track is locked.");
397 }
398
399 /* --------- */
400
401 void RNA_def_nla(BlenderRNA *brna)
402 {
403         rna_def_nlatrack(brna);
404         rna_def_nlastrip(brna);
405 }
406
407
408 #endif