Animation Editors: 'Only Selected' filtering option now works on Pose Channels too
[blender-staging.git] / source / blender / editors / animation / anim_ipo_utils.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  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
21  * All rights reserved.
22  *
23  * Contributor(s): Blender Foundation, 2005. Full recode
24  *                                 Joshua Leung
25  *
26  * ***** END GPL LICENSE BLOCK *****
27  */
28
29 /* This file contains code for presenting F-Curves and other animation data
30  * in the UI (especially for use in the Animation Editors).
31  *
32  * -- Joshua Leung, Dec 2008
33  */
34
35
36 #include <math.h>
37 #include <stdio.h>
38 #include <string.h>
39
40 #include "MEM_guardedalloc.h"
41
42 #include "BLI_blenlib.h"
43 #include "BLI_arithb.h"
44
45 #include "DNA_anim_types.h"
46 #include "DNA_key_types.h"
47 #include "DNA_object_types.h"
48 #include "DNA_space_types.h"
49 #include "DNA_scene_types.h"
50 #include "DNA_view3d_types.h"
51
52 #include "BKE_animsys.h"
53 #include "BKE_key.h"
54 #include "BKE_utildefines.h"
55
56 #include "UI_resources.h"
57 #include "ED_anim_api.h"
58
59 #include "RNA_access.h"
60 #include "RNA_types.h"
61
62 /* ----------------------- Getter functions ----------------------- */
63
64 /* gets the appropriate icon for the given blocktype */
65 // XXX some of these will be depreceated?
66 int geticon_anim_blocktype(short blocktype)
67 {
68         switch (blocktype) {
69                 case ID_OB:
70                         return ICON_OBJECT_DATA;
71                 case ID_PO:
72                         return ICON_POSE_HLT;
73                 case ID_KE:
74                         return ICON_SHAPEKEY_DATA;
75                 case ID_MA:
76                         return ICON_MATERIAL;
77                 case ID_WO:
78                         return ICON_WORLD;
79                 case ID_CU:
80                         return ICON_CURVE_DATA;
81                 case ID_CA:
82                         return ICON_CAMERA;
83                 case ID_LA:
84                         return ICON_LAMP;
85                 case ID_TE:
86                         return ICON_TEXTURE;
87                 case ID_CO:
88                         return ICON_CONSTRAINT;
89                 case ID_FLUIDSIM:
90                         return ICON_WORLD; // uggh
91                 default:
92                         return 0; // what about blank icon?
93         }
94 }
95
96 /* Write into "name" buffer, the name of the property (retrieved using RNA from the curve's settings) 
97  * WARNING: name buffer we're writing to cannot exceed 256 chars (check anim_channels_defines.c for details)
98  */
99 void getname_anim_fcurve(char *name, ID *id, FCurve *fcu)
100 {
101         /* sanity checks */
102         if (name == NULL)
103                 return;
104         else if ELEM3(NULL, id, fcu, fcu->rna_path) {
105                 if (fcu == NULL)
106                         sprintf(name, "<invalid>");
107                 else if (fcu->rna_path == NULL)
108                         sprintf(name, "<no path>");
109                 else /* id == NULL */
110                         BLI_snprintf(name, 128, "%s[%d]", fcu->rna_path, fcu->array_index);
111         }
112         else {
113                 PointerRNA id_ptr, ptr;
114                 PropertyRNA *prop;
115                 
116                 /* get RNA pointer, and resolve the path */
117                 RNA_id_pointer_create(id, &id_ptr);
118                 
119                 /* try to resolve the path */
120                 if (RNA_path_resolve(&id_ptr, fcu->rna_path, &ptr, &prop)) {
121                         char *structname=NULL, *propname=NULL, *arrayname=NULL, arrayindbuf[16];
122                         short free_structname = 0;
123                         
124                         /* For now, name will consist of 3 parts: struct-name, property name, array index
125                          * There are several options possible:
126                          *      1) <struct-name>.<property-name>.<array-index>
127                          *              i.e. Bone1.Location.X, or Object.Location.X
128                          *      2) <array-index> <property-name> (<struct name>)
129                          *              i.e. X Location (Bone1), or X Location (Object)
130                          *      
131                          * Currently, option 2 is in use, to try and make it easier to quickly identify F-Curves (it does have
132                          * problems with looking rather odd though). Option 1 is better in terms of revealing a consistent sense of 
133                          * hierarchy though, which isn't so clear with option 2.
134                          */
135                         
136                         /* for structname
137                          *      - as base, we use a custom name from the structs if one is available 
138                          *      - however, if we're showing subdata of bones (probably there will be other exceptions later)
139                          *        need to include that info too since it gets confusing otherwise
140                          */
141                         if (strstr(fcu->rna_path, "pose_channels") && strstr(fcu->rna_path, "constraints")) {
142                                 /* perform string 'chopping' to get "Bone Name : Constraint Name" */
143                                 char *pchanName= BLI_getQuotedStr(fcu->rna_path, "pose_channels[");
144                                 char *constName= BLI_getQuotedStr(fcu->rna_path, "constraints[");
145                                 
146                                 /* assemble the string to display in the UI... */
147                                 structname= BLI_sprintfN("%s : %s", pchanName, constName);
148                                 free_structname= 1;
149                                 
150                                 /* free the temp names */
151                                 if (pchanName) MEM_freeN(pchanName);
152                                 if (constName) MEM_freeN(constName);
153                         }
154                         else {
155                                 PropertyRNA *nameprop= RNA_struct_name_property(ptr.type);
156                                 if (nameprop) {
157                                         /* this gets a string which will need to be freed */
158                                         structname= RNA_property_string_get_alloc(&ptr, nameprop, NULL, 0);
159                                         free_structname= 1;
160                                 }
161                                 else
162                                         structname= (char *)RNA_struct_ui_name(ptr.type);
163                         }
164                         
165                         /* Property Name is straightforward */
166                         propname= (char *)RNA_property_ui_name(prop);
167                         
168                         /* Array Index - only if applicable */
169                         if (RNA_property_array_length(&ptr, prop)) {
170                                 char c= RNA_property_array_item_char(prop, fcu->array_index);
171                                 
172                                 /* we need to write the index to a temp buffer (in py syntax) */
173                                 if (c) sprintf(arrayindbuf, "%c ", c);
174                                 else sprintf(arrayindbuf, "[%d]", fcu->array_index);
175                                 
176                                 arrayname= &arrayindbuf[0];
177                         }
178                         else {
179                                 /* no array index */
180                                 arrayname= "";
181                         }
182                         
183                         /* putting this all together into the buffer */
184                         // XXX we need to check for invalid names...
185                         BLI_snprintf(name, 128, "%s%s (%s)", arrayname, propname, structname); 
186                         
187                         /* free temp name if nameprop is set */
188                         if (free_structname)
189                                 MEM_freeN(structname);
190                 }
191                 else {
192                         /* invalid path */
193                         BLI_snprintf(name, 128, "\"%s[%d]\"", fcu->rna_path, fcu->array_index);
194                 }
195         }
196 }
197
198 /* ------------------------------- Color Codes for F-Curve Channels ---------------------------- */
199
200 #if 0
201 /* used for FCURVE_COLOR_AUTO_RAINBOW */
202 // XXX this still doesn't work too great when there are more than 32 curves (which happens most of the time)
203 void ipo_rainbow (int cur, int tot, float *out)
204 {
205         float dfac, fac, sat;
206         
207         dfac= (float)(1.0/( (float)tot+1.0));
208         
209         /* this calculation makes 2 or 4 different cycles of rainbow colors */
210                 // 2 different cycles - for hue
211         if(cur< tot/2) fac= (float)(cur*2.0f*dfac);
212         else fac= (float)((cur-tot/2)*2.0f*dfac +dfac);
213         
214                 // third cycle with altered hue
215         if(tot > 32) fac= fac*1.95f;
216                 // clamping for excessive ranges
217         if(fac>1.0f) fac-= 1.0f;
218         
219                 // saturation adjustments for more visible range
220         if(fac>0.5f && fac<0.8f) sat= 0.5f;
221         else sat= 0.6f;
222         
223         hsv_to_rgb(fac, sat, 1.0f, out, out+1, out+2);
224 }
225 #endif
226
227 /* step between the major distinguishable color bands of the primary colors */
228 #define HSV_BANDWIDTH   0.3f
229
230 /* testbed for FCURVE_COLOR_AUTO_RAINBOW determination methods */
231 //void fcurve_rainbow (unsigned int cur, unsigned int tot, float *out)
232 void ipo_rainbow (int cur, int tot, float *out)
233 {
234         float hue, val, sat, fac;
235         int grouping;
236         
237         /* we try to divide the colours into groupings of n colors,
238          * where n is:
239          *      3 - for 'odd' numbers of curves - there should be a majority of triplets of curves
240          *      4 - for 'even' numbers of curves - there should be a majority of quartets of curves
241          * so the base color is simply one of the three primary colors
242          */
243         grouping= (4 - (tot % 2));
244         hue= HSV_BANDWIDTH * (float)(cur % grouping);
245         
246         /* 'Value' (i.e. darkness) needs to vary so that larger sets of three will be 
247          * 'darker' (i.e. smaller value), so that they don't look that similar to previous ones.
248          * However, only a range of 0.3 to 1.0 is really usable to avoid clashing
249          * with some other stuff 
250          */
251         fac = ((float)cur / (float)tot) * 0.7f;
252         
253         /* the base color can get offset a bit so that the colors aren't so identical */
254         hue += fac * HSV_BANDWIDTH; 
255         if (hue > 1.0f) hue= fmod(hue, 1.0f);
256         
257         /* saturation adjustments for more visible range */
258         if ((hue > 0.5f) && (hue < 0.8f)) sat= 0.5f;
259         else sat= 0.6f;
260         
261         /* value is fixed at 1.0f, otherwise we cannot clearly see the curves... */
262         val= 1.0f;
263         
264         /* finally, conver this to RGB colors */
265         hsv_to_rgb(hue, sat, val, out, out+1, out+2); 
266 }