Blender  V3.3
draw_manager.c
Go to the documentation of this file.
1 /* SPDX-License-Identifier: GPL-2.0-or-later
2  * Copyright 2016 Blender Foundation. */
3 
8 #include <stdio.h>
9 
10 #include "BLI_alloca.h"
11 #include "BLI_listbase.h"
12 #include "BLI_memblock.h"
13 #include "BLI_rect.h"
14 #include "BLI_string.h"
15 #include "BLI_task.h"
16 #include "BLI_threads.h"
17 
18 #include "BLF_api.h"
19 
20 #include "BKE_colortools.h"
21 #include "BKE_context.h"
22 #include "BKE_curve.h"
23 #include "BKE_curves.h"
24 #include "BKE_duplilist.h"
25 #include "BKE_editmesh.h"
26 #include "BKE_global.h"
27 #include "BKE_gpencil.h"
28 #include "BKE_lattice.h"
29 #include "BKE_main.h"
30 #include "BKE_mball.h"
31 #include "BKE_mesh.h"
32 #include "BKE_modifier.h"
33 #include "BKE_object.h"
34 #include "BKE_paint.h"
35 #include "BKE_particle.h"
36 #include "BKE_pbvh.h"
37 #include "BKE_pointcache.h"
38 #include "BKE_pointcloud.h"
39 #include "BKE_screen.h"
40 #include "BKE_subdiv_modifier.h"
41 #include "BKE_volume.h"
42 
43 #include "DNA_camera_types.h"
44 #include "DNA_mesh_types.h"
45 #include "DNA_meshdata_types.h"
46 #include "DNA_world_types.h"
47 
48 #include "ED_gpencil.h"
49 #include "ED_screen.h"
50 #include "ED_space_api.h"
51 #include "ED_view3d.h"
52 
53 #include "GPU_capabilities.h"
54 #include "GPU_framebuffer.h"
55 #include "GPU_immediate.h"
56 #include "GPU_matrix.h"
57 #include "GPU_platform.h"
58 #include "GPU_shader_shared.h"
59 #include "GPU_state.h"
60 #include "GPU_uniform_buffer.h"
61 #include "GPU_viewport.h"
62 
63 #include "IMB_colormanagement.h"
64 
65 #include "RE_engine.h"
66 #include "RE_pipeline.h"
67 
68 #include "UI_resources.h"
69 #include "UI_view2d.h"
70 
71 #include "WM_api.h"
72 #include "wm_window.h"
73 
74 #include "draw_color_management.h"
75 #include "draw_manager.h"
76 #include "draw_manager_profiling.h"
77 #include "draw_manager_testing.h"
78 #include "draw_manager_text.h"
79 #include "draw_shader.h"
80 #include "draw_subdivision.h"
81 #include "draw_texture_pool.h"
82 
83 /* only for callbacks */
84 #include "draw_cache_impl.h"
85 
95 
96 #include "GPU_context.h"
97 
98 #include "DEG_depsgraph.h"
99 #include "DEG_depsgraph_query.h"
100 
101 #include "DRW_select_buffer.h"
102 
105 
106 static struct {
107  ListBase /*DRWRegisteredDrawEngine*/ engines;
108  int len;
110 
112 {
113  memset(dst, 0x0, offsetof(DRWManager, gl_context));
114 }
115 
116 /* This function is used to reset draw manager to a state
117  * where we don't re-use data by accident across different
118  * draw calls.
119  */
120 #ifdef DEBUG
121 static void drw_state_ensure_not_reused(DRWManager *dst)
122 {
123  memset(dst, 0xff, offsetof(DRWManager, gl_context));
124 }
125 #endif
126 
127 static bool drw_draw_show_annotation(void)
128 {
129  if (DST.draw_ctx.space_data == NULL) {
130  View3D *v3d = DST.draw_ctx.v3d;
131  return (v3d && ((v3d->flag2 & V3D_SHOW_ANNOTATION) != 0) &&
132  ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0));
133  }
134 
135  switch (DST.draw_ctx.space_data->spacetype) {
136  case SPACE_IMAGE: {
138  return (sima->flag & SI_SHOW_GPENCIL) != 0;
139  }
140  case SPACE_NODE:
141  /* Don't draw the annotation for the node editor. Annotations are handled by space_image as
142  * the draw manager is only used to draw the background. */
143  return false;
144  default:
145  BLI_assert(0);
146  return false;
147  }
148 }
149 
150 /* -------------------------------------------------------------------- */
154 static void drw_task_graph_init(void)
155 {
159 }
160 
161 static void drw_task_graph_deinit(void)
162 {
164 
169 
171  DST.task_graph = NULL;
172 }
173 
176 /* -------------------------------------------------------------------- */
181 {
183 
184  if (ob->type == OB_MESH) {
185  if ((ob == DST.draw_ctx.object_edit) || DRW_object_is_in_edit_mode(ob)) {
186  View3D *v3d = DST.draw_ctx.v3d;
187  if (v3d && v3d->overlay.edit_flag & V3D_OVERLAY_EDIT_OCCLUDE_WIRE) {
188  return false;
189  }
190  }
191  }
192 
193  return true;
194 }
195 
197 {
198  if (BKE_object_is_in_editmode(ob)) {
199  if (ELEM(ob->type, OB_MESH, OB_CURVES)) {
200  if ((ob->mode & OB_MODE_EDIT) == 0) {
201  return false;
202  }
203  }
204  return true;
205  }
206  return false;
207 }
208 
210 {
212  return BKE_object_visibility(ob, mode);
213 }
214 
215 bool DRW_object_use_hide_faces(const struct Object *ob)
216 {
217  if (ob->type == OB_MESH) {
218  const Mesh *me = ob->data;
219 
220  switch (ob->mode) {
221  case OB_MODE_SCULPT:
222  return true;
224  return (me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
227  return true;
228  }
229  }
230 
231  return false;
232 }
233 
235 {
236  const bool for_render = DRW_state_is_image_render();
237  /* NOTE: psys_check_enabled is using object and particle system for only
238  * reading, but is using some other functions which are more generic and
239  * which are hard to make const-pointer. */
240  if (!psys_check_enabled((Object *)object, (ParticleSystem *)psys, for_render)) {
241  return false;
242  }
243  const DRWContextState *draw_ctx = DRW_context_state_get();
244  const Scene *scene = draw_ctx->scene;
245  if (object == draw_ctx->object_edit) {
246  return false;
247  }
248  const ParticleSettings *part = psys->part;
250  if (object->mode == OB_MODE_PARTICLE_EDIT) {
251  if (psys_in_edit_mode(draw_ctx->depsgraph, psys)) {
252  if ((pset->flag & PE_DRAW_PART) == 0) {
253  return false;
254  }
255  if ((part->childtype == 0) &&
256  (psys->flag & PSYS_HAIR_DYNAMICS && psys->pointcache->flag & PTCACHE_BAKED) == 0) {
257  return false;
258  }
259  }
260  }
261  return true;
262 }
263 
265 {
266  return DST.dupli_parent;
267 }
268 
270 {
271  return DST.dupli_source;
272 }
273 
276 /* -------------------------------------------------------------------- */
281 {
282  DST.size[0] = size[0];
283  DST.size[1] = size[1];
284  DST.inv_size[0] = 1.0f / size[0];
285  DST.inv_size[1] = 1.0f / size[1];
286 }
287 
288 const float *DRW_viewport_size_get(void)
289 {
290  return DST.size;
291 }
292 
294 {
295  return DST.inv_size;
296 }
297 
298 const float *DRW_viewport_screenvecs_get(void)
299 {
300  return &DST.screenvecs[0][0];
301 }
302 
303 const float *DRW_viewport_pixelsize_get(void)
304 {
305  return &DST.pixsize;
306 }
307 
308 /* Not a viewport variable, we could split this out. */
309 static void drw_context_state_init(void)
310 {
311  if (DST.draw_ctx.obact) {
313  }
314  else {
316  }
317 
318  /* Edit object. */
321  }
322  else {
324  }
325 
326  /* Pose object. */
329  }
332  }
333  else {
335  }
336 
340  }
341 }
342 
343 static void draw_unit_state_create(void)
344 {
348 
349  unit_m4(mats->model);
350  unit_m4(mats->modelinverse);
351 
352  copy_v3_fl(infos->orcotexfac[0], 0.0f);
353  copy_v3_fl(infos->orcotexfac[1], 1.0f);
354 
355  infos->ob_index = 0;
356  infos->ob_random = 0.0f;
357  infos->ob_flag = 1.0f;
358  copy_v3_fl(infos->ob_color, 1.0f);
359 
360  /* TODO(fclem): get rid of this. */
361  culling->bsphere.radius = -1.0f;
362  culling->user_data = NULL;
363 
365 }
366 
368 {
369  DRWData *drw_data = MEM_callocN(sizeof(DRWData), "DRWData");
370 
372 
374 
375  drw_data->commands = BLI_memblock_create(sizeof(DRWCommandChunk));
377  drw_data->callbuffers = BLI_memblock_create(sizeof(DRWCallBuffer));
378  drw_data->shgroups = BLI_memblock_create(sizeof(DRWShadingGroup));
379  drw_data->uniforms = BLI_memblock_create(sizeof(DRWUniformChunk));
380  drw_data->views = BLI_memblock_create(sizeof(DRWView));
381  drw_data->images = BLI_memblock_create(sizeof(GPUTexture *));
383  {
384  uint chunk_len = sizeof(DRWObjectMatrix) * DRW_RESOURCE_CHUNK_LEN;
385  drw_data->obmats = BLI_memblock_create_ex(sizeof(DRWObjectMatrix), chunk_len);
386  }
387  {
388  uint chunk_len = sizeof(DRWObjectInfos) * DRW_RESOURCE_CHUNK_LEN;
389  drw_data->obinfos = BLI_memblock_create_ex(sizeof(DRWObjectInfos), chunk_len);
390  }
391  {
392  uint chunk_len = sizeof(DRWCullingState) * DRW_RESOURCE_CHUNK_LEN;
393  drw_data->cullstates = BLI_memblock_create_ex(sizeof(DRWCullingState), chunk_len);
394  }
395  {
396  uint chunk_len = sizeof(DRWPass) * DRW_RESOURCE_CHUNK_LEN;
397  drw_data->passes = BLI_memblock_create_ex(sizeof(DRWPass), chunk_len);
398  }
399 
400  for (int i = 0; i < 2; i++) {
401  drw_data->view_data[i] = DRW_view_data_create(&g_registered_engines.engines);
402  }
403  return drw_data;
404 }
405 
406 /* Reduce ref count of the textures used by a viewport. */
407 static void draw_texture_release(DRWData *drw_data)
408 {
409  /* Release Image textures. */
410  BLI_memblock_iter iter;
411  GPUTexture **tex;
412  BLI_memblock_iternew(drw_data->images, &iter);
413  while ((tex = BLI_memblock_iterstep(&iter))) {
415  }
416 }
417 
418 static void drw_viewport_data_reset(DRWData *drw_data)
419 {
420  draw_texture_release(drw_data);
421 
422  BLI_memblock_clear(drw_data->commands, NULL);
424  BLI_memblock_clear(drw_data->callbuffers, NULL);
425  BLI_memblock_clear(drw_data->obmats, NULL);
426  BLI_memblock_clear(drw_data->obinfos, NULL);
427  BLI_memblock_clear(drw_data->cullstates, NULL);
428  BLI_memblock_clear(drw_data->shgroups, NULL);
429  BLI_memblock_clear(drw_data->uniforms, NULL);
430  BLI_memblock_clear(drw_data->passes, NULL);
431  BLI_memblock_clear(drw_data->views, NULL);
432  BLI_memblock_clear(drw_data->images, NULL);
438 }
439 
441 {
442  draw_texture_release(drw_data);
443 
444  BLI_memblock_destroy(drw_data->commands, NULL);
447  BLI_memblock_destroy(drw_data->obmats, NULL);
448  BLI_memblock_destroy(drw_data->obinfos, NULL);
450  BLI_memblock_destroy(drw_data->shgroups, NULL);
451  BLI_memblock_destroy(drw_data->uniforms, NULL);
452  BLI_memblock_destroy(drw_data->views, NULL);
453  BLI_memblock_destroy(drw_data->passes, NULL);
454  BLI_memblock_destroy(drw_data->images, NULL);
458  for (int i = 0; i < 2; i++) {
459  DRW_view_data_free(drw_data->view_data[i]);
460  }
461  if (drw_data->matrices_ubo != NULL) {
462  for (int i = 0; i < drw_data->ubo_len; i++) {
463  GPU_uniformbuf_free(drw_data->matrices_ubo[i]);
464  GPU_uniformbuf_free(drw_data->obinfos_ubo[i]);
465  }
466  MEM_freeN(drw_data->matrices_ubo);
467  MEM_freeN(drw_data->obinfos_ubo);
468  }
471  MEM_freeN(drw_data);
472 }
473 
475 {
476  DRWData **vmempool_p = GPU_viewport_data_get(viewport);
477  DRWData *vmempool = *vmempool_p;
478 
479  if (vmempool == NULL) {
480  *vmempool_p = vmempool = DRW_viewport_data_create();
481  }
482  return vmempool;
483 }
484 
495 static void drw_manager_init(DRWManager *dst, GPUViewport *viewport, const int size[2])
496 {
497  RegionView3D *rv3d = dst->draw_ctx.rv3d;
498  ARegion *region = dst->draw_ctx.region;
499 
500  int view = (viewport) ? GPU_viewport_active_view_get(viewport) : 0;
501 
502  if (!dst->viewport && dst->vmempool) {
503  /* Manager was init first without a viewport, created DRWData, but is being re-init.
504  * In this case, keep the old data. */
505  /* If it is being re-init with a valid viewport, it means there is something wrong. */
506  BLI_assert(viewport == NULL);
507  }
508  else if (viewport) {
509  /* Use viewport's persistent DRWData. */
510  dst->vmempool = drw_viewport_data_ensure(viewport);
511  }
512  else {
513  /* Create temporary DRWData. Freed in drw_manager_exit(). */
515  }
516 
517  dst->viewport = viewport;
518  dst->view_data_active = dst->vmempool->view_data[view];
519  dst->resource_handle = 0;
520  dst->pass_handle = 0;
521  dst->primary_view_num = 0;
522 
524 
525  bool do_validation = true;
526  if (size == NULL && viewport == NULL) {
527  /* Avoid division by 0. Engines will either override this or not use it. */
528  dst->size[0] = 1.0f;
529  dst->size[1] = 1.0f;
530  }
531  else if (size == NULL) {
532  BLI_assert(viewport);
533  GPUTexture *tex = GPU_viewport_color_texture(viewport, 0);
534  dst->size[0] = GPU_texture_width(tex);
535  dst->size[1] = GPU_texture_height(tex);
536  }
537  else {
538  BLI_assert(size);
539  dst->size[0] = size[0];
540  dst->size[1] = size[1];
541  /* Fix case when used in DRW_cache_restart(). */
542  do_validation = false;
543  }
544  dst->inv_size[0] = 1.0f / dst->size[0];
545  dst->inv_size[1] = 1.0f / dst->size[1];
546 
547  if (do_validation) {
548  DRW_view_data_texture_list_size_validate(dst->view_data_active, (int[2]){UNPACK2(dst->size)});
549  }
550 
551  if (viewport) {
553  }
554 
556  dst->default_framebuffer = dfbl->default_fb;
557 
559 
560  if (rv3d != NULL) {
561  normalize_v3_v3(dst->screenvecs[0], rv3d->viewinv[0]);
562  normalize_v3_v3(dst->screenvecs[1], rv3d->viewinv[1]);
563 
564  dst->pixsize = rv3d->pixsize;
565  dst->view_default = DRW_view_create(rv3d->viewmat, rv3d->winmat, NULL, NULL, NULL);
567 
568  if (dst->draw_ctx.sh_cfg == GPU_SHADER_CFG_CLIPPED) {
569  int plane_len = (RV3D_LOCK_FLAGS(rv3d) & RV3D_BOXCLIP) ? 4 : 6;
570  DRW_view_clip_planes_set(dst->view_default, rv3d->clip, plane_len);
571  }
572 
573  dst->view_active = dst->view_default;
574  dst->view_previous = NULL;
575  }
576  else if (region) {
577  View2D *v2d = &region->v2d;
578  float viewmat[4][4];
579  float winmat[4][4];
580 
581  rctf region_space = {0.0f, 1.0f, 0.0f, 1.0f};
582  BLI_rctf_transform_calc_m4_pivot_min(&v2d->cur, &region_space, viewmat);
583 
584  unit_m4(winmat);
585  winmat[0][0] = 2.0f;
586  winmat[1][1] = 2.0f;
587  winmat[3][0] = -1.0f;
588  winmat[3][1] = -1.0f;
589 
590  dst->view_default = DRW_view_create(viewmat, winmat, NULL, NULL, NULL);
591  dst->view_active = dst->view_default;
592  dst->view_previous = NULL;
593  }
594  else {
595  zero_v3(dst->screenvecs[0]);
596  zero_v3(dst->screenvecs[1]);
597 
598  dst->pixsize = 1.0f;
599  dst->view_default = NULL;
600  dst->view_active = NULL;
601  dst->view_previous = NULL;
602  }
603 
604  /* fclem: Is this still needed ? */
605  if (dst->draw_ctx.object_edit && rv3d) {
607  }
608 
609  if (G_draw.view_ubo == NULL) {
610  G_draw.view_ubo = GPU_uniformbuf_create_ex(sizeof(ViewInfos), NULL, "G_draw.view_ubo");
611  }
612 
613  if (dst->draw_list == NULL) {
615  }
616 
617  memset(dst->object_instance_data, 0x0, sizeof(dst->object_instance_data));
618 }
619 
620 static void drw_manager_exit(DRWManager *dst)
621 {
622  if (dst->vmempool != NULL && dst->viewport == NULL) {
624  }
625  dst->vmempool = NULL;
626  dst->viewport = NULL;
627 #ifdef DEBUG
628  /* Avoid accidental reuse. */
629  drw_state_ensure_not_reused(dst);
630 #endif
631 }
632 
634 {
636 }
637 
639 {
641 }
642 
644 {
645  if (DST.viewport) {
647  }
648 }
649 
652 /* -------------------------------------------------------------------- */
656 static uint dupli_key_hash(const void *key)
657 {
658  const DupliKey *dupli_key = (const DupliKey *)key;
659  return BLI_ghashutil_ptrhash(dupli_key->ob) ^ BLI_ghashutil_ptrhash(dupli_key->ob_data);
660 }
661 
662 static bool dupli_key_cmp(const void *key1, const void *key2)
663 {
664  const DupliKey *dupli_key1 = (const DupliKey *)key1;
665  const DupliKey *dupli_key2 = (const DupliKey *)key2;
666  return dupli_key1->ob != dupli_key2->ob || dupli_key1->ob_data != dupli_key2->ob_data;
667 }
668 
670 {
671  DupliObject *dupli = DST.dupli_source;
672  if (dupli == NULL) {
673  return;
674  }
675 
676  if (DST.dupli_origin != dupli->ob || (DST.dupli_origin_data != dupli->ob_data)) {
677  DST.dupli_origin = dupli->ob;
678  DST.dupli_origin_data = dupli->ob_data;
679  }
680  else {
681  /* Same data as previous iter. No need to poll ghash for this. */
682  return;
683  }
684 
685  if (DST.dupli_ghash == NULL) {
687  }
688 
689  DupliKey *key = MEM_callocN(sizeof(DupliKey), __func__);
690  key->ob = dupli->ob;
691  key->ob_data = dupli->ob_data;
692 
693  void **value;
694  if (!BLI_ghash_ensure_p(DST.dupli_ghash, key, &value)) {
695  *value = MEM_callocN(sizeof(void *) * g_registered_engines.len, __func__);
696 
697  /* TODO: Meh a bit out of place but this is nice as it is
698  * only done once per instance type. */
700  }
701  else {
702  MEM_freeN(key);
703  }
704  DST.dupli_datas = *(void ***)value;
705 }
706 
707 static void duplidata_value_free(void *val)
708 {
709  void **dupli_datas = val;
710  for (int i = 0; i < g_registered_engines.len; i++) {
711  MEM_SAFE_FREE(dupli_datas[i]);
712  }
713  MEM_freeN(val);
714 }
715 
716 static void duplidata_key_free(void *key)
717 {
718  DupliKey *dupli_key = (DupliKey *)key;
719  if (dupli_key->ob_data == dupli_key->ob->data) {
721  }
722  else {
723  Object temp_object = *dupli_key->ob;
724  /* Do not modify the original bound-box. */
725  temp_object.runtime.bb = NULL;
726  BKE_object_replace_data_on_shallow_copy(&temp_object, dupli_key->ob_data);
728  MEM_SAFE_FREE(temp_object.runtime.bb);
729  }
730  MEM_freeN(key);
731 }
732 
733 static void drw_duplidata_free(void)
734 {
735  if (DST.dupli_ghash != NULL) {
737  DST.dupli_ghash = NULL;
738  }
739 }
740 
741 void **DRW_duplidata_get(void *vedata)
742 {
743  if (DST.dupli_source == NULL) {
744  return NULL;
745  }
746  ViewportEngineData *ved = (ViewportEngineData *)vedata;
748  return &DST.dupli_datas[engine_type->index];
749 }
750 
753 /* -------------------------------------------------------------------- */
758 {
760  if (sled->engine_type == engine_type) {
761  return sled->storage;
762  }
763  }
764  return NULL;
765 }
766 
768  DrawEngineType *engine_type,
769  void (*callback)(void *storage))
770 {
771  ViewLayerEngineData *sled;
772 
773  for (sled = view_layer->drawdata.first; sled; sled = sled->next) {
774  if (sled->engine_type == engine_type) {
775  return &sled->storage;
776  }
777  }
778 
779  sled = MEM_callocN(sizeof(ViewLayerEngineData), "ViewLayerEngineData");
780  sled->engine_type = engine_type;
781  sled->free = callback;
782  BLI_addtail(&view_layer->drawdata, sled);
783 
784  return &sled->storage;
785 }
786 
788  void (*callback)(void *storage))
789 {
791 }
792 
795 /* -------------------------------------------------------------------- */
799 /* Used for DRW_drawdata_from_id()
800  * All ID-data-blocks which have their own 'local' DrawData
801  * should have the same arrangement in their structs.
802  */
803 typedef struct IdDdtTemplate {
805  struct AnimData *adt;
808 
809 /* Check if ID can have AnimData */
810 static bool id_type_can_have_drawdata(const short id_type)
811 {
812  /* Only some ID-blocks have this info for now */
813  /* TODO: finish adding this for the other blocktypes */
814  switch (id_type) {
815  /* has DrawData */
816  case ID_OB:
817  case ID_WO:
818  return true;
819 
820  /* no DrawData */
821  default:
822  return false;
823  }
824 }
825 
826 static bool id_can_have_drawdata(const ID *id)
827 {
828  /* sanity check */
829  if (id == NULL) {
830  return false;
831  }
832 
834 }
835 
837 {
838  /* only some ID-blocks have this info for now, so we cast the
839  * types that do to be of type IdDdtTemplate, and extract the
840  * DrawData that way
841  */
842  if (id_can_have_drawdata(id)) {
843  IdDdtTemplate *idt = (IdDdtTemplate *)id;
844  return &idt->drawdata;
845  }
846 
847  return NULL;
848 }
849 
851 {
852  DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
853 
854  if (drawdata == NULL) {
855  return NULL;
856  }
857 
858  LISTBASE_FOREACH (DrawData *, dd, drawdata) {
859  if (dd->engine_type == engine_type) {
860  return dd;
861  }
862  }
863  return NULL;
864 }
865 
867  DrawEngineType *engine_type,
868  size_t size,
869  DrawDataInitCb init_cb,
870  DrawDataFreeCb free_cb)
871 {
872  BLI_assert(size >= sizeof(DrawData));
874  /* Try to re-use existing data. */
875  DrawData *dd = DRW_drawdata_get(id, engine_type);
876  if (dd != NULL) {
877  return dd;
878  }
879 
880  DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
881 
882  /* Allocate new data. */
883  if ((GS(id->name) == ID_OB) && (((Object *)id)->base_flag & BASE_FROM_DUPLI) != 0) {
884  /* NOTE: data is not persistent in this case. It is reset each redraw. */
885  BLI_assert(free_cb == NULL); /* No callback allowed. */
886  /* Round to sizeof(float) for DRW_instance_data_request(). */
887  const size_t t = sizeof(float) - 1;
888  size = (size + t) & ~t;
889  size_t fsize = size / sizeof(float);
891  if (DST.object_instance_data[fsize] == NULL) {
893  }
895  memset(dd, 0, size);
896  }
897  else {
898  dd = MEM_callocN(size, "DrawData");
899  }
900  dd->engine_type = engine_type;
901  dd->free = free_cb;
902  /* Perform user-side initialization, if needed. */
903  if (init_cb != NULL) {
904  init_cb(dd);
905  }
906  /* Register in the list. */
907  BLI_addtail((ListBase *)drawdata, dd);
908  return dd;
909 }
910 
912 {
913  DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
914 
915  if (drawdata == NULL) {
916  return;
917  }
918 
919  LISTBASE_FOREACH (DrawData *, dd, drawdata) {
920  if (dd->free != NULL) {
921  dd->free(dd);
922  }
923  }
924 
925  BLI_freelistN((ListBase *)drawdata);
926 }
927 
928 /* Unlink (but don't free) the drawdata from the DrawDataList if the ID is an OB from dupli. */
930 {
931  if ((GS(id->name) == ID_OB) && (((Object *)id)->base_flag & BASE_FROM_DUPLI) != 0) {
932  DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
933 
934  if (drawdata == NULL) {
935  return;
936  }
937 
938  BLI_listbase_clear((ListBase *)drawdata);
939  }
940 }
941 
944 /* -------------------------------------------------------------------- */
949 {
950  Scene *scene;
951  ViewLayer *view_layer;
952  static int lasttime = 0;
953  int ctime = (int)PIL_check_seconds_timer();
954 
955  if (U.vbotimeout == 0 || (ctime - lasttime) < U.vbocollectrate || ctime == lasttime) {
956  return;
957  }
958 
959  lasttime = ctime;
960 
961  for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
962  for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
964  if (depsgraph == NULL) {
965  continue;
966  }
967 
968  /* TODO(fclem): This is not optimal since it iter over all dupli instances.
969  * In this case only the source object should be tagged. */
971  DRW_batch_cache_free_old(ob, ctime);
972  }
974  }
975  }
976 }
977 
980 /* -------------------------------------------------------------------- */
984 static void drw_engines_init(void)
985 {
987  PROFILE_START(stime);
988 
989  const DrawEngineDataSize *data_size = engine->vedata_size;
990  memset(data->psl->passes, 0, sizeof(*data->psl->passes) * data_size->psl_len);
991 
992  if (engine->engine_init) {
993  engine->engine_init(data);
994  }
995 
996  PROFILE_END_UPDATE(data->init_time, stime);
997  }
998 }
999 
1000 static void drw_engines_cache_init(void)
1001 {
1003  if (data->text_draw_cache) {
1004  DRW_text_cache_destroy(data->text_draw_cache);
1005  data->text_draw_cache = NULL;
1006  }
1007  if (DST.text_store_p == NULL) {
1008  DST.text_store_p = &data->text_draw_cache;
1009  }
1010 
1011  if (engine->cache_init) {
1012  engine->cache_init(data);
1013  }
1014  }
1015 }
1016 
1018 {
1019  if (scene->world == NULL) {
1020  return;
1021  }
1022 
1024  if (engine->id_update) {
1025  engine->id_update(data, &scene->world->id);
1026  }
1027  }
1028 }
1029 
1031 {
1032  DST.ob_handle = 0;
1033 
1034  /* HACK: DrawData is copied by COW from the duplicated object.
1035  * This is valid for IDs that cannot be instantiated but this
1036  * is not what we want in this case so we clear the pointer
1037  * ourselves here. */
1039 
1040  /* Validation for dupli objects happen elsewhere. */
1041  if (!DST.dupli_source) {
1043  }
1044 
1046  if (engine->id_update) {
1047  engine->id_update(data, &ob->id);
1048  }
1049 
1050  if (engine->cache_populate) {
1051  engine->cache_populate(data, ob);
1052  }
1053  }
1054 
1055  /* TODO: in the future it would be nice to generate once for all viewports.
1056  * But we need threaded DRW manager first. */
1057  if (!DST.dupli_source) {
1059  }
1060 
1061  /* ... and clearing it here too because this draw data is
1062  * from a mempool and must not be free individually by depsgraph. */
1064 }
1065 
1066 static void drw_engines_cache_finish(void)
1067 {
1069  if (engine->cache_finish) {
1070  engine->cache_finish(data);
1071  }
1072  }
1073 }
1074 
1075 static void drw_engines_draw_scene(void)
1076 {
1078  PROFILE_START(stime);
1079  if (engine->draw_scene) {
1080  DRW_stats_group_start(engine->idname);
1081  engine->draw_scene(data);
1082  /* Restore for next engine */
1083  if (DRW_state_is_fbo()) {
1085  }
1087  }
1088  PROFILE_END_UPDATE(data->render_time, stime);
1089  }
1090  /* Reset state after drawing */
1091  DRW_state_reset();
1092 }
1093 
1094 static void drw_engines_draw_text(void)
1095 {
1097  PROFILE_START(stime);
1098 
1099  if (data->text_draw_cache) {
1100  DRW_text_cache_draw(data->text_draw_cache, DST.draw_ctx.region, DST.draw_ctx.v3d);
1101  }
1102 
1103  PROFILE_END_UPDATE(data->render_time, stime);
1104  }
1105 }
1106 
1107 void DRW_draw_region_engine_info(int xoffset, int *yoffset, int line_height)
1108 {
1110  if (data->info[0] != '\0') {
1111  char *chr_current = data->info;
1112  char *chr_start = chr_current;
1113  int line_len = 0;
1114 
1115  const int font_id = BLF_default();
1116  UI_FontThemeColor(font_id, TH_TEXT_HI);
1117 
1118  BLF_enable(font_id, BLF_SHADOW);
1119  BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1120  BLF_shadow_offset(font_id, 1, -1);
1121 
1122  while (*chr_current++ != '\0') {
1123  line_len++;
1124  if (*chr_current == '\n') {
1125  char info[GPU_INFO_SIZE];
1126  BLI_strncpy(info, chr_start, line_len + 1);
1127  *yoffset -= line_height;
1128  BLF_draw_default(xoffset, *yoffset, 0.0f, info, sizeof(info));
1129 
1130  /* Re-start counting. */
1131  chr_start = chr_current + 1;
1132  line_len = -1;
1133  }
1134  }
1135 
1136  char info[GPU_INFO_SIZE];
1137  BLI_strncpy(info, chr_start, line_len + 1);
1138  *yoffset -= line_height;
1139  BLF_draw_default(xoffset, *yoffset, 0.0f, info, sizeof(info));
1140 
1141  BLF_disable(font_id, BLF_SHADOW);
1142  }
1143  }
1144 }
1145 
1146 static void use_drw_engine(DrawEngineType *engine)
1147 {
1149 }
1150 
1151 /* Gather all draw engines needed and store them in DST.view_data_active
1152  * That also define the rendering order of engines */
1153 static void drw_engines_enable_from_engine(const RenderEngineType *engine_type, eDrawType drawtype)
1154 {
1155  switch (drawtype) {
1156  case OB_WIRE:
1157  case OB_SOLID:
1159  break;
1160  case OB_MATERIAL:
1161  case OB_RENDER:
1162  default:
1163  if (engine_type->draw_engine != NULL) {
1164  use_drw_engine(engine_type->draw_engine);
1165  }
1166  else if ((engine_type->flag & RE_INTERNAL) == 0) {
1168  }
1169  break;
1170  }
1171 }
1172 
1174 {
1176 }
1180 static void drw_engines_enable_basic(void)
1181 {
1183 }
1184 
1186 {
1189  }
1190  else {
1192  }
1193 
1195 }
1196 
1198 {
1199  SpaceLink *space_data = DST.draw_ctx.space_data;
1200  if (!space_data) {
1201  return;
1202  }
1203 
1204  if (space_data->spacetype == SPACE_IMAGE) {
1206  }
1207  else if (space_data->spacetype == SPACE_NODE) {
1208  /* Only enable when drawing the space image backdrop. */
1209  SpaceNode *snode = (SpaceNode *)space_data;
1210  if ((snode->flag & SNODE_BACKDRAW) != 0) {
1213  }
1214  }
1215 }
1216 
1217 static void drw_engines_enable(ViewLayer *UNUSED(view_layer),
1218  RenderEngineType *engine_type,
1219  bool gpencil_engine_needed)
1220 {
1221  View3D *v3d = DST.draw_ctx.v3d;
1222  const eDrawType drawtype = v3d->shading.type;
1223  const bool use_xray = XRAY_ENABLED(v3d);
1224 
1225  drw_engines_enable_from_engine(engine_type, drawtype);
1226  if (gpencil_engine_needed && ((drawtype >= OB_SOLID) || !use_xray)) {
1228  }
1230 
1231 #ifdef WITH_DRAW_DEBUG
1232  if (G.debug_value == 31) {
1234  }
1235 #endif
1236 }
1237 
1238 static void drw_engines_disable(void)
1239 {
1241 }
1242 
1243 static void drw_engines_data_validate(void)
1244 {
1246 }
1247 
1248 /* Fast check to see if gpencil drawing engine is needed.
1249  * For slow exact check use `DRW_render_check_grease_pencil` */
1251 {
1252  const bool exclude_gpencil_rendering = v3d ? (v3d->object_type_exclude_viewport &
1253  (1 << OB_GPENCIL)) != 0 :
1254  false;
1255  return (!exclude_gpencil_rendering) && DEG_id_type_any_exists(depsgraph, ID_GD);
1256 }
1257 
1258 /* -------------------------------------------------------------------- */
1263 {
1264  RenderEngineType *engine_type = update_ctx->engine_type;
1265  ARegion *region = update_ctx->region;
1266  View3D *v3d = update_ctx->v3d;
1267  RegionView3D *rv3d = region->regiondata;
1268  Depsgraph *depsgraph = update_ctx->depsgraph;
1269  Scene *scene = update_ctx->scene;
1270  ViewLayer *view_layer = update_ctx->view_layer;
1271 
1272  GPUViewport *viewport = WM_draw_region_get_viewport(region);
1273  if (!viewport) {
1274  return;
1275  }
1276 
1277  const bool gpencil_engine_needed = drw_gpencil_engine_needed(depsgraph, v3d);
1278 
1279  if (G.is_rendering && U.experimental.use_draw_manager_acquire_lock) {
1280  return;
1281  }
1282 
1283  /* XXX Really nasty locking. But else this could
1284  * be executed by the material previews thread
1285  * while rendering a viewport. */
1287 
1288  /* Reset before using it. */
1290 
1292  .region = region,
1293  .rv3d = rv3d,
1294  .v3d = v3d,
1295  .scene = scene,
1296  .view_layer = view_layer,
1297  .obact = OBACT(view_layer),
1298  .engine_type = engine_type,
1299  .depsgraph = depsgraph,
1300  .object_mode = OB_MODE_OBJECT,
1301  };
1302 
1303  /* Custom lightweight initialize to avoid resetting the memory-pools. */
1304  DST.viewport = viewport;
1306 
1307  /* Separate update for each stereo view. */
1308  int view_count = GPU_viewport_is_stereo_get(viewport) ? 2 : 1;
1309  for (int view = 0; view < view_count; view++) {
1311 
1312  drw_engines_enable(view_layer, engine_type, gpencil_engine_needed);
1314 
1316  if (draw_engine->view_update) {
1317  draw_engine->view_update(data);
1318  }
1319  }
1320 
1322  }
1323 
1325 
1327 }
1328 
1329 /* update a viewport which belongs to a GPUOffscreen */
1331  RenderEngineType *engine_type,
1332  ARegion *region,
1333  View3D *v3d,
1334  GPUViewport *viewport)
1335 {
1336 
1337  if (viewport && GPU_viewport_do_update(viewport)) {
1338 
1341  RegionView3D *rv3d = region->regiondata;
1342 
1343  const bool gpencil_engine_needed = drw_gpencil_engine_needed(depsgraph, v3d);
1344 
1345  /* Reset before using it. */
1347 
1349  .region = region,
1350  .rv3d = rv3d,
1351  .v3d = v3d,
1352  .scene = scene,
1353  .view_layer = view_layer,
1354  .obact = OBACT(view_layer),
1355  .engine_type = engine_type,
1356  .depsgraph = depsgraph,
1357  };
1358 
1359  /* Custom lightweight initialize to avoid resetting the memory-pools. */
1360  DST.viewport = viewport;
1362 
1363  /* Separate update for each stereo view. */
1364  int view_count = GPU_viewport_is_stereo_get(viewport) ? 2 : 1;
1365  for (int view = 0; view < view_count; view++) {
1367 
1368  drw_engines_enable(view_layer, engine_type, gpencil_engine_needed);
1370 
1372  if (draw_engine->view_update) {
1373  draw_engine->view_update(data);
1374  }
1375  }
1376 
1378  }
1379 
1381  }
1382 }
1383 
1386 /* -------------------------------------------------------------------- */
1391 {
1392  RegionView3D *rv3d = DST.draw_ctx.rv3d;
1393 
1395  GPU_matrix_set(rv3d->viewmat);
1396 
1397  if (DST.draw_ctx.evil_C) {
1399  /* Callback can be nasty and do whatever they want with the state.
1400  * Don't trust them! */
1401  DRW_state_reset();
1402  }
1403 }
1404 
1406 {
1407  RegionView3D *rv3d = DST.draw_ctx.rv3d;
1408  ARegion *region = DST.draw_ctx.region;
1409  View3D *v3d = DST.draw_ctx.v3d;
1411 
1412  const bool do_annotations = drw_draw_show_annotation();
1413 
1414  if (DST.draw_ctx.evil_C) {
1416 
1417  DRW_state_reset();
1418 
1420 
1422  GPU_matrix_set(rv3d->viewmat);
1423 
1424  /* annotations - temporary drawing buffer (3d space) */
1425  /* XXX: Or should we use a proper draw/overlay engine for this case? */
1426  if (do_annotations) {
1428  /* XXX: as scene->gpd is not copied for COW yet */
1431  }
1432 
1433  drw_debug_draw();
1434 
1436  /* Apply state for callbacks. */
1437  GPU_apply_state();
1438 
1440 
1441 #ifdef WITH_XR_OPENXR
1442  /* XR callbacks (controllers, custom draw functions) for session mirror. */
1443  if ((v3d->flag & V3D_XR_SESSION_MIRROR) != 0) {
1444  if ((v3d->flag2 & V3D_XR_SHOW_CONTROLLERS) != 0) {
1446  if (art) {
1448  }
1449  }
1450  if ((v3d->flag2 & V3D_XR_SHOW_CUSTOM_OVERLAYS) != 0) {
1452  if (st) {
1454  if (art) {
1456  }
1457  }
1458  }
1459  }
1460 #endif
1461 
1462  /* Callback can be nasty and do whatever they want with the state.
1463  * Don't trust them! */
1464  DRW_state_reset();
1465 
1466  /* Needed so gizmo isn't occluded. */
1467  if ((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) {
1470  }
1471 
1474 
1476 
1477  /* annotations - temporary drawing buffer (screenspace) */
1478  /* XXX: Or should we use a proper draw/overlay engine for this case? */
1479  if (((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) && (do_annotations)) {
1481  /* XXX: as scene->gpd is not copied for COW yet */
1483  }
1484 
1485  if ((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) {
1486  /* Draw 2D after region info so we can draw on top of the camera passepartout overlay.
1487  * 'DRW_draw_region_info' sets the projection in pixel-space. */
1490  }
1491 
1492  if (G.debug_value > 20 && G.debug_value < 30) {
1494  /* local coordinate visible rect inside region, to accommodate overlapping ui */
1496  DRW_stats_draw(rect);
1497  }
1498 
1500  }
1501  else {
1502  if (v3d && ((v3d->flag2 & V3D_SHOW_ANNOTATION) != 0)) {
1504  /* XXX: as scene->gpd is not copied for COW yet */
1507  }
1508 
1509 #ifdef WITH_XR_OPENXR
1510  if ((v3d->flag & V3D_XR_SESSION_SURFACE) != 0) {
1512 
1513  DRW_state_reset();
1514 
1516 
1518  GPU_matrix_set(rv3d->viewmat);
1519 
1520  /* XR callbacks (controllers, custom draw functions) for session surface. */
1521  if (((v3d->flag2 & V3D_XR_SHOW_CONTROLLERS) != 0) ||
1522  ((v3d->flag2 & V3D_XR_SHOW_CUSTOM_OVERLAYS) != 0)) {
1524  GPU_apply_state();
1525 
1526  if ((v3d->flag2 & V3D_XR_SHOW_CONTROLLERS) != 0) {
1528  if (art) {
1530  }
1531  }
1532  if ((v3d->flag2 & V3D_XR_SHOW_CUSTOM_OVERLAYS) != 0) {
1534  if (st) {
1536  if (art) {
1538  }
1539  }
1540  }
1541 
1542  DRW_state_reset();
1543  }
1544 
1546  }
1547 #endif
1548  }
1549 }
1550 
1552 {
1554  if (*DST.text_store_p == NULL) {
1556  }
1557  return *DST.text_store_p;
1558 }
1559 
1562 /* -------------------------------------------------------------------- */
1567 {
1568  View3D *v3d = CTX_wm_view3d(C);
1569  if (v3d) {
1571  ARegion *region = CTX_wm_region(C);
1574  GPUViewport *viewport = WM_draw_region_get_bound_viewport(region);
1575 
1576  /* Reset before using it. */
1578  DST.options.draw_text = ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0 &&
1579  (v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) != 0);
1581  (v3d->shading.type != OB_RENDER);
1582  DRW_draw_render_loop_ex(depsgraph, engine_type, region, v3d, viewport, C);
1583  }
1584  else {
1586  ARegion *region = CTX_wm_region(C);
1587  GPUViewport *viewport = WM_draw_region_get_bound_viewport(region);
1589  DRW_draw_render_loop_2d_ex(depsgraph, region, viewport, C);
1590  }
1591 }
1592 
1594  RenderEngineType *engine_type,
1595  ARegion *region,
1596  View3D *v3d,
1597  GPUViewport *viewport,
1598  const bContext *evil_C)
1599 {
1600 
1603  RegionView3D *rv3d = region->regiondata;
1604 
1605  DST.draw_ctx.evil_C = evil_C;
1607  .region = region,
1608  .rv3d = rv3d,
1609  .v3d = v3d,
1610  .scene = scene,
1611  .view_layer = view_layer,
1612  .obact = OBACT(view_layer),
1613  .engine_type = engine_type,
1614  .depsgraph = depsgraph,
1615 
1616  /* reuse if caller sets */
1617  .evil_C = DST.draw_ctx.evil_C,
1618  };
1621 
1622  drw_manager_init(&DST, viewport, NULL);
1624 
1625  const int object_type_exclude_viewport = v3d->object_type_exclude_viewport;
1626  /* Check if scene needs to perform the populate loop */
1627  const bool internal_engine = (engine_type->flag & RE_INTERNAL) != 0;
1628  const bool draw_type_render = v3d->shading.type == OB_RENDER;
1629  const bool overlays_on = (v3d->flag2 & V3D_HIDE_OVERLAYS) == 0;
1630  const bool gpencil_engine_needed = drw_gpencil_engine_needed(depsgraph, v3d);
1631  const bool do_populate_loop = internal_engine || overlays_on || !draw_type_render ||
1632  gpencil_engine_needed;
1633 
1634  /* Get list of enabled engines */
1635  drw_engines_enable(view_layer, engine_type, gpencil_engine_needed);
1637 
1638  /* Update UBO's */
1640 
1641  drw_debug_init();
1645 
1646  /* No frame-buffer allowed before drawing. */
1648 
1649  /* Init engines */
1650  drw_engines_init();
1651 
1652  /* Cache filling */
1653  {
1654  PROFILE_START(stime);
1657 
1658  /* Only iterate over objects for internal engines or when overlays are enabled */
1659  if (do_populate_loop) {
1660  DST.dupli_origin = NULL;
1663  if ((object_type_exclude_viewport & (1 << ob->type)) != 0) {
1664  continue;
1665  }
1666  if (!BKE_object_is_visible_in_viewport(v3d, ob)) {
1667  continue;
1668  }
1669  DST.dupli_parent = data_.dupli_parent;
1670  DST.dupli_source = data_.dupli_object_current;
1671  drw_duplidata_load(ob);
1673  }
1675  }
1676 
1679 
1682 
1683 #ifdef USE_PROFILE
1684  double *cache_time = DRW_view_data_cache_time_get(DST.view_data_active);
1685  PROFILE_END_UPDATE(*cache_time, stime);
1686 #endif
1687  }
1688 
1689  DRW_stats_begin();
1690 
1692 
1693  /* Start Drawing */
1694  DRW_state_reset();
1695 
1697  GPU_framebuffer_clear_depth_stencil(DST.default_framebuffer, 1.0f, 0xFF);
1698 
1700 
1702 
1704 
1705  /* Fix 3D view "lagging" on APPLE and WIN32+NVIDIA. (See T56996, T61474) */
1707  GPU_flush();
1708  }
1709 
1711 
1712  DRW_stats_reset();
1713 
1715 
1716  if (WM_draw_region_get_bound_viewport(region)) {
1717  /* Don't unbind the frame-buffer yet in this case and let
1718  * GPU_viewport_unbind do it, so that we can still do further
1719  * drawing of action zones on top. */
1720  }
1721  else {
1723  }
1724 
1725  DRW_state_reset();
1727 
1729 }
1730 
1732  ARegion *region,
1733  View3D *v3d,
1734  GPUViewport *viewport)
1735 {
1736  /* Reset before using it. */
1738 
1741 
1742  DRW_draw_render_loop_ex(depsgraph, engine_type, region, v3d, viewport, NULL);
1743 }
1744 
1746  RenderEngineType *engine_type,
1747  ARegion *region,
1748  View3D *v3d,
1749  const bool is_image_render,
1750  const bool draw_background,
1751  const bool do_color_management,
1752  GPUOffScreen *ofs,
1753  GPUViewport *viewport)
1754 {
1755  const bool is_xr_surface = ((v3d->flag & V3D_XR_SESSION_SURFACE) != 0);
1756 
1757  /* Create temporary viewport if needed or update the existing viewport. */
1758  GPUViewport *render_viewport = viewport;
1759  if (viewport == NULL) {
1760  render_viewport = GPU_viewport_create();
1761  }
1762  else {
1763  drw_notify_view_update_offscreen(depsgraph, engine_type, region, v3d, render_viewport);
1764  }
1765 
1766  GPU_viewport_bind_from_offscreen(render_viewport, ofs, is_xr_surface);
1767 
1768  /* Just here to avoid an assert but shouldn't be required in practice. */
1770 
1771  /* Reset before using it. */
1773  DST.options.is_image_render = is_image_render;
1775  DRW_draw_render_loop_ex(depsgraph, engine_type, region, v3d, render_viewport, NULL);
1776 
1777  if (draw_background) {
1778  /* HACK(@fclem): In this case we need to make sure the final alpha is 1.
1779  * We use the blend mode to ensure that. A better way to fix that would
1780  * be to do that in the color-management shader. */
1781  GPU_offscreen_bind(ofs, false);
1782  GPU_clear_color(0.0f, 0.0f, 0.0f, 1.0f);
1783  /* Pre-multiply alpha over black background. */
1785  }
1786 
1789  const bool do_overlays = (v3d->flag2 & V3D_HIDE_OVERLAYS) == 0 ||
1790  (ELEM(v3d->shading.type, OB_WIRE, OB_SOLID)) ||
1791  (ELEM(v3d->shading.type, OB_MATERIAL) &&
1792  (v3d->shading.flag & V3D_SHADING_SCENE_WORLD) == 0) ||
1793  (ELEM(v3d->shading.type, OB_RENDER) &&
1795  GPU_viewport_unbind_from_offscreen(render_viewport, ofs, do_color_management, do_overlays);
1796 
1797  if (draw_background) {
1798  /* Reset default. */
1800  }
1801 
1802  /* Free temporary viewport. */
1803  if (viewport == NULL) {
1804  GPU_viewport_free(render_viewport);
1805  }
1806 }
1807 
1809 {
1811  return false;
1812  }
1813 
1815  if (ob->type == OB_GPENCIL) {
1817  return true;
1818  }
1819  }
1820  }
1822 
1823  return false;
1824 }
1825 
1827  struct RenderLayer *render_layer,
1828  const rcti *rect)
1829 {
1833  draw_engine_gpencil_type.render_to_image(gpdata, engine, render_layer, rect);
1834  }
1835 }
1836 
1838 {
1839  /* This function should only be called if there are grease pencil objects,
1840  * especially important to avoid failing in background renders without OpenGL context. */
1842 
1845  RenderEngineType *engine_type = engine->type;
1846  Render *render = engine->re;
1847 
1848  DRW_render_context_enable(render);
1849 
1850  /* Reset before using it. */
1852  DST.options.is_image_render = true;
1853  DST.options.is_scene_render = true;
1855  DST.buffer_finish_called = true;
1856 
1858  .scene = scene,
1859  .view_layer = view_layer,
1860  .engine_type = engine_type,
1861  .depsgraph = depsgraph,
1862  .object_mode = OB_MODE_OBJECT,
1863  };
1865 
1866  const int size[2] = {engine->resolution_x, engine->resolution_y};
1867 
1869 
1870  /* Main rendering. */
1871  rctf view_rect;
1872  rcti render_rect;
1873  RE_GetViewPlane(render, &view_rect, &render_rect);
1874  if (BLI_rcti_is_empty(&render_rect)) {
1875  BLI_rcti_init(&render_rect, 0, size[0], 0, size[1]);
1876  }
1877 
1878  RenderResult *render_result = RE_engine_get_result(engine);
1879  RenderLayer *render_layer = RE_GetRenderLayer(render_result, view_layer->name);
1880  for (RenderView *render_view = render_result->views.first; render_view != NULL;
1881  render_view = render_view->next) {
1882  RE_SetActiveRenderView(render, render_view->name);
1883  DRW_view_reset();
1884  DST.buffer_finish_called = false;
1885  DRW_render_gpencil_to_image(engine, render_layer, &render_rect);
1886  }
1887 
1888  DRW_state_reset();
1889 
1891 
1893 
1894  /* Restore Drawing area. */
1896 
1898 
1899  DST.buffer_finish_called = false;
1900 }
1901 
1902 /* Callback function for RE_engine_update_render_passes to ensure all
1903  * render passes are registered. */
1905  struct Scene *UNUSED(scene),
1906  struct ViewLayer *view_layer,
1907  const char *name,
1908  int channels,
1909  const char *chanid,
1911 {
1912  RenderEngine *engine = user_data;
1913  RE_engine_add_pass(engine, name, channels, chanid, view_layer->name);
1914 }
1915 
1917 {
1920  RenderEngineType *engine_type = engine->type;
1921  DrawEngineType *draw_engine_type = engine_type->draw_engine;
1922  Render *render = engine->re;
1923 
1924  /* IMPORTANT: We don't support immediate mode in render mode!
1925  * This shall remain in effect until immediate mode supports
1926  * multiple threads. */
1927 
1928  /* Reset before using it. */
1930  DST.options.is_image_render = true;
1931  DST.options.is_scene_render = true;
1934  .scene = scene,
1935  .view_layer = view_layer,
1936  .engine_type = engine_type,
1937  .depsgraph = depsgraph,
1938  .object_mode = OB_MODE_OBJECT,
1939  };
1941 
1942  /* Begin GPU workload Boundary */
1943  GPU_render_begin();
1944 
1945  const int size[2] = {engine->resolution_x, engine->resolution_y};
1946 
1948 
1950  draw_engine_type);
1951 
1952  /* Main rendering. */
1953  rctf view_rect;
1954  rcti render_rect;
1955  RE_GetViewPlane(render, &view_rect, &render_rect);
1956  if (BLI_rcti_is_empty(&render_rect)) {
1957  BLI_rcti_init(&render_rect, 0, size[0], 0, size[1]);
1958  }
1959 
1960  /* Reset state before drawing */
1961  DRW_state_reset();
1962 
1963  /* set default viewport */
1964  GPU_viewport(0, 0, size[0], size[1]);
1965 
1966  /* Update the render passes. This needs to be done before acquiring the render result. */
1968  engine, scene, view_layer, draw_render_result_ensure_pass_cb, engine);
1969 
1970  /* Init render result. */
1971  RenderResult *render_result = RE_engine_begin_result(engine,
1972  0,
1973  0,
1974  size[0],
1975  size[1],
1976  view_layer->name,
1977  /* RR_ALL_VIEWS */ NULL);
1978  RenderLayer *render_layer = render_result->layers.first;
1979  for (RenderView *render_view = render_result->views.first; render_view != NULL;
1980  render_view = render_view->next) {
1981  RE_SetActiveRenderView(render, render_view->name);
1982  DRW_view_reset();
1983  engine_type->draw_engine->render_to_image(data, engine, render_layer, &render_rect);
1984  DST.buffer_finish_called = false;
1985  }
1986 
1987  RE_engine_end_result(engine, render_result, false, false, false);
1988 
1989  if (engine_type->draw_engine->store_metadata) {
1990  RenderResult *final_render_result = RE_engine_get_result(engine);
1991  engine_type->draw_engine->store_metadata(data, final_render_result);
1992  }
1993 
1995 
1997 
2000 
2001  /* Reset state after drawing */
2002  DRW_state_reset();
2003 
2004  /* End GPU workload Boundary */
2005  GPU_render_end();
2006 }
2007 
2009  void *vedata,
2010  RenderEngine *engine,
2011  struct Depsgraph *depsgraph,
2012  void (*callback)(void *vedata, Object *ob, RenderEngine *engine, struct Depsgraph *depsgraph))
2013 {
2014  const DRWContextState *draw_ctx = DRW_context_state_get();
2018 
2020  const int object_type_exclude_viewport = draw_ctx->v3d ?
2021  draw_ctx->v3d->object_type_exclude_viewport :
2022  0;
2023  DST.dupli_origin = NULL;
2026  if ((object_type_exclude_viewport & (1 << ob->type)) == 0) {
2027  DST.dupli_parent = data_.dupli_parent;
2028  DST.dupli_source = data_.dupli_object_current;
2029  DST.ob_handle = 0;
2030  drw_duplidata_load(ob);
2031 
2032  if (!DST.dupli_source) {
2034  }
2035  callback(vedata, ob, engine, depsgraph);
2036  if (!DST.dupli_source) {
2038  }
2039  }
2040  }
2042 
2045 }
2046 
2047 void DRW_custom_pipeline(DrawEngineType *draw_engine_type,
2048  struct Depsgraph *depsgraph,
2049  void (*callback)(void *vedata, void *user_data),
2050  void *user_data)
2051 {
2054 
2055  /* Reset before using it. */
2057  DST.options.is_image_render = true;
2058  DST.options.is_scene_render = true;
2059  DST.options.draw_background = false;
2060 
2062  .scene = scene,
2063  .view_layer = view_layer,
2064  .engine_type = NULL,
2065  .depsgraph = depsgraph,
2066  .object_mode = OB_MODE_OBJECT,
2067  };
2069 
2071 
2075 
2077  draw_engine_type);
2078 
2079  /* Execute the callback */
2081  DST.buffer_finish_called = false;
2082 
2084 
2086 
2087  /* The use of custom pipeline in other thread using the same
2088  * resources as the main thread (viewport) may lead to data
2089  * races and undefined behavior on certain drivers. Using
2090  * GPU_finish to sync seems to fix the issue. (see T62997) */
2092  if (type == GPU_BACKEND_OPENGL) {
2093  GPU_finish();
2094  }
2095 
2097 }
2098 
2100 {
2102 
2103  drw_manager_init(&DST, DST.viewport, (int[2]){UNPACK2(DST.size)});
2104 
2105  DST.buffer_finish_called = false;
2106 
2110 }
2111 
2113  ARegion *region,
2114  GPUViewport *viewport,
2115  const bContext *evil_C)
2116 {
2119 
2120  DST.draw_ctx.evil_C = evil_C;
2122  .region = region,
2123  .scene = scene,
2124  .view_layer = view_layer,
2125  .obact = OBACT(view_layer),
2126  .depsgraph = depsgraph,
2127  .space_data = CTX_wm_space_data(evil_C),
2128 
2129  /* reuse if caller sets */
2130  .evil_C = DST.draw_ctx.evil_C,
2131  };
2132 
2134  drw_manager_init(&DST, viewport, NULL);
2136 
2137  /* TODO(jbakker): Only populate when editor needs to draw object.
2138  * for the image editor this is when showing UV's. */
2139  const bool do_populate_loop = (DST.draw_ctx.space_data->spacetype == SPACE_IMAGE);
2140  const bool do_annotations = drw_draw_show_annotation();
2141  const bool do_draw_gizmos = (DST.draw_ctx.space_data->spacetype != SPACE_IMAGE);
2142 
2143  /* Get list of enabled engines */
2146 
2147  /* Update UBO's */
2149 
2150  drw_debug_init();
2151 
2152  /* No frame-buffer allowed before drawing. */
2155  GPU_framebuffer_clear_depth_stencil(DST.default_framebuffer, 1.0f, 0xFF);
2156 
2157  /* Init engines */
2158  drw_engines_init();
2160 
2161  /* Cache filling */
2162  {
2163  PROFILE_START(stime);
2165 
2166  /* Only iterate over objects when overlay uses object data. */
2167  if (do_populate_loop) {
2170  }
2172  }
2173 
2175 
2177 
2178 #ifdef USE_PROFILE
2179  double *cache_time = DRW_view_data_cache_time_get(DST.view_data_active);
2180  PROFILE_END_UPDATE(*cache_time, stime);
2181 #endif
2182  }
2184 
2185  DRW_stats_begin();
2186 
2188 
2189  /* Start Drawing */
2190  DRW_state_reset();
2191 
2192  if (DST.draw_ctx.evil_C) {
2194  }
2195 
2197 
2198  /* Fix 3D view being "laggy" on macos and win+nvidia. (See T56996, T61474) */
2200  GPU_flush();
2201  }
2202 
2203  if (DST.draw_ctx.evil_C) {
2205  DRW_state_reset();
2206 
2208 
2211  wmOrtho2(
2212  region->v2d.cur.xmin, region->v2d.cur.xmax, region->v2d.cur.ymin, region->v2d.cur.ymax);
2213  if (do_annotations) {
2215  }
2219  /* Callback can be nasty and do whatever they want with the state.
2220  * Don't trust them! */
2221  DRW_state_reset();
2222 
2225 
2226  if (do_annotations) {
2229  }
2230  }
2231 
2234 
2235  if (do_draw_gizmos) {
2238  }
2239 
2240  DRW_stats_reset();
2241 
2242  if (G.debug_value > 20 && G.debug_value < 30) {
2244  /* local coordinate visible rect inside region, to accommodate overlapping ui */
2246  DRW_stats_draw(rect);
2247  }
2248 
2250 
2251  if (WM_draw_region_get_bound_viewport(region)) {
2252  /* Don't unbind the frame-buffer yet in this case and let
2253  * GPU_viewport_unbind do it, so that we can still do further
2254  * drawing of action zones on top. */
2255  }
2256  else {
2258  }
2259 
2260  DRW_state_reset();
2262 
2264 }
2265 
2266 static struct DRWSelectBuffer {
2270 
2272 {
2275  }
2276 
2277  if ((g_select_buffer.texture_depth != NULL) &&
2282  }
2283 
2286  "select_depth", size[0], size[1], 1, GPU_DEPTH_COMPONENT24, NULL);
2287 
2290 
2292  }
2293 }
2294 
2296 {
2297  BLI_assert_msg(!DST.buffer_finish_called, "DRW_render_instance_buffer_finish called twice!");
2298  DST.buffer_finish_called = true;
2301 }
2302 
2303 void DRW_render_set_time(RenderEngine *engine, Depsgraph *depsgraph, int frame, float subframe)
2304 {
2305  RE_engine_frame_set(engine, frame, subframe);
2308 }
2309 
2311  ARegion *region,
2312  View3D *v3d,
2313  bool use_obedit_skip,
2314  bool draw_surface,
2315  bool UNUSED(use_nearest),
2316  const bool do_material_sub_selection,
2317  const rcti *rect,
2318  DRW_SelectPassFn select_pass_fn,
2319  void *select_pass_user_data,
2320  DRW_ObjectFilterFn object_filter_fn,
2321  void *object_filter_user_data)
2322 {
2326  Object *obact = OBACT(view_layer);
2327  Object *obedit = use_obedit_skip ? NULL : OBEDIT_FROM_OBACT(obact);
2328 #ifndef USE_GPU_SELECT
2329  UNUSED_VARS(scene, view_layer, v3d, region, rect);
2330 #else
2331  RegionView3D *rv3d = region->regiondata;
2332 
2333  /* Reset before using it. */
2335 
2336  bool use_obedit = false;
2337  /* obedit_ctx_mode is used for selecting the right draw engines */
2338  // eContextObjectMode obedit_ctx_mode;
2339  /* object_mode is used for filtering objects in the depsgraph */
2340  eObjectMode object_mode;
2341  int object_type = 0;
2342  if (obedit != NULL) {
2343  object_type = obedit->type;
2344  object_mode = obedit->mode;
2345  if (obedit->type == OB_MBALL) {
2346  use_obedit = true;
2347  // obedit_ctx_mode = CTX_MODE_EDIT_METABALL;
2348  }
2349  else if (obedit->type == OB_ARMATURE) {
2350  use_obedit = true;
2351  // obedit_ctx_mode = CTX_MODE_EDIT_ARMATURE;
2352  }
2353  }
2354  if (v3d->overlay.flag & V3D_OVERLAY_BONE_SELECT) {
2355  if (!(v3d->flag2 & V3D_HIDE_OVERLAYS)) {
2356  /* NOTE: don't use "BKE_object_pose_armature_get" here, it breaks selection. */
2357  Object *obpose = OBPOSE_FROM_OBACT(obact);
2358  if (obpose == NULL) {
2359  Object *obweight = OBWEIGHTPAINT_FROM_OBACT(obact);
2360  if (obweight) {
2361  /* Only use Armature pose selection, when connected armature is in pose mode. */
2362  Object *ob_armature = BKE_modifiers_is_deformed_by_armature(obweight);
2363  if (ob_armature && ob_armature->mode == OB_MODE_POSE) {
2364  obpose = ob_armature;
2365  }
2366  }
2367  }
2368 
2369  if (obpose) {
2370  use_obedit = true;
2371  object_type = obpose->type;
2372  object_mode = obpose->mode;
2373  // obedit_ctx_mode = CTX_MODE_POSE;
2374  }
2375  }
2376  }
2377 
2378  /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2380  .region = region,
2381  .rv3d = rv3d,
2382  .v3d = v3d,
2383  .scene = scene,
2384  .view_layer = view_layer,
2385  .obact = obact,
2386  .engine_type = engine_type,
2387  .depsgraph = depsgraph,
2388  };
2390 
2391  const int viewport_size[2] = {BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)};
2392  drw_manager_init(&DST, NULL, viewport_size);
2393 
2394  DST.options.is_select = true;
2395  DST.options.is_material_select = do_material_sub_selection;
2397  /* Get list of enabled engines */
2398  if (use_obedit) {
2400  }
2401  else if (!draw_surface) {
2402  /* grease pencil selection */
2405  }
2406 
2408  }
2409  else {
2410  /* Draw surface for occlusion. */
2412  /* grease pencil selection */
2415  }
2416 
2418  }
2420 
2421  /* Update UBO's */
2423 
2424  /* Init engines */
2425  drw_engines_init();
2429 
2430  {
2433 
2434  if (use_obedit) {
2435  FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, object_type, object_mode, ob_iter) {
2436  drw_engines_cache_populate(ob_iter);
2437  }
2439  }
2440  else {
2441  /* When selecting pose-bones in pose mode, check for visibility not select-ability
2442  * as pose-bones have their own selection restriction flag. */
2443  const bool use_pose_exception = (DST.draw_ctx.object_pose != NULL);
2444 
2445  const int object_type_exclude_select = (v3d->object_type_exclude_viewport |
2447  bool filter_exclude = false;
2448  DST.dupli_origin = NULL;
2451  if (!BKE_object_is_visible_in_viewport(v3d, ob)) {
2452  continue;
2453  }
2454 
2455  if (use_pose_exception && (ob->mode & OB_MODE_POSE)) {
2456  if ((ob->base_flag & BASE_VISIBLE_VIEWLAYER) == 0) {
2457  continue;
2458  }
2459  }
2460  else {
2461  if ((ob->base_flag & BASE_SELECTABLE) == 0) {
2462  continue;
2463  }
2464  }
2465 
2466  if ((object_type_exclude_select & (1 << ob->type)) == 0) {
2467  if (object_filter_fn != NULL) {
2468  if (ob->base_flag & BASE_FROM_DUPLI) {
2469  /* pass (use previous filter_exclude value) */
2470  }
2471  else {
2472  filter_exclude = (object_filter_fn(ob, object_filter_user_data) == false);
2473  }
2474  if (filter_exclude) {
2475  continue;
2476  }
2477  }
2478 
2479  DRW_select_load_id(ob->runtime.select_id);
2480  DST.dupli_parent = data_.dupli_parent;
2481  DST.dupli_source = data_.dupli_object_current;
2482  drw_duplidata_load(ob);
2484  }
2485  }
2487  }
2488 
2492 
2494  }
2495 
2496  /* Setup frame-buffer. */
2499  GPU_framebuffer_clear_depth(g_select_buffer.framebuffer_depth_only, 1.0f);
2500 
2501  /* Start Drawing */
2502  DRW_state_reset();
2504 
2506 
2507  /* Only 1-2 passes. */
2508  while (true) {
2509  if (!select_pass_fn(DRW_SELECT_PASS_PRE, select_pass_user_data)) {
2510  break;
2511  }
2513 
2515 
2516  DRW_state_lock(0);
2517 
2518  if (!select_pass_fn(DRW_SELECT_PASS_POST, select_pass_user_data)) {
2519  break;
2520  }
2521  }
2522 
2524 
2525  DRW_state_reset();
2527 
2529 
2531 
2532 #endif /* USE_GPU_SELECT */
2533 }
2534 
2539  ARegion *region,
2540  View3D *v3d,
2541  GPUViewport *viewport,
2542  const bool use_gpencil,
2543  const bool use_basic,
2544  const bool use_overlay)
2545 {
2549  RegionView3D *rv3d = region->regiondata;
2550 
2551  /* Reset before using it. */
2553 
2554  DST.options.is_depth = true;
2555 
2556  /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2558  .region = region,
2559  .rv3d = rv3d,
2560  .v3d = v3d,
2561  .scene = scene,
2562  .view_layer = view_layer,
2563  .obact = OBACT(view_layer),
2564  .engine_type = engine_type,
2565  .depsgraph = depsgraph,
2566  };
2568  drw_manager_init(&DST, viewport, NULL);
2569 
2570  if (use_gpencil) {
2572  }
2573  if (use_basic) {
2575  }
2576  if (use_overlay) {
2578  }
2579 
2581 
2582  /* Setup frame-buffer. */
2583  GPUTexture *depth_tx = GPU_viewport_depth_texture(viewport);
2584 
2585  GPUFrameBuffer *depth_fb = NULL;
2586  GPU_framebuffer_ensure_config(&depth_fb,
2587  {
2588  GPU_ATTACHMENT_TEXTURE(depth_tx),
2589  GPU_ATTACHMENT_NONE,
2590  });
2591 
2592  GPU_framebuffer_bind(depth_fb);
2593  GPU_framebuffer_clear_depth(depth_fb, 1.0f);
2594 
2595  /* Update UBO's */
2597 
2598  /* Init engines */
2599  drw_engines_init();
2603 
2604  {
2607 
2608  const int object_type_exclude_viewport = v3d->object_type_exclude_viewport;
2609  DST.dupli_origin = NULL;
2612  if ((object_type_exclude_viewport & (1 << ob->type)) != 0) {
2613  continue;
2614  }
2615  if (!BKE_object_is_visible_in_viewport(v3d, ob)) {
2616  continue;
2617  }
2618  DST.dupli_parent = data_.dupli_parent;
2619  DST.dupli_source = data_.dupli_object_current;
2620  drw_duplidata_load(ob);
2622  }
2624 
2627 
2630  }
2631 
2632  /* Start Drawing */
2633  DRW_state_reset();
2634 
2636 
2638 
2640 
2641  DRW_state_reset();
2642 
2643  /* TODO: Reading depth for operators should be done here. */
2644 
2646  GPU_framebuffer_free(depth_fb);
2647 
2649 
2651 }
2652 
2653 void DRW_draw_select_id(Depsgraph *depsgraph, ARegion *region, View3D *v3d, const rcti *rect)
2654 {
2656  GPUViewport *viewport = WM_draw_region_get_viewport(region);
2657  if (!viewport) {
2658  /* Selection engine requires a viewport.
2659  * TODO(germano): This should be done internally in the engine. */
2660  sel_ctx->is_dirty = true;
2661  sel_ctx->objects_drawn_len = 0;
2662  sel_ctx->index_drawn_len = 1;
2663  return;
2664  }
2665 
2668 
2669  /* Reset before using it. */
2671 
2672  /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2674  .region = region,
2675  .rv3d = region->regiondata,
2676  .v3d = v3d,
2677  .scene = scene,
2678  .view_layer = view_layer,
2679  .obact = OBACT(view_layer),
2680  .depsgraph = depsgraph,
2681  };
2684 
2685  drw_manager_init(&DST, viewport, NULL);
2686 
2687  /* Update UBO's */
2690 
2691  /* Init Select Engine */
2692  sel_ctx->last_rect = *rect;
2693 
2695  drw_engines_init();
2696  {
2698 
2699  Object **obj = &sel_ctx->objects[0];
2700  for (uint remaining = sel_ctx->objects_len; remaining--; obj++) {
2701  Object *obj_eval = DEG_get_evaluated_object(depsgraph, *obj);
2702  drw_engines_cache_populate(obj_eval);
2703  }
2704 
2706 
2708 #if 0 /* This is a workaround to a nasty bug that seems to be a nasty driver bug. (See T69377) */
2710 #else
2711  DST.buffer_finish_called = true;
2712  // DRW_instance_buffer_finish(DST.vmempool->idatalist);
2714 #endif
2715  }
2716 
2717  /* Start Drawing */
2718  DRW_state_reset();
2720  DRW_state_reset();
2721 
2723 
2725 }
2726 
2728  Scene *scene, ARegion *region, View3D *v3d, GPUViewport *viewport, Object *object)
2729 {
2730  RegionView3D *rv3d = region->regiondata;
2731 
2733  GPU_matrix_set(rv3d->viewmat);
2734  GPU_matrix_mul(object->obmat);
2735 
2736  /* Setup frame-buffer. */
2737  GPUTexture *depth_tx = GPU_viewport_depth_texture(viewport);
2738 
2739  GPUFrameBuffer *depth_fb = NULL;
2740  GPU_framebuffer_ensure_config(&depth_fb,
2741  {
2742  GPU_ATTACHMENT_TEXTURE(depth_tx),
2743  GPU_ATTACHMENT_NONE,
2744  });
2745 
2746  GPU_framebuffer_bind(depth_fb);
2747  GPU_framebuffer_clear_depth(depth_fb, 1.0f);
2749 
2750  struct GPUClipPlanes planes;
2751  const bool use_clipping_planes = RV3D_CLIPPING_ENABLED(v3d, rv3d);
2752  if (use_clipping_planes) {
2753  GPU_clip_distances(6);
2754  ED_view3d_clipping_local(rv3d, object->obmat);
2755  for (int i = 0; i < 6; i++) {
2756  copy_v4_v4(planes.world[i], rv3d->clip_local[i]);
2757  }
2758  copy_m4_m4(planes.ModelMatrix, object->obmat);
2759  }
2760 
2761  drw_batch_cache_validate(object);
2762 
2763  switch (object->type) {
2764  case OB_MESH: {
2765  GPUBatch *batch;
2766 
2767  Mesh *me = object->data;
2768 
2769  if (object->mode & OB_MODE_EDIT) {
2771  }
2772  else {
2774  }
2775  struct TaskGraph *task_graph = BLI_task_graph_create();
2776  DRW_mesh_batch_cache_create_requested(task_graph, object, me, scene, false, true);
2777  BLI_task_graph_work_and_wait(task_graph);
2778  BLI_task_graph_free(task_graph);
2779 
2780  const eGPUShaderConfig sh_cfg = use_clipping_planes ? GPU_SHADER_CFG_CLIPPED :
2783 
2784  GPUUniformBuf *ubo = NULL;
2785  if (use_clipping_planes) {
2786  ubo = GPU_uniformbuf_create_ex(sizeof(struct GPUClipPlanes), &planes, __func__);
2787  GPU_batch_uniformbuf_bind(batch, "clipPlanes", ubo);
2788  }
2789 
2791  GPU_uniformbuf_free(ubo);
2792 
2793  } break;
2794  case OB_CURVES_LEGACY:
2795  case OB_SURF:
2796  break;
2797  }
2798 
2799  if (RV3D_CLIPPING_ENABLED(v3d, rv3d)) {
2800  GPU_clip_distances(0);
2801  }
2802 
2803  GPU_matrix_set(rv3d->viewmat);
2806 
2807  GPU_framebuffer_free(depth_fb);
2808 }
2809 
2812 /* -------------------------------------------------------------------- */
2817 {
2820 }
2821 
2823 {
2824  return DST.options.is_select;
2825 }
2826 
2828 {
2830 }
2831 
2833 {
2834  return DST.options.is_depth;
2835 }
2836 
2838 {
2839  return DST.options.is_image_render;
2840 }
2841 
2843 {
2845  return DST.options.is_scene_render;
2846 }
2847 
2849 {
2851 }
2852 
2854 {
2855  if (DST.draw_ctx.evil_C != NULL) {
2857  return ED_screen_animation_playing(wm) != NULL;
2858  }
2859  return false;
2860 }
2861 
2863 {
2864  const RegionView3D *rv3d = DST.draw_ctx.rv3d;
2865  return (rv3d) && (rv3d->rflag & (RV3D_NAVIGATING | RV3D_PAINTING));
2866 }
2867 
2869 {
2870  return (DST.options.is_select) == 0 && (DST.options.is_depth) == 0 &&
2871  (DST.options.is_scene_render) == 0 && (DST.options.draw_text) == 0;
2872 }
2873 
2875 {
2876  View3D *v3d = DST.draw_ctx.v3d;
2877  return (DRW_state_is_scene_render() == false) && (v3d != NULL) &&
2878  ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0);
2879 }
2880 
2882 {
2883  return DST.options.draw_background;
2884 }
2885 
2888 /* -------------------------------------------------------------------- */
2893 {
2894  return &DST.draw_ctx;
2895 }
2896 
2899 /* -------------------------------------------------------------------- */
2904 {
2905  return draw_engine_type->render_to_image;
2906 }
2907 
2908 void DRW_engine_register(DrawEngineType *draw_engine_type)
2909 {
2910  DRWRegisteredDrawEngine *draw_engine = MEM_mallocN(sizeof(DRWRegisteredDrawEngine), __func__);
2911  draw_engine->draw_engine = draw_engine_type;
2912  draw_engine->index = g_registered_engines.len;
2913 
2914  BLI_addtail(&g_registered_engines.engines, draw_engine);
2916 }
2917 
2919 {
2920  if (U.experimental.enable_eevee_next) {
2922  }
2923 }
2924 
2926 {
2929 
2931 
2935 #ifdef WITH_DRAW_DEBUG
2937 #endif
2938 
2941 
2942  /* setup callbacks */
2943  {
2946 
2949 
2952 
2955 
2958 
2961 
2964 
2967 
2970 
2972  }
2973 }
2974 
2976 {
2978  for (DRWRegisteredDrawEngine *type = g_registered_engines.engines.first; type; type = next) {
2979  next = type->next;
2981 
2982  if (type->draw_engine->engine_free) {
2983  type->draw_engine->engine_free();
2984  }
2985  MEM_freeN(type);
2986  }
2987 
2989  g_registered_engines.len = 0;
2990 }
2991 
2993 {
2995 
2996  if (DST.gl_context == NULL) {
2997  /* Nothing has been setup. Nothing to clear.
2998  * Otherwise, DRW_opengl_context_enable can
2999  * create a context in background mode. (see T62355) */
3000  return;
3001  }
3002 
3004 
3006  GPU_FRAMEBUFFER_FREE_SAFE(g_select_buffer.framebuffer_depth_only);
3007 
3008  DRW_shaders_free();
3009  DRW_curves_free();
3010  DRW_volume_free();
3012  DRW_stats_free();
3013  DRW_globals_free();
3014 
3019 
3020  if (DST.draw_list) {
3022  }
3023 
3025 }
3026 
3028 {
3029  if (G.background && DST.gl_context == NULL) {
3030  WM_init_opengl();
3031  }
3032 
3036  return;
3037  }
3038 
3039  void *re_gl_context = RE_gl_context_get(render);
3040 
3041  /* Changing Context */
3042  if (re_gl_context != NULL) {
3043  DRW_opengl_render_context_enable(re_gl_context);
3044  /* We need to query gpu context after a gl context has been bound. */
3045  void *re_gpu_context = NULL;
3046  re_gpu_context = RE_gpu_context_get(render);
3047  DRW_gpu_render_context_enable(re_gpu_context);
3048  }
3049  else {
3051  }
3052 }
3053 
3055 {
3059  return;
3060  }
3061 
3062  void *re_gl_context = RE_gl_context_get(render);
3063 
3064  if (re_gl_context != NULL) {
3065  void *re_gpu_context = NULL;
3066  re_gpu_context = RE_gpu_context_get(render);
3067  DRW_gpu_render_context_disable(re_gpu_context);
3068  DRW_opengl_render_context_disable(re_gl_context);
3069  }
3070  else {
3072  }
3073 }
3074 
3077 /* -------------------------------------------------------------------- */
3082 {
3083  BLI_assert(DST.gl_context == NULL); /* Ensure it's called once */
3084 
3086  /* This changes the active context. */
3089  /* Be sure to create gpu_context too. */
3091  /* So we activate the window's one afterwards. */
3093 }
3094 
3096 {
3098  if (DST.gl_context != NULL) {
3104  }
3105 }
3106 
3108 {
3109  if (DST.gl_context != NULL) {
3110  /* IMPORTANT: We don't support immediate mode in render mode!
3111  * This shall remain in effect until immediate mode supports
3112  * multiple threads. */
3114  GPU_render_begin();
3117  }
3118 }
3119 
3121 {
3122  if (DST.gl_context != NULL) {
3123 #ifdef __APPLE__
3124  /* Need to flush before disabling draw context, otherwise it does not
3125  * always finish drawing and viewport can be empty or partially drawn */
3127  GPU_flush();
3128  }
3129 #endif
3130 
3131  if (BLI_thread_is_main() && restore) {
3133  }
3134  else {
3137  }
3138 
3139  /* Render boundaries are opened and closed here as this may be
3140  * called outside of an existing render loop. */
3141  GPU_render_end();
3142 
3144  }
3145 }
3146 
3148 {
3149  /* TODO: should be replace by a more elegant alternative. */
3150 
3151  if (G.background && DST.gl_context == NULL) {
3152  WM_init_opengl();
3153  }
3155 }
3156 
3158 {
3160 }
3161 
3162 void DRW_opengl_render_context_enable(void *re_gl_context)
3163 {
3164  /* If thread is main you should use DRW_opengl_context_enable(). */
3166 
3167  /* TODO: get rid of the blocking. Only here because of the static global DST. */
3169  WM_opengl_context_activate(re_gl_context);
3170 }
3171 
3172 void DRW_opengl_render_context_disable(void *re_gl_context)
3173 {
3174  WM_opengl_context_release(re_gl_context);
3175  /* TODO: get rid of the blocking. */
3177 }
3178 
3179 void DRW_gpu_render_context_enable(void *re_gpu_context)
3180 {
3181  /* If thread is main you should use DRW_opengl_context_enable(). */
3183 
3184  GPU_context_active_set(re_gpu_context);
3185 }
3186 
3187 void DRW_gpu_render_context_disable(void *UNUSED(re_gpu_context))
3188 {
3189  GPU_flush();
3191 }
3192 
3195 #ifdef WITH_XR_OPENXR
3196 
3197 /* XXX
3198  * There should really be no such getter, but for VR we currently can't easily avoid it. OpenXR
3199  * needs some low level info for the OpenGL context that will be used for submitting the
3200  * final framebuffer. VR could in theory create its own context, but that would mean we have to
3201  * switch to it just to submit the final frame, which has notable performance impact.
3202  *
3203  * We could "inject" a context through DRW_opengl_render_context_enable(), but that would have to
3204  * work from the main thread, which is tricky to get working too. The preferable solution would
3205  * be using a separate thread for VR drawing where a single context can stay active. */
3206 void *DRW_xr_opengl_context_get(void)
3207 {
3208  return DST.gl_context;
3209 }
3210 
3211 /* XXX See comment on DRW_xr_opengl_context_get(). */
3212 void *DRW_xr_gpu_context_get(void)
3213 {
3214  return DST.gpu_context;
3215 }
3216 
3217 /* XXX See comment on DRW_xr_opengl_context_get(). */
3218 void DRW_xr_drawing_begin(void)
3219 {
3221 }
3222 
3223 /* XXX See comment on DRW_xr_opengl_context_get(). */
3224 void DRW_xr_drawing_end(void)
3225 {
3227 }
3228 
3229 #endif
3230 
3233 /* -------------------------------------------------------------------- */
3237 #ifdef WITH_OPENGL_DRAW_TESTS
3238 
3239 void DRW_draw_state_init_gtests(eGPUShaderConfig sh_cfg)
3240 {
3241  DST.draw_ctx.sh_cfg = sh_cfg;
3242 }
3243 
3244 #endif
3245 
3248 /* -------------------------------------------------------------------- */
3277 {
3278  if (!BLI_thread_is_main()) {
3279  return false;
3280  }
3281 
3283  /* Context release is requested from the outside of the draw manager main draw loop, indicate
3284  * this to the `DRW_opengl_context_activate()` so that it restores drawable of the window. */
3285  return false;
3286  }
3287 
3290 
3291  return true;
3292 }
3293 
3294 void DRW_opengl_context_activate(bool drw_state)
3295 {
3296  if (!BLI_thread_is_main()) {
3297  return;
3298  }
3299 
3300  if (drw_state) {
3303  }
3304  else {
3306  }
3307 }
3308 
typedef float(TangentPoint)[2]
struct wmWindowManager * CTX_wm_manager(const bContext *C)
Definition: context.c:713
struct View3D * CTX_wm_view3d(const bContext *C)
Definition: context.c:784
struct Depsgraph * CTX_data_expect_evaluated_depsgraph(const bContext *C)
Definition: context.c:1519
struct SpaceLink * CTX_wm_space_data(const bContext *C)
Definition: context.c:743
struct ARegion * CTX_wm_region(const bContext *C)
Definition: context.c:749
void(* BKE_curve_batch_cache_free_cb)(struct Curve *cu)
Definition: curve.cc:5522
void(* BKE_curve_batch_cache_dirty_tag_cb)(struct Curve *cu, int mode)
Definition: curve.cc:5521
Low-level operations for curves that cannot be defined in the C++ header yet.
void(* BKE_curves_batch_cache_dirty_tag_cb)(struct Curves *curves, int mode)
Definition: curves.cc:348
void(* BKE_curves_batch_cache_free_cb)(struct Curves *curves)
Definition: curves.cc:349
void(* BKE_gpencil_batch_cache_dirty_tag_cb)(struct bGPdata *gpd)
Definition: gpencil.c:332
void(* BKE_gpencil_batch_cache_free_cb)(struct bGPdata *gpd)
Definition: gpencil.c:333
void(* BKE_lattice_batch_cache_free_cb)(struct Lattice *lt)
Definition: lattice.c:782
void(* BKE_lattice_batch_cache_dirty_tag_cb)(struct Lattice *lt, int mode)
Definition: lattice.c:781
#define FOREACH_OBJECT_IN_MODE_END
Definition: BKE_layer.h:384
bool BKE_object_is_visible_in_viewport(const struct View3D *v3d, const struct Object *ob)
#define FOREACH_OBJECT_IN_MODE_BEGIN(_view_layer, _v3d, _object_type, _object_mode, _instance)
Definition: BKE_layer.h:380
void(* BKE_mball_batch_cache_dirty_tag_cb)(struct MetaBall *mb, int mode)
Definition: mball.c:740
void(* BKE_mball_batch_cache_free_cb)(struct MetaBall *mb)
Definition: mball.c:741
void(* BKE_mesh_batch_cache_dirty_tag_cb)(struct Mesh *me, eMeshBatchDirtyMode mode)
void(* BKE_mesh_batch_cache_free_cb)(struct Mesh *me)
struct Object * BKE_modifiers_is_deformed_by_armature(struct Object *ob)
General operations, lookup, etc. for blender objects.
struct Object * BKE_object_pose_armature_get(struct Object *ob)
Definition: object.cc:2511
@ OB_VISIBLE_SELF
Definition: BKE_object.h:150
void BKE_object_replace_data_on_shallow_copy(struct Object *ob, struct ID *new_data)
Definition: object.cc:5590
int BKE_object_visibility(const struct Object *ob, int dag_eval_mode)
bool BKE_object_is_in_editmode(const struct Object *ob)
bool psys_check_enabled(struct Object *ob, struct ParticleSystem *psys, bool use_render_params)
Definition: particle.c:801
void(* BKE_particle_batch_cache_dirty_tag_cb)(struct ParticleSystem *psys, int mode)
Definition: particle.c:5271
bool psys_in_edit_mode(struct Depsgraph *depsgraph, const struct ParticleSystem *psys)
void(* BKE_particle_batch_cache_free_cb)(struct ParticleSystem *psys)
Definition: particle.c:5272
A BVH for high poly meshes.
General operations for point clouds.
void(* BKE_pointcloud_batch_cache_free_cb)(struct PointCloud *pointcloud)
Definition: pointcloud.cc:434
void(* BKE_pointcloud_batch_cache_dirty_tag_cb)(struct PointCloud *pointcloud, int mode)
Definition: pointcloud.cc:433
struct Depsgraph * BKE_scene_get_depsgraph(const struct Scene *scene, const struct ViewLayer *view_layer)
struct SpaceType * BKE_spacetype_from_id(int spaceid)
Definition: screen.c:353
struct ARegionType * BKE_regiontype_from_id(const struct SpaceType *st, int regionid)
void(* BKE_subsurf_modifier_free_gpu_cache_cb)(struct Subdiv *subdiv)
Volume data-block.
void(* BKE_volume_batch_cache_dirty_tag_cb)(struct Volume *volume, int mode)
Definition: volume.cc:1212
void(* BKE_volume_batch_cache_free_cb)(struct Volume *volume)
Definition: volume.cc:1213
@ BLF_SHADOW
Definition: BLF_api.h:336
int BLF_default(void)
Definition: blf_default.c:44
void BLF_shadow_offset(int fontid, int x, int y)
Definition: blf.c:806
void BLF_shadow(int fontid, int level, const float rgba[4]) ATTR_NONNULL(3)
Definition: blf.c:796
void BLF_disable(int fontid, int option)
Definition: blf.c:279
void BLF_enable(int fontid, int option)
Definition: blf.c:270
void BLF_draw_default(float x, float y, float z, const char *str, size_t str_len) ATTR_NONNULL()
Definition: blf_default.c:59
#define BLI_assert(a)
Definition: BLI_assert.h:46
#define BLI_assert_msg(a, msg)
Definition: BLI_assert.h:53
unsigned int BLI_ghashutil_ptrhash(const void *key)
GSet * BLI_gset_ptr_new(const char *info)
GHash * BLI_ghash_new(GHashHashFP hashfp, GHashCmpFP cmpfp, const char *info) ATTR_MALLOC ATTR_WARN_UNUSED_RESULT
Definition: BLI_ghash.c:689
void BLI_ghash_free(GHash *gh, GHashKeyFreeFP keyfreefp, GHashValFreeFP valfreefp)
Definition: BLI_ghash.c:863
void BLI_gset_free(GSet *gs, GSetKeyFreeFP keyfreefp)
Definition: BLI_ghash.c:1037
bool BLI_ghash_ensure_p(GHash *gh, void *key, void ***r_val) ATTR_WARN_UNUSED_RESULT
Definition: BLI_ghash.c:755
#define LISTBASE_FOREACH(type, var, list)
Definition: BLI_listbase.h:336
BLI_INLINE void BLI_listbase_clear(struct ListBase *lb)
Definition: BLI_listbase.h:273
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
void BLI_remlink(struct ListBase *listbase, void *vlink) ATTR_NONNULL(1)
Definition: listbase.c:100
int BLI_listbase_count(const struct ListBase *listbase) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
void unit_m4(float m[4][4])
Definition: rct.c:1090
void copy_m4_m4(float m1[4][4], const float m2[4][4])
Definition: math_matrix.c:77
MINLINE void copy_v4_v4(float r[4], const float a[4])
MINLINE float normalize_v3_v3(float r[3], const float a[3])
MINLINE void copy_v3_fl(float r[3], float f)
MINLINE void zero_v3(float r[3])
void BLI_memblock_destroy(BLI_memblock *mblk, MemblockValFreeFP free_callback) ATTR_NONNULL(1)
Definition: BLI_memblock.c:66
#define BLI_memblock_create(elem_size)
Definition: BLI_memblock.h:32
void BLI_memblock_iternew(BLI_memblock *mblk, BLI_memblock_iter *iter) ATTR_NONNULL()
Definition: BLI_memblock.c:145
BLI_memblock * BLI_memblock_create_ex(uint elem_size, uint chunk_size) ATTR_WARN_UNUSED_RESULT
Definition: BLI_memblock.c:47
void * BLI_memblock_iterstep(BLI_memblock_iter *iter) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL()
Definition: BLI_memblock.c:157
void * BLI_memblock_alloc(BLI_memblock *mblk) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition: BLI_memblock.c:115
void BLI_memblock_clear(BLI_memblock *mblk, MemblockValFreeFP free_callback) ATTR_NONNULL(1)
Definition: BLI_memblock.c:86
BLI_INLINE int BLI_rcti_size_y(const struct rcti *rct)
Definition: BLI_rect.h:190
void BLI_rcti_init(struct rcti *rect, int xmin, int xmax, int ymin, int ymax)
Definition: rct.c:417
void BLI_rctf_transform_calc_m4_pivot_min(const rctf *dst, const rctf *src, float matrix[4][4])
Definition: rct.c:554
BLI_INLINE int BLI_rcti_size_x(const struct rcti *rct)
Definition: BLI_rect.h:186
bool BLI_rcti_is_empty(const struct rcti *rect)
char * BLI_strncpy(char *__restrict dst, const char *__restrict src, size_t maxncpy) ATTR_NONNULL()
Definition: string.c:64
unsigned int uint
Definition: BLI_sys_types.h:67
struct TaskGraph * BLI_task_graph_create(void)
Definition: task_graph.cc:98
void BLI_task_graph_free(struct TaskGraph *task_graph)
Definition: task_graph.cc:103
void BLI_task_graph_work_and_wait(struct TaskGraph *task_graph)
Definition: task_graph.cc:108
void BLI_ticket_mutex_unlock(TicketMutex *ticket)
Definition: threads.cc:562
void BLI_ticket_mutex_lock(TicketMutex *ticket)
Definition: threads.cc:548
void BLI_ticket_mutex_free(TicketMutex *ticket)
Definition: threads.cc:541
int BLI_thread_is_main(void)
Definition: threads.cc:207
TicketMutex * BLI_ticket_mutex_alloc(void)
Definition: threads.cc:530
#define UNUSED_VARS(...)
#define UNUSED(x)
#define ELEM(...)
struct Depsgraph Depsgraph
Definition: DEG_depsgraph.h:35
eEvaluationMode
Definition: DEG_depsgraph.h:44
@ DAG_EVAL_RENDER
Definition: DEG_depsgraph.h:46
@ DAG_EVAL_VIEWPORT
Definition: DEG_depsgraph.h:45
struct Scene * DEG_get_input_scene(const Depsgraph *graph)
bool DEG_id_type_any_exists(const struct Depsgraph *depsgraph, short id_type)
#define DEG_OBJECT_ITER_FOR_RENDER_ENGINE_BEGIN(graph_, instance_)
struct ViewLayer * DEG_get_evaluated_view_layer(const struct Depsgraph *graph)
#define DEG_OBJECT_ITER_FOR_RENDER_ENGINE_END
struct Object * DEG_get_evaluated_object(const struct Depsgraph *depsgraph, struct Object *object)
struct Scene * DEG_get_evaluated_scene(const struct Depsgraph *graph)
void(* DrawDataFreeCb)(struct DrawData *engine_data)
Definition: DNA_ID.h:30
void(* DrawDataInitCb)(struct DrawData *engine_data)
Definition: DNA_ID.h:29
@ ID_GD
Definition: DNA_ID_enums.h:71
@ ID_WO
Definition: DNA_ID_enums.h:59
@ ID_OB
Definition: DNA_ID_enums.h:47
@ BASE_FROM_DUPLI
@ BASE_SELECTABLE
@ BASE_VISIBLE_VIEWLAYER
@ BASE_VISIBLE_DEPSGRAPH
@ ME_EDIT_PAINT_FACE_SEL
eNodeSocketDatatype
eDrawType
@ OB_WIRE
@ OB_SOLID
@ OB_RENDER
@ OB_MATERIAL
#define OB_MODE_ALL_WEIGHT_PAINT
eObjectMode
@ OB_MODE_PARTICLE_EDIT
@ OB_MODE_EDIT
@ OB_MODE_WEIGHT_PAINT
@ OB_MODE_SCULPT
@ OB_MODE_POSE
@ OB_MODE_TEXTURE_PAINT
@ OB_MODE_OBJECT
@ OB_MODE_VERTEX_PAINT
@ OB_MBALL
@ OB_SURF
@ OB_ARMATURE
@ OB_MESH
@ OB_CURVES_LEGACY
@ OB_CURVES
@ OB_GPENCIL
#define PSYS_HAIR_DYNAMICS
@ PTCACHE_BAKED
#define OBPOSE_FROM_OBACT(ob)
#define OBEDIT_FROM_OBACT(ob)
#define PE_DRAW_PART
#define OBWEIGHTPAINT_FROM_OBACT(ob)
#define OBACT(_view_layer)
@ R_ADDSKY
@ RGN_TYPE_WINDOW
@ RGN_TYPE_XR
@ SI_SHOW_GPENCIL
@ SNODE_BACKDRAW
@ SPACE_NODE
@ SPACE_IMAGE
@ SPACE_VIEW3D
#define V3D_SHOW_ANNOTATION
@ V3D_OVERLAY_HIDE_TEXT
@ V3D_OVERLAY_BONE_SELECT
#define RV3D_LOCK_FLAGS(rv3d)
@ RV3D_BOXCLIP
#define RV3D_CLIPPING_ENABLED(v3d, rv3d)
@ V3D_SHADING_SCENE_WORLD_RENDER
@ V3D_SHADING_SCENE_WORLD
@ V3D_GIZMO_HIDE
#define V3D_XR_SESSION_MIRROR
@ V3D_OVERLAY_EDIT_OCCLUDE_WIRE
#define RV3D_PAINTING
#define V3D_XR_SHOW_CONTROLLERS
#define V3D_HIDE_OVERLAYS
#define V3D_XR_SESSION_SURFACE
#define V3D_XR_SHOW_CUSTOM_OVERLAYS
#define RV3D_NAVIGATING
void DRW_cache_free_old_subdiv(void)
void DRW_instance_data_list_free(struct DRWInstanceDataList *idatalist)
@ DRW_SELECT_PASS_POST
Definition: DRW_engine.h:62
@ DRW_SELECT_PASS_PRE
Definition: DRW_engine.h:61
bool(* DRW_ObjectFilterFn)(struct Object *ob, void *user_data)
Definition: DRW_engine.h:65
void DRW_uniform_attrs_pool_free(struct GHash *table)
bool(* DRW_SelectPassFn)(eDRWSelectStage stage, void *user_data)
Definition: DRW_engine.h:64
struct DRWInstanceDataList * DRW_instance_data_list_create(void)
@ DRW_STATE_WRITE_DEPTH
Definition: DRW_render.h:302
#define DRW_UBO_FREE_SAFE(ubo)
Definition: DRW_render.h:191
struct DRWPass DRWPass
Definition: DRW_render.h:78
#define DRW_STATE_DEPTH_TEST_ENABLED
Definition: DRW_render.h:359
struct DRWContextState DRWContextState
#define DRW_TEXTURE_FREE_SAFE(tex)
Definition: DRW_render.h:183
void ED_region_pixelspace(const struct ARegion *region)
bScreen * ED_screen_animation_playing(const struct wmWindowManager *wm)
const rcti * ED_region_visible_rect(ARegion *region)
Definition: area.c:3763
#define REGION_DRAW_POST_VIEW
Definition: ED_space_api.h:62
void ED_region_draw_cb_draw(const struct bContext *C, struct ARegion *region, int type)
void ED_region_surface_draw_cb_draw(struct ARegionType *art, int type)
Definition: spacetypes.c:270
#define REGION_DRAW_PRE_VIEW
Definition: ED_space_api.h:64
#define XRAY_ENABLED(v3d)
Definition: ED_view3d.h:1299
struct RenderEngineType * ED_view3d_engine_type(const struct Scene *scene, int drawtype)
void ED_view3d_clipping_local(struct RegionView3D *rv3d, const float mat[4][4])
Definition: view3d_edit.c:755
void ED_view3d_init_mats_rv3d(const struct Object *ob, struct RegionView3D *rv3d)
Definition: space_view3d.c:166
static AppView * view
GPUBatch
Definition: GPU_batch.h:78
void GPU_batch_program_set_builtin_with_config(GPUBatch *batch, eGPUBuiltinShader shader_id, eGPUShaderConfig sh_cfg)
Definition: gpu_batch.cc:279
#define GPU_batch_uniformbuf_bind(batch, name, ubo)
Definition: GPU_batch.h:159
void GPU_batch_draw(GPUBatch *batch)
Definition: gpu_batch.cc:223
bool GPU_use_main_context_workaround(void)
void GPU_context_main_lock(void)
Definition: gpu_context.cc:171
void GPU_render_begin(void)
Definition: gpu_context.cc:190
GPUContext * GPU_context_active_get(void)
Definition: gpu_context.cc:142
void GPU_context_discard(GPUContext *)
Definition: gpu_context.cc:110
GPUContext * GPU_context_create(void *ghost_window)
Definition: gpu_context.cc:93
eGPUBackendType GPU_backend_get_type(void)
Definition: gpu_context.cc:274
void GPU_context_active_set(GPUContext *)
Definition: gpu_context.cc:127
void GPU_context_main_unlock(void)
Definition: gpu_context.cc:176
void GPU_render_end(void)
Definition: gpu_context.cc:196
GPUDrawList * GPU_draw_list_create(int length)
Definition: gpu_drawlist.cc:18
void GPU_draw_list_discard(GPUDrawList *list)
Definition: gpu_drawlist.cc:24
GPUFrameBuffer * GPU_framebuffer_back_get(void)
struct GPUFrameBuffer GPUFrameBuffer
bool GPU_framebuffer_check_valid(GPUFrameBuffer *fb, char err_out[256])
void GPU_framebuffer_restore(void)
GPUFrameBuffer * GPU_framebuffer_active_get(void)
void GPU_framebuffer_free(GPUFrameBuffer *fb)
void GPU_framebuffer_bind(GPUFrameBuffer *fb)
GPUFrameBuffer * GPU_framebuffer_create(const char *name)
_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 type
_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 GLsizei GLsizei GLenum type _GL_VOID_RET _GL_VOID GLsizei GLenum GLenum const void *pixels _GL_VOID_RET _GL_VOID const void *pointer _GL_VOID_RET _GL_VOID GLdouble v _GL_VOID_RET _GL_VOID GLfloat v _GL_VOID_RET _GL_VOID GLint GLint i2 _GL_VOID_RET _GL_VOID GLint j _GL_VOID_RET _GL_VOID GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble GLdouble GLdouble zFar _GL_VOID_RET _GL_UINT GLdouble *equation _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLenum GLfloat *v _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLfloat *values _GL_VOID_RET _GL_VOID GLushort *values _GL_VOID_RET _GL_VOID GLenum GLfloat *params _GL_VOID_RET _GL_VOID GLenum GLdouble *params _GL_VOID_RET _GL_VOID GLenum GLint *params _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_BOOL GLfloat param _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLushort pattern _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLint GLdouble GLdouble GLint GLint const GLdouble *points _GL_VOID_RET _GL_VOID GLdouble GLdouble u2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLint GLdouble GLdouble v2 _GL_VOID_RET _GL_VOID GLenum GLfloat param _GL_VOID_RET _GL_VOID GLenum GLint param _GL_VOID_RET _GL_VOID GLenum mode _GL_VOID_RET _GL_VOID GLdouble GLdouble nz _GL_VOID_RET _GL_VOID GLfloat GLfloat nz _GL_VOID_RET _GL_VOID GLint GLint nz _GL_VOID_RET _GL_VOID GLshort GLshort nz _GL_VOID_RET _GL_VOID GLsizei const void *pointer _GL_VOID_RET _GL_VOID GLsizei const GLfloat *values _GL_VOID_RET _GL_VOID GLsizei const GLushort *values _GL_VOID_RET _GL_VOID GLint param _GL_VOID_RET _GL_VOID const GLuint const GLclampf *priorities _GL_VOID_RET _GL_VOID GLdouble y _GL_VOID_RET _GL_VOID GLfloat y _GL_VOID_RET _GL_VOID GLint y _GL_VOID_RET _GL_VOID GLshort y _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLfloat GLfloat z _GL_VOID_RET _GL_VOID GLint GLint z _GL_VOID_RET _GL_VOID GLshort GLshort z _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble w _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat w _GL_VOID_RET _GL_VOID GLint GLint GLint w _GL_VOID_RET _GL_VOID GLshort GLshort GLshort w _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble y2 _GL_VOID_RET _GL_VOID GLfloat GLfloat GLfloat y2 _GL_VOID_RET _GL_VOID GLint GLint GLint y2 _GL_VOID_RET _GL_VOID GLshort GLshort GLshort y2 _GL_VOID_RET _GL_VOID GLdouble GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLdouble GLdouble z _GL_VOID_RET _GL_VOID GLuint *buffer _GL_VOID_RET _GL_VOID GLdouble t _GL_VOID_RET _GL_VOID GLfloat t _GL_VOID_RET _GL_VOID GLint t _GL_VOID_RET _GL_VOID GLshort t _GL_VOID_RET _GL_VOID GLdouble t
void GPU_matrix_identity_projection_set(void)
Definition: gpu_matrix.cc:154
void GPU_matrix_pop_projection(void)
Definition: gpu_matrix.cc:140
#define GPU_matrix_set(x)
Definition: GPU_matrix.h:225
#define GPU_matrix_mul(x)
Definition: GPU_matrix.h:224
#define GPU_matrix_projection_set(x)
Definition: GPU_matrix.h:226
void GPU_matrix_identity_set(void)
Definition: gpu_matrix.cc:168
void GPU_matrix_push_projection(void)
Definition: gpu_matrix.cc:133
eGPUBackendType
Definition: GPU_platform.h:15
@ GPU_BACKEND_OPENGL
Definition: GPU_platform.h:17
@ GPU_DRIVER_ANY
Definition: GPU_platform.h:47
bool GPU_type_matches_ex(eGPUDeviceType device, eGPUOSType os, eGPUDriverType driver, eGPUBackendType backend)
@ GPU_OS_ANY
Definition: GPU_platform.h:40
@ GPU_OS_MAC
Definition: GPU_platform.h:38
@ GPU_DEVICE_ANY
Definition: GPU_platform.h:31
eGPUShaderConfig
Definition: GPU_shader.h:364
@ GPU_SHADER_CFG_DEFAULT
Definition: GPU_shader.h:365
@ GPU_SHADER_CFG_CLIPPED
Definition: GPU_shader.h:366
@ GPU_SHADER_3D_DEPTH_ONLY
Definition: GPU_shader.h:277
@ GPU_BLEND_NONE
Definition: GPU_state.h:60
@ GPU_BLEND_ALPHA_PREMULT
Definition: GPU_state.h:63
void GPU_blend(eGPUBlend blend)
Definition: gpu_state.cc:39
void GPU_apply_state(void)
Definition: gpu_state.cc:301
void GPU_flush(void)
Definition: gpu_state.cc:291
void GPU_finish(void)
Definition: gpu_state.cc:296
void GPU_viewport(int x, int y, int width, int height)
Definition: gpu_state.cc:191
@ GPU_DEPTH_LESS_EQUAL
Definition: GPU_state.h:86
@ GPU_DEPTH_NONE
Definition: GPU_state.h:83
void GPU_depth_test(eGPUDepthTest test)
Definition: gpu_state.cc:65
void GPU_clip_distances(int distances_enabled)
Definition: gpu_state.cc:121
int GPU_texture_height(const GPUTexture *tex)
Definition: gpu_texture.cc:607
struct GPUTexture GPUTexture
Definition: GPU_texture.h:17
int GPU_texture_width(const GPUTexture *tex)
Definition: gpu_texture.cc:602
void GPU_texture_free(GPUTexture *tex)
Definition: gpu_texture.cc:564
GPUTexture * GPU_texture_create_2d(const char *name, int w, int h, int mip_len, eGPUTextureFormat format, const float *data)
Definition: gpu_texture.cc:291
@ GPU_DEPTH_COMPONENT24
Definition: GPU_texture.h:166
struct GPUUniformBuf GPUUniformBuf
GPUUniformBuf * GPU_uniformbuf_create_ex(size_t size, const void *data, const char *name)
void GPU_uniformbuf_free(GPUUniformBuf *ubo)
GPUTexture * GPU_viewport_color_texture(GPUViewport *viewport, int view)
Definition: gpu_viewport.c:559
void GPU_viewport_bind_from_offscreen(GPUViewport *viewport, struct GPUOffScreen *ofs, bool is_xr_surface)
Definition: gpu_viewport.c:188
GPUViewport * GPU_viewport_create(void)
Definition: gpu_viewport.c:98
bool GPU_viewport_is_stereo_get(GPUViewport *viewport)
Definition: gpu_viewport.c:554
bool GPU_viewport_do_update(GPUViewport *viewport)
Definition: gpu_viewport.c:91
void GPU_viewport_unbind_from_offscreen(GPUViewport *viewport, struct GPUOffScreen *ofs, bool display_colorspace, bool do_overlay_merge)
Definition: gpu_viewport.c:508
int GPU_viewport_active_view_get(GPUViewport *viewport)
Definition: gpu_viewport.c:549
void GPU_viewport_free(GPUViewport *viewport)
Definition: gpu_viewport.c:585
struct DRWData ** GPU_viewport_data_get(GPUViewport *viewport)
Definition: gpu_viewport.c:114
void GPU_viewport_tag_update(GPUViewport *viewport)
Definition: gpu_viewport.c:86
GPUTexture * GPU_viewport_depth_texture(GPUViewport *viewport)
Definition: gpu_viewport.c:569
#define MEM_SAFE_FREE(v)
Group Output data from inside of a node group A color picker Mix two input colors RGB to Convert a color s luminance to a grayscale value Generate a normal vector and a dot product Bright Control the brightness and contrast of the input color Vector Map an input vectors to used to fine tune the interpolation of the input Camera Retrieve information about the camera and how it relates to the current shading point s position Clamp a value between a minimum and a maximum Vector Perform vector math operation Invert a producing a negative Combine Generate a color from its and blue channels(Deprecated)") DefNode(ShaderNode
#define RE_INTERNAL
Definition: RE_engine.h:43
#define C
Definition: RandGen.cpp:25
@ TH_TEXT_HI
Definition: UI_resources.h:43
void UI_FontThemeColor(int fontid, int colorid)
Definition: resources.c:1134
void UI_SetTheme(int spacetype, int regionid)
Definition: resources.c:1045
void ED_annotation_draw_view2d(const bContext *C, bool onlyv2d)
void ED_annotation_draw_view3d(Scene *scene, struct Depsgraph *depsgraph, View3D *v3d, ARegion *region, bool only3d)
DrawEngineType draw_engine_basic_type
Definition: basic_engine.c:254
return(oflags[bm->toolflag_index].f &oflag) !=0
static DBVT_INLINE btScalar size(const btDbvtVolume &a)
Definition: btDbvt.cpp:52
unsigned int U
Definition: btGjkEpa3.h:78
Scene scene
const Depsgraph * depsgraph
void * user_data
DEGForeachIDComponentCallback callback
SyclQueue void void size_t num_bytes void
void drw_batch_cache_generate_requested_evaluated_mesh_or_curve(Object *ob)
Definition: draw_cache.c:3362
void drw_batch_cache_generate_requested(Object *ob)
Definition: draw_cache.c:3329
void DRW_shape_cache_free(void)
Definition: draw_cache.c:153
void DRW_batch_cache_free_old(Object *ob, int ctime)
Definition: draw_cache.c:3397
void DRW_particle_batch_cache_free(struct ParticleSystem *psys)
void DRW_mesh_batch_cache_create_requested(struct TaskGraph *task_graph, struct Object *ob, struct Mesh *me, const struct Scene *scene, bool is_paint_mode, bool use_hide)
void DRW_curve_batch_cache_free(struct Curve *cu)
void DRW_lattice_batch_cache_free(struct Lattice *lt)
void DRW_gpencil_batch_cache_dirty_tag(struct bGPdata *gpd)
void DRW_lattice_batch_cache_dirty_tag(struct Lattice *lt, int mode)
void DRW_gpencil_batch_cache_free(struct bGPdata *gpd)
void DRW_volume_batch_cache_free(struct Volume *volume)
void DRW_particle_batch_cache_dirty_tag(struct ParticleSystem *psys, int mode)
void DRW_curves_batch_cache_dirty_tag(struct Curves *curves, int mode)
void DRW_mball_batch_cache_dirty_tag(struct MetaBall *mb, int mode)
void DRW_mesh_batch_cache_dirty_tag(struct Mesh *me, eMeshBatchDirtyMode mode)
void DRW_mball_batch_cache_free(struct MetaBall *mb)
void DRW_pointcloud_batch_cache_dirty_tag(struct PointCloud *pointcloud, int mode)
void DRW_volume_batch_cache_dirty_tag(struct Volume *volume, int mode)
void DRW_pointcloud_batch_cache_free(struct PointCloud *pointcloud)
void DRW_curves_batch_cache_free(struct Curves *curves)
struct GPUBatch * DRW_mesh_batch_cache_get_edit_triangles(struct Mesh *me)
void DRW_mesh_batch_cache_free(struct Mesh *me)
void DRW_curve_batch_cache_dirty_tag(struct Curve *cu, int mode)
struct GPUBatch * DRW_mesh_batch_cache_get_surface(struct Mesh *me)
void DRW_subdiv_cache_free(Subdiv *subdiv)
void DRW_viewport_colormanagement_set(GPUViewport *viewport)
void DRW_globals_update(void)
Definition: draw_common.c:39
struct DRW_Global G_draw
Definition: draw_common.c:32
void DRW_globals_free(void)
Definition: draw_common.c:251
void DRW_volume_free(void)
Definition: draw_volume.cc:83
void DRW_curves_init(struct DRWData *drw_data)
Definition: draw_curves.cc:98
void DRW_smoke_init(struct DRWData *drw_data)
Definition: draw_fluid.c:553
void DRW_volume_ubos_pool_free(void *pool)
Definition: draw_volume.cc:64
void DRW_curves_ubos_pool_free(struct CurvesUniformBufPool *pool)
Definition: draw_curves.cc:132
void DRW_curves_update(void)
Definition: draw_curves.cc:414
void DRW_smoke_exit(struct DRWData *drw_data)
Definition: draw_fluid.c:558
void DRW_volume_init(struct DRWData *drw_data)
Definition: draw_volume.cc:104
void DRW_curves_free(void)
Definition: draw_curves.cc:497
void drw_debug_draw(void)
Definition: draw_debug.c:187
void drw_debug_init(void)
Definition: draw_debug.c:193
void * DRW_instance_data_next(DRWInstanceData *idata)
void DRW_instance_data_list_free_unused(DRWInstanceDataList *idatalist)
DRWInstanceData * DRW_instance_data_request(DRWInstanceDataList *idatalist, uint attr_size)
GHash * DRW_uniform_attrs_pool_new()
void DRW_instance_buffer_finish(DRWInstanceDataList *idatalist)
void DRW_uniform_attrs_pool_clear_all(GHash *table)
void DRW_instance_data_list_reset(DRWInstanceDataList *idatalist)
void DRW_instance_data_list_resize(DRWInstanceDataList *idatalist)
#define MAX_INSTANCE_DATA_SIZE
void DRW_drawdata_free(ID *id)
Definition: draw_manager.c:911
const float * DRW_viewport_pixelsize_get(void)
Definition: draw_manager.c:303
bool DRW_opengl_context_release(void)
bool DRW_state_is_opengl_render(void)
struct Object * DRW_object_get_dupli_parent(const Object *UNUSED(ob))
Definition: draw_manager.c:264
void DRW_opengl_context_create(void)
void DRW_gpu_render_context_enable(void *re_gpu_context)
bool DRW_state_is_playback(void)
static void drw_engines_enable_overlays(void)
static void drw_duplidata_load(Object *ob)
Definition: draw_manager.c:669
int len
Definition: draw_manager.c:108
static void drw_notify_view_update_offscreen(struct Depsgraph *depsgraph, RenderEngineType *engine_type, ARegion *region, View3D *v3d, GPUViewport *viewport)
bool DRW_render_check_grease_pencil(Depsgraph *depsgraph)
void ** DRW_duplidata_get(void *vedata)
Definition: draw_manager.c:741
bool DRW_state_is_select(void)
static void drw_engines_world_update(Scene *scene)
static void drw_engines_draw_text(void)
void DRW_draw_region_engine_info(int xoffset, int *yoffset, int line_height)
static void drw_engines_enable(ViewLayer *UNUSED(view_layer), RenderEngineType *engine_type, bool gpencil_engine_needed)
void DRW_draw_view(const bContext *C)
DrawData * DRW_drawdata_ensure(ID *id, DrawEngineType *engine_type, size_t size, DrawDataInitCb init_cb, DrawDataFreeCb free_cb)
Definition: draw_manager.c:866
bool DRW_state_show_text(void)
void DRW_draw_select_id(Depsgraph *depsgraph, ARegion *region, View3D *v3d, const rcti *rect)
static void drw_engines_cache_finish(void)
void DRW_engines_free(void)
bool DRW_state_is_navigating(void)
static void drw_manager_exit(DRWManager *dst)
Definition: draw_manager.c:620
void DRW_opengl_context_enable(void)
bool DRW_state_is_depth(void)
static void drw_engine_enable_image_editor(void)
bool DRW_engine_render_support(DrawEngineType *draw_engine_type)
static void drw_manager_init(DRWManager *dst, GPUViewport *viewport, const int size[2])
Definition: draw_manager.c:495
void DRW_draw_depth_loop(struct Depsgraph *depsgraph, ARegion *region, View3D *v3d, GPUViewport *viewport, const bool use_gpencil, const bool use_basic, const bool use_overlay)
DRWData * DRW_viewport_data_create(void)
Definition: draw_manager.c:367
struct IdDdtTemplate IdDdtTemplate
void * DRW_view_layer_engine_data_get(DrawEngineType *engine_type)
Definition: draw_manager.c:757
static void drw_task_graph_deinit(void)
Definition: draw_manager.c:161
void ** DRW_view_layer_engine_data_ensure(DrawEngineType *engine_type, void(*callback)(void *storage))
Definition: draw_manager.c:787
void DRW_notify_view_update(const DRWUpdateContext *update_ctx)
static void drw_engines_init(void)
Definition: draw_manager.c:984
static void drw_engines_data_validate(void)
bool DRW_object_is_in_edit_mode(const Object *ob)
Definition: draw_manager.c:196
void DRW_render_viewport_size_set(const int size[2])
Definition: draw_manager.c:280
static void drw_engines_draw_scene(void)
static void duplidata_value_free(void *val)
Definition: draw_manager.c:707
void DRW_opengl_render_context_disable(void *re_gl_context)
static DRWData * drw_viewport_data_ensure(GPUViewport *viewport)
Definition: draw_manager.c:474
bool DRW_state_is_material_select(void)
static void use_drw_engine(DrawEngineType *engine)
DefaultFramebufferList * DRW_viewport_framebuffer_list_get(void)
Definition: draw_manager.c:633
void DRW_render_instance_buffer_finish(void)
static void DRW_render_gpencil_to_image(RenderEngine *engine, struct RenderLayer *render_layer, const rcti *rect)
void DRW_engines_register(void)
void DRW_draw_render_loop_ex(struct Depsgraph *depsgraph, RenderEngineType *engine_type, ARegion *region, View3D *v3d, GPUViewport *viewport, const bContext *evil_C)
static void drw_state_prepare_clean_for_draw(DRWManager *dst)
Definition: draw_manager.c:111
bool DRW_object_is_renderable(const Object *ob)
Definition: draw_manager.c:180
void DRW_opengl_context_disable_ex(bool restore)
static void drw_context_state_init(void)
Definition: draw_manager.c:309
void DRW_cache_free_old_batches(Main *bmain)
Definition: draw_manager.c:948
void DRW_draw_render_loop_offscreen(struct Depsgraph *depsgraph, RenderEngineType *engine_type, ARegion *region, View3D *v3d, const bool is_image_render, const bool draw_background, const bool do_color_management, GPUOffScreen *ofs, GPUViewport *viewport)
DRWManager DST
Definition: draw_manager.c:104
void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph)
void DRW_draw_depth_object(Scene *scene, ARegion *region, View3D *v3d, GPUViewport *viewport, Object *object)
static void drw_registered_engines_free(void)
void ** DRW_view_layer_engine_data_ensure_ex(ViewLayer *view_layer, DrawEngineType *engine_type, void(*callback)(void *storage))
Definition: draw_manager.c:767
int DRW_object_visibility_in_active_context(const Object *ob)
Definition: draw_manager.c:209
static uint dupli_key_hash(const void *key)
Definition: draw_manager.c:656
void DRW_draw_callbacks_post_scene(void)
static void drw_engines_enable_basic(void)
static bool drw_draw_show_annotation(void)
Definition: draw_manager.c:127
bool DRW_state_draw_support(void)
void DRW_render_context_disable(Render *render)
bool DRW_state_is_fbo(void)
struct DupliObject * DRW_object_get_dupli(const Object *UNUSED(ob))
Definition: draw_manager.c:269
static void drw_engines_cache_populate(Object *ob)
bool DRW_object_is_visible_psys_in_active_context(const Object *object, const ParticleSystem *psys)
Definition: draw_manager.c:234
void DRW_draw_select_loop(struct Depsgraph *depsgraph, ARegion *region, View3D *v3d, bool use_obedit_skip, bool draw_surface, bool UNUSED(use_nearest), const bool do_material_sub_selection, const rcti *rect, DRW_SelectPassFn select_pass_fn, void *select_pass_user_data, DRW_ObjectFilterFn object_filter_fn, void *object_filter_user_data)
ListBase engines
Definition: draw_manager.c:107
const DRWContextState * DRW_context_state_get(void)
void DRW_render_to_image(RenderEngine *engine, struct Depsgraph *depsgraph)
void DRW_viewport_data_free(DRWData *drw_data)
Definition: draw_manager.c:440
void DRW_draw_callbacks_pre_scene(void)
bool DRW_state_draw_background(void)
static void draw_unit_state_create(void)
Definition: draw_manager.c:343
static void drw_engines_enable_from_engine(const RenderEngineType *engine_type, eDrawType drawtype)
static void drw_engines_enable_editors(void)
void DRW_opengl_context_enable_ex(bool UNUSED(restore))
void DRW_opengl_render_context_enable(void *re_gl_context)
void DRW_cache_restart(void)
DrawData * DRW_drawdata_get(ID *id, DrawEngineType *engine_type)
Definition: draw_manager.c:850
static void drw_engines_cache_init(void)
static void draw_render_result_ensure_pass_cb(void *user_data, struct Scene *UNUSED(scene), struct ViewLayer *view_layer, const char *name, int channels, const char *chanid, eNodeSocketDatatype UNUSED(type))
static void drw_task_graph_init(void)
Definition: draw_manager.c:154
void DRW_opengl_context_activate(bool drw_state)
static void duplidata_key_free(void *key)
Definition: draw_manager.c:716
const float * DRW_viewport_size_get(void)
Definition: draw_manager.c:288
void DRW_draw_render_loop_2d_ex(struct Depsgraph *depsgraph, ARegion *region, GPUViewport *viewport, const bContext *evil_C)
static bool drw_gpencil_engine_needed(Depsgraph *depsgraph, View3D *v3d)
bool DRW_object_use_hide_faces(const struct Object *ob)
Definition: draw_manager.c:215
void DRW_engine_register(DrawEngineType *draw_engine_type)
static struct DRWSelectBuffer g_select_buffer
const float * DRW_viewport_screenvecs_get(void)
Definition: draw_manager.c:298
void DRW_opengl_context_disable(void)
void DRW_render_set_time(RenderEngine *engine, Depsgraph *depsgraph, int frame, float subframe)
static struct @293 g_registered_engines
static void drw_engines_disable(void)
bool DRW_state_is_image_render(void)
void DRW_opengl_context_destroy(void)
void DRW_custom_pipeline(DrawEngineType *draw_engine_type, struct Depsgraph *depsgraph, void(*callback)(void *vedata, void *user_data), void *user_data)
const float * DRW_viewport_invert_size_get(void)
Definition: draw_manager.c:293
DrawDataList * DRW_drawdatalist_from_id(ID *id)
Definition: draw_manager.c:836
static void drw_duplidata_free(void)
Definition: draw_manager.c:733
static bool id_can_have_drawdata(const ID *id)
Definition: draw_manager.c:826
static bool dupli_key_cmp(const void *key1, const void *key2)
Definition: draw_manager.c:662
void DRW_render_context_enable(Render *render)
void DRW_gpu_render_context_disable(void *UNUSED(re_gpu_context))
bool DRW_state_is_scene_render(void)
void DRW_engines_register_experimental(void)
static void draw_select_framebuffer_depth_only_setup(const int size[2])
void DRW_viewport_request_redraw(void)
Definition: draw_manager.c:643
struct DRWTextStore * DRW_text_cache_ensure(void)
static void drw_viewport_data_reset(DRWData *drw_data)
Definition: draw_manager.c:418
static void draw_texture_release(DRWData *drw_data)
Definition: draw_manager.c:407
DefaultTextureList * DRW_viewport_texture_list_get(void)
Definition: draw_manager.c:638
void DRW_render_object_iter(void *vedata, RenderEngine *engine, struct Depsgraph *depsgraph, void(*callback)(void *vedata, Object *ob, RenderEngine *engine, struct Depsgraph *depsgraph))
static void drw_drawdata_unlink_dupli(ID *id)
Definition: draw_manager.c:929
void DRW_draw_render_loop(struct Depsgraph *depsgraph, ARegion *region, View3D *v3d, GPUViewport *viewport)
static bool id_type_can_have_drawdata(const short id_type)
Definition: draw_manager.c:810
void drw_resource_buffer_finish(DRWData *vmempool)
#define PROFILE_END_UPDATE(time_update, time_start)
Definition: draw_manager.h:69
#define PROFILE_START(time_start)
Definition: draw_manager.h:58
#define DRW_DRAWLIST_LEN
Definition: draw_manager.h:557
#define DRW_RESOURCE_CHUNK_LEN
Definition: draw_manager.h:116
struct DRWObjectInfos DRWObjectInfos
struct DRWObjectMatrix DRWObjectMatrix
BLI_INLINE void DRW_handle_increment(DRWResourceHandle *handle)
Definition: draw_manager.h:149
struct DRWCullingState DRWCullingState
DRWView * DRW_view_create(const float viewmat[4][4], const float winmat[4][4], const float(*culling_viewmat)[4], const float(*culling_winmat)[4], DRWCallVisibilityFn *visibility_fn)
void DRW_view_clip_planes_set(DRWView *view, float(*planes)[4], int plane_len)
void DRW_view_camtexco_set(DRWView *view, float texco[4])
void DRW_view_reset(void)
void DRW_state_reset(void)
void DRW_state_lock(DRWState state)
void DRW_select_load_id(uint id)
void DRW_stats_begin(void)
void DRW_stats_group_start(const char *name)
void DRW_stats_reset(void)
void DRW_stats_draw(const rcti *rect)
void DRW_stats_group_end(void)
void DRW_stats_free(void)
void DRW_text_cache_draw(DRWTextStore *dt, ARegion *region, struct View3D *v3d)
DRWTextStore * DRW_text_cache_create(void)
void DRW_text_cache_destroy(struct DRWTextStore *dt)
void DRW_shaders_free()
Definition: draw_shader.cc:114
void DRW_texture_pool_free(DRWTexturePool *pool)
void DRW_texture_pool_reset(DRWTexturePool *pool)
DRWTexturePool * DRW_texture_pool_create()
void DRW_draw_cursor_2d(void)
Definition: draw_view.c:257
void DRW_draw_gizmo_2d(void)
Definition: draw_view.c:287
void DRW_draw_region_info(void)
Definition: draw_view.c:38
void DRW_draw_gizmo_3d(void)
Definition: draw_view.c:276
void DRW_view_data_use_engine(DRWViewData *view_data, DrawEngineType *engine_type)
ViewportEngineData * DRW_view_data_engine_data_get_ensure(DRWViewData *view_data, DrawEngineType *engine_type)
DRWViewData * DRW_view_data_create(ListBase *engine_types)
void DRW_view_data_free(DRWViewData *view_data)
DefaultTextureList * DRW_view_data_default_texture_list_get(DRWViewData *view_data)
void DRW_view_data_default_lists_from_viewport(DRWViewData *view_data, GPUViewport *viewport)
double * DRW_view_data_cache_time_get(DRWViewData *view_data)
DefaultFramebufferList * DRW_view_data_default_framebuffer_list_get(DRWViewData *view_data)
void DRW_view_data_texture_list_size_validate(DRWViewData *view_data, const int size[2])
void DRW_view_data_reset(DRWViewData *view_data)
void DRW_view_data_free_unused(DRWViewData *view_data)
#define DRW_ENABLED_ENGINE_ITER(view_data_, engine_, data_)
#define GPU_INFO_SIZE
RenderEngineType DRW_engine_viewport_eevee_type
Definition: eevee_engine.c:636
RenderEngineType DRW_engine_viewport_eevee_next_type
void RE_engine_frame_set(RenderEngine *engine, int frame, float subframe)
Definition: engine.c:785
void RE_engine_update_render_passes(struct RenderEngine *engine, struct Scene *scene, struct ViewLayer *view_layer, update_render_passes_cb_t callback, void *callback_data)
Definition: engine.c:1150
void RE_engine_add_pass(RenderEngine *engine, const char *name, int channels, const char *chan_id, const char *layername)
Definition: engine.c:424
void RE_engines_register(RenderEngineType *render_type)
Definition: engine.c:90
RenderResult * RE_engine_get_result(RenderEngine *engine)
Definition: engine.c:481
void RE_engine_end_result(RenderEngine *engine, RenderResult *result, bool cancel, bool highlight, bool merge_results)
Definition: engine.c:439
ListBase R_engines
Definition: engine.c:57
RenderResult * RE_engine_begin_result(RenderEngine *engine, int x, int y, int w, int h, const char *layername, const char *viewname)
Definition: engine.c:344
T * data_
Definition: eval_output.h:163
RenderEngineType DRW_engine_viewport_external_type
bool DRW_engine_external_acquire_for_image_editor(void)
DrawEngineType draw_engine_external_type
DrawEngineType draw_engine_gpencil_type
struct @653::@655 batch
void GPU_framebuffer_texture_attach(GPUFrameBuffer *fb, GPUTexture *tex, int slot, int mip)
void GPU_clear_color(float red, float green, float blue, float alpha)
void GPU_offscreen_bind(GPUOffScreen *ofs, bool save)
DrawEngineType draw_engine_image_type
void RE_GetViewPlane(Render *re, rctf *r_viewplane, rcti *r_disprect)
Definition: initrender.c:210
#define GS(x)
Definition: iris.c:225
void(* MEM_freeN)(void *vmemh)
Definition: mallocn.c:27
void *(* MEM_callocN)(size_t len, const char *str)
Definition: mallocn.c:31
void *(* MEM_mallocN)(size_t len, const char *str)
Definition: mallocn.c:33
static ulong * next
#define G(x, y, z)
static const pxr::TfToken st("st", pxr::TfToken::Immortal)
void drw_batch_cache_validate(Object *custom)
Definition: draw_cache.c:3298
DrawEngineType draw_engine_overlay_type
void * RE_gpu_context_get(Render *re)
Definition: pipeline.c:932
void * RE_gl_context_get(Render *re)
Definition: pipeline.c:927
RenderLayer * RE_GetRenderLayer(RenderResult *rr, const char *name)
Definition: pipeline.c:244
void RE_SetActiveRenderView(Render *re, const char *viewname)
Definition: pipeline.c:1666
DrawEngineType draw_engine_debug_select_type
DrawEngineType draw_engine_select_type
struct SELECTID_Context * DRW_select_engine_context_get(void)
void * regiondata
float radius
Definition: DRW_render.h:86
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
const struct bContext * evil_C
Definition: DRW_render.h:997
struct Depsgraph * depsgraph
Definition: DRW_render.h:987
eGPUShaderConfig sh_cfg
Definition: DRW_render.h:993
struct ViewLayer * view_layer
Definition: DRW_render.h:980
eObjectMode object_mode
Definition: DRW_render.h:991
struct View3D * v3d
Definition: DRW_render.h:976
struct ARegion * region
Definition: DRW_render.h:974
struct Object * object_pose
Definition: DRW_render.h:1002
struct Object * object_edit
Definition: DRW_render.h:1003
struct RegionView3D * rv3d
Definition: DRW_render.h:975
BoundSphere bsphere
Definition: draw_manager.h:107
struct GHash * obattrs_ubo_pool
Definition: draw_manager.h:530
struct BLI_memblock * images
Definition: draw_manager.h:527
struct BLI_memblock * commands_small
Definition: draw_manager.h:518
uint ubo_len
Definition: draw_manager.h:531
struct BLI_memblock * obinfos
Definition: draw_manager.h:521
struct BLI_memblock * commands
Definition: draw_manager.h:517
struct BLI_memblock * shgroups
Definition: draw_manager.h:523
struct BLI_memblock * passes
Definition: draw_manager.h:526
void * volume_grids_ubos
Definition: draw_manager.h:533
struct BLI_memblock * uniforms
Definition: draw_manager.h:524
struct DRWTexturePool * texture_pool
Definition: draw_manager.h:540
struct GPUUniformBuf ** obinfos_ubo
Definition: draw_manager.h:529
struct DRWViewData * view_data[2]
Definition: draw_manager.h:542
struct BLI_memblock * obmats
Definition: draw_manager.h:520
struct GPUUniformBuf ** matrices_ubo
Definition: draw_manager.h:528
DRWInstanceDataList * idatalist
Definition: draw_manager.h:515
struct BLI_memblock * views
Definition: draw_manager.h:525
struct BLI_memblock * callbuffers
Definition: draw_manager.h:519
struct CurvesUniformBufPool * curves_ubos
Definition: draw_manager.h:544
struct BLI_memblock * cullstates
Definition: draw_manager.h:522
uint is_image_render
Definition: draw_manager.h:609
struct DupliObject * dupli_source
Definition: draw_manager.h:575
DRWResourceHandle ob_handle
Definition: draw_manager.h:566
uint draw_background
Definition: draw_manager.h:611
struct DRWViewData * view_data_active
Definition: draw_manager.h:564
DRWResourceHandle pass_handle
Definition: draw_manager.h:572
DRWView * view_active
Definition: draw_manager.h:624
struct TaskGraph * task_graph
Definition: draw_manager.h:635
DRWContextState draw_ctx
Definition: draw_manager.h:616
DRWView * view_previous
Definition: draw_manager.h:625
float size[2]
Definition: draw_manager.h:600
bool buffer_finish_called
Definition: draw_manager.h:621
DRWResourceHandle resource_handle
Definition: draw_manager.h:570
struct ID * dupli_origin_data
Definition: draw_manager.h:581
uint primary_view_num
Definition: draw_manager.h:626
float inv_size[2]
Definition: draw_manager.h:601
void ** dupli_datas
Definition: draw_manager.h:587
GPUViewport * viewport
Definition: draw_manager.h:598
float screenvecs[2][3]
Definition: draw_manager.h:602
struct DRWTextStore ** text_store_p
Definition: draw_manager.h:619
DRWInstanceData * object_instance_data[MAX_INSTANCE_DATA_SIZE]
Definition: draw_manager.h:585
float pixsize
Definition: draw_manager.h:603
struct Object * dupli_parent
Definition: draw_manager.h:577
struct GSet * delayed_extraction
Definition: draw_manager.h:637
uint is_material_select
Definition: draw_manager.h:607
struct GHash * dupli_ghash
Definition: draw_manager.h:583
struct DRWManager::@313 options
struct GPUFrameBuffer * default_framebuffer
Definition: draw_manager.h:599
uint is_scene_render
Definition: draw_manager.h:610
uint is_select
Definition: draw_manager.h:606
GPUDrawList * draw_list
Definition: draw_manager.h:649
struct Object * dupli_origin
Definition: draw_manager.h:579
DRWData * vmempool
Definition: draw_manager.h:562
uint draw_text
Definition: draw_manager.h:612
TicketMutex * gl_context_mutex
Definition: draw_manager.h:647
DRWView * view_default
Definition: draw_manager.h:623
GPUContext * gpu_context
Definition: draw_manager.h:645
void * gl_context
Definition: draw_manager.h:644
float orcotexfac[2][4]
Definition: draw_manager.h:173
float ob_color[4]
Definition: draw_manager.h:174
float modelinverse[4][4]
Definition: draw_manager.h:169
float model[4][4]
Definition: draw_manager.h:168
DrawEngineType * draw_engine
Definition: draw_manager.h:92
struct GPUFrameBuffer * framebuffer_depth_only
struct GPUTexture * texture_depth
struct Scene * scene
Definition: DRW_engine.h:52
struct View3D * v3d
Definition: DRW_engine.h:55
struct ARegion * region
Definition: DRW_engine.h:54
struct RenderEngineType * engine_type
Definition: DRW_engine.h:56
struct ViewLayer * view_layer
Definition: DRW_engine.h:53
struct Depsgraph * depsgraph
Definition: DRW_engine.h:51
struct GPUUniformBuf * block_ubo
Definition: draw_common.h:129
struct GPUTexture * weight_ramp
Definition: draw_common.h:132
struct GPUTexture * ramp
Definition: draw_common.h:131
struct GPUUniformBuf * view_ubo
Definition: draw_common.h:134
struct GPUFrameBuffer * overlay_fb
struct GPUFrameBuffer * default_fb
struct DrawEngineType * engine_type
Definition: DNA_ID.h:36
DrawDataFreeCb free
Definition: DNA_ID.h:38
void(* store_metadata)(void *vedata, struct RenderResult *render_result)
Definition: DRW_render.h:135
void(* render_to_image)(void *vedata, struct RenderEngine *engine, struct RenderLayer *layer, const struct rcti *rect)
Definition: DRW_render.h:131
struct ID * ob_data
Definition: draw_manager.h:551
struct Object * ob
Definition: draw_manager.h:550
struct ID * ob_data
Definition: BKE_duplilist.h:36
struct Object * ob
Definition: BKE_duplilist.h:34
float4x4 ModelMatrix
Definition: DNA_ID.h:368
void * next
Definition: DNA_ID.h:369
char name[66]
Definition: DNA_ID.h:378
struct AnimData * adt
Definition: draw_manager.c:805
DrawDataList drawdata
Definition: draw_manager.c:806
void * first
Definition: DNA_listBase.h:31
Definition: BKE_main.h:121
ListBase scenes
Definition: BKE_main.h:168
char editflag
struct BoundBox * bb
short base_flag
Object_Runtime runtime
float obmat[4][4]
void * data
ParticleSettings * part
struct PointCache * pointcache
float viewcamtexcofac[4]
float clip[6][4]
float viewmat[4][4]
float clip_local[6][4]
float viewinv[4][4]
float winmat[4][4]
struct DrawEngineType * draw_engine
Definition: RE_engine.h:113
RenderEngineType * type
Definition: RE_engine.h:128
struct Render * re
Definition: RE_engine.h:135
int resolution_x
Definition: RE_engine.h:139
int resolution_y
Definition: RE_engine.h:139
ListBase views
Definition: RE_pipeline.h:125
ListBase layers
Definition: RE_pipeline.h:122
char name[RE_MAXNAME]
Definition: render_types.h:42
struct Object ** objects
struct ToolSettings * toolsettings
struct RenderData r
ListBase view_layers
struct World * world
struct ParticleEditSettings particle
View3DOverlay overlay
int object_type_exclude_select
int object_type_exclude_viewport
char gizmo_flag
View3DShading shading
struct DrawEngineType * engine_type
struct ViewLayerEngineData * next
void(* free)(void *storage)
ListBase drawdata
struct ViewLayer * next
char name[64]
struct DRWRegisteredDrawEngine * engine_type
float xmax
Definition: DNA_vec_types.h:69
float xmin
Definition: DNA_vec_types.h:69
float ymax
Definition: DNA_vec_types.h:70
float ymin
Definition: DNA_vec_types.h:70
double PIL_check_seconds_timer(void)
Definition: time.c:64
static void draw_background(const rcti *rect)
Definition: time_scrub_ui.c:48
GPUViewport * WM_draw_region_get_viewport(ARegion *region)
Definition: wm_draw.c:846
GPUViewport * WM_draw_region_get_bound_viewport(ARegion *region)
Definition: wm_draw.c:856
void WM_init_opengl(void)
Definition: wm_init_exit.c:162
void wmOrtho2(float x1, float x2, float y1, float y2)
Definition: wm_subwindow.c:84
void * WM_opengl_context_create(void)
Definition: wm_window.c:2353
void wm_window_reset_drawable(void)
Definition: wm_window.c:1049
void WM_opengl_context_activate(void *context)
Definition: wm_window.c:2380
void WM_opengl_context_release(void *context)
Definition: wm_window.c:2386
void WM_opengl_context_dispose(void *context)
Definition: wm_window.c:2374
ARegionType * WM_xr_surface_controller_region_type_get(void)
RenderEngineType DRW_engine_viewport_workbench_type