DRW: Add batch garbage collection
[blender.git] / source / blender / draw / intern / draw_manager.c
1 /*
2  * This program is free software; you can redistribute it and/or
3  * modify it under the terms of the GNU General Public License
4  * as published by the Free Software Foundation; either version 2
5  * of the License, or (at your option) any later version.
6  *
7  * This program is distributed in the hope that it will be useful,
8  * but WITHOUT ANY WARRANTY; without even the implied warranty of
9  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10  * GNU General Public License for more details.
11  *
12  * You should have received a copy of the GNU General Public License
13  * along with this program; if not, write to the Free Software Foundation,
14  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
15  *
16  * Copyright 2016, Blender Foundation.
17  */
18
19 /** \file
20  * \ingroup draw
21  */
22
23 #include <stdio.h>
24
25 #include "BLI_listbase.h"
26 #include "BLI_mempool.h"
27 #include "BLI_rect.h"
28 #include "BLI_string.h"
29 #include "BLI_threads.h"
30
31 #include "BLF_api.h"
32
33 #include "BKE_colortools.h"
34 #include "BKE_curve.h"
35 #include "BKE_global.h"
36 #include "BKE_gpencil.h"
37 #include "BKE_lattice.h"
38 #include "BKE_main.h"
39 #include "BKE_mball.h"
40 #include "BKE_mesh.h"
41 #include "BKE_object.h"
42 #include "BKE_particle.h"
43 #include "BKE_pointcache.h"
44
45 #include "draw_manager.h"
46 #include "DNA_camera_types.h"
47 #include "DNA_mesh_types.h"
48 #include "DNA_meshdata_types.h"
49 #include "DNA_world_types.h"
50
51 #include "ED_space_api.h"
52 #include "ED_screen.h"
53 #include "ED_gpencil.h"
54 #include "ED_view3d.h"
55
56 #include "GPU_draw.h"
57 #include "GPU_extensions.h"
58 #include "GPU_framebuffer.h"
59 #include "GPU_immediate.h"
60 #include "GPU_uniformbuffer.h"
61 #include "GPU_viewport.h"
62 #include "GPU_matrix.h"
63 #include "GPU_select.h"
64
65 #include "IMB_colormanagement.h"
66
67 #include "RE_engine.h"
68 #include "RE_pipeline.h"
69
70 #include "UI_resources.h"
71
72 #include "WM_api.h"
73 #include "wm_window.h"
74
75 #include "draw_manager_text.h"
76 #include "draw_manager_profiling.h"
77
78 /* only for callbacks */
79 #include "draw_cache_impl.h"
80
81 #include "draw_mode_engines.h"
82 #include "engines/eevee/eevee_engine.h"
83 #include "engines/basic/basic_engine.h"
84 #include "engines/workbench/workbench_engine.h"
85 #include "engines/external/external_engine.h"
86
87 #include "GPU_context.h"
88
89 #include "DEG_depsgraph.h"
90 #include "DEG_depsgraph_query.h"
91
92 #ifdef USE_GPU_SELECT
93 #  include "GPU_select.h"
94 #endif
95
96 /** Render State: No persistent data between draw calls. */
97 DRWManager DST = {NULL};
98
99 static ListBase DRW_engines = {NULL, NULL};
100
101 static void drw_state_prepare_clean_for_draw(DRWManager *dst)
102 {
103   memset(dst, 0x0, offsetof(DRWManager, gl_context));
104
105   /* Maybe not the best place for this. */
106   if (!DST.uniform_names.buffer) {
107     DST.uniform_names.buffer = MEM_callocN(DRW_UNIFORM_BUFFER_NAME, "Name Buffer");
108     DST.uniform_names.buffer_len = DRW_UNIFORM_BUFFER_NAME;
109   }
110   else if (DST.uniform_names.buffer_len > DRW_UNIFORM_BUFFER_NAME) {
111     DST.uniform_names.buffer = MEM_reallocN(DST.uniform_names.buffer, DRW_UNIFORM_BUFFER_NAME);
112     DST.uniform_names.buffer_len = DRW_UNIFORM_BUFFER_NAME;
113   }
114   DST.uniform_names.buffer_ofs = 0;
115 }
116
117 /* This function is used to reset draw manager to a state
118  * where we don't re-use data by accident across different
119  * draw calls.
120  */
121 #ifdef DEBUG
122 static void drw_state_ensure_not_reused(DRWManager *dst)
123 {
124   memset(dst, 0xff, offsetof(DRWManager, gl_context));
125 }
126 #endif
127
128 /* -------------------------------------------------------------------- */
129
130 void DRW_draw_callbacks_pre_scene(void)
131 {
132   RegionView3D *rv3d = DST.draw_ctx.rv3d;
133
134   GPU_matrix_projection_set(rv3d->winmat);
135   GPU_matrix_set(rv3d->viewmat);
136 }
137
138 void DRW_draw_callbacks_post_scene(void)
139 {
140   RegionView3D *rv3d = DST.draw_ctx.rv3d;
141
142   GPU_matrix_projection_set(rv3d->winmat);
143   GPU_matrix_set(rv3d->viewmat);
144 }
145
146 struct DRWTextStore *DRW_text_cache_ensure(void)
147 {
148   BLI_assert(DST.text_store_p);
149   if (*DST.text_store_p == NULL) {
150     *DST.text_store_p = DRW_text_cache_create();
151   }
152   return *DST.text_store_p;
153 }
154
155 /* -------------------------------------------------------------------- */
156 /** \name Settings
157  * \{ */
158
159 bool DRW_object_is_renderable(const Object *ob)
160 {
161   BLI_assert((ob->base_flag & BASE_VISIBLE) != 0);
162
163   if (ob->type == OB_MESH) {
164     if ((ob == DST.draw_ctx.object_edit) || BKE_object_is_in_editmode(ob)) {
165       View3D *v3d = DST.draw_ctx.v3d;
166       const int mask = (V3D_OVERLAY_EDIT_OCCLUDE_WIRE | V3D_OVERLAY_EDIT_WEIGHT);
167
168       if (v3d && v3d->overlay.edit_flag & mask) {
169         return false;
170       }
171     }
172   }
173
174   return true;
175 }
176
177 /**
178  * Return whether this object is visible depending if
179  * we are rendering or drawing in the viewport.
180  */
181 int DRW_object_visibility_in_active_context(const Object *ob)
182 {
183   const eEvaluationMode mode = DRW_state_is_scene_render() ? DAG_EVAL_RENDER : DAG_EVAL_VIEWPORT;
184   return BKE_object_visibility(ob, mode);
185 }
186
187 bool DRW_object_is_flat_normal(const Object *ob)
188 {
189   if (ob->type == OB_MESH) {
190     const Mesh *me = ob->data;
191     if (me->mpoly && me->mpoly[0].flag & ME_SMOOTH) {
192       return false;
193     }
194   }
195   return true;
196 }
197
198 bool DRW_object_use_hide_faces(const struct Object *ob)
199 {
200   if (ob->type == OB_MESH) {
201     const Mesh *me = ob->data;
202
203     switch (ob->mode) {
204       case OB_MODE_TEXTURE_PAINT:
205         return (me->editflag & ME_EDIT_PAINT_FACE_SEL) != 0;
206       case OB_MODE_VERTEX_PAINT:
207       case OB_MODE_WEIGHT_PAINT:
208         return (me->editflag & (ME_EDIT_PAINT_FACE_SEL | ME_EDIT_PAINT_VERT_SEL)) != 0;
209     }
210   }
211
212   return false;
213 }
214
215 bool DRW_object_is_visible_psys_in_active_context(const Object *object, const ParticleSystem *psys)
216 {
217   const bool for_render = DRW_state_is_image_render();
218   /* NOTE: psys_check_enabled is using object and particle system for only
219    * reading, but is using some other functions which are more generic and
220    * which are hard to make const-pointer. */
221   if (!psys_check_enabled((Object *)object, (ParticleSystem *)psys, for_render)) {
222     return false;
223   }
224   const DRWContextState *draw_ctx = DRW_context_state_get();
225   const Scene *scene = draw_ctx->scene;
226   if (object == draw_ctx->object_edit) {
227     return false;
228   }
229   const ParticleSettings *part = psys->part;
230   const ParticleEditSettings *pset = &scene->toolsettings->particle;
231   if (object->mode == OB_MODE_PARTICLE_EDIT) {
232     if (psys_in_edit_mode(draw_ctx->depsgraph, psys)) {
233       if ((pset->flag & PE_DRAW_PART) == 0) {
234         return false;
235       }
236       if ((part->childtype == 0) &&
237           (psys->flag & PSYS_HAIR_DYNAMICS && psys->pointcache->flag & PTCACHE_BAKED) == 0) {
238         return false;
239       }
240     }
241   }
242   return true;
243 }
244
245 struct Object *DRW_object_get_dupli_parent(const Object *UNUSED(ob))
246 {
247   return DST.dupli_parent;
248 }
249
250 struct DupliObject *DRW_object_get_dupli(const Object *UNUSED(ob))
251 {
252   return DST.dupli_source;
253 }
254
255 /** \} */
256
257 /* -------------------------------------------------------------------- */
258 /** \name Color Management
259  * \{ */
260
261 /* Use color management profile to draw texture to framebuffer */
262 void DRW_transform_to_display(GPUTexture *tex, bool use_view_transform, bool use_render_settings)
263 {
264   drw_state_set(DRW_STATE_WRITE_COLOR);
265
266   GPUVertFormat *vert_format = immVertexFormat();
267   uint pos = GPU_vertformat_attr_add(vert_format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
268   uint texco = GPU_vertformat_attr_add(vert_format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
269
270   const float dither = 1.0f;
271
272   bool use_ocio = false;
273
274   /* View transform is already applied for offscreen, don't apply again, see: T52046 */
275   if (!(DST.options.is_image_render && !DST.options.is_scene_render)) {
276     Scene *scene = DST.draw_ctx.scene;
277     ColorManagedDisplaySettings *display_settings = &scene->display_settings;
278     ColorManagedViewSettings view_settings;
279     if (use_render_settings) {
280       /* Use full render settings, for renders with scene lighting. */
281       view_settings = scene->view_settings;
282     }
283     else if (use_view_transform) {
284       /* Use only view transform + look and nothing else for lookdev without
285        * scene lighting, as exposure depends on scene light intensity. */
286       BKE_color_managed_view_settings_init_render(&view_settings, display_settings, NULL);
287       STRNCPY(view_settings.view_transform, scene->view_settings.view_transform);
288       STRNCPY(view_settings.look, scene->view_settings.look);
289     }
290     else {
291       /* For workbench use only default view transform in configuration,
292        * using no scene settings. */
293       BKE_color_managed_view_settings_init_render(&view_settings, display_settings, NULL);
294     }
295
296     use_ocio = IMB_colormanagement_setup_glsl_draw_from_space(
297         &view_settings, display_settings, NULL, dither, false);
298   }
299
300   if (!use_ocio) {
301     /* View transform is already applied for offscreen, don't apply again, see: T52046 */
302     if (DST.options.is_image_render && !DST.options.is_scene_render) {
303       immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_COLOR);
304       immUniformColor4f(1.0f, 1.0f, 1.0f, 1.0f);
305     }
306     else {
307       immBindBuiltinProgram(GPU_SHADER_2D_IMAGE_LINEAR_TO_SRGB);
308     }
309     immUniform1i("image", 0);
310   }
311
312   GPU_texture_bind(tex, 0); /* OCIO texture bind point is 0 */
313
314   float mat[4][4];
315   unit_m4(mat);
316   immUniformMatrix4fv("ModelViewProjectionMatrix", mat);
317
318   /* Full screen triangle */
319   immBegin(GPU_PRIM_TRIS, 3);
320   immAttr2f(texco, 0.0f, 0.0f);
321   immVertex2f(pos, -1.0f, -1.0f);
322
323   immAttr2f(texco, 2.0f, 0.0f);
324   immVertex2f(pos, 3.0f, -1.0f);
325
326   immAttr2f(texco, 0.0f, 2.0f);
327   immVertex2f(pos, -1.0f, 3.0f);
328   immEnd();
329
330   GPU_texture_unbind(tex);
331
332   if (use_ocio) {
333     IMB_colormanagement_finish_glsl_draw();
334   }
335   else {
336     immUnbindProgram();
337   }
338 }
339
340 /* Draw texture to framebuffer without any color transforms */
341 void DRW_transform_none(GPUTexture *tex)
342 {
343   drw_state_set(DRW_STATE_WRITE_COLOR);
344
345   /* Draw as texture for final render (without immediate mode). */
346   GPUBatch *geom = DRW_cache_fullscreen_quad_get();
347   GPU_batch_program_set_builtin(geom, GPU_SHADER_2D_IMAGE_COLOR);
348
349   GPU_texture_bind(tex, 0);
350
351   const float white[4] = {1.0f, 1.0f, 1.0f, 1.0f};
352   GPU_batch_uniform_4fv(geom, "color", white);
353
354   float mat[4][4];
355   unit_m4(mat);
356   GPU_batch_uniform_mat4(geom, "ModelViewProjectionMatrix", mat);
357
358   GPU_batch_program_use_begin(geom);
359   GPU_batch_draw_range_ex(geom, 0, 0, false);
360   GPU_batch_program_use_end(geom);
361
362   GPU_texture_unbind(tex);
363 }
364
365 /** \} */
366
367 /* -------------------------------------------------------------------- */
368 /** \name Multisample Resolve
369  * \{ */
370
371 /**
372  * Use manual multisample resolve pass.
373  * Much quicker than blitting back and forth.
374  * Assume destination fb is bound.
375  */
376 void DRW_multisamples_resolve(GPUTexture *src_depth, GPUTexture *src_color, bool use_depth)
377 {
378   DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND_PREMUL;
379
380   if (use_depth) {
381     state |= DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL;
382   }
383   drw_state_set(state);
384
385   int samples = GPU_texture_samples(src_depth);
386
387   BLI_assert(samples > 0);
388   BLI_assert(GPU_texture_samples(src_color) == samples);
389
390   GPUBatch *geom = DRW_cache_fullscreen_quad_get();
391
392   int builtin;
393   if (use_depth) {
394     switch (samples) {
395       case 2:
396         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST;
397         break;
398       case 4:
399         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_4_DEPTH_TEST;
400         break;
401       case 8:
402         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_8_DEPTH_TEST;
403         break;
404       case 16:
405         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_16_DEPTH_TEST;
406         break;
407       default:
408         BLI_assert(!"Mulisample count unsupported by blit shader.");
409         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_2_DEPTH_TEST;
410         break;
411     }
412   }
413   else {
414     switch (samples) {
415       case 2:
416         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_2;
417         break;
418       case 4:
419         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_4;
420         break;
421       case 8:
422         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_8;
423         break;
424       case 16:
425         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_16;
426         break;
427       default:
428         BLI_assert(!"Mulisample count unsupported by blit shader.");
429         builtin = GPU_SHADER_2D_IMAGE_MULTISAMPLE_2;
430         break;
431     }
432   }
433
434   GPU_batch_program_set_builtin(geom, builtin);
435
436   if (use_depth) {
437     GPU_texture_bind(src_depth, 0);
438     GPU_batch_uniform_1i(geom, "depthMulti", 0);
439   }
440
441   GPU_texture_bind(src_color, 1);
442   GPU_batch_uniform_1i(geom, "colorMulti", 1);
443
444   float mat[4][4];
445   unit_m4(mat);
446   GPU_batch_uniform_mat4(geom, "ModelViewProjectionMatrix", mat);
447
448   /* avoid gpuMatrix calls */
449   GPU_batch_program_use_begin(geom);
450   GPU_batch_draw_range_ex(geom, 0, 0, false);
451   GPU_batch_program_use_end(geom);
452 }
453
454 /** \} */
455
456 /* -------------------------------------------------------------------- */
457 /** \name Viewport (DRW_viewport)
458  * \{ */
459
460 void *drw_viewport_engine_data_ensure(void *engine_type)
461 {
462   void *data = GPU_viewport_engine_data_get(DST.viewport, engine_type);
463
464   if (data == NULL) {
465     data = GPU_viewport_engine_data_create(DST.viewport, engine_type);
466   }
467   return data;
468 }
469
470 void DRW_engine_viewport_data_size_get(
471     const void *engine_type_v, int *r_fbl_len, int *r_txl_len, int *r_psl_len, int *r_stl_len)
472 {
473   const DrawEngineType *engine_type = engine_type_v;
474
475   if (r_fbl_len) {
476     *r_fbl_len = engine_type->vedata_size->fbl_len;
477   }
478   if (r_txl_len) {
479     *r_txl_len = engine_type->vedata_size->txl_len;
480   }
481   if (r_psl_len) {
482     *r_psl_len = engine_type->vedata_size->psl_len;
483   }
484   if (r_stl_len) {
485     *r_stl_len = engine_type->vedata_size->stl_len;
486   }
487 }
488
489 /* WARNING: only use for custom pipeline. 99% of the time, you don't want to use this. */
490 void DRW_render_viewport_size_set(int size[2])
491 {
492   DST.size[0] = size[0];
493   DST.size[1] = size[1];
494 }
495
496 const float *DRW_viewport_size_get(void)
497 {
498   return DST.size;
499 }
500
501 const float *DRW_viewport_invert_size_get(void)
502 {
503   return DST.inv_size;
504 }
505
506 const float *DRW_viewport_screenvecs_get(void)
507 {
508   return &DST.screenvecs[0][0];
509 }
510
511 const float *DRW_viewport_pixelsize_get(void)
512 {
513   return &DST.pixsize;
514 }
515
516 static void drw_viewport_cache_resize(void)
517 {
518   /* Release the memiter before clearing the mempools that references them */
519   GPU_viewport_cache_release(DST.viewport);
520
521   if (DST.vmempool != NULL) {
522     BLI_mempool_clear_ex(DST.vmempool->calls, BLI_mempool_len(DST.vmempool->calls));
523     BLI_mempool_clear_ex(DST.vmempool->states, BLI_mempool_len(DST.vmempool->states));
524     BLI_mempool_clear_ex(DST.vmempool->shgroups, BLI_mempool_len(DST.vmempool->shgroups));
525     BLI_mempool_clear_ex(DST.vmempool->uniforms, BLI_mempool_len(DST.vmempool->uniforms));
526     BLI_mempool_clear_ex(DST.vmempool->passes, BLI_mempool_len(DST.vmempool->passes));
527   }
528
529   DRW_instance_data_list_free_unused(DST.idatalist);
530   DRW_instance_data_list_resize(DST.idatalist);
531 }
532
533 /* Not a viewport variable, we could split this out. */
534 static void drw_context_state_init(void)
535 {
536   if (DST.draw_ctx.obact) {
537     DST.draw_ctx.object_mode = DST.draw_ctx.obact->mode;
538   }
539   else {
540     DST.draw_ctx.object_mode = OB_MODE_OBJECT;
541   }
542
543   /* Edit object. */
544   if (DST.draw_ctx.object_mode & OB_MODE_EDIT) {
545     DST.draw_ctx.object_edit = DST.draw_ctx.obact;
546   }
547   else {
548     DST.draw_ctx.object_edit = NULL;
549   }
550
551   /* Pose object. */
552   if (DST.draw_ctx.object_mode & OB_MODE_POSE) {
553     DST.draw_ctx.object_pose = DST.draw_ctx.obact;
554   }
555   else if (DST.draw_ctx.object_mode & OB_MODE_WEIGHT_PAINT) {
556     DST.draw_ctx.object_pose = BKE_object_pose_armature_get(DST.draw_ctx.obact);
557   }
558   else {
559     DST.draw_ctx.object_pose = NULL;
560   }
561
562   DST.draw_ctx.sh_cfg = GPU_SHADER_CFG_DEFAULT;
563   if (DST.draw_ctx.rv3d && DST.draw_ctx.rv3d->rflag & RV3D_CLIPPING) {
564     DST.draw_ctx.sh_cfg = GPU_SHADER_CFG_CLIPPED;
565   }
566 }
567
568 /* It also stores viewport variable to an immutable place: DST
569  * This is because a cache uniform only store reference
570  * to its value. And we don't want to invalidate the cache
571  * if this value change per viewport */
572 static void drw_viewport_var_init(void)
573 {
574   RegionView3D *rv3d = DST.draw_ctx.rv3d;
575   /* Refresh DST.size */
576   if (DST.viewport) {
577     int size[2];
578     GPU_viewport_size_get(DST.viewport, size);
579     DST.size[0] = size[0];
580     DST.size[1] = size[1];
581     DST.inv_size[0] = 1.0f / size[0];
582     DST.inv_size[1] = 1.0f / size[1];
583
584     DefaultFramebufferList *fbl = (DefaultFramebufferList *)GPU_viewport_framebuffer_list_get(
585         DST.viewport);
586     DST.default_framebuffer = fbl->default_fb;
587
588     DST.vmempool = GPU_viewport_mempool_get(DST.viewport);
589
590     if (DST.vmempool->calls == NULL) {
591       DST.vmempool->calls = BLI_mempool_create(sizeof(DRWCall), 0, 512, 0);
592     }
593     if (DST.vmempool->states == NULL) {
594       DST.vmempool->states = BLI_mempool_create(
595           sizeof(DRWCallState), 0, 512, BLI_MEMPOOL_ALLOW_ITER);
596     }
597     if (DST.vmempool->shgroups == NULL) {
598       DST.vmempool->shgroups = BLI_mempool_create(sizeof(DRWShadingGroup), 0, 256, 0);
599     }
600     if (DST.vmempool->uniforms == NULL) {
601       DST.vmempool->uniforms = BLI_mempool_create(sizeof(DRWUniform), 0, 512, 0);
602     }
603     if (DST.vmempool->passes == NULL) {
604       DST.vmempool->passes = BLI_mempool_create(sizeof(DRWPass), 0, 64, 0);
605     }
606
607     DST.idatalist = GPU_viewport_instance_data_list_get(DST.viewport);
608     DRW_instance_data_list_reset(DST.idatalist);
609   }
610   else {
611     DST.size[0] = 0;
612     DST.size[1] = 0;
613
614     DST.inv_size[0] = 0;
615     DST.inv_size[1] = 0;
616
617     DST.default_framebuffer = NULL;
618     DST.vmempool = NULL;
619   }
620
621   if (rv3d != NULL) {
622     /* Refresh DST.screenvecs */
623     copy_v3_v3(DST.screenvecs[0], rv3d->viewinv[0]);
624     copy_v3_v3(DST.screenvecs[1], rv3d->viewinv[1]);
625     normalize_v3(DST.screenvecs[0]);
626     normalize_v3(DST.screenvecs[1]);
627
628     /* Refresh DST.pixelsize */
629     DST.pixsize = rv3d->pixsize;
630
631     copy_m4_m4(DST.original_mat.mat[DRW_MAT_PERS], rv3d->persmat);
632     copy_m4_m4(DST.original_mat.mat[DRW_MAT_PERSINV], rv3d->persinv);
633     copy_m4_m4(DST.original_mat.mat[DRW_MAT_VIEW], rv3d->viewmat);
634     copy_m4_m4(DST.original_mat.mat[DRW_MAT_VIEWINV], rv3d->viewinv);
635     copy_m4_m4(DST.original_mat.mat[DRW_MAT_WIN], rv3d->winmat);
636     invert_m4_m4(DST.original_mat.mat[DRW_MAT_WININV], rv3d->winmat);
637
638     memcpy(DST.view_data.matstate.mat, DST.original_mat.mat, sizeof(DST.original_mat.mat));
639
640     copy_v4_v4(DST.view_data.viewcamtexcofac, rv3d->viewcamtexcofac);
641   }
642   else {
643     copy_v4_fl4(DST.view_data.viewcamtexcofac, 1.0f, 1.0f, 0.0f, 0.0f);
644   }
645
646   /* Reset facing */
647   DST.frontface = GL_CCW;
648   DST.backface = GL_CW;
649   glFrontFace(DST.frontface);
650
651   if (DST.draw_ctx.object_edit) {
652     ED_view3d_init_mats_rv3d(DST.draw_ctx.object_edit, rv3d);
653   }
654
655   /* Alloc array of texture reference. */
656   memset(&DST.RST, 0x0, sizeof(DST.RST));
657
658   if (G_draw.view_ubo == NULL) {
659     G_draw.view_ubo = DRW_uniformbuffer_create(sizeof(ViewUboStorage), NULL);
660   }
661
662   DST.override_mat = 0;
663   DST.dirty_mat = true;
664   DST.state_cache_id = 1;
665
666   DST.clipping.updated = false;
667
668   memset(DST.object_instance_data, 0x0, sizeof(DST.object_instance_data));
669 }
670
671 void DRW_viewport_matrix_get(float mat[4][4], DRWViewportMatrixType type)
672 {
673   BLI_assert(type >= 0 && type < DRW_MAT_COUNT);
674   /* Can't use this in render mode. */
675   BLI_assert(((DST.override_mat & (1 << type)) != 0) || DST.draw_ctx.rv3d != NULL);
676
677   copy_m4_m4(mat, DST.view_data.matstate.mat[type]);
678 }
679
680 void DRW_viewport_matrix_get_all(DRWMatrixState *state)
681 {
682   memcpy(state, DST.view_data.matstate.mat, sizeof(DRWMatrixState));
683 }
684
685 void DRW_viewport_matrix_override_set(const float mat[4][4], DRWViewportMatrixType type)
686 {
687   BLI_assert(type < DRW_MAT_COUNT);
688   copy_m4_m4(DST.view_data.matstate.mat[type], mat);
689   DST.override_mat |= (1 << type);
690   DST.dirty_mat = true;
691   DST.clipping.updated = false;
692 }
693
694 void DRW_viewport_matrix_override_unset(DRWViewportMatrixType type)
695 {
696   BLI_assert(type < DRW_MAT_COUNT);
697   copy_m4_m4(DST.view_data.matstate.mat[type], DST.original_mat.mat[type]);
698   DST.override_mat &= ~(1 << type);
699   DST.dirty_mat = true;
700   DST.clipping.updated = false;
701 }
702
703 void DRW_viewport_matrix_override_set_all(DRWMatrixState *state)
704 {
705   memcpy(DST.view_data.matstate.mat, state, sizeof(DRWMatrixState));
706   DST.override_mat = 0xFFFFFF;
707   DST.dirty_mat = true;
708   DST.clipping.updated = false;
709 }
710
711 void DRW_viewport_matrix_override_unset_all(void)
712 {
713   memcpy(DST.view_data.matstate.mat, DST.original_mat.mat, sizeof(DRWMatrixState));
714   DST.override_mat = 0;
715   DST.dirty_mat = true;
716   DST.clipping.updated = false;
717 }
718
719 bool DRW_viewport_is_persp_get(void)
720 {
721   RegionView3D *rv3d = DST.draw_ctx.rv3d;
722   if (rv3d) {
723     return rv3d->is_persp;
724   }
725   else {
726     return DST.view_data.matstate.mat[DRW_MAT_WIN][3][3] == 0.0f;
727   }
728 }
729
730 float DRW_viewport_near_distance_get(void)
731 {
732   float projmat[4][4];
733   DRW_viewport_matrix_get(projmat, DRW_MAT_WIN);
734
735   if (DRW_viewport_is_persp_get()) {
736     return -projmat[3][2] / (projmat[2][2] - 1.0f);
737   }
738   else {
739     return -(projmat[3][2] + 1.0f) / projmat[2][2];
740   }
741 }
742
743 float DRW_viewport_far_distance_get(void)
744 {
745   float projmat[4][4];
746   DRW_viewport_matrix_get(projmat, DRW_MAT_WIN);
747
748   if (DRW_viewport_is_persp_get()) {
749     return -projmat[3][2] / (projmat[2][2] + 1.0f);
750   }
751   else {
752     return -(projmat[3][2] - 1.0f) / projmat[2][2];
753   }
754 }
755
756 DefaultFramebufferList *DRW_viewport_framebuffer_list_get(void)
757 {
758   return GPU_viewport_framebuffer_list_get(DST.viewport);
759 }
760
761 DefaultTextureList *DRW_viewport_texture_list_get(void)
762 {
763   return GPU_viewport_texture_list_get(DST.viewport);
764 }
765
766 void DRW_viewport_request_redraw(void)
767 {
768   GPU_viewport_tag_update(DST.viewport);
769 }
770
771 /** \} */
772
773 /* -------------------------------------------------------------------- */
774 /** \name ViewLayers (DRW_scenelayer)
775  * \{ */
776
777 void *DRW_view_layer_engine_data_get(DrawEngineType *engine_type)
778 {
779   for (ViewLayerEngineData *sled = DST.draw_ctx.view_layer->drawdata.first; sled;
780        sled = sled->next) {
781     if (sled->engine_type == engine_type) {
782       return sled->storage;
783     }
784   }
785   return NULL;
786 }
787
788 void **DRW_view_layer_engine_data_ensure_ex(ViewLayer *view_layer,
789                                             DrawEngineType *engine_type,
790                                             void (*callback)(void *storage))
791 {
792   ViewLayerEngineData *sled;
793
794   for (sled = view_layer->drawdata.first; sled; sled = sled->next) {
795     if (sled->engine_type == engine_type) {
796       return &sled->storage;
797     }
798   }
799
800   sled = MEM_callocN(sizeof(ViewLayerEngineData), "ViewLayerEngineData");
801   sled->engine_type = engine_type;
802   sled->free = callback;
803   BLI_addtail(&view_layer->drawdata, sled);
804
805   return &sled->storage;
806 }
807
808 void **DRW_view_layer_engine_data_ensure(DrawEngineType *engine_type,
809                                          void (*callback)(void *storage))
810 {
811   return DRW_view_layer_engine_data_ensure_ex(DST.draw_ctx.view_layer, engine_type, callback);
812 }
813
814 /** \} */
815
816 /* -------------------------------------------------------------------- */
817 /** \name Draw Data (DRW_drawdata)
818  * \{ */
819
820 /* Used for DRW_drawdata_from_id()
821  * All ID-datablocks which have their own 'local' DrawData
822  * should have the same arrangement in their structs.
823  */
824 typedef struct IdDdtTemplate {
825   ID id;
826   struct AnimData *adt;
827   DrawDataList drawdata;
828 } IdDdtTemplate;
829
830 /* Check if ID can have AnimData */
831 static bool id_type_can_have_drawdata(const short id_type)
832 {
833   /* Only some ID-blocks have this info for now */
834   /* TODO: finish adding this for the other blocktypes */
835   switch (id_type) {
836     /* has DrawData */
837     case ID_OB:
838     case ID_WO:
839       return true;
840
841     /* no DrawData */
842     default:
843       return false;
844   }
845 }
846
847 static bool id_can_have_drawdata(const ID *id)
848 {
849   /* sanity check */
850   if (id == NULL) {
851     return false;
852   }
853
854   return id_type_can_have_drawdata(GS(id->name));
855 }
856
857 /* Get DrawData from the given ID-block. In order for this to work, we assume that
858  * the DrawData pointer is stored in the struct in the same fashion as in IdDdtTemplate.
859  */
860 DrawDataList *DRW_drawdatalist_from_id(ID *id)
861 {
862   /* only some ID-blocks have this info for now, so we cast the
863    * types that do to be of type IdDdtTemplate, and extract the
864    * DrawData that way
865    */
866   if (id_can_have_drawdata(id)) {
867     IdDdtTemplate *idt = (IdDdtTemplate *)id;
868     return &idt->drawdata;
869   }
870   else {
871     return NULL;
872   }
873 }
874
875 DrawData *DRW_drawdata_get(ID *id, DrawEngineType *engine_type)
876 {
877   DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
878
879   if (drawdata == NULL) {
880     return NULL;
881   }
882
883   LISTBASE_FOREACH (DrawData *, dd, drawdata) {
884     if (dd->engine_type == engine_type) {
885       return dd;
886     }
887   }
888   return NULL;
889 }
890
891 DrawData *DRW_drawdata_ensure(ID *id,
892                               DrawEngineType *engine_type,
893                               size_t size,
894                               DrawDataInitCb init_cb,
895                               DrawDataFreeCb free_cb)
896 {
897   BLI_assert(size >= sizeof(DrawData));
898   BLI_assert(id_can_have_drawdata(id));
899   /* Try to re-use existing data. */
900   DrawData *dd = DRW_drawdata_get(id, engine_type);
901   if (dd != NULL) {
902     return dd;
903   }
904
905   DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
906
907   /* Allocate new data. */
908   if ((GS(id->name) == ID_OB) && (((Object *)id)->base_flag & BASE_FROM_DUPLI) != 0) {
909     /* NOTE: data is not persistent in this case. It is reset each redraw. */
910     BLI_assert(free_cb == NULL); /* No callback allowed. */
911     /* Round to sizeof(float) for DRW_instance_data_request(). */
912     const size_t t = sizeof(float) - 1;
913     size = (size + t) & ~t;
914     size_t fsize = size / sizeof(float);
915     BLI_assert(fsize < MAX_INSTANCE_DATA_SIZE);
916     if (DST.object_instance_data[fsize] == NULL) {
917       DST.object_instance_data[fsize] = DRW_instance_data_request(DST.idatalist, fsize);
918     }
919     dd = (DrawData *)DRW_instance_data_next(DST.object_instance_data[fsize]);
920     memset(dd, 0, size);
921   }
922   else {
923     dd = MEM_callocN(size, "DrawData");
924   }
925   dd->engine_type = engine_type;
926   dd->free = free_cb;
927   /* Perform user-side initialization, if needed. */
928   if (init_cb != NULL) {
929     init_cb(dd);
930   }
931   /* Register in the list. */
932   BLI_addtail((ListBase *)drawdata, dd);
933   return dd;
934 }
935
936 void DRW_drawdata_free(ID *id)
937 {
938   DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
939
940   if (drawdata == NULL) {
941     return;
942   }
943
944   LISTBASE_FOREACH (DrawData *, dd, drawdata) {
945     if (dd->free != NULL) {
946       dd->free(dd);
947     }
948   }
949
950   BLI_freelistN((ListBase *)drawdata);
951 }
952
953 /* Unlink (but don't free) the drawdata from the DrawDataList if the ID is an OB from dupli. */
954 static void drw_drawdata_unlink_dupli(ID *id)
955 {
956   if ((GS(id->name) == ID_OB) && (((Object *)id)->base_flag & BASE_FROM_DUPLI) != 0) {
957     DrawDataList *drawdata = DRW_drawdatalist_from_id(id);
958
959     if (drawdata == NULL) {
960       return;
961     }
962
963     BLI_listbase_clear((ListBase *)drawdata);
964   }
965 }
966
967 /** \} */
968
969 /* -------------------------------------------------------------------- */
970 /** \name Rendering (DRW_engines)
971  * \{ */
972
973 #define DRW_BATCH_COLLECTION_RATE 60 /* in sec */
974
975 void DRW_cache_free_old_batches(Main *bmain)
976 {
977   Scene *scene;
978   ViewLayer *view_layer;
979   static int lasttime = 0;
980   int ctime = (int)PIL_check_seconds_timer();
981
982   if (ctime % DRW_BATCH_COLLECTION_RATE || ctime == lasttime)
983     return;
984
985   lasttime = ctime;
986
987   for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
988     for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
989       Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, false);
990
991       /* TODO(fclem): This is not optimal since it iter over all dupli instances.
992        * In this case only the source object should be tagged. */
993       int iter_flags = DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY | DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET |
994                        DEG_ITER_OBJECT_FLAG_VISIBLE | DEG_ITER_OBJECT_FLAG_DUPLI;
995
996       DEG_OBJECT_ITER_BEGIN (depsgraph, ob, iter_flags) {
997         DRW_batch_cache_free_old(ob, ctime);
998       }
999       DEG_OBJECT_ITER_END;
1000     }
1001   }
1002 }
1003
1004 /** \} */
1005
1006 /* -------------------------------------------------------------------- */
1007 /** \name Rendering (DRW_engines)
1008  * \{ */
1009
1010 static void drw_engines_init(void)
1011 {
1012   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1013     DrawEngineType *engine = link->data;
1014     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1015     PROFILE_START(stime);
1016
1017     if (engine->engine_init) {
1018       engine->engine_init(data);
1019     }
1020
1021     PROFILE_END_UPDATE(data->init_time, stime);
1022   }
1023 }
1024
1025 static void drw_engines_cache_init(void)
1026 {
1027   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1028     DrawEngineType *engine = link->data;
1029     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1030
1031     if (data->text_draw_cache) {
1032       DRW_text_cache_destroy(data->text_draw_cache);
1033       data->text_draw_cache = NULL;
1034     }
1035     if (DST.text_store_p == NULL) {
1036       DST.text_store_p = &data->text_draw_cache;
1037     }
1038
1039     if (engine->cache_init) {
1040       engine->cache_init(data);
1041     }
1042   }
1043 }
1044
1045 static void drw_engines_world_update(Scene *scene)
1046 {
1047   if (scene->world == NULL) {
1048     return;
1049   }
1050
1051   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1052     DrawEngineType *engine = link->data;
1053     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1054
1055     if (engine->id_update) {
1056       engine->id_update(data, &scene->world->id);
1057     }
1058   }
1059 }
1060
1061 static void drw_engines_cache_populate(Object *ob)
1062 {
1063   DST.ob_state = NULL;
1064
1065   /* HACK: DrawData is copied by COW from the duplicated object.
1066    * This is valid for IDs that cannot be instantiated but this
1067    * is not what we want in this case so we clear the pointer
1068    * ourselves here. */
1069   drw_drawdata_unlink_dupli((ID *)ob);
1070
1071   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1072     DrawEngineType *engine = link->data;
1073     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1074
1075     if (engine->id_update) {
1076       engine->id_update(data, &ob->id);
1077     }
1078
1079     if (engine->cache_populate) {
1080       engine->cache_populate(data, ob);
1081     }
1082   }
1083
1084   /* TODO: in the future it would be nice to generate once for all viewports.
1085    * But we need threaded DRW manager first. */
1086   drw_batch_cache_generate_requested(ob);
1087
1088   /* ... and clearing it here too because theses draw data are
1089    * from a mempool and must not be free individually by depsgraph. */
1090   drw_drawdata_unlink_dupli((ID *)ob);
1091 }
1092
1093 static void drw_engines_cache_finish(void)
1094 {
1095   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1096     DrawEngineType *engine = link->data;
1097     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1098
1099     if (engine->cache_finish) {
1100       engine->cache_finish(data);
1101     }
1102   }
1103 }
1104
1105 static void drw_engines_draw_background(void)
1106 {
1107   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1108     DrawEngineType *engine = link->data;
1109     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1110
1111     if (engine->draw_background) {
1112       PROFILE_START(stime);
1113
1114       DRW_stats_group_start(engine->idname);
1115       engine->draw_background(data);
1116       DRW_stats_group_end();
1117
1118       PROFILE_END_UPDATE(data->background_time, stime);
1119       return;
1120     }
1121   }
1122
1123   /* No draw_background found, doing default background */
1124   if (DRW_state_draw_background()) {
1125     DRW_draw_background();
1126   }
1127 }
1128
1129 static void drw_engines_draw_scene(void)
1130 {
1131   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1132     DrawEngineType *engine = link->data;
1133     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1134     PROFILE_START(stime);
1135
1136     if (engine->draw_scene) {
1137       DRW_stats_group_start(engine->idname);
1138       engine->draw_scene(data);
1139       /* Restore for next engine */
1140       if (DRW_state_is_fbo()) {
1141         GPU_framebuffer_bind(DST.default_framebuffer);
1142       }
1143       DRW_stats_group_end();
1144     }
1145
1146     PROFILE_END_UPDATE(data->render_time, stime);
1147   }
1148   /* Reset state after drawing */
1149   DRW_state_reset();
1150 }
1151
1152 static void drw_engines_draw_text(void)
1153 {
1154   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1155     DrawEngineType *engine = link->data;
1156     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1157     PROFILE_START(stime);
1158
1159     if (data->text_draw_cache) {
1160       DRW_text_cache_draw(data->text_draw_cache, DST.draw_ctx.ar);
1161     }
1162
1163     PROFILE_END_UPDATE(data->render_time, stime);
1164   }
1165 }
1166
1167 /* Draw render engine info. */
1168 void DRW_draw_region_engine_info(int xoffset, int yoffset)
1169 {
1170   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1171     DrawEngineType *engine = link->data;
1172     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1173
1174     if (data->info[0] != '\0') {
1175       char *chr_current = data->info;
1176       char *chr_start = chr_current;
1177       int line_len = 0;
1178
1179       const int font_id = BLF_default();
1180       UI_FontThemeColor(font_id, TH_TEXT_HI);
1181
1182       BLF_enable(font_id, BLF_SHADOW);
1183       BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1184       BLF_shadow_offset(font_id, 1, -1);
1185
1186       while (*chr_current++ != '\0') {
1187         line_len++;
1188         if (*chr_current == '\n') {
1189           char info[GPU_INFO_SIZE];
1190           BLI_strncpy(info, chr_start, line_len + 1);
1191           yoffset -= U.widget_unit;
1192           BLF_draw_default(xoffset, yoffset, 0.0f, info, sizeof(info));
1193
1194           /* Re-start counting. */
1195           chr_start = chr_current + 1;
1196           line_len = -1;
1197         }
1198       }
1199
1200       char info[GPU_INFO_SIZE];
1201       BLI_strncpy(info, chr_start, line_len + 1);
1202       yoffset -= U.widget_unit;
1203       BLF_draw_default(xoffset, yoffset, 0.0f, info, sizeof(info));
1204
1205       BLF_disable(font_id, BLF_SHADOW);
1206     }
1207   }
1208 }
1209
1210 static void use_drw_engine(DrawEngineType *engine)
1211 {
1212   LinkData *ld = MEM_callocN(sizeof(LinkData), "enabled engine link data");
1213   ld->data = engine;
1214   BLI_addtail(&DST.enabled_engines, ld);
1215 }
1216
1217 /**
1218  * Use for external render engines.
1219  */
1220 static void drw_engines_enable_external(void)
1221 {
1222   use_drw_engine(DRW_engine_viewport_external_type.draw_engine);
1223 }
1224
1225 /* TODO revisit this when proper layering is implemented */
1226 /* Gather all draw engines needed and store them in DST.enabled_engines
1227  * That also define the rendering order of engines */
1228 static void drw_engines_enable_from_engine(RenderEngineType *engine_type,
1229                                            int drawtype,
1230                                            bool use_xray)
1231 {
1232   switch (drawtype) {
1233     case OB_WIRE:
1234       use_drw_engine(&draw_engine_workbench_transparent);
1235       break;
1236
1237     case OB_SOLID:
1238       if (use_xray) {
1239         use_drw_engine(&draw_engine_workbench_transparent);
1240       }
1241       else {
1242         use_drw_engine(&draw_engine_workbench_solid);
1243       }
1244       break;
1245
1246     case OB_MATERIAL:
1247     case OB_RENDER:
1248     default:
1249       /* TODO layers */
1250       if (engine_type->draw_engine != NULL) {
1251         use_drw_engine(engine_type->draw_engine);
1252       }
1253
1254       if ((engine_type->flag & RE_INTERNAL) == 0) {
1255         drw_engines_enable_external();
1256       }
1257       break;
1258   }
1259 }
1260
1261 static void drw_engines_enable_from_object_mode(void)
1262 {
1263   use_drw_engine(&draw_engine_object_type);
1264   /* TODO(fclem) remove this, it does not belong to it's own engine. */
1265   use_drw_engine(&draw_engine_motion_path_type);
1266 }
1267
1268 static void drw_engines_enable_from_paint_mode(int mode)
1269 {
1270   switch (mode) {
1271     case CTX_MODE_SCULPT:
1272       use_drw_engine(&draw_engine_sculpt_type);
1273       break;
1274     case CTX_MODE_PAINT_WEIGHT:
1275     case CTX_MODE_PAINT_VERTEX:
1276       use_drw_engine(&draw_engine_paint_vertex_type);
1277       break;
1278     case CTX_MODE_PAINT_TEXTURE:
1279       use_drw_engine(&draw_engine_paint_texture_type);
1280       break;
1281     default:
1282       break;
1283   }
1284 }
1285
1286 static void drw_engines_enable_from_mode(int mode)
1287 {
1288   switch (mode) {
1289     case CTX_MODE_EDIT_MESH:
1290       use_drw_engine(&draw_engine_edit_mesh_type);
1291       break;
1292     case CTX_MODE_EDIT_SURFACE:
1293     case CTX_MODE_EDIT_CURVE:
1294       use_drw_engine(&draw_engine_edit_curve_type);
1295       break;
1296     case CTX_MODE_EDIT_TEXT:
1297       use_drw_engine(&draw_engine_edit_text_type);
1298       break;
1299     case CTX_MODE_EDIT_ARMATURE:
1300       use_drw_engine(&draw_engine_edit_armature_type);
1301       break;
1302     case CTX_MODE_EDIT_METABALL:
1303       use_drw_engine(&draw_engine_edit_metaball_type);
1304       break;
1305     case CTX_MODE_EDIT_LATTICE:
1306       use_drw_engine(&draw_engine_edit_lattice_type);
1307       break;
1308     case CTX_MODE_PARTICLE:
1309       use_drw_engine(&draw_engine_particle_type);
1310       break;
1311     case CTX_MODE_POSE:
1312     case CTX_MODE_PAINT_WEIGHT:
1313       /* The pose engine clears the depth of the default framebuffer
1314        * to draw an object with `OB_DRAWXRAY`.
1315        * (different of workbench that has its own framebuffer).
1316        * So make sure you call its `draw_scene` after all the other engines. */
1317       use_drw_engine(&draw_engine_pose_type);
1318       break;
1319     case CTX_MODE_SCULPT:
1320     case CTX_MODE_PAINT_VERTEX:
1321     case CTX_MODE_PAINT_TEXTURE:
1322     case CTX_MODE_OBJECT:
1323     case CTX_MODE_PAINT_GPENCIL:
1324     case CTX_MODE_EDIT_GPENCIL:
1325     case CTX_MODE_SCULPT_GPENCIL:
1326     case CTX_MODE_WEIGHT_GPENCIL:
1327       break;
1328     default:
1329       BLI_assert(!"Draw mode invalid");
1330       break;
1331   }
1332 }
1333
1334 static void drw_engines_enable_from_overlays(int UNUSED(overlay_flag))
1335 {
1336   use_drw_engine(&draw_engine_overlay_type);
1337 }
1338 /**
1339  * Use for select and depth-drawing.
1340  */
1341 static void drw_engines_enable_basic(void)
1342 {
1343   use_drw_engine(DRW_engine_viewport_basic_type.draw_engine);
1344 }
1345
1346 static void drw_engines_enable(ViewLayer *view_layer, RenderEngineType *engine_type)
1347 {
1348   Object *obact = OBACT(view_layer);
1349   const enum eContextObjectMode mode = CTX_data_mode_enum_ex(
1350       DST.draw_ctx.object_edit, obact, DST.draw_ctx.object_mode);
1351   View3D *v3d = DST.draw_ctx.v3d;
1352   const int drawtype = v3d->shading.type;
1353   const bool use_xray = XRAY_ENABLED(v3d);
1354
1355   drw_engines_enable_from_engine(engine_type, drawtype, use_xray);
1356   /* grease pencil */
1357   use_drw_engine(&draw_engine_gpencil_type);
1358
1359   if (DRW_state_draw_support()) {
1360     /* Draw paint modes first so that they are drawn below the wireframes. */
1361     drw_engines_enable_from_paint_mode(mode);
1362     drw_engines_enable_from_overlays(v3d->overlay.flag);
1363     drw_engines_enable_from_object_mode();
1364     drw_engines_enable_from_mode(mode);
1365   }
1366   else {
1367     /* Force enable overlays engine for wireframe mode */
1368     if (v3d->shading.type == OB_WIRE) {
1369       drw_engines_enable_from_overlays(v3d->overlay.flag);
1370     }
1371   }
1372 }
1373
1374 static void drw_engines_disable(void)
1375 {
1376   BLI_freelistN(&DST.enabled_engines);
1377 }
1378
1379 static uint DRW_engines_get_hash(void)
1380 {
1381   uint hash = 0;
1382   /* The cache depends on enabled engines */
1383   /* FIXME : if collision occurs ... segfault */
1384   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1385     DrawEngineType *engine = link->data;
1386     hash += BLI_ghashutil_strhash_p(engine->idname);
1387   }
1388
1389   return hash;
1390 }
1391
1392 /* -------------------------------------------------------------------- */
1393 /** \name View Update
1394  * \{ */
1395
1396 void DRW_notify_view_update(const DRWUpdateContext *update_ctx)
1397 {
1398   RenderEngineType *engine_type = update_ctx->engine_type;
1399   ARegion *ar = update_ctx->ar;
1400   View3D *v3d = update_ctx->v3d;
1401   RegionView3D *rv3d = ar->regiondata;
1402   Depsgraph *depsgraph = update_ctx->depsgraph;
1403   Scene *scene = update_ctx->scene;
1404   ViewLayer *view_layer = update_ctx->view_layer;
1405
1406   /* Separate update for each stereo view. */
1407   for (int view = 0; view < 2; view++) {
1408     GPUViewport *viewport = WM_draw_region_get_viewport(ar, view);
1409     if (!viewport) {
1410       continue;
1411     }
1412
1413     /* XXX Really nasty locking. But else this could
1414      * be executed by the material previews thread
1415      * while rendering a viewport. */
1416     BLI_ticket_mutex_lock(DST.gl_context_mutex);
1417
1418     /* Reset before using it. */
1419     drw_state_prepare_clean_for_draw(&DST);
1420
1421     DST.viewport = viewport;
1422     DST.draw_ctx = (DRWContextState){
1423         .ar = ar,
1424         .rv3d = rv3d,
1425         .v3d = v3d,
1426         .scene = scene,
1427         .view_layer = view_layer,
1428         .obact = OBACT(view_layer),
1429         .engine_type = engine_type,
1430         .depsgraph = depsgraph,
1431         .object_mode = OB_MODE_OBJECT,
1432     };
1433
1434     drw_engines_enable(view_layer, engine_type);
1435
1436     for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1437       DrawEngineType *draw_engine = link->data;
1438       ViewportEngineData *data = drw_viewport_engine_data_ensure(draw_engine);
1439
1440       if (draw_engine->view_update) {
1441         draw_engine->view_update(data);
1442       }
1443     }
1444
1445     DST.viewport = NULL;
1446
1447     drw_engines_disable();
1448
1449     BLI_ticket_mutex_unlock(DST.gl_context_mutex);
1450   }
1451 }
1452
1453 /** \} */
1454
1455 /* -------------------------------------------------------------------- */
1456 /** \name Main Draw Loops (DRW_draw)
1457  * \{ */
1458
1459 /* Everything starts here.
1460  * This function takes care of calling all cache and rendering functions
1461  * for each relevant engine / mode engine. */
1462 void DRW_draw_view(const bContext *C)
1463 {
1464   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1465   ARegion *ar = CTX_wm_region(C);
1466   View3D *v3d = CTX_wm_view3d(C);
1467   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1468   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
1469   GPUViewport *viewport = WM_draw_region_get_bound_viewport(ar);
1470
1471   /* Reset before using it. */
1472   drw_state_prepare_clean_for_draw(&DST);
1473   DST.options.draw_text = ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0 &&
1474                            (v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) != 0);
1475   DRW_draw_render_loop_ex(depsgraph, engine_type, ar, v3d, viewport, C);
1476 }
1477
1478 /**
1479  * Used for both regular and off-screen drawing.
1480  * Need to reset DST before calling this function
1481  */
1482 void DRW_draw_render_loop_ex(struct Depsgraph *depsgraph,
1483                              RenderEngineType *engine_type,
1484                              ARegion *ar,
1485                              View3D *v3d,
1486                              GPUViewport *viewport,
1487                              const bContext *evil_C)
1488 {
1489
1490   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1491   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
1492   RegionView3D *rv3d = ar->regiondata;
1493   const bool do_annotations = (((v3d->flag2 & V3D_SHOW_ANNOTATION) != 0) &&
1494                                ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0));
1495   const bool do_camera_frame = !DST.options.is_image_render;
1496
1497   DST.draw_ctx.evil_C = evil_C;
1498   DST.viewport = viewport;
1499
1500   /* Setup viewport */
1501   GPU_viewport_engines_data_validate(DST.viewport, DRW_engines_get_hash());
1502
1503   DST.draw_ctx = (DRWContextState){
1504       .ar = ar,
1505       .rv3d = rv3d,
1506       .v3d = v3d,
1507       .scene = scene,
1508       .view_layer = view_layer,
1509       .obact = OBACT(view_layer),
1510       .engine_type = engine_type,
1511       .depsgraph = depsgraph,
1512
1513       /* reuse if caller sets */
1514       .evil_C = DST.draw_ctx.evil_C,
1515   };
1516   drw_context_state_init();
1517   drw_viewport_var_init();
1518
1519   /* Get list of enabled engines */
1520   drw_engines_enable(view_layer, engine_type);
1521
1522   /* Update ubos */
1523   DRW_globals_update();
1524
1525   drw_debug_init();
1526   DRW_hair_init();
1527
1528   /* No framebuffer allowed before drawing. */
1529   BLI_assert(GPU_framebuffer_active_get() == NULL);
1530
1531   /* Init engines */
1532   drw_engines_init();
1533
1534   /* Cache filling */
1535   {
1536     PROFILE_START(stime);
1537     drw_engines_cache_init();
1538     drw_engines_world_update(scene);
1539
1540     const int object_type_exclude_viewport = v3d->object_type_exclude_viewport;
1541     DEG_OBJECT_ITER_BEGIN (depsgraph,
1542                            ob,
1543                            DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
1544                                DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET | DEG_ITER_OBJECT_FLAG_VISIBLE |
1545                                DEG_ITER_OBJECT_FLAG_DUPLI) {
1546       if ((object_type_exclude_viewport & (1 << ob->type)) != 0) {
1547         continue;
1548       }
1549       if (v3d->localvd && ((v3d->local_view_uuid & ob->base_local_view_bits) == 0)) {
1550         continue;
1551       }
1552       DST.dupli_parent = data_.dupli_parent;
1553       DST.dupli_source = data_.dupli_object_current;
1554       drw_engines_cache_populate(ob);
1555     }
1556     DEG_OBJECT_ITER_END;
1557
1558     drw_engines_cache_finish();
1559
1560     DRW_render_instance_buffer_finish();
1561
1562 #ifdef USE_PROFILE
1563     double *cache_time = GPU_viewport_cache_time_get(DST.viewport);
1564     PROFILE_END_UPDATE(*cache_time, stime);
1565 #endif
1566   }
1567
1568   DRW_stats_begin();
1569
1570   GPU_framebuffer_bind(DST.default_framebuffer);
1571
1572   /* Start Drawing */
1573   DRW_state_reset();
1574
1575   DRW_hair_update();
1576
1577   drw_engines_draw_background();
1578
1579   /* WIP, single image drawn over the camera view (replace) */
1580   bool do_bg_image = false;
1581   if (rv3d->persp == RV3D_CAMOB) {
1582     Object *cam_ob = v3d->camera;
1583     if (cam_ob && cam_ob->type == OB_CAMERA) {
1584       Camera *cam = cam_ob->data;
1585       if (!BLI_listbase_is_empty(&cam->bg_images)) {
1586         do_bg_image = true;
1587       }
1588     }
1589   }
1590
1591   GPU_framebuffer_bind(DST.default_framebuffer);
1592
1593   if (do_bg_image) {
1594     ED_view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, false, do_camera_frame);
1595   }
1596
1597   DRW_draw_callbacks_pre_scene();
1598   if (DST.draw_ctx.evil_C) {
1599     ED_region_draw_cb_draw(DST.draw_ctx.evil_C, DST.draw_ctx.ar, REGION_DRAW_PRE_VIEW);
1600   }
1601
1602   drw_engines_draw_scene();
1603
1604 #ifdef __APPLE__
1605   /* Fix 3D view being "laggy" on macos. (See T56996) */
1606   GPU_flush();
1607 #endif
1608
1609   /* annotations - temporary drawing buffer (3d space) */
1610   /* XXX: Or should we use a proper draw/overlay engine for this case? */
1611   if (do_annotations) {
1612     GPU_depth_test(false);
1613     /* XXX: as scene->gpd is not copied for COW yet */
1614     ED_annotation_draw_view3d(DEG_get_input_scene(depsgraph), depsgraph, v3d, ar, true);
1615     GPU_depth_test(true);
1616   }
1617
1618   DRW_draw_callbacks_post_scene();
1619   if (DST.draw_ctx.evil_C) {
1620     DRW_state_reset();
1621     ED_region_draw_cb_draw(DST.draw_ctx.evil_C, DST.draw_ctx.ar, REGION_DRAW_POST_VIEW);
1622     /* Callback can be nasty and do whatever they want with the state.
1623      * Don't trust them! */
1624     DRW_state_reset();
1625   }
1626
1627   DRW_state_reset();
1628
1629   drw_debug_draw();
1630
1631   GPU_depth_test(false);
1632   drw_engines_draw_text();
1633   GPU_depth_test(true);
1634
1635   if (DST.draw_ctx.evil_C) {
1636     /* needed so gizmo isn't obscured */
1637     if ((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) {
1638       glDisable(GL_DEPTH_TEST);
1639       DRW_draw_gizmo_3d();
1640     }
1641
1642     DRW_draw_region_info();
1643
1644     /* annotations - temporary drawing buffer (screenspace) */
1645     /* XXX: Or should we use a proper draw/overlay engine for this case? */
1646     if (((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) && (do_annotations)) {
1647       GPU_depth_test(false);
1648       /* XXX: as scene->gpd is not copied for COW yet */
1649       ED_annotation_draw_view3d(DEG_get_input_scene(depsgraph), depsgraph, v3d, ar, false);
1650       GPU_depth_test(true);
1651     }
1652
1653     if ((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) {
1654       /* Draw 2D after region info so we can draw on top of the camera passepartout overlay.
1655        * 'DRW_draw_region_info' sets the projection in pixel-space. */
1656       GPU_depth_test(false);
1657       DRW_draw_gizmo_2d();
1658       GPU_depth_test(true);
1659     }
1660   }
1661
1662   DRW_stats_reset();
1663
1664   if (do_bg_image) {
1665     ED_view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, true, do_camera_frame);
1666   }
1667
1668   if (G.debug_value > 20 && G.debug_value < 30) {
1669     GPU_depth_test(false);
1670     rcti rect; /* local coordinate visible rect inside region, to accommodate overlapping ui */
1671     ED_region_visible_rect(DST.draw_ctx.ar, &rect);
1672     DRW_stats_draw(&rect);
1673     GPU_depth_test(true);
1674   }
1675
1676   if (WM_draw_region_get_bound_viewport(ar)) {
1677     /* Don't unbind the framebuffer yet in this case and let
1678      * GPU_viewport_unbind do it, so that we can still do further
1679      * drawing of action zones on top. */
1680   }
1681   else {
1682     GPU_framebuffer_restore();
1683   }
1684
1685   DRW_state_reset();
1686   drw_engines_disable();
1687
1688   drw_viewport_cache_resize();
1689
1690 #ifdef DEBUG
1691   /* Avoid accidental reuse. */
1692   drw_state_ensure_not_reused(&DST);
1693 #endif
1694 }
1695
1696 void DRW_draw_render_loop(struct Depsgraph *depsgraph,
1697                           ARegion *ar,
1698                           View3D *v3d,
1699                           GPUViewport *viewport)
1700 {
1701   /* Reset before using it. */
1702   drw_state_prepare_clean_for_draw(&DST);
1703
1704   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1705   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
1706
1707   DRW_draw_render_loop_ex(depsgraph, engine_type, ar, v3d, viewport, NULL);
1708 }
1709
1710 /* @viewport CAN be NULL, in this case we create one. */
1711 void DRW_draw_render_loop_offscreen(struct Depsgraph *depsgraph,
1712                                     RenderEngineType *engine_type,
1713                                     ARegion *ar,
1714                                     View3D *v3d,
1715                                     const bool draw_background,
1716                                     const bool do_color_management,
1717                                     GPUOffScreen *ofs,
1718                                     GPUViewport *viewport)
1719 {
1720   /* Create temporary viewport if needed. */
1721   GPUViewport *render_viewport = viewport;
1722   if (viewport == NULL) {
1723     render_viewport = GPU_viewport_create_from_offscreen(ofs);
1724   }
1725
1726   GPU_framebuffer_restore();
1727
1728   /* Reset before using it. */
1729   drw_state_prepare_clean_for_draw(&DST);
1730   /* WATCH: Force color management to output CManaged byte buffer by
1731    * forcing is_image_render to false. */
1732   DST.options.is_image_render = !do_color_management;
1733   DST.options.draw_background = draw_background;
1734   DRW_draw_render_loop_ex(depsgraph, engine_type, ar, v3d, render_viewport, NULL);
1735
1736   /* Free temporary viewport. */
1737   if (viewport == NULL) {
1738     /* don't free data owned by 'ofs' */
1739     GPU_viewport_clear_from_offscreen(render_viewport);
1740     GPU_viewport_free(render_viewport);
1741   }
1742
1743   /* we need to re-bind (annoying!) */
1744   GPU_offscreen_bind(ofs, false);
1745 }
1746
1747 /* Helper to check if exit object type to render. */
1748 bool DRW_render_check_grease_pencil(Depsgraph *depsgraph)
1749 {
1750   DEG_OBJECT_ITER_FOR_RENDER_ENGINE_BEGIN (depsgraph, ob) {
1751     if (ob->type == OB_GPENCIL) {
1752       if (DRW_object_visibility_in_active_context(ob) & OB_VISIBLE_SELF) {
1753         return true;
1754       }
1755     }
1756   }
1757   DEG_OBJECT_ITER_FOR_RENDER_ENGINE_END;
1758
1759   return false;
1760 }
1761
1762 static void DRW_render_gpencil_to_image(RenderEngine *engine,
1763                                         struct RenderLayer *render_layer,
1764                                         const rcti *rect)
1765 {
1766   if (draw_engine_gpencil_type.render_to_image) {
1767     ViewportEngineData *gpdata = drw_viewport_engine_data_ensure(&draw_engine_gpencil_type);
1768     draw_engine_gpencil_type.render_to_image(gpdata, engine, render_layer, rect);
1769   }
1770 }
1771
1772 void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph)
1773 {
1774   /* This function is only valid for Cycles
1775    * Eevee done all work in the Eevee render directly.
1776    * Maybe it can be done equal for both engines?
1777    */
1778   if (STREQ(engine->type->name, "Eevee")) {
1779     return;
1780   }
1781
1782   /* Early out if there are no grease pencil objects, especially important
1783    * to avoid failing in in background renders without OpenGL context. */
1784   if (!DRW_render_check_grease_pencil(depsgraph)) {
1785     return;
1786   }
1787
1788   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1789   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
1790   RenderEngineType *engine_type = engine->type;
1791   RenderData *r = &scene->r;
1792   Render *render = engine->re;
1793   /* Changing Context */
1794   if (G.background && DST.gl_context == NULL) {
1795     WM_init_opengl(G_MAIN);
1796   }
1797
1798   void *re_gl_context = RE_gl_context_get(render);
1799   void *re_gpu_context = NULL;
1800
1801   /* Changing Context */
1802   if (re_gl_context != NULL) {
1803     DRW_opengl_render_context_enable(re_gl_context);
1804     /* We need to query gpu context after a gl context has been bound. */
1805     re_gpu_context = RE_gpu_context_get(render);
1806     DRW_gawain_render_context_enable(re_gpu_context);
1807   }
1808   else {
1809     DRW_opengl_context_enable();
1810   }
1811
1812   /* Reset before using it. */
1813   drw_state_prepare_clean_for_draw(&DST);
1814   DST.options.is_image_render = true;
1815   DST.options.is_scene_render = true;
1816   DST.options.draw_background = scene->r.alphamode == R_ADDSKY;
1817   DST.buffer_finish_called = true;
1818
1819   DST.draw_ctx = (DRWContextState){
1820       .scene = scene,
1821       .view_layer = view_layer,
1822       .engine_type = engine_type,
1823       .depsgraph = depsgraph,
1824       .object_mode = OB_MODE_OBJECT,
1825   };
1826   drw_context_state_init();
1827
1828   DST.viewport = GPU_viewport_create();
1829   const int size[2] = {(r->size * r->xsch) / 100, (r->size * r->ysch) / 100};
1830   GPU_viewport_size_set(DST.viewport, size);
1831
1832   drw_viewport_var_init();
1833
1834   /* Main rendering. */
1835   rctf view_rect;
1836   rcti render_rect;
1837   RE_GetViewPlane(render, &view_rect, &render_rect);
1838   if (BLI_rcti_is_empty(&render_rect)) {
1839     BLI_rcti_init(&render_rect, 0, size[0], 0, size[1]);
1840   }
1841
1842   RenderResult *render_result = RE_engine_get_result(engine);
1843   RenderLayer *render_layer = render_result->layers.first;
1844
1845   DRW_render_gpencil_to_image(engine, render_layer, &render_rect);
1846
1847   /* Force cache to reset. */
1848   drw_viewport_cache_resize();
1849   GPU_viewport_free(DST.viewport);
1850   DRW_state_reset();
1851
1852   glDisable(GL_DEPTH_TEST);
1853
1854   /* Restore Drawing area. */
1855   GPU_framebuffer_restore();
1856
1857   /* Changing Context */
1858   /* GPXX Review this context */
1859   DRW_opengl_context_disable();
1860
1861   DST.buffer_finish_called = false;
1862 }
1863
1864 void DRW_render_to_image(RenderEngine *engine, struct Depsgraph *depsgraph)
1865 {
1866   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1867   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
1868   RenderEngineType *engine_type = engine->type;
1869   DrawEngineType *draw_engine_type = engine_type->draw_engine;
1870   Render *render = engine->re;
1871
1872   if (G.background && DST.gl_context == NULL) {
1873     WM_init_opengl(G_MAIN);
1874   }
1875
1876   void *re_gl_context = RE_gl_context_get(render);
1877   void *re_gpu_context = NULL;
1878
1879   /* Changing Context */
1880   if (re_gl_context != NULL) {
1881     DRW_opengl_render_context_enable(re_gl_context);
1882     /* We need to query gpu context after a gl context has been bound. */
1883     re_gpu_context = RE_gpu_context_get(render);
1884     DRW_gawain_render_context_enable(re_gpu_context);
1885   }
1886   else {
1887     DRW_opengl_context_enable();
1888   }
1889
1890   /* IMPORTANT: We dont support immediate mode in render mode!
1891    * This shall remain in effect until immediate mode supports
1892    * multiple threads. */
1893
1894   /* Reset before using it. */
1895   drw_state_prepare_clean_for_draw(&DST);
1896   DST.options.is_image_render = true;
1897   DST.options.is_scene_render = true;
1898   DST.options.draw_background = scene->r.alphamode == R_ADDSKY;
1899
1900   DST.draw_ctx = (DRWContextState){
1901       .scene = scene,
1902       .view_layer = view_layer,
1903       .engine_type = engine_type,
1904       .depsgraph = depsgraph,
1905       .object_mode = OB_MODE_OBJECT,
1906   };
1907   drw_context_state_init();
1908
1909   DST.viewport = GPU_viewport_create();
1910   const int size[2] = {engine->resolution_x, engine->resolution_y};
1911   GPU_viewport_size_set(DST.viewport, size);
1912
1913   drw_viewport_var_init();
1914
1915   ViewportEngineData *data = drw_viewport_engine_data_ensure(draw_engine_type);
1916
1917   /* set default viewport */
1918   glViewport(0, 0, size[0], size[1]);
1919
1920   /* Main rendering. */
1921   rctf view_rect;
1922   rcti render_rect;
1923   RE_GetViewPlane(render, &view_rect, &render_rect);
1924   if (BLI_rcti_is_empty(&render_rect)) {
1925     BLI_rcti_init(&render_rect, 0, size[0], 0, size[1]);
1926   }
1927
1928   /* Reset state before drawing */
1929   DRW_state_reset();
1930
1931   /* Init render result. */
1932   RenderResult *render_result = RE_engine_begin_result(engine,
1933                                                        0,
1934                                                        0,
1935                                                        (int)size[0],
1936                                                        (int)size[1],
1937                                                        view_layer->name,
1938                                                        /* RR_ALL_VIEWS */ NULL);
1939
1940   RenderLayer *render_layer = render_result->layers.first;
1941   for (RenderView *render_view = render_result->views.first; render_view != NULL;
1942        render_view = render_view->next) {
1943     RE_SetActiveRenderView(render, render_view->name);
1944     engine_type->draw_engine->render_to_image(data, engine, render_layer, &render_rect);
1945     /* grease pencil: render result is merged in the previous render result. */
1946     if (DRW_render_check_grease_pencil(depsgraph)) {
1947       DRW_state_reset();
1948       DRW_render_gpencil_to_image(engine, render_layer, &render_rect);
1949     }
1950     DST.buffer_finish_called = false;
1951   }
1952
1953   RE_engine_end_result(engine, render_result, false, false, false);
1954
1955   /* Force cache to reset. */
1956   drw_viewport_cache_resize();
1957
1958   GPU_viewport_free(DST.viewport);
1959   GPU_framebuffer_restore();
1960
1961 #ifdef DEBUG
1962   /* Avoid accidental reuse. */
1963   drw_state_ensure_not_reused(&DST);
1964 #endif
1965
1966   /* Reset state after drawing */
1967   DRW_state_reset();
1968
1969   /* Changing Context */
1970   if (re_gl_context != NULL) {
1971     DRW_gawain_render_context_disable(re_gpu_context);
1972     DRW_opengl_render_context_disable(re_gl_context);
1973   }
1974   else {
1975     DRW_opengl_context_disable();
1976   }
1977 }
1978
1979 void DRW_render_object_iter(
1980     void *vedata,
1981     RenderEngine *engine,
1982     struct Depsgraph *depsgraph,
1983     void (*callback)(void *vedata, Object *ob, RenderEngine *engine, struct Depsgraph *depsgraph))
1984 {
1985   const DRWContextState *draw_ctx = DRW_context_state_get();
1986
1987   DRW_hair_init();
1988
1989   const int object_type_exclude_viewport = draw_ctx->v3d ?
1990                                                draw_ctx->v3d->object_type_exclude_viewport :
1991                                                0;
1992   DEG_OBJECT_ITER_BEGIN (depsgraph,
1993                          ob,
1994                          DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
1995                              DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET | DEG_ITER_OBJECT_FLAG_VISIBLE |
1996                              DEG_ITER_OBJECT_FLAG_DUPLI) {
1997     if ((object_type_exclude_viewport & (1 << ob->type)) == 0) {
1998       DST.dupli_parent = data_.dupli_parent;
1999       DST.dupli_source = data_.dupli_object_current;
2000       DST.ob_state = NULL;
2001       callback(vedata, ob, engine, depsgraph);
2002
2003       drw_batch_cache_generate_requested(ob);
2004     }
2005   }
2006   DEG_OBJECT_ITER_END;
2007 }
2008
2009 /* Assume a valid gl context is bound (and that the gl_context_mutex has been acquired).
2010  * This function only setup DST and execute the given function.
2011  * Warning: similar to DRW_render_to_image you cannot use default lists (dfbl & dtxl). */
2012 void DRW_custom_pipeline(DrawEngineType *draw_engine_type,
2013                          struct Depsgraph *depsgraph,
2014                          void (*callback)(void *vedata, void *user_data),
2015                          void *user_data)
2016 {
2017   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2018   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2019
2020   /* Reset before using it. */
2021   drw_state_prepare_clean_for_draw(&DST);
2022   DST.options.is_image_render = true;
2023   DST.options.is_scene_render = true;
2024   DST.options.draw_background = false;
2025
2026   DST.draw_ctx = (DRWContextState){
2027       .scene = scene,
2028       .view_layer = view_layer,
2029       .engine_type = NULL,
2030       .depsgraph = depsgraph,
2031       .object_mode = OB_MODE_OBJECT,
2032   };
2033   drw_context_state_init();
2034
2035   DST.viewport = GPU_viewport_create();
2036   const int size[2] = {1, 1};
2037   GPU_viewport_size_set(DST.viewport, size);
2038
2039   drw_viewport_var_init();
2040
2041   DRW_hair_init();
2042
2043   ViewportEngineData *data = drw_viewport_engine_data_ensure(draw_engine_type);
2044
2045   /* Execute the callback */
2046   callback(data, user_data);
2047   DST.buffer_finish_called = false;
2048
2049   GPU_viewport_free(DST.viewport);
2050   GPU_framebuffer_restore();
2051
2052   /* The use of custom pipeline in other thread using the same
2053    * resources as the main thread (viewport) may lead to data
2054    * races and undefined behavior on certain drivers. Using
2055    * GPU_finish to sync seems to fix the issue. (see T62997) */
2056   GPU_finish();
2057
2058 #ifdef DEBUG
2059   /* Avoid accidental reuse. */
2060   drw_state_ensure_not_reused(&DST);
2061 #endif
2062 }
2063
2064 static struct DRWSelectBuffer {
2065   struct GPUFrameBuffer *framebuffer_depth_only;
2066   struct GPUFrameBuffer *framebuffer_select_id;
2067   struct GPUTexture *texture_depth;
2068   struct GPUTexture *texture_u32;
2069 } g_select_buffer = {NULL};
2070
2071 static void draw_select_framebuffer_depth_only_setup(const int size[2])
2072 {
2073   if (g_select_buffer.framebuffer_depth_only == NULL) {
2074     g_select_buffer.framebuffer_depth_only = GPU_framebuffer_create();
2075     g_select_buffer.framebuffer_select_id = GPU_framebuffer_create();
2076   }
2077
2078   if ((g_select_buffer.texture_depth != NULL) &&
2079       ((GPU_texture_width(g_select_buffer.texture_depth) != size[0]) ||
2080        (GPU_texture_height(g_select_buffer.texture_depth) != size[1]))) {
2081     GPU_texture_free(g_select_buffer.texture_depth);
2082     g_select_buffer.texture_depth = NULL;
2083   }
2084
2085   if (g_select_buffer.texture_depth == NULL) {
2086     g_select_buffer.texture_depth = GPU_texture_create_2d(
2087         size[0], size[1], GPU_DEPTH_COMPONENT24, NULL, NULL);
2088
2089     GPU_framebuffer_texture_attach(
2090         g_select_buffer.framebuffer_depth_only, g_select_buffer.texture_depth, 0, 0);
2091
2092     GPU_framebuffer_texture_attach(
2093         g_select_buffer.framebuffer_select_id, g_select_buffer.texture_depth, 0, 0);
2094
2095     GPU_framebuffer_check_valid(g_select_buffer.framebuffer_depth_only, NULL);
2096     GPU_framebuffer_check_valid(g_select_buffer.framebuffer_select_id, NULL);
2097   }
2098 }
2099
2100 static void draw_select_framebuffer_select_id_setup(const int size[2])
2101 {
2102   draw_select_framebuffer_depth_only_setup(size);
2103
2104   if ((g_select_buffer.texture_u32 != NULL) &&
2105       ((GPU_texture_width(g_select_buffer.texture_u32) != size[0]) ||
2106        (GPU_texture_height(g_select_buffer.texture_u32) != size[1]))) {
2107     GPU_texture_free(g_select_buffer.texture_u32);
2108     g_select_buffer.texture_u32 = NULL;
2109   }
2110
2111   if (g_select_buffer.texture_u32 == NULL) {
2112     g_select_buffer.texture_u32 = GPU_texture_create_2d(size[0], size[1], GPU_R32UI, NULL, NULL);
2113
2114     GPU_framebuffer_texture_attach(
2115         g_select_buffer.framebuffer_select_id, g_select_buffer.texture_u32, 0, 0);
2116
2117     GPU_framebuffer_check_valid(g_select_buffer.framebuffer_select_id, NULL);
2118   }
2119 }
2120
2121 /* Must run after all instance datas have been added. */
2122 void DRW_render_instance_buffer_finish(void)
2123 {
2124   BLI_assert(!DST.buffer_finish_called && "DRW_render_instance_buffer_finish called twice!");
2125   DST.buffer_finish_called = true;
2126   DRW_instance_buffer_finish(DST.idatalist);
2127 }
2128
2129 /**
2130  * object mode select-loop, see: ED_view3d_draw_select_loop (legacy drawing).
2131  */
2132 void DRW_draw_select_loop(struct Depsgraph *depsgraph,
2133                           ARegion *ar,
2134                           View3D *v3d,
2135                           bool UNUSED(use_obedit_skip),
2136                           bool draw_surface,
2137                           bool UNUSED(use_nearest),
2138                           const rcti *rect,
2139                           DRW_SelectPassFn select_pass_fn,
2140                           void *select_pass_user_data,
2141                           DRW_ObjectFilterFn object_filter_fn,
2142                           void *object_filter_user_data)
2143 {
2144   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2145   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
2146   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2147   Object *obact = OBACT(view_layer);
2148   Object *obedit = OBEDIT_FROM_OBACT(obact);
2149 #ifndef USE_GPU_SELECT
2150   UNUSED_VARS(vc, scene, view_layer, v3d, ar, rect);
2151 #else
2152   RegionView3D *rv3d = ar->regiondata;
2153
2154   /* Reset before using it. */
2155   drw_state_prepare_clean_for_draw(&DST);
2156
2157   bool use_obedit = false;
2158   int obedit_mode = 0;
2159   if (obedit != NULL) {
2160     if (obedit->type == OB_MBALL) {
2161       use_obedit = true;
2162       obedit_mode = CTX_MODE_EDIT_METABALL;
2163     }
2164     else if (obedit->type == OB_ARMATURE) {
2165       use_obedit = true;
2166       obedit_mode = CTX_MODE_EDIT_ARMATURE;
2167     }
2168   }
2169   if (v3d->overlay.flag & V3D_OVERLAY_BONE_SELECT) {
2170     if (!(v3d->flag2 & V3D_HIDE_OVERLAYS)) {
2171       /* Note: don't use "BKE_object_pose_armature_get" here, it breaks selection. */
2172       Object *obpose = OBPOSE_FROM_OBACT(obact);
2173       if (obpose) {
2174         use_obedit = true;
2175         obedit_mode = CTX_MODE_POSE;
2176       }
2177     }
2178   }
2179
2180   int viewport_size[2] = {BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)};
2181   struct GPUViewport *viewport = GPU_viewport_create();
2182   GPU_viewport_size_set(viewport, viewport_size);
2183
2184   DST.viewport = viewport;
2185   DST.options.is_select = true;
2186
2187   /* Get list of enabled engines */
2188   if (use_obedit) {
2189     drw_engines_enable_from_paint_mode(obedit_mode);
2190     drw_engines_enable_from_mode(obedit_mode);
2191   }
2192   else if (!draw_surface) {
2193     /* grease pencil selection */
2194     use_drw_engine(&draw_engine_gpencil_type);
2195
2196     drw_engines_enable_from_overlays(v3d->overlay.flag);
2197     drw_engines_enable_from_object_mode();
2198   }
2199   else {
2200     drw_engines_enable_basic();
2201     /* grease pencil selection */
2202     use_drw_engine(&draw_engine_gpencil_type);
2203
2204     drw_engines_enable_from_overlays(v3d->overlay.flag);
2205     drw_engines_enable_from_object_mode();
2206   }
2207
2208   /* Setup viewport */
2209
2210   /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2211   DST.draw_ctx = (DRWContextState){
2212       .ar = ar,
2213       .rv3d = rv3d,
2214       .v3d = v3d,
2215       .scene = scene,
2216       .view_layer = view_layer,
2217       .obact = obact,
2218       .engine_type = engine_type,
2219       .depsgraph = depsgraph,
2220   };
2221   drw_context_state_init();
2222   drw_viewport_var_init();
2223
2224   /* Update ubos */
2225   DRW_globals_update();
2226
2227   /* Init engines */
2228   drw_engines_init();
2229   DRW_hair_init();
2230
2231   {
2232     drw_engines_cache_init();
2233     drw_engines_world_update(scene);
2234
2235     if (use_obedit) {
2236 #  if 0
2237       drw_engines_cache_populate(obact);
2238 #  else
2239       FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
2240         drw_engines_cache_populate(ob_iter);
2241       }
2242       FOREACH_OBJECT_IN_MODE_END;
2243 #  endif
2244     }
2245     else {
2246       const int object_type_exclude_select = (v3d->object_type_exclude_viewport |
2247                                               v3d->object_type_exclude_select);
2248       bool filter_exclude = false;
2249       DEG_OBJECT_ITER_BEGIN (depsgraph,
2250                              ob,
2251                              DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
2252                                  DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET |
2253                                  DEG_ITER_OBJECT_FLAG_VISIBLE | DEG_ITER_OBJECT_FLAG_DUPLI) {
2254         if (v3d->localvd && ((v3d->local_view_uuid & ob->base_local_view_bits) == 0)) {
2255           continue;
2256         }
2257
2258         if ((ob->base_flag & BASE_SELECTABLE) &&
2259             (object_type_exclude_select & (1 << ob->type)) == 0) {
2260           if (object_filter_fn != NULL) {
2261             if (ob->base_flag & BASE_FROM_DUPLI) {
2262               /* pass (use previous filter_exclude value) */
2263             }
2264             else {
2265               filter_exclude = (object_filter_fn(ob, object_filter_user_data) == false);
2266             }
2267             if (filter_exclude) {
2268               continue;
2269             }
2270           }
2271
2272           /* This relies on dupli instances being after their instancing object. */
2273           if ((ob->base_flag & BASE_FROM_DUPLI) == 0) {
2274             Object *ob_orig = DEG_get_original_object(ob);
2275             DRW_select_load_id(ob_orig->select_id);
2276           }
2277           DST.dupli_parent = data_.dupli_parent;
2278           DST.dupli_source = data_.dupli_object_current;
2279           drw_engines_cache_populate(ob);
2280         }
2281       }
2282       DEG_OBJECT_ITER_END;
2283     }
2284
2285     drw_engines_cache_finish();
2286
2287     DRW_render_instance_buffer_finish();
2288   }
2289
2290   /* Setup framebuffer */
2291   draw_select_framebuffer_depth_only_setup(viewport_size);
2292   GPU_framebuffer_bind(g_select_buffer.framebuffer_depth_only);
2293   GPU_framebuffer_clear_depth(g_select_buffer.framebuffer_depth_only, 1.0f);
2294
2295   /* Start Drawing */
2296   DRW_state_reset();
2297   DRW_draw_callbacks_pre_scene();
2298
2299   DRW_hair_update();
2300
2301   DRW_state_lock(DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_ALWAYS | DRW_STATE_DEPTH_LESS_EQUAL |
2302                  DRW_STATE_DEPTH_EQUAL | DRW_STATE_DEPTH_GREATER | DRW_STATE_DEPTH_ALWAYS);
2303
2304   /* Only 1-2 passes. */
2305   while (true) {
2306     if (!select_pass_fn(DRW_SELECT_PASS_PRE, select_pass_user_data)) {
2307       break;
2308     }
2309
2310     drw_engines_draw_scene();
2311
2312     if (!select_pass_fn(DRW_SELECT_PASS_POST, select_pass_user_data)) {
2313       break;
2314     }
2315   }
2316
2317   DRW_state_lock(0);
2318
2319   DRW_draw_callbacks_post_scene();
2320
2321   DRW_state_reset();
2322   drw_engines_disable();
2323
2324 #  ifdef DEBUG
2325   /* Avoid accidental reuse. */
2326   drw_state_ensure_not_reused(&DST);
2327 #  endif
2328   GPU_framebuffer_restore();
2329
2330   /* Cleanup for selection state */
2331   GPU_viewport_free(viewport);
2332 #endif /* USE_GPU_SELECT */
2333 }
2334
2335 static void draw_depth_texture_to_screen(GPUTexture *texture)
2336 {
2337   const float w = (float)GPU_texture_width(texture);
2338   const float h = (float)GPU_texture_height(texture);
2339
2340   GPUVertFormat *format = immVertexFormat();
2341   uint texcoord = GPU_vertformat_attr_add(format, "texCoord", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2342   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
2343
2344   immBindBuiltinProgram(GPU_SHADER_3D_IMAGE_DEPTH_COPY);
2345
2346   GPU_texture_bind(texture, 0);
2347
2348   immUniform1i("image", 0); /* default GL_TEXTURE0 unit */
2349
2350   immBegin(GPU_PRIM_TRI_STRIP, 4);
2351
2352   immAttr2f(texcoord, 0.0f, 0.0f);
2353   immVertex2f(pos, 0.0f, 0.0f);
2354
2355   immAttr2f(texcoord, 1.0f, 0.0f);
2356   immVertex2f(pos, w, 0.0f);
2357
2358   immAttr2f(texcoord, 0.0f, 1.0f);
2359   immVertex2f(pos, 0.0f, h);
2360
2361   immAttr2f(texcoord, 1.0f, 1.0f);
2362   immVertex2f(pos, w, h);
2363
2364   immEnd();
2365
2366   GPU_texture_unbind(texture);
2367
2368   immUnbindProgram();
2369 }
2370
2371 /**
2372  * object mode select-loop, see: ED_view3d_draw_depth_loop (legacy drawing).
2373  */
2374 static void drw_draw_depth_loop_imp(void)
2375 {
2376   DRW_opengl_context_enable();
2377
2378   /* Setup framebuffer */
2379   DefaultFramebufferList *fbl = (DefaultFramebufferList *)GPU_viewport_framebuffer_list_get(
2380       DST.viewport);
2381   GPU_framebuffer_bind(fbl->depth_only_fb);
2382   GPU_framebuffer_clear_depth(fbl->depth_only_fb, 1.0f);
2383
2384   /* Setup viewport */
2385   drw_context_state_init();
2386   drw_viewport_var_init();
2387
2388   /* Update ubos */
2389   DRW_globals_update();
2390
2391   /* Init engines */
2392   drw_engines_init();
2393   DRW_hair_init();
2394
2395   {
2396     drw_engines_cache_init();
2397     drw_engines_world_update(DST.draw_ctx.scene);
2398
2399     View3D *v3d = DST.draw_ctx.v3d;
2400     const int object_type_exclude_viewport = v3d->object_type_exclude_viewport;
2401     DEG_OBJECT_ITER_BEGIN (DST.draw_ctx.depsgraph,
2402                            ob,
2403                            DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
2404                                DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET | DEG_ITER_OBJECT_FLAG_VISIBLE |
2405                                DEG_ITER_OBJECT_FLAG_DUPLI) {
2406       if ((object_type_exclude_viewport & (1 << ob->type)) != 0) {
2407         continue;
2408       }
2409
2410       if (v3d->localvd && ((v3d->local_view_uuid & ob->base_local_view_bits) == 0)) {
2411         continue;
2412       }
2413
2414       DST.dupli_parent = data_.dupli_parent;
2415       DST.dupli_source = data_.dupli_object_current;
2416       drw_engines_cache_populate(ob);
2417     }
2418     DEG_OBJECT_ITER_END;
2419
2420     drw_engines_cache_finish();
2421
2422     DRW_render_instance_buffer_finish();
2423   }
2424
2425   /* Start Drawing */
2426   DRW_state_reset();
2427
2428   DRW_hair_update();
2429
2430   DRW_draw_callbacks_pre_scene();
2431   drw_engines_draw_scene();
2432   DRW_draw_callbacks_post_scene();
2433
2434   DRW_state_reset();
2435
2436   /* TODO: Reading depth for operators should be done here. */
2437
2438   GPU_framebuffer_restore();
2439
2440   /* Changin context */
2441   DRW_opengl_context_disable();
2442 }
2443
2444 /**
2445  * object mode select-loop, see: ED_view3d_draw_depth_loop (legacy drawing).
2446  */
2447 void DRW_draw_depth_loop(struct Depsgraph *depsgraph,
2448                          ARegion *ar,
2449                          View3D *v3d,
2450                          GPUViewport *viewport)
2451 {
2452   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2453   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
2454   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2455   RegionView3D *rv3d = ar->regiondata;
2456
2457   /* Reset before using it. */
2458   drw_state_prepare_clean_for_draw(&DST);
2459
2460   DST.viewport = viewport;
2461   DST.options.is_depth = true;
2462
2463   /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2464   DST.draw_ctx = (DRWContextState){
2465       .ar = ar,
2466       .rv3d = rv3d,
2467       .v3d = v3d,
2468       .scene = scene,
2469       .view_layer = view_layer,
2470       .obact = OBACT(view_layer),
2471       .engine_type = engine_type,
2472       .depsgraph = depsgraph,
2473   };
2474
2475   /* Get list of enabled engines */
2476   {
2477     drw_engines_enable_basic();
2478     if (DRW_state_draw_support()) {
2479       drw_engines_enable_from_object_mode();
2480     }
2481   }
2482
2483   drw_draw_depth_loop_imp();
2484
2485   drw_engines_disable();
2486
2487   /* XXX Drawing the resulting buffer to the BACK_BUFFER */
2488   GPU_matrix_push();
2489   GPU_matrix_push_projection();
2490   wmOrtho2_region_pixelspace(DST.draw_ctx.ar);
2491   GPU_matrix_identity_set();
2492
2493   glEnable(GL_DEPTH_TEST); /* Cannot write to depth buffer without testing */
2494   glDepthFunc(GL_ALWAYS);
2495   DefaultTextureList *dtxl = (DefaultTextureList *)GPU_viewport_texture_list_get(DST.viewport);
2496   draw_depth_texture_to_screen(dtxl->depth);
2497   glDepthFunc(GL_LEQUAL);
2498
2499   GPU_matrix_pop();
2500   GPU_matrix_pop_projection();
2501
2502 #ifdef DEBUG
2503   /* Avoid accidental reuse. */
2504   drw_state_ensure_not_reused(&DST);
2505 #endif
2506 }
2507
2508 /**
2509  * Converted from ED_view3d_draw_depth_gpencil (legacy drawing).
2510  */
2511 void DRW_draw_depth_loop_gpencil(struct Depsgraph *depsgraph,
2512                                  ARegion *ar,
2513                                  View3D *v3d,
2514                                  GPUViewport *viewport)
2515 {
2516   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2517   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2518   RegionView3D *rv3d = ar->regiondata;
2519
2520   /* Reset before using it. */
2521   drw_state_prepare_clean_for_draw(&DST);
2522
2523   DST.viewport = viewport;
2524   DST.options.is_depth = true;
2525
2526   /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2527   DST.draw_ctx = (DRWContextState){
2528       .ar = ar,
2529       .rv3d = rv3d,
2530       .v3d = v3d,
2531       .scene = scene,
2532       .view_layer = view_layer,
2533       .obact = OBACT(view_layer),
2534       .depsgraph = depsgraph,
2535   };
2536
2537   use_drw_engine(&draw_engine_gpencil_type);
2538   drw_draw_depth_loop_imp();
2539   drw_engines_disable();
2540
2541 #ifdef DEBUG
2542   /* Avoid accidental reuse. */
2543   drw_state_ensure_not_reused(&DST);
2544 #endif
2545 }
2546
2547 /* Set an opengl context to be used with shaders that draw on U32 colors. */
2548 void DRW_framebuffer_select_id_setup(ARegion *ar, const bool clear)
2549 {
2550   RegionView3D *rv3d = ar->regiondata;
2551
2552   DRW_opengl_context_enable();
2553
2554   /* Setup framebuffer */
2555   int viewport_size[2] = {ar->winx, ar->winy};
2556   draw_select_framebuffer_select_id_setup(viewport_size);
2557   GPU_framebuffer_bind(g_select_buffer.framebuffer_select_id);
2558
2559   /* dithering and AA break color coding, so disable */
2560   glDisable(GL_DITHER);
2561
2562   GPU_depth_test(true);
2563   glDisable(GL_SCISSOR_TEST);
2564
2565   if (clear) {
2566     GPU_framebuffer_clear_color_depth(
2567         g_select_buffer.framebuffer_select_id, (const float[4]){0.0f}, 1.0f);
2568   }
2569
2570   if (rv3d->rflag & RV3D_CLIPPING) {
2571     ED_view3d_clipping_set(rv3d);
2572   }
2573 }
2574
2575 /* Ends the context for selection and restoring the previous one. */
2576 void DRW_framebuffer_select_id_release(ARegion *ar)
2577 {
2578   RegionView3D *rv3d = ar->regiondata;
2579
2580   if (rv3d->rflag & RV3D_CLIPPING) {
2581     ED_view3d_clipping_disable();
2582   }
2583
2584   GPU_depth_test(false);
2585
2586   GPU_framebuffer_restore();
2587
2588   DRW_opengl_context_disable();
2589 }
2590
2591 /* Read a block of pixels from the select frame buffer. */
2592 void DRW_framebuffer_select_id_read(const rcti *rect, uint *r_buf)
2593 {
2594   /* clamp rect by texture */
2595   rcti r = {
2596       .xmin = 0,
2597       .xmax = GPU_texture_width(g_select_buffer.texture_u32),
2598       .ymin = 0,
2599       .ymax = GPU_texture_height(g_select_buffer.texture_u32),
2600   };
2601
2602   rcti rect_clamp = *rect;
2603   if (BLI_rcti_isect(&r, &rect_clamp, &rect_clamp)) {
2604     GPU_texture_read_rect(g_select_buffer.texture_u32, GPU_DATA_UNSIGNED_INT, &rect_clamp, r_buf);
2605
2606     if (!BLI_rcti_compare(rect, &rect_clamp)) {
2607       GPU_select_buffer_stride_realign(rect, &rect_clamp, r_buf);
2608     }
2609   }
2610   else {
2611     size_t buf_size = BLI_rcti_size_x(rect) * BLI_rcti_size_y(rect) * sizeof(*r_buf);
2612
2613     memset(r_buf, 0, buf_size);
2614   }
2615 }
2616
2617 /** \} */
2618
2619 /* -------------------------------------------------------------------- */
2620 /** \name Draw Manager State (DRW_state)
2621  * \{ */
2622
2623 void DRW_state_dfdy_factors_get(float dfdyfac[2])
2624 {
2625   GPU_get_dfdy_factors(dfdyfac);
2626 }
2627
2628 /**
2629  * When false, drawing doesn't output to a pixel buffer
2630  * eg: Occlusion queries, or when we have setup a context to draw in already.
2631  */
2632 bool DRW_state_is_fbo(void)
2633 {
2634   return ((DST.default_framebuffer != NULL) || DST.options.is_image_render);
2635 }
2636
2637 /**
2638  * For when engines need to know if this is drawing for selection or not.
2639  */
2640 bool DRW_state_is_select(void)
2641 {
2642   return DST.options.is_select;
2643 }
2644
2645 bool DRW_state_is_depth(void)
2646 {
2647   return DST.options.is_depth;
2648 }
2649
2650 /**
2651  * Whether we are rendering for an image
2652  */
2653 bool DRW_state_is_image_render(void)
2654 {
2655   return DST.options.is_image_render;
2656 }
2657
2658 /**
2659  * Whether we are rendering only the render engine,
2660  * or if we should also render the mode engines.
2661  */
2662 bool DRW_state_is_scene_render(void)
2663 {
2664   BLI_assert(DST.options.is_scene_render ? DST.options.is_image_render : true);
2665   return DST.options.is_scene_render;
2666 }
2667
2668 /**
2669  * Whether we are rendering simple opengl render
2670  */
2671 bool DRW_state_is_opengl_render(void)
2672 {
2673   return DST.options.is_image_render && !DST.options.is_scene_render;
2674 }
2675
2676 bool DRW_state_is_playback(void)
2677 {
2678   if (DST.draw_ctx.evil_C != NULL) {
2679     struct wmWindowManager *wm = CTX_wm_manager(DST.draw_ctx.evil_C);
2680     return ED_screen_animation_playing(wm) != NULL;
2681   }
2682   return false;
2683 }
2684
2685 /**
2686  * Should text draw in this mode?
2687  */
2688 bool DRW_state_show_text(void)
2689 {
2690   return (DST.options.is_select) == 0 && (DST.options.is_depth) == 0 &&
2691          (DST.options.is_scene_render) == 0 && (DST.options.draw_text) == 0;
2692 }
2693
2694 /**
2695  * Should draw support elements
2696  * Objects center, selection outline, probe data, ...
2697  */
2698 bool DRW_state_draw_support(void)
2699 {
2700   View3D *v3d = DST.draw_ctx.v3d;
2701   return (DRW_state_is_scene_render() == false) && (v3d != NULL) &&
2702          ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0);
2703 }
2704
2705 /**
2706  * Whether we should render the background
2707  */
2708 bool DRW_state_draw_background(void)
2709 {
2710   if (DRW_state_is_image_render() == false) {
2711     return true;
2712   }
2713   return DST.options.draw_background;
2714 }
2715
2716 /** \} */
2717
2718 /* -------------------------------------------------------------------- */
2719 /** \name Context State (DRW_context_state)
2720  * \{ */
2721
2722 const DRWContextState *DRW_context_state_get(void)
2723 {
2724   return &DST.draw_ctx;
2725 }
2726
2727 /** \} */
2728
2729 /* -------------------------------------------------------------------- */
2730 /** \name Init/Exit (DRW_engines)
2731  * \{ */
2732
2733 bool DRW_engine_render_support(DrawEngineType *draw_engine_type)
2734 {
2735   return draw_engine_type->render_to_image;
2736 }
2737
2738 void DRW_engine_register(DrawEngineType *draw_engine_type)
2739 {
2740   BLI_addtail(&DRW_engines, draw_engine_type);
2741 }
2742
2743 void DRW_engines_register(void)
2744 {
2745   RE_engines_register(&DRW_engine_viewport_eevee_type);
2746   RE_engines_register(&DRW_engine_viewport_workbench_type);
2747
2748   DRW_engine_register(&draw_engine_workbench_solid);
2749   DRW_engine_register(&draw_engine_workbench_transparent);
2750
2751   DRW_engine_register(&draw_engine_object_type);
2752   DRW_engine_register(&draw_engine_edit_armature_type);
2753   DRW_engine_register(&draw_engine_edit_curve_type);
2754   DRW_engine_register(&draw_engine_edit_lattice_type);
2755   DRW_engine_register(&draw_engine_edit_mesh_type);
2756   DRW_engine_register(&draw_engine_edit_metaball_type);
2757   DRW_engine_register(&draw_engine_edit_text_type);
2758   DRW_engine_register(&draw_engine_motion_path_type);
2759   DRW_engine_register(&draw_engine_overlay_type);
2760   DRW_engine_register(&draw_engine_paint_texture_type);
2761   DRW_engine_register(&draw_engine_paint_vertex_type);
2762   DRW_engine_register(&draw_engine_particle_type);
2763   DRW_engine_register(&draw_engine_pose_type);
2764   DRW_engine_register(&draw_engine_sculpt_type);
2765   DRW_engine_register(&draw_engine_gpencil_type);
2766
2767   /* setup callbacks */
2768   {
2769     BKE_mball_batch_cache_dirty_tag_cb = DRW_mball_batch_cache_dirty_tag;
2770     BKE_mball_batch_cache_free_cb = DRW_mball_batch_cache_free;
2771
2772     BKE_curve_batch_cache_dirty_tag_cb = DRW_curve_batch_cache_dirty_tag;
2773     BKE_curve_batch_cache_free_cb = DRW_curve_batch_cache_free;
2774
2775     BKE_mesh_batch_cache_dirty_tag_cb = DRW_mesh_batch_cache_dirty_tag;
2776     BKE_mesh_batch_cache_free_cb = DRW_mesh_batch_cache_free;
2777
2778     BKE_lattice_batch_cache_dirty_tag_cb = DRW_lattice_batch_cache_dirty_tag;
2779     BKE_lattice_batch_cache_free_cb = DRW_lattice_batch_cache_free;
2780
2781     BKE_particle_batch_cache_dirty_tag_cb = DRW_particle_batch_cache_dirty_tag;
2782     BKE_particle_batch_cache_free_cb = DRW_particle_batch_cache_free;
2783
2784     BKE_gpencil_batch_cache_dirty_tag_cb = DRW_gpencil_batch_cache_dirty_tag;
2785     BKE_gpencil_batch_cache_free_cb = DRW_gpencil_batch_cache_free;
2786   }
2787 }
2788
2789 void DRW_engines_free(void)
2790 {
2791   if (DST.gl_context == NULL) {
2792     /* Nothing has been setup. Nothing to clear.
2793      * Otherwise, DRW_opengl_context_enable can
2794      * create a context in background mode. (see T62355) */
2795     return;
2796   }
2797
2798   DRW_opengl_context_enable();
2799
2800   DRW_TEXTURE_FREE_SAFE(g_select_buffer.texture_u32);
2801   DRW_TEXTURE_FREE_SAFE(g_select_buffer.texture_depth);
2802   GPU_FRAMEBUFFER_FREE_SAFE(g_select_buffer.framebuffer_select_id);
2803   GPU_FRAMEBUFFER_FREE_SAFE(g_select_buffer.framebuffer_depth_only);
2804
2805   DRW_hair_free();
2806   DRW_shape_cache_free();
2807   DRW_stats_free();
2808   DRW_globals_free();
2809
2810   DrawEngineType *next;
2811   for (DrawEngineType *type = DRW_engines.first; type; type = next) {
2812     next = type->next;
2813     BLI_remlink(&R_engines, type);
2814
2815     if (type->engine_free) {
2816       type->engine_free();
2817     }
2818   }
2819
2820   DRW_UBO_FREE_SAFE(G_draw.block_ubo);
2821   DRW_UBO_FREE_SAFE(G_draw.view_ubo);
2822   DRW_TEXTURE_FREE_SAFE(G_draw.ramp);
2823   DRW_TEXTURE_FREE_SAFE(G_draw.weight_ramp);
2824   MEM_SAFE_FREE(g_pos_format);
2825
2826   MEM_SAFE_FREE(DST.uniform_names.buffer);
2827
2828   DRW_opengl_context_disable();
2829 }
2830
2831 /** \} */
2832
2833 /** \name Init/Exit (DRW_opengl_ctx)
2834  * \{ */
2835
2836 void DRW_opengl_context_create(void)
2837 {
2838   BLI_assert(DST.gl_context == NULL); /* Ensure it's called once */
2839
2840   DST.gl_context_mutex = BLI_ticket_mutex_alloc();
2841   if (!G.background) {
2842     immDeactivate();
2843   }
2844   /* This changes the active context. */
2845   DST.gl_context = WM_opengl_context_create();
2846   WM_opengl_context_activate(DST.gl_context);
2847   /* Be sure to create gawain.context too. */
2848   DST.gpu_context = GPU_context_create();
2849   if (!G.background) {
2850     immActivate();
2851   }
2852   /* Set default Blender OpenGL state */
2853   GPU_state_init();
2854   /* So we activate the window's one afterwards. */
2855   wm_window_reset_drawable();
2856 }
2857
2858 void DRW_opengl_context_destroy(void)
2859 {
2860   BLI_assert(BLI_thread_is_main());
2861   if (DST.gl_context != NULL) {
2862     WM_opengl_context_activate(DST.gl_context);
2863     GPU_context_active_set(DST.gpu_context);
2864     GPU_context_discard(DST.gpu_context);
2865     WM_opengl_context_dispose(DST.gl_context);
2866     BLI_ticket_mutex_free(DST.gl_context_mutex);
2867   }
2868 }
2869
2870 void DRW_opengl_context_enable_ex(bool restore)
2871 {
2872   if (DST.gl_context != NULL) {
2873     /* IMPORTANT: We dont support immediate mode in render mode!
2874      * This shall remain in effect until immediate mode supports
2875      * multiple threads. */
2876     BLI_ticket_mutex_lock(DST.gl_context_mutex);
2877     if (BLI_thread_is_main() && restore) {
2878       if (!G.background) {
2879         immDeactivate();
2880       }
2881     }
2882     WM_opengl_context_activate(DST.gl_context);
2883     GPU_context_active_set(DST.gpu_context);
2884     if (BLI_thread_is_main() && restore) {
2885       if (!G.background) {
2886         immActivate();
2887       }
2888       BLF_batch_reset();
2889     }
2890   }
2891 }
2892
2893 void DRW_opengl_context_disable_ex(bool restore)
2894 {
2895   if (DST.gl_context != NULL) {
2896 #ifdef __APPLE__
2897     /* Need to flush before disabling draw context, otherwise it does not
2898      * always finish drawing and viewport can be empty or partially drawn */
2899     GPU_flush();
2900 #endif
2901
2902     if (BLI_thread_is_main() && restore) {
2903       wm_window_reset_drawable();
2904     }
2905     else {
2906       WM_opengl_context_release(DST.gl_context);
2907       GPU_context_active_set(NULL);
2908     }
2909
2910     BLI_ticket_mutex_unlock(DST.gl_context_mutex);
2911   }
2912 }
2913
2914 void DRW_opengl_context_enable(void)
2915 {
2916   if (G.background && DST.gl_context == NULL) {
2917     WM_init_opengl(G_MAIN);
2918   }
2919   DRW_opengl_context_enable_ex(true);
2920 }
2921
2922 void DRW_opengl_context_disable(void)
2923 {
2924   DRW_opengl_context_disable_ex(true);
2925 }
2926
2927 void DRW_opengl_render_context_enable(void *re_gl_context)
2928 {
2929   /* If thread is main you should use DRW_opengl_context_enable(). */
2930   BLI_assert(!BLI_thread_is_main());
2931
2932   /* TODO get rid of the blocking. Only here because of the static global DST. */
2933   BLI_ticket_mutex_lock(DST.gl_context_mutex);
2934   WM_opengl_context_activate(re_gl_context);
2935 }
2936
2937 void DRW_opengl_render_context_disable(void *re_gl_context)
2938 {
2939   GPU_flush();
2940   WM_opengl_context_release(re_gl_context);
2941   /* TODO get rid of the blocking. */
2942   BLI_ticket_mutex_unlock(DST.gl_context_mutex);
2943 }
2944
2945 /* Needs to be called AFTER DRW_opengl_render_context_enable() */
2946 void DRW_gawain_render_context_enable(void *re_gpu_context)
2947 {
2948   /* If thread is main you should use DRW_opengl_context_enable(). */
2949   BLI_assert(!BLI_thread_is_main());
2950
2951   GPU_context_active_set(re_gpu_context);
2952   DRW_shape_cache_reset(); /* XXX fix that too. */
2953 }
2954
2955 /* Needs to be called BEFORE DRW_opengl_render_context_disable() */
2956 void DRW_gawain_render_context_disable(void *UNUSED(re_gpu_context))
2957 {
2958   DRW_shape_cache_reset(); /* XXX fix that too. */
2959   GPU_context_active_set(NULL);
2960 }
2961
2962 /** \} */