Cleanup: misc spelling fixes
[blender.git] / source / blender / editors / include / ED_keyframes_draw.h
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * The Original Code is Copyright (C) (C) 2009 Blender Foundation, Joshua Leung
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup editors
22  */
23
24 #ifndef __ED_KEYFRAMES_DRAW_H__
25 #define __ED_KEYFRAMES_DRAW_H__
26
27 struct AnimData;
28 struct CacheFile;
29 struct DLRBT_Tree;
30 struct FCurve;
31 struct ListBase;
32 struct MaskLayer;
33 struct Object;
34 struct Palette;
35 struct Scene;
36 struct View2D;
37 struct bAction;
38 struct bActionGroup;
39 struct bAnimContext;
40 struct bDopeSheet;
41 struct bGPDlayer;
42
43 /* ****************************** Base Structs ****************************** */
44
45 /* Information about the stretch of time from current to the next column */
46 typedef struct ActKeyBlockInfo {
47   /* Combination of flags from all curves. */
48   short flag;
49   /* Mask of flags that differ between curves. */
50   short conflict;
51
52   /* Selection flag. */
53   char sel;
54 } ActKeyBlockInfo;
55
56 /* Keyframe Column Struct */
57 typedef struct ActKeyColumn {
58   /* ListBase linkage */
59   struct ActKeyColumn *next, *prev;
60
61   /* sorting-tree linkage */
62   /** 'children' of this node, less than and greater than it (respectively) */
63   struct ActKeyColumn *left, *right;
64   /** parent of this node in the tree */
65   struct ActKeyColumn *parent;
66   /** DLRB_BLACK or DLRB_RED */
67   char tree_col;
68
69   /* keyframe info */
70   /** eBezTripe_KeyframeType */
71   char key_type;
72   /** eKeyframeHandleDrawOpts */
73   char handle_type;
74   /** eKeyframeExtremeDrawOpts */
75   char extreme_type;
76   short sel;
77   float cfra;
78
79   /* key-block info */
80   ActKeyBlockInfo block;
81
82   /* number of curves and keys in this column */
83   short totcurve, totkey, totblock;
84 } ActKeyColumn;
85
86 /* ActKeyBlockInfo - Flag */
87 typedef enum eActKeyBlock_Hold {
88   /* Key block represents a moving hold */
89   ACTKEYBLOCK_FLAG_MOVING_HOLD = (1 << 0),
90   /* Key block represents a static hold */
91   ACTKEYBLOCK_FLAG_STATIC_HOLD = (1 << 1),
92   /* Key block represents any kind of hold */
93   ACTKEYBLOCK_FLAG_ANY_HOLD = (1 << 2),
94   /* The curve segment uses non-bezier interpolation */
95   ACTKEYBLOCK_FLAG_NON_BEZIER = (1 << 3),
96 } eActKeyBlock_Flag;
97
98 /* *********************** Keyframe Drawing ****************************** */
99
100 /* options for keyframe shape drawing */
101 typedef enum eKeyframeShapeDrawOpts {
102   /* only the border */
103   KEYFRAME_SHAPE_FRAME = 0,
104   /* only the inside filling */
105   KEYFRAME_SHAPE_INSIDE,
106   /* the whole thing */
107   KEYFRAME_SHAPE_BOTH,
108 } eKeyframeShapeDrawOpts;
109
110 /* Handle type. */
111 typedef enum eKeyframeHandleDrawOpts {
112   /* Don't draw */
113   KEYFRAME_HANDLE_NONE = 0,
114   /* Various marks in order of increasing display priority. */
115   KEYFRAME_HANDLE_AUTO_CLAMP,
116   KEYFRAME_HANDLE_AUTO,
117   KEYFRAME_HANDLE_VECTOR,
118   KEYFRAME_HANDLE_ALIGNED,
119   KEYFRAME_HANDLE_FREE,
120 } eKeyframeHandleDrawOpts;
121
122 /* Extreme type. */
123 typedef enum eKeyframeExtremeDrawOpts {
124   KEYFRAME_EXTREME_NONE = 0,
125   /* Minimum/maximum present. */
126   KEYFRAME_EXTREME_MIN = (1 << 0),
127   KEYFRAME_EXTREME_MAX = (1 << 1),
128   /* Grouped keys have different states. */
129   KEYFRAME_EXTREME_MIXED = (1 << 2),
130   /* Both neighbors are equal to this key. */
131   KEYFRAME_EXTREME_FLAT = (1 << 3),
132 } eKeyframeExtremeDrawOpts;
133
134 /* draw simple diamond-shape keyframe */
135 /* caller should set up vertex format, bind GPU_SHADER_KEYFRAME_DIAMOND,
136  * immBegin(GPU_PRIM_POINTS, n), then call this n times */
137 void draw_keyframe_shape(float x,
138                          float y,
139                          float size,
140                          bool sel,
141                          short key_type,
142                          short mode,
143                          float alpha,
144                          unsigned int pos_id,
145                          unsigned int size_id,
146                          unsigned int color_id,
147                          unsigned int outline_color_id,
148                          unsigned int linemask_id,
149                          short ipo_type,
150                          short extreme_type);
151
152 /* ******************************* Methods ****************************** */
153
154 /* Channel Drawing ------------------ */
155 /* F-Curve */
156 void draw_fcurve_channel(struct View2D *v2d,
157                          struct AnimData *adt,
158                          struct FCurve *fcu,
159                          float ypos,
160                          float yscale_fac,
161                          int saction_flag);
162 /* Action Group Summary */
163 void draw_agroup_channel(struct View2D *v2d,
164                          struct AnimData *adt,
165                          struct bActionGroup *agrp,
166                          float ypos,
167                          float yscale_fac,
168                          int saction_flag);
169 /* Action Summary */
170 void draw_action_channel(struct View2D *v2d,
171                          struct AnimData *adt,
172                          struct bAction *act,
173                          float ypos,
174                          float yscale_fac,
175                          int saction_flag);
176 /* Object Summary */
177 void draw_object_channel(struct View2D *v2d,
178                          struct bDopeSheet *ads,
179                          struct Object *ob,
180                          float ypos,
181                          float yscale_fac,
182                          int saction_flag);
183 /* Scene Summary */
184 void draw_scene_channel(struct View2D *v2d,
185                         struct bDopeSheet *ads,
186                         struct Scene *sce,
187                         float ypos,
188                         float yscale_fac,
189                         int saction_flag);
190 /* DopeSheet Summary */
191 void draw_summary_channel(
192     struct View2D *v2d, struct bAnimContext *ac, float ypos, float yscale_fac, int saction_flag);
193 /* Grease Pencil datablock summary */
194 void draw_gpencil_channel(struct View2D *v2d,
195                           struct bDopeSheet *ads,
196                           struct bGPdata *gpd,
197                           float ypos,
198                           float yscale_fac,
199                           int saction_flag);
200 /* Grease Pencil Layer */
201 void draw_gpl_channel(struct View2D *v2d,
202                       struct bDopeSheet *ads,
203                       struct bGPDlayer *gpl,
204                       float ypos,
205                       float yscale_fac,
206                       int saction_flag);
207 /* Mask Layer */
208 void draw_masklay_channel(struct View2D *v2d,
209                           struct bDopeSheet *ads,
210                           struct MaskLayer *masklay,
211                           float ypos,
212                           float yscale_fac,
213                           int saction_flag);
214
215 /* Keydata Generation --------------- */
216 /* F-Curve */
217 void fcurve_to_keylist(struct AnimData *adt,
218                        struct FCurve *fcu,
219                        struct DLRBT_Tree *keys,
220                        int saction_flag);
221 /* Action Group */
222 void agroup_to_keylist(struct AnimData *adt,
223                        struct bActionGroup *agrp,
224                        struct DLRBT_Tree *keys,
225                        int saction_flag);
226 /* Action */
227 void action_to_keylist(struct AnimData *adt,
228                        struct bAction *act,
229                        struct DLRBT_Tree *keys,
230                        int saction_flag);
231 /* Object */
232 void ob_to_keylist(struct bDopeSheet *ads,
233                    struct Object *ob,
234                    struct DLRBT_Tree *keys,
235                    int saction_flag);
236 /* Cache File */
237 void cachefile_to_keylist(struct bDopeSheet *ads,
238                           struct CacheFile *cache_file,
239                           struct DLRBT_Tree *keys,
240                           int saction_flag);
241 /* Scene */
242 void scene_to_keylist(struct bDopeSheet *ads,
243                       struct Scene *sce,
244                       struct DLRBT_Tree *keys,
245                       int saction_flag);
246 /* DopeSheet Summary */
247 void summary_to_keylist(struct bAnimContext *ac, struct DLRBT_Tree *keys, int saction_flag);
248 /* Grease Pencil datablock summary */
249 void gpencil_to_keylist(struct bDopeSheet *ads,
250                         struct bGPdata *gpd,
251                         struct DLRBT_Tree *keys,
252                         const bool active);
253 /* Grease Pencil Layer */
254 void gpl_to_keylist(struct bDopeSheet *ads, struct bGPDlayer *gpl, struct DLRBT_Tree *keys);
255 /* Mask */
256 void mask_to_keylist(struct bDopeSheet *UNUSED(ads),
257                      struct MaskLayer *masklay,
258                      struct DLRBT_Tree *keys);
259
260 /* ActKeyColumn API ---------------- */
261 /* Comparator callback used for ActKeyColumns and cframe float-value pointer */
262 short compare_ak_cfraPtr(void *node, void *data);
263
264 /* Checks if ActKeyColumn has any block data */
265 bool actkeyblock_is_valid(ActKeyColumn *ab);
266
267 /* Checks if ActKeyColumn can be used as a block (i.e. drawn/used to detect "holds") */
268 int actkeyblock_get_valid_hold(ActKeyColumn *ab);
269
270 #endif /*  __ED_KEYFRAMES_DRAW_H__ */