8c4e0065a1922095e66d71e62cef3e42bdfb5cea
[blender.git] / source / blender / editors / animation / anim_ipo_utils.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
19  * All rights reserved.
20  *
21  * Contributor(s): Blender Foundation, 2005. Full recode
22  *                                 Joshua Leung
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/animation/anim_ipo_utils.c
28  *  \ingroup edanimation
29  */
30
31
32 /* This file contains code for presenting F-Curves and other animation data
33  * in the UI (especially for use in the Animation Editors).
34  *
35  * -- Joshua Leung, Dec 2008
36  */
37
38
39 #include "MEM_guardedalloc.h"
40
41 #include "BLI_blenlib.h"
42 #include "BLI_math.h"
43 #include "BLI_utildefines.h"
44
45 #include "DNA_anim_types.h"
46
47 #include "RNA_access.h"
48
49 #include "ED_anim_api.h"
50
51 /* ----------------------- Getter functions ----------------------- */
52
53 /* Write into "name" buffer, the name of the property (retrieved using RNA from the curve's settings),
54  * and return the icon used for the struct that this property refers to 
55  * WARNING: name buffer we're writing to cannot exceed 256 chars (check anim_channels_defines.c for details)
56  */
57 int getname_anim_fcurve(char *name, ID *id, FCurve *fcu)
58 {
59         int icon = 0;
60         
61         /* sanity checks */
62         if (name == NULL)
63                 return icon;
64         else if ELEM3(NULL, id, fcu, fcu->rna_path) {
65                 if (fcu == NULL)
66                         strcpy(name, "<invalid>");
67                 else if (fcu->rna_path == NULL)
68                         strcpy(name, "<no path>");
69                 else /* id == NULL */
70                         BLI_snprintf(name, 256, "%s[%d]", fcu->rna_path, fcu->array_index);
71         }
72         else {
73                 PointerRNA id_ptr, ptr;
74                 PropertyRNA *prop;
75                 
76                 /* get RNA pointer, and resolve the path */
77                 RNA_id_pointer_create(id, &id_ptr);
78                 
79                 /* try to resolve the path */
80                 if (RNA_path_resolve(&id_ptr, fcu->rna_path, &ptr, &prop)) {
81                         const char *structname=NULL, *propname=NULL;
82                         char arrayindbuf[16];
83                         const char *arrayname=NULL;
84                         short free_structname = 0;
85                         
86                         /* For now, name will consist of 3 parts: struct-name, property name, array index
87                          * There are several options possible:
88                          *      1) <struct-name>.<property-name>.<array-index>
89                          *              i.e. Bone1.Location.X, or Object.Location.X
90                          *      2) <array-index> <property-name> (<struct name>)
91                          *              i.e. X Location (Bone1), or X Location (Object)
92                          *      
93                          * Currently, option 2 is in use, to try and make it easier to quickly identify F-Curves (it does have
94                          * problems with looking rather odd though). Option 1 is better in terms of revealing a consistent sense of 
95                          * hierarchy though, which isn't so clear with option 2.
96                          */
97                         
98                         /* for structname
99                          *      - as base, we use a custom name from the structs if one is available 
100                          *      - however, if we're showing subdata of bones (probably there will be other exceptions later)
101                          *        need to include that info too since it gets confusing otherwise
102                          *      - if a pointer just refers to the ID-block, then don't repeat this info
103                          *        since this just introduces clutter
104                          */
105                         if (strstr(fcu->rna_path, "bones") && strstr(fcu->rna_path, "constraints")) {
106                                 /* perform string 'chopping' to get "Bone Name : Constraint Name" */
107                                 char *pchanName= BLI_getQuotedStr(fcu->rna_path, "bones[");
108                                 char *constName= BLI_getQuotedStr(fcu->rna_path, "constraints[");
109                                 
110                                 /* assemble the string to display in the UI... */
111                                 structname= BLI_sprintfN("%s : %s", pchanName, constName);
112                                 free_structname= 1;
113                                 
114                                 /* free the temp names */
115                                 if (pchanName) MEM_freeN(pchanName);
116                                 if (constName) MEM_freeN(constName);
117                         }
118                         else if (ptr.data != ptr.id.data) {
119                                 PropertyRNA *nameprop= RNA_struct_name_property(ptr.type);
120                                 if (nameprop) {
121                                         /* this gets a string which will need to be freed */
122                                         structname= RNA_property_string_get_alloc(&ptr, nameprop, NULL, 0, NULL);
123                                         free_structname= 1;
124                                 }
125                                 else
126                                         structname= RNA_struct_ui_name(ptr.type);
127                         }
128                         
129                         /* Property Name is straightforward */
130                         propname= RNA_property_ui_name(prop);
131                         
132                         /* Array Index - only if applicable */
133                         if (RNA_property_array_length(&ptr, prop)) {
134                                 char c= RNA_property_array_item_char(prop, fcu->array_index);
135                                 
136                                 /* we need to write the index to a temp buffer (in py syntax) */
137                                 if (c) sprintf(arrayindbuf, "%c ", c);
138                                 else sprintf(arrayindbuf, "[%d]", fcu->array_index);
139                                 
140                                 arrayname= &arrayindbuf[0];
141                         }
142                         else {
143                                 /* no array index */
144                                 arrayname= "";
145                         }
146                         
147                         /* putting this all together into the buffer */
148                         // XXX we need to check for invalid names...
149                         // XXX the name length limit needs to be passed in or as some define
150                         if (structname)
151                                 BLI_snprintf(name, 256, "%s%s (%s)", arrayname, propname, structname); 
152                         else
153                                 BLI_snprintf(name, 256, "%s%s", arrayname, propname); 
154                         
155                         /* free temp name if nameprop is set */
156                         if (free_structname)
157                                 MEM_freeN((void *)structname);
158                         
159                         
160                         /* Icon for this property's owner:
161                          *      use the struct's icon if it is set
162                          */
163                         icon= RNA_struct_ui_icon(ptr.type);
164                         
165                         /* valid path - remove the invalid tag since we now know how to use it saving
166                          * users manual effort to reenable using "Revive Disabled FCurves" [#29629]
167                          */
168                         fcu->flag &= ~FCURVE_DISABLED;
169                 }
170                 else {
171                         /* invalid path */
172                         BLI_snprintf(name, 256, "\"%s[%d]\"", fcu->rna_path, fcu->array_index);
173                         
174                         /* icon for this should be the icon for the base ID */
175                         // TODO: or should we just use the error icon?
176                         icon= RNA_struct_ui_icon(id_ptr.type);
177                         
178                         /* tag F-Curve as disabled - as not usable path */
179                         fcu->flag |= FCURVE_DISABLED;
180                 }
181         }
182         
183         /* return the icon that the active data had */
184         return icon;
185 }
186
187 /* ------------------------------- Color Codes for F-Curve Channels ---------------------------- */
188
189 /* step between the major distinguishable color bands of the primary colors */
190 #define HSV_BANDWIDTH   0.3f
191
192 /* used to determine the color of F-Curves with FCURVE_COLOR_AUTO_RAINBOW set */
193 //void fcurve_rainbow (unsigned int cur, unsigned int tot, float *out)
194 void getcolor_fcurve_rainbow (int cur, int tot, float *out)
195 {
196         float hue, val, sat, fac;
197         int grouping;
198         
199         /* we try to divide the color into groupings of n colors,
200          * where n is:
201          *      3 - for 'odd' numbers of curves - there should be a majority of triplets of curves
202          *      4 - for 'even' numbers of curves - there should be a majority of quartets of curves
203          * so the base color is simply one of the three primary colors
204          */
205         grouping= (4 - (tot % 2));
206         hue= HSV_BANDWIDTH * (float)(cur % grouping);
207         
208         /* 'Value' (i.e. darkness) needs to vary so that larger sets of three will be 
209          * 'darker' (i.e. smaller value), so that they don't look that similar to previous ones.
210          * However, only a range of 0.3 to 1.0 is really usable to avoid clashing
211          * with some other stuff 
212          */
213         fac = ((float)cur / (float)tot) * 0.7f;
214         
215         /* the base color can get offset a bit so that the colors aren't so identical */
216         hue += fac * HSV_BANDWIDTH; 
217         if (hue > 1.0f) hue= fmod(hue, 1.0f);
218         
219         /* saturation adjustments for more visible range */
220         if ((hue > 0.5f) && (hue < 0.8f)) sat= 0.5f;
221         else sat= 0.6f;
222         
223         /* value is fixed at 1.0f, otherwise we cannot clearly see the curves... */
224         val= 1.0f;
225         
226         /* finally, conver this to RGB colors */
227         hsv_to_rgb(hue, sat, val, out, out+1, out+2); 
228 }