Blender  V3.3
keyframes_draw.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2009 Blender Foundation, Joshua Leung. All rights reserved. */
3 
8 /* System includes ----------------------------------------------------- */
9 
10 #include <float.h>
11 
12 #include "MEM_guardedalloc.h"
13 
14 #include "BLI_dlrbTree.h"
15 #include "BLI_listbase.h"
16 #include "BLI_rect.h"
17 
18 #include "DNA_anim_types.h"
19 #include "DNA_gpencil_types.h"
20 #include "DNA_mask_types.h"
21 #include "DNA_object_types.h"
22 #include "DNA_scene_types.h"
23 
24 #include "GPU_immediate.h"
25 #include "GPU_state.h"
26 
27 #include "UI_interface.h"
28 #include "UI_resources.h"
29 #include "UI_view2d.h"
30 
31 #include "ED_anim_api.h"
32 #include "ED_keyframes_draw.h"
33 #include "ED_keyframes_keylist.h"
34 
35 /* *************************** Keyframe Drawing *************************** */
36 
38  float y,
39  float size,
40  bool sel,
41  short key_type,
42  short mode,
43  float alpha,
44  const KeyframeShaderBindings *sh_bindings,
45  short handle_type,
46  short extreme_type)
47 {
48  bool draw_fill = ELEM(mode, KEYFRAME_SHAPE_INSIDE, KEYFRAME_SHAPE_BOTH);
49  bool draw_outline = ELEM(mode, KEYFRAME_SHAPE_FRAME, KEYFRAME_SHAPE_BOTH);
50 
51  BLI_assert(draw_fill || draw_outline);
52 
53  /* tweak size of keyframe shape according to type of keyframe
54  * - 'proper' keyframes have key_type = 0, so get drawn at full size
55  */
56  switch (key_type) {
57  case BEZT_KEYTYPE_KEYFRAME: /* must be full size */
58  break;
59 
60  case BEZT_KEYTYPE_BREAKDOWN: /* slightly smaller than normal keyframe */
61  size *= 0.85f;
62  break;
63 
64  case BEZT_KEYTYPE_MOVEHOLD: /* Slightly smaller than normal keyframes
65  * (but by less than for breakdowns). */
66  size *= 0.925f;
67  break;
68 
69  case BEZT_KEYTYPE_EXTREME: /* slightly larger */
70  size *= 1.2f;
71  break;
72 
73  default:
74  size -= 0.8f * key_type;
75  }
76 
77  uchar fill_col[4];
78  uchar outline_col[4];
79  uint flags = 0;
80 
81  /* draw! */
82  if (draw_fill) {
83  /* get interior colors from theme (for selected and unselected only) */
84  switch (key_type) {
85  case BEZT_KEYTYPE_BREAKDOWN: /* bluish frames (default theme) */
87  break;
88  case BEZT_KEYTYPE_EXTREME: /* reddish frames (default theme) */
90  break;
91  case BEZT_KEYTYPE_JITTER: /* greenish frames (default theme) */
93  break;
94  case BEZT_KEYTYPE_MOVEHOLD: /* similar to traditional keyframes, but different... */
96  break;
97  case BEZT_KEYTYPE_KEYFRAME: /* traditional yellowish frames (default theme) */
98  default:
100  }
101 
102  /* NOTE: we don't use the straight alpha from the theme, or else effects such as
103  * graying out protected/muted channels doesn't work correctly!
104  */
105  fill_col[3] *= alpha;
106 
107  if (!draw_outline) {
108  /* force outline color to match */
109  outline_col[0] = fill_col[0];
110  outline_col[1] = fill_col[1];
111  outline_col[2] = fill_col[2];
112  outline_col[3] = fill_col[3];
113  }
114  }
115 
116  if (draw_outline) {
117  /* exterior - black frame */
119  outline_col[3] *= alpha;
120 
121  if (!draw_fill) {
122  /* fill color needs to be (outline.rgb, 0) */
123  fill_col[0] = outline_col[0];
124  fill_col[1] = outline_col[1];
125  fill_col[2] = outline_col[2];
126  fill_col[3] = 0;
127  }
128 
129  /* Handle type to outline shape. */
130  switch (handle_type) {
133  break; /* circle */
136  break; /* circle with dot */
139  break; /* square */
142  break; /* clipped diamond */
143 
145  default:
146  flags = GPU_KEYFRAME_SHAPE_DIAMOND; /* diamond */
147  }
148 
149  /* Extreme type to arrow-like shading. */
150  if (extreme_type & KEYFRAME_EXTREME_MAX) {
152  }
153  if (extreme_type & KEYFRAME_EXTREME_MIN) {
155  }
156  if (extreme_type & GPU_KEYFRAME_SHAPE_ARROW_END_MIXED) {
157  flags |= 0x400;
158  }
159  }
160 
161  immAttr1f(sh_bindings->size_id, size);
162  immAttr4ubv(sh_bindings->color_id, fill_col);
163  immAttr4ubv(sh_bindings->outline_color_id, outline_col);
164  immAttr1u(sh_bindings->flags_id, flags);
165  immVertex2f(sh_bindings->pos_id, x, y);
166 }
167 
168 /* Common attributes shared between the draw calls. */
169 typedef struct DrawKeylistUIData {
170  float alpha;
171  float icon_size;
174  float ipo_size;
177  float sel_color[4];
178  float unsel_color[4];
179  float sel_mhcol[4];
180  float unsel_mhcol[4];
181  float ipo_color[4];
182  float ipo_color_mix[4];
183 
184  /* Show interpolation and handle type? */
185  bool show_ipo;
187 
189  View2D *v2d,
190  float yscale_fac,
191  bool channel_locked,
192  eSAction_Flag saction_flag)
193 {
194  /* locked channels are less strongly shown, as feedback for locked channels in DopeSheet */
195  /* TODO: allow this opacity factor to be themed? */
196  ctx->alpha = channel_locked ? 0.25f : 1.0f;
197 
198  ctx->icon_size = U.widget_unit * 0.5f * yscale_fac;
199  ctx->half_icon_size = 0.5f * ctx->icon_size;
200  ctx->smaller_size = 0.35f * ctx->icon_size;
201  ctx->ipo_size = 0.1f * ctx->icon_size;
202  ctx->gpencil_size = ctx->smaller_size * 0.8f;
203  ctx->screenspace_margin = (0.35f * (float)UI_UNIT_X) / UI_view2d_scale_get_x(v2d);
204 
205  ctx->show_ipo = (saction_flag & SACTION_SHOW_INTERPOLATION) != 0;
206 
210 
211  ctx->sel_color[3] *= ctx->alpha;
212  ctx->unsel_color[3] *= ctx->alpha;
213  ctx->ipo_color[3] *= ctx->alpha;
214 
215  copy_v4_v4(ctx->sel_mhcol, ctx->sel_color);
216  ctx->sel_mhcol[3] *= 0.8f;
217  copy_v4_v4(ctx->unsel_mhcol, ctx->unsel_color);
218  ctx->unsel_mhcol[3] *= 0.8f;
219  copy_v4_v4(ctx->ipo_color_mix, ctx->ipo_color);
220  ctx->ipo_color_mix[3] *= 0.5f;
221 }
222 
224  const ActKeyColumn *ab,
225  float ypos)
226 {
228  float size = 1.0f;
229  switch (ab->next->key_type) {
232  case BEZT_KEYTYPE_JITTER:
233  size *= 0.5f;
234  break;
236  size *= 0.8f;
237  break;
238  default:
239  break;
240  }
242  &(const rctf){
243  .xmin = ab->cfra,
244  .xmax = min_ff(ab->next->cfra - (ctx->screenspace_margin * size), ab->next->cfra),
245  .ymin = ypos - ctx->gpencil_size,
246  .ymax = ypos + ctx->gpencil_size,
247  },
248  true,
249  0.25f * (float)UI_UNIT_X,
250  (ab->block.sel) ? ctx->sel_mhcol : ctx->unsel_mhcol);
251 }
252 
254  const ActKeyColumn *ab,
255  float ypos)
256 {
257 
259  &(const rctf){
260  .xmin = ab->cfra,
261  .xmax = ab->next->cfra,
262  .ymin = ypos - ctx->smaller_size,
263  .ymax = ypos + ctx->smaller_size,
264  },
265  true,
266  3.0f,
267  (ab->block.sel) ? ctx->sel_mhcol : ctx->unsel_mhcol);
268 }
269 
271  const ActKeyColumn *ab,
272  float ypos)
273 {
275  &(const rctf){
276  .xmin = ab->cfra,
277  .xmax = ab->next->cfra,
278  .ymin = ypos - ctx->half_icon_size,
279  .ymax = ypos + ctx->half_icon_size,
280  },
281  true,
282  3.0f,
283  (ab->block.sel) ? ctx->sel_color : ctx->unsel_color);
284 }
285 
287  const ActKeyColumn *ab,
288  float ypos)
289 {
291  &(const rctf){
292  .xmin = ab->cfra,
293  .xmax = ab->next->cfra,
294  .ymin = ypos - ctx->ipo_size,
295  .ymax = ypos + ctx->ipo_size,
296  },
297  true,
298  3.0f,
300 }
301 
302 static void draw_keylist_block(const DrawKeylistUIData *ctx, const ActKeyColumn *ab, float ypos)
303 {
304 
305  /* Draw grease pencil bars between keyframes. */
306  if ((ab->next != NULL) && (ab->block.flag & ACTKEYBLOCK_FLAG_GPENCIL)) {
307  draw_keylist_block_gpencil(ctx, ab, ypos);
308  }
309  else {
310  /* Draw other types. */
312 
313  int valid_hold = actkeyblock_get_valid_hold(ab);
314  if (valid_hold != 0) {
315  if ((valid_hold & ACTKEYBLOCK_FLAG_STATIC_HOLD) == 0) {
316  /* draw "moving hold" long-keyframe block - slightly smaller */
317  draw_keylist_block_moving_hold(ctx, ab, ypos);
318  }
319  else {
320  /* draw standard long-keyframe block */
321  draw_keylist_block_standard(ctx, ab, ypos);
322  }
323  }
324  if (ctx->show_ipo && actkeyblock_is_valid(ab) &&
326  /* draw an interpolation line */
328  }
329  }
330 }
331 
332 static void draw_keylist_blocks(const DrawKeylistUIData *ctx,
333  const ActKeyColumn *keys,
334  const int key_len,
335  float ypos)
336 {
337  for (int i = 0; i < key_len; i++) {
338  const ActKeyColumn *ab = &keys[i];
339  draw_keylist_block(ctx, ab, ypos);
340  }
341 }
342 
343 static bool draw_keylist_is_visible_key(const View2D *v2d, const ActKeyColumn *ak)
344 {
345  return IN_RANGE_INCL(ak->cfra, v2d->cur.xmin, v2d->cur.xmax);
346 }
347 
348 static void draw_keylist_keys(const DrawKeylistUIData *ctx,
349  View2D *v2d,
350  const KeyframeShaderBindings *sh_bindings,
351  const ActKeyColumn *keys,
352  const int key_len,
353  float ypos,
354  eSAction_Flag saction_flag)
355 {
356  short handle_type = KEYFRAME_HANDLE_NONE, extreme_type = KEYFRAME_EXTREME_NONE;
357 
358  for (int i = 0; i < key_len; i++) {
359  const ActKeyColumn *ak = &keys[i];
360  if (draw_keylist_is_visible_key(v2d, ak)) {
361  if (ctx->show_ipo) {
362  handle_type = ak->handle_type;
363  }
364  if (saction_flag & SACTION_SHOW_EXTREMES) {
365  extreme_type = ak->extreme_type;
366  }
367 
369  ypos,
370  ctx->icon_size,
371  (ak->sel & SELECT),
372  ak->key_type,
374  ctx->alpha,
375  sh_bindings,
376  handle_type,
377  extreme_type);
378  }
379  }
380 }
381 
382 /* *************************** Drawing Stack *************************** */
393 
394 typedef struct AnimKeylistDrawListElem {
398 
399  float yscale_fac;
400  float ypos;
403 
414 
416 
418 {
419  switch (elem->type) {
420  case ANIM_KEYLIST_SUMMARY: {
421  summary_to_keylist(elem->ac, elem->keylist, elem->saction_flag);
422  break;
423  }
424  case ANIM_KEYLIST_SCENE: {
425  scene_to_keylist(elem->ads, elem->sce, elem->keylist, elem->saction_flag);
426  break;
427  }
428  case ANIM_KEYLIST_OBJECT: {
429  ob_to_keylist(elem->ads, elem->ob, elem->keylist, elem->saction_flag);
430  break;
431  }
432  case ANIM_KEYLIST_FCURVE: {
433  fcurve_to_keylist(elem->adt, elem->fcu, elem->keylist, elem->saction_flag);
434  break;
435  }
436  case ANIM_KEYLIST_ACTION: {
437  action_to_keylist(elem->adt, elem->act, elem->keylist, elem->saction_flag);
438  break;
439  }
440  case ANIM_KEYLIST_AGROUP: {
441  agroup_to_keylist(elem->adt, elem->agrp, elem->keylist, elem->saction_flag);
442  break;
443  }
444  case ANIM_KEYLIST_GP_LAYER: {
445  gpl_to_keylist(elem->ads, elem->gpl, elem->keylist);
446  break;
447  }
449  mask_to_keylist(elem->ads, elem->masklay, elem->keylist);
450  break;
451  }
452  }
453 }
454 
456 {
457  DrawKeylistUIData ctx;
458  draw_keylist_ui_data_init(&ctx, v2d, elem->yscale_fac, elem->channel_locked, elem->saction_flag);
459 
460  const int key_len = ED_keylist_array_len(elem->keylist);
461  const ActKeyColumn *keys = ED_keylist_array(elem->keylist);
462  draw_keylist_blocks(&ctx, keys, key_len, elem->ypos);
463 }
464 
466  View2D *v2d,
467  const KeyframeShaderBindings *sh_bindings)
468 {
469  DrawKeylistUIData ctx;
470  draw_keylist_ui_data_init(&ctx, v2d, elem->yscale_fac, elem->channel_locked, elem->saction_flag);
471 
472  const int key_len = ED_keylist_array_len(elem->keylist);
473  const ActKeyColumn *keys = ED_keylist_array(elem->keylist);
474  draw_keylist_keys(&ctx, v2d, sh_bindings, keys, key_len, elem->ypos, elem->saction_flag);
475 }
476 
478 {
480 }
481 
482 typedef struct AnimKeylistDrawList {
483  ListBase /* AnimKeylistDrawListElem */ channels;
485 
487 {
488  return MEM_callocN(sizeof(AnimKeylistDrawList), __func__);
489 }
490 
492 {
493  LISTBASE_FOREACH (AnimKeylistDrawListElem *, elem, &draw_list->channels) {
496  }
497 }
498 
500 {
501  LISTBASE_FOREACH (AnimKeylistDrawListElem *, elem, &draw_list->channels) {
503  }
504 }
505 
507  const ListBase * /*ActKeyColumn*/ keys)
508 {
509  /* count keys */
510  uint len = 0;
511 
512  LISTBASE_FOREACH (ActKeyColumn *, ak, keys) {
513  /* Optimization: if keyframe doesn't appear within 5 units (screenspace)
514  * in visible area, don't draw.
515  * This might give some improvements,
516  * since we current have to flip between view/region matrices.
517  */
518  if (draw_keylist_is_visible_key(v2d, ak)) {
519  len++;
520  }
521  }
522  return len;
523 }
524 
526  const View2D *v2d)
527 {
528  uint len = 0;
529  LISTBASE_FOREACH (AnimKeylistDrawListElem *, elem, &draw_list->channels) {
530  const ListBase *keys = ED_keylist_listbase(elem->keylist);
532  }
533  return len;
534 }
535 
537 {
538  const int visible_key_len = ED_keylist_draw_list_visible_key_len(draw_list, v2d);
539  if (visible_key_len == 0) {
540  return;
541  }
542 
544 
546  KeyframeShaderBindings sh_bindings;
547 
550  sh_bindings.color_id = GPU_vertformat_attr_add(
553  format, "outlineColor", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
555 
558  immUniform1f("outline_scale", 1.0f);
559  immUniform2f("ViewportSize", BLI_rcti_size_x(&v2d->mask) + 1, BLI_rcti_size_y(&v2d->mask) + 1);
560  immBegin(GPU_PRIM_POINTS, visible_key_len);
561 
562  LISTBASE_FOREACH (AnimKeylistDrawListElem *, elem, &draw_list->channels) {
563  ED_keylist_draw_list_elem_draw_keys(elem, v2d, &sh_bindings);
564  }
565 
566  immEnd();
567  GPU_program_point_size(false);
569 
571 }
572 
574 {
575  ED_keylist_draw_list_draw_blocks(draw_list, v2d);
576  ED_keylist_draw_list_draw_keys(draw_list, v2d);
577 }
578 
580 {
582  ED_keylist_draw_list_draw(draw_list, v2d);
583 }
584 
586 {
587  LISTBASE_FOREACH (AnimKeylistDrawListElem *, elem, &draw_list->channels) {
588  ED_keylist_free(elem->keylist);
589  }
590  BLI_freelistN(&draw_list->channels);
591  MEM_freeN(draw_list);
592 }
593 
595  AnimKeylistDrawList *draw_list,
597  float ypos,
598  float yscale_fac,
599  eSAction_Flag saction_flag)
600 {
601  AnimKeylistDrawListElem *draw_elem = MEM_callocN(sizeof(AnimKeylistDrawListElem), __func__);
602  BLI_addtail(&draw_list->channels, draw_elem);
603  draw_elem->type = elem_type;
604  draw_elem->keylist = ED_keylist_create();
605  draw_elem->ypos = ypos;
606  draw_elem->yscale_fac = yscale_fac;
607  draw_elem->saction_flag = saction_flag;
608  return draw_elem;
609 }
610 
611 /* *************************** Channel Drawing Funcs *************************** */
612 
614  bAnimContext *ac,
615  float ypos,
616  float yscale_fac,
617  int saction_flag)
618 {
619  saction_flag &= ~SACTION_SHOW_EXTREMES;
621  draw_list, ANIM_KEYLIST_SUMMARY, ypos, yscale_fac, saction_flag);
622  draw_elem->ac = ac;
623 }
624 
626  bDopeSheet *ads,
627  Scene *sce,
628  float ypos,
629  float yscale_fac,
630  int saction_flag)
631 {
632  saction_flag &= ~SACTION_SHOW_EXTREMES;
634  draw_list, ANIM_KEYLIST_SCENE, ypos, yscale_fac, saction_flag);
635  draw_elem->ads = ads;
636  draw_elem->sce = sce;
637 }
638 
640  bDopeSheet *ads,
641  Object *ob,
642  float ypos,
643  float yscale_fac,
644  int saction_flag)
645 {
646  saction_flag &= ~SACTION_SHOW_EXTREMES;
648  draw_list, ANIM_KEYLIST_OBJECT, ypos, yscale_fac, saction_flag);
649  draw_elem->ads = ads;
650  draw_elem->ob = ob;
651 }
652 
654  AnimData *adt,
655  FCurve *fcu,
656  float ypos,
657  float yscale_fac,
658  int saction_flag)
659 {
660  const bool locked = (fcu->flag & FCURVE_PROTECTED) ||
661  ((fcu->grp) && (fcu->grp->flag & AGRP_PROTECTED)) ||
662  ((adt && adt->action) &&
664 
666  draw_list, ANIM_KEYLIST_FCURVE, ypos, yscale_fac, saction_flag);
667  draw_elem->adt = adt;
668  draw_elem->fcu = fcu;
669  draw_elem->channel_locked = locked;
670 }
671 
673  AnimData *adt,
674  bActionGroup *agrp,
675  float ypos,
676  float yscale_fac,
677  int saction_flag)
678 {
679  bool locked = (agrp->flag & AGRP_PROTECTED) ||
680  ((adt && adt->action) &&
682 
684  draw_list, ANIM_KEYLIST_AGROUP, ypos, yscale_fac, saction_flag);
685  draw_elem->adt = adt;
686  draw_elem->agrp = agrp;
687  draw_elem->channel_locked = locked;
688 }
689 
691  AnimData *adt,
692  bAction *act,
693  float ypos,
694  float yscale_fac,
695  int saction_flag)
696 {
697  const bool locked = (act && (ID_IS_LINKED(act) || ID_IS_OVERRIDE_LIBRARY(act)));
698  saction_flag &= ~SACTION_SHOW_EXTREMES;
699 
701  draw_list, ANIM_KEYLIST_ACTION, ypos, yscale_fac, saction_flag);
702  draw_elem->adt = adt;
703  draw_elem->act = act;
704  draw_elem->channel_locked = locked;
705 }
706 
708  bDopeSheet *ads,
709  bGPDlayer *gpl,
710  float ypos,
711  float yscale_fac,
712  int saction_flag)
713 {
714  bool locked = (gpl->flag & GP_LAYER_LOCKED) != 0;
716  draw_list, ANIM_KEYLIST_GP_LAYER, ypos, yscale_fac, saction_flag);
717  draw_elem->ads = ads;
718  draw_elem->gpl = gpl;
719  draw_elem->channel_locked = locked;
720 }
721 
723  bDopeSheet *ads,
724  MaskLayer *masklay,
725  float ypos,
726  float yscale_fac,
727  int saction_flag)
728 {
729  bool locked = (masklay->flag & MASK_LAYERFLAG_LOCKED) != 0;
731  draw_list, ANIM_KEYLIST_MASK_LAYER, ypos, yscale_fac, saction_flag);
732  draw_elem->ads = ads;
733  draw_elem->masklay = masklay;
734  draw_elem->channel_locked = locked;
735 }
typedef float(TangentPoint)[2]
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
void void BLI_freelistN(struct ListBase *listbase) ATTR_NONNULL(1)
Definition: listbase.c:466
void BLI_addtail(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:80
MINLINE float min_ff(float a, float b)
MINLINE void copy_v4_v4(float r[4], const float a[4])
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition: BLI_rect.h:190
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition: BLI_rect.h:186
unsigned char uchar
Definition: BLI_sys_types.h:70
unsigned int uint
Definition: BLI_sys_types.h:67
#define ELEM(...)
#define IN_RANGE_INCL(a, b, c)
#define ID_IS_LINKED(_id)
Definition: DNA_ID.h:566
#define ID_IS_OVERRIDE_LIBRARY(_id)
Definition: DNA_ID.h:588
@ AGRP_PROTECTED
eSAction_Flag
@ SACTION_SHOW_INTERPOLATION
@ SACTION_SHOW_EXTREMES
@ FCURVE_PROTECTED
@ BEZT_KEYTYPE_EXTREME
@ BEZT_KEYTYPE_JITTER
@ BEZT_KEYTYPE_BREAKDOWN
@ BEZT_KEYTYPE_MOVEHOLD
@ BEZT_KEYTYPE_KEYFRAME
@ GP_LAYER_LOCKED
@ MASK_LAYERFLAG_LOCKED
Object is a sort of wrapper for general info.
@ ACTKEYBLOCK_FLAG_GPENCIL
@ ACTKEYBLOCK_FLAG_NON_BEZIER
@ ACTKEYBLOCK_FLAG_STATIC_HOLD
@ KEYFRAME_SHAPE_INSIDE
@ KEYFRAME_SHAPE_BOTH
@ KEYFRAME_SHAPE_FRAME
@ KEYFRAME_HANDLE_VECTOR
@ KEYFRAME_HANDLE_FREE
@ KEYFRAME_HANDLE_AUTO_CLAMP
@ KEYFRAME_HANDLE_NONE
@ KEYFRAME_HANDLE_AUTO
@ KEYFRAME_HANDLE_ALIGNED
@ KEYFRAME_EXTREME_MAX
@ KEYFRAME_EXTREME_NONE
@ KEYFRAME_EXTREME_MIN
void immUniform2f(const char *name, float x, float y)
void immAttr4ubv(uint attr_id, const unsigned char data[4])
void immUnbindProgram(void)
void immVertex2f(uint attr_id, float x, float y)
void immAttr1f(uint attr_id, float x)
void immBindBuiltinProgram(eGPUBuiltinShader shader_id)
void immAttr1u(uint attr_id, uint x)
void immUniform1f(const char *name, float x)
GPUVertFormat * immVertexFormat(void)
void immBegin(GPUPrimType, uint vertex_len)
void immEnd(void)
_GL_VOID GLfloat value _GL_VOID_RET _GL_VOID const GLuint GLboolean *residences _GL_BOOL_RET _GL_VOID GLsizei GLfloat GLfloat GLfloat GLfloat const GLubyte *bitmap _GL_VOID_RET _GL_VOID GLenum const void *lists _GL_VOID_RET _GL_VOID const GLdouble *equation _GL_VOID_RET _GL_VOID GLdouble GLdouble blue _GL_VOID_RET _GL_VOID GLfloat GLfloat blue _GL_VOID_RET _GL_VOID GLint GLint blue _GL_VOID_RET _GL_VOID GLshort GLshort blue _GL_VOID_RET _GL_VOID GLubyte GLubyte blue _GL_VOID_RET _GL_VOID GLuint GLuint blue _GL_VOID_RET _GL_VOID GLushort GLushort blue _GL_VOID_RET _GL_VOID GLbyte GLbyte GLbyte alpha _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble alpha _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat alpha _GL_VOID_RET _GL_VOID GLint GLint GLint alpha _GL_VOID_RET _GL_VOID GLshort GLshort GLshort alpha _GL_VOID_RET _GL_VOID GLubyte GLubyte GLubyte alpha _GL_VOID_RET _GL_VOID GLuint GLuint GLuint alpha _GL_VOID_RET _GL_VOID GLushort GLushort GLushort alpha _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLint y
@ GPU_PRIM_POINTS
Definition: GPU_primitive.h:19
@ GPU_SHADER_KEYFRAME_SHAPE
Definition: GPU_shader.h:192
@ GPU_KEYFRAME_SHAPE_INNER_DOT
Definition: GPU_shader.h:398
@ GPU_KEYFRAME_SHAPE_CIRCLE
Definition: GPU_shader.h:395
@ GPU_KEYFRAME_SHAPE_ARROW_END_MIXED
Definition: GPU_shader.h:401
@ GPU_KEYFRAME_SHAPE_DIAMOND
Definition: GPU_shader.h:394
@ GPU_KEYFRAME_SHAPE_ARROW_END_MAX
Definition: GPU_shader.h:399
@ GPU_KEYFRAME_SHAPE_ARROW_END_MIN
Definition: GPU_shader.h:400
@ GPU_KEYFRAME_SHAPE_CLIPPED_VERTICAL
Definition: GPU_shader.h:396
#define GPU_KEYFRAME_SHAPE_SQUARE
Definition: GPU_shader.h:403
void GPU_program_point_size(bool enable)
Definition: gpu_state.cc:172
@ GPU_BLEND_NONE
Definition: GPU_state.h:60
@ GPU_BLEND_ALPHA
Definition: GPU_state.h:62
void GPU_blend(eGPUBlend blend)
Definition: gpu_state.cc:39
@ GPU_FETCH_FLOAT
@ GPU_FETCH_INT_TO_FLOAT_UNIT
@ GPU_FETCH_INT
uint GPU_vertformat_attr_add(GPUVertFormat *, const char *name, GPUVertCompType, uint comp_len, GPUVertFetchMode)
@ GPU_COMP_F32
@ GPU_COMP_U32
@ GPU_COMP_U8
Read Guarded memory(de)allocation.
void UI_draw_roundbox_4fv(const struct rctf *rect, bool filled, float rad, const float col[4])
void UI_draw_roundbox_corner_set(int type)
@ UI_CNR_BOTTOM_RIGHT
@ UI_CNR_TOP_RIGHT
@ UI_CNR_NONE
#define UI_UNIT_X
@ TH_KEYBORDER_SELECT
Definition: UI_resources.h:153
@ TH_KEYTYPE_BREAKDOWN
Definition: UI_resources.h:145
@ TH_KEYTYPE_KEYFRAME
Definition: UI_resources.h:141
@ TH_DOPESHEET_IPOLINE
Definition: UI_resources.h:214
@ TH_KEYBORDER
Definition: UI_resources.h:152
@ TH_KEYTYPE_JITTER
Definition: UI_resources.h:147
@ TH_KEYTYPE_EXTREME
Definition: UI_resources.h:143
@ TH_KEYTYPE_KEYFRAME_SELECT
Definition: UI_resources.h:142
@ TH_KEYTYPE_MOVEHOLD
Definition: UI_resources.h:149
@ TH_KEYTYPE_BREAKDOWN_SELECT
Definition: UI_resources.h:146
@ TH_KEYTYPE_EXTREME_SELECT
Definition: UI_resources.h:144
@ TH_STRIP
Definition: UI_resources.h:138
@ TH_KEYTYPE_MOVEHOLD_SELECT
Definition: UI_resources.h:150
@ TH_KEYTYPE_JITTER_SELECT
Definition: UI_resources.h:148
@ TH_STRIP_SELECT
Definition: UI_resources.h:139
void UI_GetThemeColor4fv(int colorid, float col[4])
Definition: resources.c:1173
void UI_GetThemeColor4ubv(int colorid, unsigned char col[4])
Definition: resources.c:1352
float UI_view2d_scale_get_x(const struct View2D *v2d)
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
unsigned int U
Definition: btGjkEpa3.h:78
#define SELECT
int len
Definition: draw_manager.c:108
static void draw_keylist_block_standard(const DrawKeylistUIData *ctx, const ActKeyColumn *ab, float ypos)
static void ED_keylist_draw_list_build_keylists(AnimKeylistDrawList *draw_list)
static void draw_keylist_block_gpencil(const DrawKeylistUIData *ctx, const ActKeyColumn *ab, float ypos)
static void ED_keylist_draw_list_elem_build_keylist(AnimKeylistDrawListElem *elem)
void draw_gpl_channel(AnimKeylistDrawList *draw_list, bDopeSheet *ads, bGPDlayer *gpl, float ypos, float yscale_fac, int saction_flag)
static int ED_keylist_draw_keylist_visible_key_len(const View2D *v2d, const ListBase *keys)
void draw_object_channel(AnimKeylistDrawList *draw_list, bDopeSheet *ads, Object *ob, float ypos, float yscale_fac, int saction_flag)
static void ED_keylist_draw_list_draw_keys(AnimKeylistDrawList *draw_list, View2D *v2d)
void draw_fcurve_channel(AnimKeylistDrawList *draw_list, AnimData *adt, FCurve *fcu, float ypos, float yscale_fac, int saction_flag)
void ED_keylist_draw_list_flush(AnimKeylistDrawList *draw_list, View2D *v2d)
struct DrawKeylistUIData DrawKeylistUIData
static int ED_keylist_draw_list_visible_key_len(const AnimKeylistDrawList *draw_list, const View2D *v2d)
struct AnimKeylistDrawListElem AnimKeylistDrawListElem
static void draw_keylist_block_interpolation_line(const DrawKeylistUIData *ctx, const ActKeyColumn *ab, float ypos)
static AnimKeylistDrawListElem * ed_keylist_draw_list_add_elem(AnimKeylistDrawList *draw_list, eAnimKeylistDrawListElemType elem_type, float ypos, float yscale_fac, eSAction_Flag saction_flag)
static void draw_keylist_block(const DrawKeylistUIData *ctx, const ActKeyColumn *ab, float ypos)
AnimKeylistDrawList * ED_keylist_draw_list_create(void)
eAnimKeylistDrawListElemType
@ ANIM_KEYLIST_ACTION
@ ANIM_KEYLIST_SUMMARY
@ ANIM_KEYLIST_OBJECT
@ ANIM_KEYLIST_MASK_LAYER
@ ANIM_KEYLIST_FCURVE
@ ANIM_KEYLIST_AGROUP
@ ANIM_KEYLIST_SCENE
@ ANIM_KEYLIST_GP_LAYER
static void ED_keylist_draw_list_elem_draw_blocks(AnimKeylistDrawListElem *elem, View2D *v2d)
static void draw_keylist_ui_data_init(DrawKeylistUIData *ctx, View2D *v2d, float yscale_fac, bool channel_locked, eSAction_Flag saction_flag)
static void ED_keylist_draw_list_draw_blocks(AnimKeylistDrawList *draw_list, View2D *v2d)
void draw_keyframe_shape(float x, float y, float size, bool sel, short key_type, short mode, float alpha, const KeyframeShaderBindings *sh_bindings, short handle_type, short extreme_type)
void ED_keylist_draw_list_free(AnimKeylistDrawList *draw_list)
void draw_action_channel(AnimKeylistDrawList *draw_list, AnimData *adt, bAction *act, float ypos, float yscale_fac, int saction_flag)
static void ED_keylist_draw_list_elem_prepare_for_drawing(AnimKeylistDrawListElem *elem)
static void draw_keylist_block_moving_hold(const DrawKeylistUIData *ctx, const ActKeyColumn *ab, float ypos)
static bool draw_keylist_is_visible_key(const View2D *v2d, const ActKeyColumn *ak)
struct AnimKeylistDrawList AnimKeylistDrawList
static void ED_keylist_draw_list_elem_draw_keys(AnimKeylistDrawListElem *elem, View2D *v2d, const KeyframeShaderBindings *sh_bindings)
void draw_agroup_channel(AnimKeylistDrawList *draw_list, AnimData *adt, bActionGroup *agrp, float ypos, float yscale_fac, int saction_flag)
void draw_scene_channel(AnimKeylistDrawList *draw_list, bDopeSheet *ads, Scene *sce, float ypos, float yscale_fac, int saction_flag)
void draw_masklay_channel(AnimKeylistDrawList *draw_list, bDopeSheet *ads, MaskLayer *masklay, float ypos, float yscale_fac, int saction_flag)
static void draw_keylist_keys(const DrawKeylistUIData *ctx, View2D *v2d, const KeyframeShaderBindings *sh_bindings, const ActKeyColumn *keys, const int key_len, float ypos, eSAction_Flag saction_flag)
static void draw_keylist_blocks(const DrawKeylistUIData *ctx, const ActKeyColumn *keys, const int key_len, float ypos)
void draw_summary_channel(struct AnimKeylistDrawList *draw_list, bAnimContext *ac, float ypos, float yscale_fac, int saction_flag)
static void ED_keylist_draw_list_draw(AnimKeylistDrawList *draw_list, View2D *v2d)
void fcurve_to_keylist(AnimData *adt, FCurve *fcu, AnimKeylist *keylist, const int saction_flag)
AnimKeylist * ED_keylist_create()
void scene_to_keylist(bDopeSheet *ads, Scene *sce, AnimKeylist *keylist, const int saction_flag)
void mask_to_keylist(bDopeSheet *UNUSED(ads), MaskLayer *masklay, AnimKeylist *keylist)
bool actkeyblock_is_valid(const ActKeyColumn *ac)
void ob_to_keylist(bDopeSheet *ads, Object *ob, AnimKeylist *keylist, const int saction_flag)
const ActKeyColumn * ED_keylist_array(const struct AnimKeylist *keylist)
void summary_to_keylist(bAnimContext *ac, AnimKeylist *keylist, const int saction_flag)
void ED_keylist_prepare_for_direct_access(AnimKeylist *keylist)
int actkeyblock_get_valid_hold(const ActKeyColumn *ac)
void ED_keylist_free(AnimKeylist *keylist)
int64_t ED_keylist_array_len(const struct AnimKeylist *keylist)
void action_to_keylist(AnimData *adt, bAction *act, AnimKeylist *keylist, const int saction_flag)
const struct ListBase * ED_keylist_listbase(const AnimKeylist *keylist)
void gpl_to_keylist(bDopeSheet *UNUSED(ads), bGPDlayer *gpl, AnimKeylist *keylist)
void agroup_to_keylist(AnimData *adt, bActionGroup *agrp, AnimKeylist *keylist, const int saction_flag)
format
Definition: logImageCore.h:38
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
ActKeyBlockInfo block
struct ActKeyColumn * next
bAction * action
struct AnimKeylistDrawListElem * next
struct AnimKeylist * keylist
eSAction_Flag saction_flag
struct AnimKeylistDrawListElem * prev
eAnimKeylistDrawListElemType type
bActionGroup * grp
short flag
float xmax
Definition: DNA_vec_types.h:69
float xmin
Definition: DNA_vec_types.h:69