Blender  V3.3
overlay_engine.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2019 Blender Foundation. */
3 
10 #include "DRW_engine.h"
11 #include "DRW_render.h"
12 
13 #include "DEG_depsgraph_query.h"
14 
15 #include "ED_view3d.h"
16 
17 #include "UI_interface.h"
18 
19 #include "BKE_object.h"
20 #include "BKE_paint.h"
21 
22 #include "DNA_space_types.h"
23 
24 #include "overlay_engine.h"
25 #include "overlay_private.h"
26 
27 /* -------------------------------------------------------------------- */
31 static void OVERLAY_engine_init(void *vedata)
32 {
33  OVERLAY_Data *data = vedata;
34  OVERLAY_StorageList *stl = data->stl;
35  const DRWContextState *draw_ctx = DRW_context_state_get();
36  const RegionView3D *rv3d = draw_ctx->rv3d;
37  const View3D *v3d = draw_ctx->v3d;
38  const Scene *scene = draw_ctx->scene;
39  const ToolSettings *ts = scene->toolsettings;
40 
41  if (!stl->pd) {
42  /* Allocate transient pointers. */
43  stl->pd = MEM_callocN(sizeof(*stl->pd), __func__);
44  }
45 
46  /* Allocate instance. */
47  if (data->instance == NULL) {
48  data->instance = MEM_callocN(sizeof(*data->instance), __func__);
49  }
50 
51  OVERLAY_PrivateData *pd = stl->pd;
52  pd->space_type = v3d != NULL ? SPACE_VIEW3D : draw_ctx->space_data->spacetype;
53 
54  if (pd->space_type == SPACE_IMAGE) {
55  const SpaceImage *sima = (SpaceImage *)draw_ctx->space_data;
57  pd->clipping_state = 0;
60  return;
61  }
62  if (pd->space_type == SPACE_NODE) {
63  pd->hide_overlays = true;
64  pd->clipping_state = 0;
65  return;
66  }
67 
68  pd->hide_overlays = (v3d->flag2 & V3D_HIDE_OVERLAYS) != 0;
70  draw_ctx->object_edit, draw_ctx->obact, draw_ctx->object_mode);
71 
72  if (!pd->hide_overlays) {
73  pd->overlay = v3d->overlay;
74  pd->v3d_flag = v3d->flag;
75  pd->v3d_gridflag = v3d->gridflag;
76  }
77  else {
78  memset(&pd->overlay, 0, sizeof(pd->overlay));
79  pd->v3d_flag = 0;
80  pd->v3d_gridflag = 0;
86  }
87 
88  if (v3d->shading.type == OB_WIRE) {
90  }
91 
92  if (ts->sculpt) {
93  if (ts->sculpt->flags & SCULPT_HIDE_FACE_SETS) {
95  }
96  if (ts->sculpt->flags & SCULPT_HIDE_MASK) {
98  }
99  }
100 
101  pd->use_in_front = (v3d->shading.type <= OB_SOLID) ||
103  pd->wireframe_mode = (v3d->shading.type == OB_WIRE);
105  pd->xray_opacity = XRAY_ALPHA(v3d);
106  pd->xray_enabled = XRAY_ACTIVE(v3d);
108  pd->clear_in_front = (v3d->shading.type != OB_SOLID);
109  pd->cfra = DEG_get_ctime(draw_ctx->depsgraph);
110 
112 
113  switch (stl->pd->ctx_mode) {
114  case CTX_MODE_EDIT_MESH:
115  OVERLAY_edit_mesh_init(vedata);
116  break;
118  OVERLAY_edit_curves_init(vedata);
119  break;
120  default:
121  /* Nothing to do. */
122  break;
123  }
124  OVERLAY_facing_init(vedata);
125  OVERLAY_grid_init(vedata);
126  OVERLAY_image_init(vedata);
127  OVERLAY_outline_init(vedata);
128  OVERLAY_wireframe_init(vedata);
129  OVERLAY_paint_init(vedata);
130 }
131 
132 static void OVERLAY_cache_init(void *vedata)
133 {
134  OVERLAY_Data *data = vedata;
135  OVERLAY_StorageList *stl = data->stl;
136  OVERLAY_PrivateData *pd = stl->pd;
137 
138  if (pd->space_type == SPACE_IMAGE) {
140  OVERLAY_grid_cache_init(vedata);
142  return;
143  }
144  if (pd->space_type == SPACE_NODE) {
146  return;
147  }
148 
149  switch (pd->ctx_mode) {
150  case CTX_MODE_EDIT_MESH:
152  /* `pd->edit_mesh.flag` is valid after calling `OVERLAY_edit_mesh_cache_init`. */
153  const bool draw_edit_weights = (pd->edit_mesh.flag & V3D_OVERLAY_EDIT_WEIGHT);
154  if (draw_edit_weights) {
155  OVERLAY_paint_cache_init(vedata);
156  }
157  break;
159  case CTX_MODE_EDIT_CURVE:
161  break;
162  case CTX_MODE_EDIT_TEXT:
164  break;
166  break;
168  break;
171  break;
172  case CTX_MODE_PARTICLE:
174  break;
175  case CTX_MODE_POSE:
179  OVERLAY_paint_cache_init(vedata);
180  break;
181  case CTX_MODE_SCULPT:
183  break;
190  break;
193  break;
196  break;
197  case CTX_MODE_OBJECT:
198  break;
199  default:
200  BLI_assert_msg(0, "Draw mode invalid");
201  break;
202  }
206  OVERLAY_fade_cache_init(vedata);
208  OVERLAY_extra_cache_init(vedata);
211  OVERLAY_grid_cache_init(vedata);
212  OVERLAY_image_cache_init(vedata);
219 }
220 
221 BLI_INLINE OVERLAY_DupliData *OVERLAY_duplidata_get(Object *ob, void *vedata, bool *do_init)
222 {
223  OVERLAY_DupliData **dupli_data = (OVERLAY_DupliData **)DRW_duplidata_get(vedata);
224  *do_init = false;
226  return NULL;
227  }
228 
229  if (dupli_data) {
230  if (*dupli_data == NULL) {
231  *dupli_data = MEM_callocN(sizeof(OVERLAY_DupliData), __func__);
232  *do_init = true;
233  }
234  else if ((*dupli_data)->base_flag != ob->base_flag) {
235  /* Select state might have change, reinitialize. */
236  *do_init = true;
237  }
238  return *dupli_data;
239  }
240  return NULL;
241 }
242 
243 static bool overlay_object_is_edit_mode(const OVERLAY_PrivateData *pd, const Object *ob)
244 {
245  if (DRW_object_is_in_edit_mode(ob)) {
246  /* Also check for context mode as the object mode is not 100% reliable. (see T72490) */
247  switch (ob->type) {
248  case OB_MESH:
249  return pd->ctx_mode == CTX_MODE_EDIT_MESH;
250  case OB_ARMATURE:
251  return pd->ctx_mode == CTX_MODE_EDIT_ARMATURE;
252  case OB_CURVES_LEGACY:
253  return pd->ctx_mode == CTX_MODE_EDIT_CURVE;
254  case OB_SURF:
255  return pd->ctx_mode == CTX_MODE_EDIT_SURFACE;
256  case OB_LATTICE:
257  return pd->ctx_mode == CTX_MODE_EDIT_LATTICE;
258  case OB_MBALL:
259  return pd->ctx_mode == CTX_MODE_EDIT_METABALL;
260  case OB_FONT:
261  return pd->ctx_mode == CTX_MODE_EDIT_TEXT;
262  case OB_CURVES:
263  return pd->ctx_mode == CTX_MODE_EDIT_CURVES;
264  case OB_POINTCLOUD:
265  case OB_VOLUME:
266  /* No edit mode yet. */
267  return false;
268  }
269  }
270  return false;
271 }
272 
273 static bool overlay_should_fade_object(Object *ob, Object *active_object)
274 {
275  if (!active_object || !ob) {
276  return false;
277  }
278 
279  if (ELEM(active_object->mode, OB_MODE_OBJECT, OB_MODE_POSE)) {
280  return false;
281  }
282 
283  if ((active_object->mode & ob->mode) != 0) {
284  return false;
285  }
286 
287  return true;
288 }
289 
290 static void OVERLAY_cache_populate(void *vedata, Object *ob)
291 {
292  OVERLAY_Data *data = vedata;
293  OVERLAY_PrivateData *pd = data->stl->pd;
294 
295  if (pd->space_type == SPACE_IMAGE) {
296  return;
297  }
298 
299  const DRWContextState *draw_ctx = DRW_context_state_get();
300  const bool is_select = DRW_state_is_select();
301  const bool renderable = DRW_object_is_renderable(ob);
302  const bool in_pose_mode = ob->type == OB_ARMATURE && OVERLAY_armature_is_pose_mode(ob, draw_ctx);
303  const bool in_edit_mode = overlay_object_is_edit_mode(pd, ob);
304  const bool is_instance = (ob->base_flag & BASE_FROM_DUPLI);
305  const bool instance_parent_in_edit_mode = is_instance ?
307  pd, DRW_object_get_dupli_parent(ob)) :
308  false;
309  const bool in_particle_edit_mode = (ob->mode == OB_MODE_PARTICLE_EDIT) &&
310  (pd->ctx_mode == CTX_MODE_PARTICLE);
311  const bool in_paint_mode = (ob == draw_ctx->obact) &&
312  (draw_ctx->object_mode & OB_MODE_ALL_PAINT);
313  const bool in_sculpt_curve_mode = (ob == draw_ctx->obact) &&
314  (draw_ctx->object_mode & OB_MODE_SCULPT_CURVES);
315  const bool in_sculpt_mode = (ob == draw_ctx->obact) && (ob->sculpt != NULL) &&
316  (ob->sculpt->mode_type == OB_MODE_SCULPT);
317  const bool in_curves_sculpt_mode = (ob == draw_ctx->obact) &&
318  (ob->mode == OB_MODE_SCULPT_CURVES);
319  const bool has_surface = ELEM(ob->type,
320  OB_MESH,
322  OB_SURF,
323  OB_MBALL,
324  OB_FONT,
325  OB_GPENCIL,
326  OB_CURVES,
328  OB_VOLUME);
329  const bool draw_surface = (ob->dt >= OB_WIRE) && (renderable || (ob->dt == OB_WIRE));
330  const bool draw_facing = draw_surface && (pd->overlay.flag & V3D_OVERLAY_FACE_ORIENTATION) &&
331  !is_select;
332  const bool draw_fade = draw_surface && (pd->overlay.flag & V3D_OVERLAY_FADE_INACTIVE) &&
333  overlay_should_fade_object(ob, draw_ctx->obact);
334  const bool draw_mode_transfer = draw_surface;
335  const bool draw_bones = (pd->overlay.flag & V3D_OVERLAY_HIDE_BONES) == 0;
336  const bool draw_wires = draw_surface && has_surface &&
337  (pd->wireframe_mode || !pd->hide_overlays);
338  const bool draw_outlines = !in_edit_mode && !in_paint_mode && !in_sculpt_curve_mode &&
339  renderable && has_surface && !instance_parent_in_edit_mode &&
340  (pd->v3d_flag & V3D_SELECT_OUTLINE) &&
341  (ob->base_flag & BASE_SELECTED);
342  const bool draw_bone_selection = (ob->type == OB_MESH) && pd->armature.do_pose_fade_geom &&
343  !is_select;
344  const bool draw_edit_weights = in_edit_mode && (pd->edit_mesh.flag & V3D_OVERLAY_EDIT_WEIGHT);
345  const bool draw_extras =
346  (!pd->hide_overlays) &&
347  (((pd->overlay.flag & V3D_OVERLAY_HIDE_OBJECT_XTRAS) == 0) ||
348  /* Show if this is the camera we're looking through since it's useful for selecting. */
349  ((draw_ctx->rv3d->persp == RV3D_CAMOB) && ((ID *)draw_ctx->v3d->camera == ob->id.orig_id)));
350 
351  const bool draw_motion_paths = (pd->overlay.flag & V3D_OVERLAY_HIDE_MOTION_PATHS) == 0;
352 
353  bool do_init;
354  OVERLAY_DupliData *dupli = OVERLAY_duplidata_get(ob, vedata, &do_init);
355 
356  if (draw_fade) {
357  OVERLAY_fade_cache_populate(vedata, ob);
358  }
359  if (draw_facing) {
360  OVERLAY_facing_cache_populate(vedata, ob);
361  }
362  if (draw_mode_transfer) {
364  }
365  if (draw_wires) {
366  OVERLAY_wireframe_cache_populate(vedata, ob, dupli, do_init);
367  }
368  if (draw_outlines) {
369  OVERLAY_outline_cache_populate(vedata, ob, dupli, do_init);
370  }
371  if (draw_bone_selection) {
372  OVERLAY_pose_cache_populate(vedata, ob);
373  }
374 
375  if (ob->type == OB_VOLUME) {
376  OVERLAY_volume_cache_populate(vedata, ob);
377  }
378 
379  if (in_edit_mode && !pd->hide_overlays) {
380  switch (ob->type) {
381  case OB_MESH:
383  if (draw_edit_weights) {
385  }
386  break;
387  case OB_ARMATURE:
388  if (draw_bones) {
390  }
391  break;
392  case OB_CURVES_LEGACY:
394  break;
395  case OB_SURF:
397  break;
398  case OB_LATTICE:
400  break;
401  case OB_MBALL:
403  break;
404  case OB_FONT:
406  break;
407  case OB_CURVES:
409  break;
410  }
411  }
412  else if (in_pose_mode && draw_bones) {
414  }
415  else if (in_paint_mode && !pd->hide_overlays) {
416  switch (draw_ctx->object_mode) {
419  break;
422  break;
425  break;
426  default:
427  break;
428  }
429  }
430  else if (in_particle_edit_mode) {
432  }
433 
434  if (in_sculpt_mode) {
435  OVERLAY_sculpt_cache_populate(vedata, ob);
436  }
437  else if (in_curves_sculpt_mode) {
439  }
440 
441  if (draw_motion_paths) {
443  }
444 
445  if (!pd->hide_overlays) {
446  switch (ob->type) {
447  case OB_ARMATURE:
448  if (draw_bones && (is_select || (!in_edit_mode && !in_pose_mode))) {
450  }
451  break;
452  case OB_MBALL:
453  if (!in_edit_mode) {
455  }
456  break;
457  case OB_GPENCIL:
458  OVERLAY_gpencil_cache_populate(vedata, ob);
459  break;
460  }
461  }
462  /* Non-Meshes */
463  if (draw_extras) {
464  switch (ob->type) {
465  case OB_EMPTY:
466  OVERLAY_empty_cache_populate(vedata, ob);
467  break;
468  case OB_LAMP:
469  OVERLAY_light_cache_populate(vedata, ob);
470  break;
471  case OB_CAMERA:
472  OVERLAY_camera_cache_populate(vedata, ob);
473  break;
474  case OB_SPEAKER:
475  OVERLAY_speaker_cache_populate(vedata, ob);
476  break;
477  case OB_LIGHTPROBE:
479  break;
480  case OB_LATTICE: {
481  /* Unlike the other types above, lattices actually have a bounding box defined, so hide the
482  * lattice wires if only the bounding-box is requested. */
483  if (ob->dt > OB_BOUNDBOX) {
484  OVERLAY_lattice_cache_populate(vedata, ob);
485  }
486  break;
487  }
488  }
489  }
490 
493  }
494 
495  /* Relationship, object center, bounding-box... etc. */
496  if (!pd->hide_overlays) {
497  OVERLAY_extra_cache_populate(vedata, ob);
498  }
499 
500  if (dupli) {
501  dupli->base_flag = ob->base_flag;
502  }
503 }
504 
505 static void OVERLAY_cache_finish(void *vedata)
506 {
507  OVERLAY_Data *data = vedata;
508  OVERLAY_PrivateData *pd = data->stl->pd;
509 
510  if (ELEM(pd->space_type, SPACE_IMAGE)) {
512  return;
513  }
514  if (ELEM(pd->space_type, SPACE_NODE)) {
515  return;
516  }
517 
518  /* TODO(fclem): Only do this when really needed. */
519  {
520  /* HACK we allocate the in front depth here to avoid the overhead when if is not needed. */
523 
525 
526  GPU_framebuffer_ensure_config(
527  &dfbl->in_front_fb,
528  {GPU_ATTACHMENT_TEXTURE(dtxl->depth_in_front), GPU_ATTACHMENT_TEXTURE(dtxl->color)});
529  }
530 
535 }
536 
537 static void OVERLAY_draw_scene(void *vedata)
538 {
539  OVERLAY_Data *data = vedata;
540  OVERLAY_PrivateData *pd = data->stl->pd;
541  OVERLAY_FramebufferList *fbl = data->fbl;
543 
544  /* Needs to be done first as it modifies the scene color and depth buffer. */
545  if (pd->space_type == SPACE_VIEW3D) {
547  }
548 
549  if (DRW_state_is_fbo()) {
551  /* Don't clear background for the node editor. The node editor draws the background and we
552  * need to mask out the image from the already drawn overlay color buffer. */
553  if (pd->space_type != SPACE_NODE) {
554  const float clear_col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
555  GPU_framebuffer_clear_color(dfbl->overlay_only_fb, clear_col);
556  }
557  }
558 
559  if (pd->space_type == SPACE_IMAGE) {
562  if (DRW_state_is_fbo()) {
564  }
566  return;
567  }
568  if (pd->space_type == SPACE_NODE) {
570  return;
571  }
572 
574  OVERLAY_background_draw(vedata);
575 
577 
579 
580  if (DRW_state_is_fbo()) {
582  }
583 
584  OVERLAY_outline_draw(vedata);
585  OVERLAY_xray_depth_copy(vedata);
586 
587  if (DRW_state_is_fbo()) {
589  }
590 
591  OVERLAY_image_draw(vedata);
592  OVERLAY_fade_draw(vedata);
593  OVERLAY_facing_draw(vedata);
595  OVERLAY_extra_blend_draw(vedata);
596  OVERLAY_volume_draw(vedata);
597 
598  /* These overlays are drawn here to avoid artifacts with wire-frame opacity. */
599  switch (pd->ctx_mode) {
600  case CTX_MODE_SCULPT:
601  OVERLAY_sculpt_draw(vedata);
602  break;
605  break;
606  case CTX_MODE_EDIT_MESH:
607  case CTX_MODE_POSE:
611  OVERLAY_paint_draw(vedata);
612  break;
613  default:
614  break;
615  }
616 
617  if (DRW_state_is_fbo()) {
619  }
620 
621  OVERLAY_wireframe_draw(vedata);
622  OVERLAY_armature_draw(vedata);
623  OVERLAY_particle_draw(vedata);
624  OVERLAY_metaball_draw(vedata);
625  OVERLAY_gpencil_draw(vedata);
626  OVERLAY_extra_draw(vedata);
627 
628  if (DRW_state_is_fbo()) {
630  }
631 
632  OVERLAY_xray_fade_draw(vedata);
633  OVERLAY_grid_draw(vedata);
634 
636 
637  if (DRW_state_is_fbo()) {
639  }
640 
644 
645  if (DRW_state_is_fbo()) {
647  }
648 
653 
654  if (DRW_state_is_fbo()) {
656  }
657 
659  OVERLAY_motion_path_draw(vedata);
661 
663  /* Edit modes have their own selection code. */
664  return;
665  }
666 
667  /* Functions after this point can change FBO freely. */
668 
669  switch (pd->ctx_mode) {
670  case CTX_MODE_EDIT_MESH:
671  OVERLAY_edit_mesh_draw(vedata);
672  break;
674  case CTX_MODE_EDIT_CURVE:
675  OVERLAY_edit_curve_draw(vedata);
676  break;
677  case CTX_MODE_EDIT_TEXT:
678  OVERLAY_edit_text_draw(vedata);
679  break;
682  break;
683  case CTX_MODE_POSE:
684  OVERLAY_pose_draw(vedata);
685  break;
686  case CTX_MODE_PARTICLE:
688  break;
695  break;
697  break;
699  OVERLAY_edit_curves_draw(vedata);
700  break;
701  default:
702  break;
703  }
704 
705  OVERLAY_antialiasing_end(vedata);
706 }
707 
708 static void OVERLAY_engine_free(void)
709 {
711 }
712 
713 static void OVERLAY_instance_free(void *instance_)
714 {
716  DRW_UBO_FREE_SAFE(instance->grid_ubo);
718 }
719 
722 /* -------------------------------------------------------------------- */
727 
729  NULL,
730  NULL,
731  N_("Overlay"),
740  NULL,
741  NULL,
742  NULL,
743  NULL,
744 };
745 
748 #undef SELECT_ENGINE
enum eContextObjectMode CTX_data_mode_enum_ex(const struct Object *obedit, const struct Object *ob, eObjectMode object_mode)
@ CTX_MODE_EDIT_GPENCIL
Definition: BKE_context.h:120
@ CTX_MODE_EDIT_CURVE
Definition: BKE_context.h:105
@ CTX_MODE_PAINT_TEXTURE
Definition: BKE_context.h:116
@ CTX_MODE_EDIT_SURFACE
Definition: BKE_context.h:106
@ CTX_MODE_WEIGHT_GPENCIL
Definition: BKE_context.h:122
@ CTX_MODE_PARTICLE
Definition: BKE_context.h:117
@ CTX_MODE_SCULPT
Definition: BKE_context.h:113
@ CTX_MODE_VERTEX_GPENCIL
Definition: BKE_context.h:123
@ CTX_MODE_OBJECT
Definition: BKE_context.h:118
@ CTX_MODE_EDIT_MESH
Definition: BKE_context.h:104
@ CTX_MODE_SCULPT_CURVES
Definition: BKE_context.h:124
@ CTX_MODE_EDIT_TEXT
Definition: BKE_context.h:107
@ CTX_MODE_EDIT_CURVES
Definition: BKE_context.h:111
@ CTX_MODE_EDIT_ARMATURE
Definition: BKE_context.h:108
@ CTX_MODE_SCULPT_GPENCIL
Definition: BKE_context.h:121
@ CTX_MODE_EDIT_LATTICE
Definition: BKE_context.h:110
@ CTX_MODE_PAINT_GPENCIL
Definition: BKE_context.h:119
@ CTX_MODE_PAINT_VERTEX
Definition: BKE_context.h:115
@ CTX_MODE_EDIT_METABALL
Definition: BKE_context.h:109
@ CTX_MODE_PAINT_WEIGHT
Definition: BKE_context.h:114
@ CTX_MODE_POSE
Definition: BKE_context.h:112
General operations, lookup, etc. for blender objects.
bool BKE_scene_uses_blender_workbench(const struct Scene *scene)
#define BLI_assert_msg(a, msg)
Definition: BLI_assert.h:53
#define BLI_INLINE
BLI_INLINE bool BLI_listbase_is_empty(const struct ListBase *lb)
Definition: BLI_listbase.h:269
#define ELEM(...)
float DEG_get_ctime(const Depsgraph *graph)
@ BASE_FROM_DUPLI
@ BASE_SELECTED
#define OB_MODE_ALL_PAINT
@ OB_WIRE
@ OB_BOUNDBOX
@ OB_SOLID
@ OB_MODE_PARTICLE_EDIT
@ OB_MODE_WEIGHT_PAINT
@ OB_MODE_SCULPT
@ OB_MODE_SCULPT_CURVES
@ OB_MODE_POSE
@ OB_MODE_TEXTURE_PAINT
@ OB_MODE_OBJECT
@ OB_MODE_VERTEX_PAINT
@ OB_SPEAKER
@ OB_LATTICE
@ OB_MBALL
@ OB_EMPTY
@ OB_SURF
@ OB_CAMERA
@ OB_FONT
@ OB_ARMATURE
@ OB_LAMP
@ OB_MESH
@ OB_POINTCLOUD
@ OB_VOLUME
@ OB_CURVES_LEGACY
@ OB_CURVES
@ OB_GPENCIL
@ OB_LIGHTPROBE
@ SCULPT_HIDE_MASK
@ SCULPT_HIDE_FACE_SETS
@ SI_OVERLAY_SHOW_OVERLAYS
@ SPACE_NODE
@ SPACE_IMAGE
@ SPACE_VIEW3D
@ V3D_OVERLAY_FACE_ORIENTATION
@ V3D_OVERLAY_HIDE_OBJECT_ORIGINS
@ V3D_OVERLAY_HIDE_BONES
@ V3D_OVERLAY_HIDE_MOTION_PATHS
@ V3D_OVERLAY_WIREFRAMES
@ V3D_OVERLAY_HIDE_OBJECT_XTRAS
@ V3D_OVERLAY_FADE_INACTIVE
@ V3D_OVERLAY_HIDE_TEXT
#define RV3D_CAMOB
#define V3D_SELECT_OUTLINE
#define RV3D_CLIPPING_ENABLED(v3d, rv3d)
@ V3D_OVERLAY_EDIT_WEIGHT
#define V3D_HIDE_OVERLAYS
@ DRW_STATE_CLIP_PLANES
Definition: DRW_render.h:342
#define DRW_UBO_FREE_SAFE(ubo)
Definition: DRW_render.h:191
#define DRW_VIEWPORT_DATA_SIZE(ty)
Definition: DRW_render.h:96
#define XRAY_ACTIVE(v3d)
Definition: ED_view3d.h:1300
#define XRAY_ALPHA(v3d)
Definition: ED_view3d.h:1294
void GPU_framebuffer_bind(GPUFrameBuffer *fb)
@ GPU_DEPTH24_STENCIL8
Definition: GPU_texture.h:120
in reality light always falls off quadratically Particle Retrieve the data of the particle that spawned the object instance
Scene scene
struct Object * DRW_object_get_dupli_parent(const Object *UNUSED(ob))
Definition: draw_manager.c:264
void ** DRW_duplidata_get(void *vedata)
Definition: draw_manager.c:741
bool DRW_state_is_select(void)
bool DRW_state_is_depth(void)
bool DRW_object_is_in_edit_mode(const Object *ob)
Definition: draw_manager.c:196
DefaultFramebufferList * DRW_viewport_framebuffer_list_get(void)
Definition: draw_manager.c:633
bool DRW_object_is_renderable(const Object *ob)
Definition: draw_manager.c:180
bool DRW_state_is_fbo(void)
const DRWContextState * DRW_context_state_get(void)
DefaultTextureList * DRW_viewport_texture_list_get(void)
Definition: draw_manager.c:638
void DRW_view_set_active(const DRWView *view)
void DRW_texture_ensure_fullscreen_2d(GPUTexture **tex, eGPUTextureFormat format, DRWTextureFlag flags)
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void OVERLAY_antialiasing_cache_init(OVERLAY_Data *vedata)
void OVERLAY_antialiasing_cache_finish(OVERLAY_Data *vedata)
void OVERLAY_antialiasing_init(OVERLAY_Data *vedata)
void OVERLAY_xray_depth_copy(OVERLAY_Data *vedata)
void OVERLAY_antialiasing_start(OVERLAY_Data *vedata)
void OVERLAY_xray_depth_infront_copy(OVERLAY_Data *vedata)
void OVERLAY_xray_fade_draw(OVERLAY_Data *vedata)
void OVERLAY_antialiasing_end(OVERLAY_Data *vedata)
void OVERLAY_armature_in_front_draw(OVERLAY_Data *vedata)
bool OVERLAY_armature_is_pose_mode(Object *ob, const DRWContextState *draw_ctx)
void OVERLAY_edit_armature_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_armature_cache_finish(OVERLAY_Data *vedata)
void OVERLAY_armature_cache_init(OVERLAY_Data *vedata)
void OVERLAY_pose_armature_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_pose_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_armature_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_pose_draw(OVERLAY_Data *vedata)
void OVERLAY_armature_draw(OVERLAY_Data *vedata)
void OVERLAY_background_cache_init(OVERLAY_Data *vedata)
void OVERLAY_background_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_curve_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_curve_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_edit_curve_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_surf_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_edit_curves_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_curves_init(OVERLAY_Data *vedata)
void OVERLAY_edit_curves_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_edit_curves_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_mesh_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_mesh_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_edit_mesh_init(OVERLAY_Data *vedata)
void OVERLAY_edit_mesh_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_text_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_text_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_edit_text_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_uv_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_uv_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_uv_cache_finish(OVERLAY_Data *vedata)
void OVERLAY_edit_uv_init(OVERLAY_Data *vedata)
static void OVERLAY_draw_scene(void *vedata)
BLI_INLINE OVERLAY_DupliData * OVERLAY_duplidata_get(Object *ob, void *vedata, bool *do_init)
static const DrawEngineDataSize overlay_data_size
static void OVERLAY_engine_free(void)
static void OVERLAY_cache_init(void *vedata)
static void OVERLAY_cache_populate(void *vedata, Object *ob)
static bool overlay_object_is_edit_mode(const OVERLAY_PrivateData *pd, const Object *ob)
DrawEngineType draw_engine_overlay_type
static void OVERLAY_engine_init(void *vedata)
static bool overlay_should_fade_object(Object *ob, Object *active_object)
static void OVERLAY_cache_finish(void *vedata)
static void OVERLAY_instance_free(void *instance_)
void OVERLAY_extra_centers_draw(OVERLAY_Data *vedata)
void OVERLAY_extra_in_front_draw(OVERLAY_Data *vedata)
void OVERLAY_extra_cache_init(OVERLAY_Data *vedata)
Definition: overlay_extra.c:47
void OVERLAY_camera_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_light_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_lightprobe_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_extra_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_extra_blend_draw(OVERLAY_Data *vedata)
void OVERLAY_extra_draw(OVERLAY_Data *vedata)
void OVERLAY_empty_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_speaker_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_facing_infront_draw(OVERLAY_Data *vedata)
void OVERLAY_facing_draw(OVERLAY_Data *vedata)
void OVERLAY_facing_init(OVERLAY_Data *UNUSED(vedata))
void OVERLAY_facing_cache_init(OVERLAY_Data *vedata)
void OVERLAY_facing_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_fade_cache_populate(OVERLAY_Data *vedata, Object *ob)
Definition: overlay_fade.c:47
void OVERLAY_fade_draw(OVERLAY_Data *vedata)
Definition: overlay_fade.c:71
void OVERLAY_fade_infront_draw(OVERLAY_Data *vedata)
Definition: overlay_fade.c:78
void OVERLAY_fade_cache_init(OVERLAY_Data *vedata)
Definition: overlay_fade.c:19
void OVERLAY_edit_gpencil_cache_init(OVERLAY_Data *vedata)
void OVERLAY_gpencil_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_gpencil_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_gpencil_draw(OVERLAY_Data *vedata)
void OVERLAY_gpencil_draw(OVERLAY_Data *vedata)
void OVERLAY_grid_draw(OVERLAY_Data *vedata)
Definition: overlay_grid.c:299
void OVERLAY_grid_init(OVERLAY_Data *vedata)
Definition: overlay_grid.c:24
void OVERLAY_grid_cache_init(OVERLAY_Data *ved)
Definition: overlay_grid.c:205
void OVERLAY_image_cache_init(OVERLAY_Data *vedata)
Definition: overlay_image.c:37
void OVERLAY_image_background_draw(OVERLAY_Data *vedata)
void OVERLAY_image_in_front_draw(OVERLAY_Data *vedata)
void OVERLAY_image_scene_background_draw(OVERLAY_Data *vedata)
void OVERLAY_image_cache_finish(OVERLAY_Data *vedata)
void OVERLAY_image_draw(OVERLAY_Data *vedata)
void OVERLAY_image_init(OVERLAY_Data *vedata)
Definition: overlay_image.c:28
void OVERLAY_lattice_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_edit_lattice_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_lattice_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_lattice_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_metaball_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_metaball_in_front_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_metaball_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_metaball_draw(OVERLAY_Data *vedata)
void OVERLAY_metaball_cache_init(OVERLAY_Data *vedata)
void OVERLAY_mode_transfer_cache_init(OVERLAY_Data *vedata)
void OVERLAY_mode_transfer_cache_finish(OVERLAY_Data *vedata)
void OVERLAY_mode_transfer_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_mode_transfer_infront_draw(OVERLAY_Data *vedata)
void OVERLAY_mode_transfer_draw(OVERLAY_Data *vedata)
void OVERLAY_motion_path_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_motion_path_draw(OVERLAY_Data *vedata)
void OVERLAY_motion_path_cache_init(OVERLAY_Data *vedata)
void OVERLAY_outline_cache_populate(OVERLAY_Data *vedata, Object *ob, OVERLAY_DupliData *dupli, bool init_dupli)
void OVERLAY_outline_draw(OVERLAY_Data *vedata)
void OVERLAY_outline_init(OVERLAY_Data *vedata)
void OVERLAY_outline_cache_init(OVERLAY_Data *vedata)
void OVERLAY_paint_texture_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_paint_init(OVERLAY_Data *vedata)
Definition: overlay_paint.c:52
void OVERLAY_paint_cache_init(OVERLAY_Data *vedata)
Definition: overlay_paint.c:64
void OVERLAY_paint_draw(OVERLAY_Data *vedata)
void OVERLAY_paint_weight_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_paint_vertex_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_particle_draw(OVERLAY_Data *vedata)
void OVERLAY_edit_particle_cache_init(OVERLAY_Data *vedata)
void OVERLAY_particle_cache_init(OVERLAY_Data *vedata)
void OVERLAY_edit_particle_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_particle_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_edit_particle_draw(OVERLAY_Data *vedata)
void OVERLAY_sculpt_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_shader_free(void)
void OVERLAY_sculpt_draw(OVERLAY_Data *vedata)
void OVERLAY_wireframe_draw(OVERLAY_Data *vedata)
void OVERLAY_volume_draw(OVERLAY_Data *vedata)
void OVERLAY_sculpt_curves_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_wireframe_in_front_draw(OVERLAY_Data *vedata)
void OVERLAY_sculpt_curves_cache_init(OVERLAY_Data *vedata)
void OVERLAY_volume_cache_populate(OVERLAY_Data *vedata, Object *ob)
void OVERLAY_volume_cache_init(OVERLAY_Data *vedata)
void OVERLAY_sculpt_cache_init(OVERLAY_Data *vedata)
void OVERLAY_wireframe_cache_populate(OVERLAY_Data *vedata, Object *ob, OVERLAY_DupliData *dupli, bool init_dupli)
void OVERLAY_sculpt_curves_draw(OVERLAY_Data *vedata)
void OVERLAY_wireframe_cache_init(OVERLAY_Data *vedata)
void OVERLAY_wireframe_init(OVERLAY_Data *vedata)
struct Object * obact
Definition: DRW_render.h:983
struct Scene * scene
Definition: DRW_render.h:979
struct SpaceLink * space_data
Definition: DRW_render.h:977
struct Depsgraph * depsgraph
Definition: DRW_render.h:987
eObjectMode object_mode
Definition: DRW_render.h:991
struct View3D * v3d
Definition: DRW_render.h:976
struct Object * object_edit
Definition: DRW_render.h:1003
struct RegionView3D * rv3d
Definition: DRW_render.h:975
struct GPUFrameBuffer * overlay_only_fb
struct GPUFrameBuffer * in_front_fb
struct GPUFrameBuffer * overlay_fb
struct GPUTexture * depth_in_front
Definition: DNA_ID.h:368
struct ID * orig_id
Definition: DNA_ID.h:419
struct GPUFrameBuffer * overlay_line_in_front_fb
struct GPUFrameBuffer * overlay_in_front_fb
struct GPUFrameBuffer * overlay_default_fb
struct GPUFrameBuffer * overlay_line_fb
struct GPUFrameBuffer * overlay_color_only_fb
View3DOverlay overlay
struct OVERLAY_PrivateData::@256 armature
struct OVERLAY_PrivateData::@252 edit_mesh
enum eContextObjectMode ctx_mode
struct OVERLAY_PrivateData * pd
ListBase particlesystem
short base_flag
struct SculptSession * sculpt
struct ToolSettings * toolsettings
eObjectMode mode_type
Definition: BKE_paint.h:642
SpaceImageOverlay overlay
float sculpt_mode_mask_opacity
float sculpt_mode_face_sets_opacity
View3DOverlay overlay
struct Object * camera
View3DShading shading
#define N_(msgid)