Cleanup: formatting, unused args
[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 Garbage Collection
971  * \{ */
972
973 void DRW_cache_free_old_batches(Main *bmain)
974 {
975   Scene *scene;
976   ViewLayer *view_layer;
977   static int lasttime = 0;
978   int ctime = (int)PIL_check_seconds_timer();
979
980   if (U.vbotimeout == 0 || (ctime - lasttime) < U.vbocollectrate || ctime == lasttime)
981     return;
982
983   lasttime = ctime;
984
985   for (scene = bmain->scenes.first; scene; scene = scene->id.next) {
986     for (view_layer = scene->view_layers.first; view_layer; view_layer = view_layer->next) {
987       Depsgraph *depsgraph = BKE_scene_get_depsgraph(scene, view_layer, false);
988
989       /* TODO(fclem): This is not optimal since it iter over all dupli instances.
990        * In this case only the source object should be tagged. */
991       int iter_flags = DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY | DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET |
992                        DEG_ITER_OBJECT_FLAG_VISIBLE | DEG_ITER_OBJECT_FLAG_DUPLI;
993
994       DEG_OBJECT_ITER_BEGIN (depsgraph, ob, iter_flags) {
995         DRW_batch_cache_free_old(ob, ctime);
996       }
997       DEG_OBJECT_ITER_END;
998     }
999   }
1000 }
1001
1002 /** \} */
1003
1004 /* -------------------------------------------------------------------- */
1005 /** \name Rendering (DRW_engines)
1006  * \{ */
1007
1008 static void drw_engines_init(void)
1009 {
1010   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1011     DrawEngineType *engine = link->data;
1012     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1013     PROFILE_START(stime);
1014
1015     if (engine->engine_init) {
1016       engine->engine_init(data);
1017     }
1018
1019     PROFILE_END_UPDATE(data->init_time, stime);
1020   }
1021 }
1022
1023 static void drw_engines_cache_init(void)
1024 {
1025   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1026     DrawEngineType *engine = link->data;
1027     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1028
1029     if (data->text_draw_cache) {
1030       DRW_text_cache_destroy(data->text_draw_cache);
1031       data->text_draw_cache = NULL;
1032     }
1033     if (DST.text_store_p == NULL) {
1034       DST.text_store_p = &data->text_draw_cache;
1035     }
1036
1037     if (engine->cache_init) {
1038       engine->cache_init(data);
1039     }
1040   }
1041 }
1042
1043 static void drw_engines_world_update(Scene *scene)
1044 {
1045   if (scene->world == NULL) {
1046     return;
1047   }
1048
1049   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1050     DrawEngineType *engine = link->data;
1051     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1052
1053     if (engine->id_update) {
1054       engine->id_update(data, &scene->world->id);
1055     }
1056   }
1057 }
1058
1059 static void drw_engines_cache_populate(Object *ob)
1060 {
1061   DST.ob_state = NULL;
1062
1063   /* HACK: DrawData is copied by COW from the duplicated object.
1064    * This is valid for IDs that cannot be instantiated but this
1065    * is not what we want in this case so we clear the pointer
1066    * ourselves here. */
1067   drw_drawdata_unlink_dupli((ID *)ob);
1068
1069   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1070     DrawEngineType *engine = link->data;
1071     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1072
1073     if (engine->id_update) {
1074       engine->id_update(data, &ob->id);
1075     }
1076
1077     if (engine->cache_populate) {
1078       engine->cache_populate(data, ob);
1079     }
1080   }
1081
1082   /* TODO: in the future it would be nice to generate once for all viewports.
1083    * But we need threaded DRW manager first. */
1084   drw_batch_cache_generate_requested(ob);
1085
1086   /* ... and clearing it here too because theses draw data are
1087    * from a mempool and must not be free individually by depsgraph. */
1088   drw_drawdata_unlink_dupli((ID *)ob);
1089 }
1090
1091 static void drw_engines_cache_finish(void)
1092 {
1093   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1094     DrawEngineType *engine = link->data;
1095     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1096
1097     if (engine->cache_finish) {
1098       engine->cache_finish(data);
1099     }
1100   }
1101 }
1102
1103 static void drw_engines_draw_background(void)
1104 {
1105   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1106     DrawEngineType *engine = link->data;
1107     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1108
1109     if (engine->draw_background) {
1110       PROFILE_START(stime);
1111
1112       DRW_stats_group_start(engine->idname);
1113       engine->draw_background(data);
1114       DRW_stats_group_end();
1115
1116       PROFILE_END_UPDATE(data->background_time, stime);
1117       return;
1118     }
1119   }
1120
1121   /* No draw_background found, doing default background */
1122   if (DRW_state_draw_background()) {
1123     DRW_draw_background();
1124   }
1125 }
1126
1127 static void drw_engines_draw_scene(void)
1128 {
1129   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1130     DrawEngineType *engine = link->data;
1131     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1132     PROFILE_START(stime);
1133
1134     if (engine->draw_scene) {
1135       DRW_stats_group_start(engine->idname);
1136       engine->draw_scene(data);
1137       /* Restore for next engine */
1138       if (DRW_state_is_fbo()) {
1139         GPU_framebuffer_bind(DST.default_framebuffer);
1140       }
1141       DRW_stats_group_end();
1142     }
1143
1144     PROFILE_END_UPDATE(data->render_time, stime);
1145   }
1146   /* Reset state after drawing */
1147   DRW_state_reset();
1148 }
1149
1150 static void drw_engines_draw_text(void)
1151 {
1152   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1153     DrawEngineType *engine = link->data;
1154     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1155     PROFILE_START(stime);
1156
1157     if (data->text_draw_cache) {
1158       DRW_text_cache_draw(data->text_draw_cache, DST.draw_ctx.ar);
1159     }
1160
1161     PROFILE_END_UPDATE(data->render_time, stime);
1162   }
1163 }
1164
1165 /* Draw render engine info. */
1166 void DRW_draw_region_engine_info(int xoffset, int yoffset)
1167 {
1168   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1169     DrawEngineType *engine = link->data;
1170     ViewportEngineData *data = drw_viewport_engine_data_ensure(engine);
1171
1172     if (data->info[0] != '\0') {
1173       char *chr_current = data->info;
1174       char *chr_start = chr_current;
1175       int line_len = 0;
1176
1177       const int font_id = BLF_default();
1178       UI_FontThemeColor(font_id, TH_TEXT_HI);
1179
1180       BLF_enable(font_id, BLF_SHADOW);
1181       BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1182       BLF_shadow_offset(font_id, 1, -1);
1183
1184       while (*chr_current++ != '\0') {
1185         line_len++;
1186         if (*chr_current == '\n') {
1187           char info[GPU_INFO_SIZE];
1188           BLI_strncpy(info, chr_start, line_len + 1);
1189           yoffset -= U.widget_unit;
1190           BLF_draw_default(xoffset, yoffset, 0.0f, info, sizeof(info));
1191
1192           /* Re-start counting. */
1193           chr_start = chr_current + 1;
1194           line_len = -1;
1195         }
1196       }
1197
1198       char info[GPU_INFO_SIZE];
1199       BLI_strncpy(info, chr_start, line_len + 1);
1200       yoffset -= U.widget_unit;
1201       BLF_draw_default(xoffset, yoffset, 0.0f, info, sizeof(info));
1202
1203       BLF_disable(font_id, BLF_SHADOW);
1204     }
1205   }
1206 }
1207
1208 static void use_drw_engine(DrawEngineType *engine)
1209 {
1210   LinkData *ld = MEM_callocN(sizeof(LinkData), "enabled engine link data");
1211   ld->data = engine;
1212   BLI_addtail(&DST.enabled_engines, ld);
1213 }
1214
1215 /**
1216  * Use for external render engines.
1217  */
1218 static void drw_engines_enable_external(void)
1219 {
1220   use_drw_engine(DRW_engine_viewport_external_type.draw_engine);
1221 }
1222
1223 /* TODO revisit this when proper layering is implemented */
1224 /* Gather all draw engines needed and store them in DST.enabled_engines
1225  * That also define the rendering order of engines */
1226 static void drw_engines_enable_from_engine(RenderEngineType *engine_type,
1227                                            int drawtype,
1228                                            bool use_xray)
1229 {
1230   switch (drawtype) {
1231     case OB_WIRE:
1232       use_drw_engine(&draw_engine_workbench_transparent);
1233       break;
1234
1235     case OB_SOLID:
1236       if (use_xray) {
1237         use_drw_engine(&draw_engine_workbench_transparent);
1238       }
1239       else {
1240         use_drw_engine(&draw_engine_workbench_solid);
1241       }
1242       break;
1243
1244     case OB_MATERIAL:
1245     case OB_RENDER:
1246     default:
1247       /* TODO layers */
1248       if (engine_type->draw_engine != NULL) {
1249         use_drw_engine(engine_type->draw_engine);
1250       }
1251
1252       if ((engine_type->flag & RE_INTERNAL) == 0) {
1253         drw_engines_enable_external();
1254       }
1255       break;
1256   }
1257 }
1258
1259 static void drw_engines_enable_from_object_mode(void)
1260 {
1261   use_drw_engine(&draw_engine_object_type);
1262   /* TODO(fclem) remove this, it does not belong to it's own engine. */
1263   use_drw_engine(&draw_engine_motion_path_type);
1264 }
1265
1266 static void drw_engines_enable_from_paint_mode(int mode)
1267 {
1268   switch (mode) {
1269     case CTX_MODE_SCULPT:
1270       use_drw_engine(&draw_engine_sculpt_type);
1271       break;
1272     case CTX_MODE_PAINT_WEIGHT:
1273     case CTX_MODE_PAINT_VERTEX:
1274       use_drw_engine(&draw_engine_paint_vertex_type);
1275       break;
1276     case CTX_MODE_PAINT_TEXTURE:
1277       use_drw_engine(&draw_engine_paint_texture_type);
1278       break;
1279     default:
1280       break;
1281   }
1282 }
1283
1284 static void drw_engines_enable_from_mode(int mode)
1285 {
1286   switch (mode) {
1287     case CTX_MODE_EDIT_MESH:
1288       use_drw_engine(&draw_engine_edit_mesh_type);
1289       break;
1290     case CTX_MODE_EDIT_SURFACE:
1291     case CTX_MODE_EDIT_CURVE:
1292       use_drw_engine(&draw_engine_edit_curve_type);
1293       break;
1294     case CTX_MODE_EDIT_TEXT:
1295       use_drw_engine(&draw_engine_edit_text_type);
1296       break;
1297     case CTX_MODE_EDIT_ARMATURE:
1298       use_drw_engine(&draw_engine_edit_armature_type);
1299       break;
1300     case CTX_MODE_EDIT_METABALL:
1301       use_drw_engine(&draw_engine_edit_metaball_type);
1302       break;
1303     case CTX_MODE_EDIT_LATTICE:
1304       use_drw_engine(&draw_engine_edit_lattice_type);
1305       break;
1306     case CTX_MODE_PARTICLE:
1307       use_drw_engine(&draw_engine_particle_type);
1308       break;
1309     case CTX_MODE_POSE:
1310     case CTX_MODE_PAINT_WEIGHT:
1311       /* The pose engine clears the depth of the default framebuffer
1312        * to draw an object with `OB_DRAWXRAY`.
1313        * (different of workbench that has its own framebuffer).
1314        * So make sure you call its `draw_scene` after all the other engines. */
1315       use_drw_engine(&draw_engine_pose_type);
1316       break;
1317     case CTX_MODE_SCULPT:
1318     case CTX_MODE_PAINT_VERTEX:
1319     case CTX_MODE_PAINT_TEXTURE:
1320     case CTX_MODE_OBJECT:
1321     case CTX_MODE_PAINT_GPENCIL:
1322     case CTX_MODE_EDIT_GPENCIL:
1323     case CTX_MODE_SCULPT_GPENCIL:
1324     case CTX_MODE_WEIGHT_GPENCIL:
1325       break;
1326     default:
1327       BLI_assert(!"Draw mode invalid");
1328       break;
1329   }
1330 }
1331
1332 static void drw_engines_enable_from_overlays(int UNUSED(overlay_flag))
1333 {
1334   use_drw_engine(&draw_engine_overlay_type);
1335 }
1336 /**
1337  * Use for select and depth-drawing.
1338  */
1339 static void drw_engines_enable_basic(void)
1340 {
1341   use_drw_engine(DRW_engine_viewport_basic_type.draw_engine);
1342 }
1343
1344 static void drw_engines_enable(ViewLayer *view_layer, RenderEngineType *engine_type)
1345 {
1346   Object *obact = OBACT(view_layer);
1347   const enum eContextObjectMode mode = CTX_data_mode_enum_ex(
1348       DST.draw_ctx.object_edit, obact, DST.draw_ctx.object_mode);
1349   View3D *v3d = DST.draw_ctx.v3d;
1350   const int drawtype = v3d->shading.type;
1351   const bool use_xray = XRAY_ENABLED(v3d);
1352
1353   drw_engines_enable_from_engine(engine_type, drawtype, use_xray);
1354   /* grease pencil */
1355   use_drw_engine(&draw_engine_gpencil_type);
1356
1357   if (DRW_state_draw_support()) {
1358     /* Draw paint modes first so that they are drawn below the wireframes. */
1359     drw_engines_enable_from_paint_mode(mode);
1360     drw_engines_enable_from_overlays(v3d->overlay.flag);
1361     drw_engines_enable_from_object_mode();
1362     drw_engines_enable_from_mode(mode);
1363   }
1364   else {
1365     /* Force enable overlays engine for wireframe mode */
1366     if (v3d->shading.type == OB_WIRE) {
1367       drw_engines_enable_from_overlays(v3d->overlay.flag);
1368     }
1369   }
1370 }
1371
1372 static void drw_engines_disable(void)
1373 {
1374   BLI_freelistN(&DST.enabled_engines);
1375 }
1376
1377 static uint DRW_engines_get_hash(void)
1378 {
1379   uint hash = 0;
1380   /* The cache depends on enabled engines */
1381   /* FIXME : if collision occurs ... segfault */
1382   for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1383     DrawEngineType *engine = link->data;
1384     hash += BLI_ghashutil_strhash_p(engine->idname);
1385   }
1386
1387   return hash;
1388 }
1389
1390 /* -------------------------------------------------------------------- */
1391 /** \name View Update
1392  * \{ */
1393
1394 void DRW_notify_view_update(const DRWUpdateContext *update_ctx)
1395 {
1396   RenderEngineType *engine_type = update_ctx->engine_type;
1397   ARegion *ar = update_ctx->ar;
1398   View3D *v3d = update_ctx->v3d;
1399   RegionView3D *rv3d = ar->regiondata;
1400   Depsgraph *depsgraph = update_ctx->depsgraph;
1401   Scene *scene = update_ctx->scene;
1402   ViewLayer *view_layer = update_ctx->view_layer;
1403
1404   /* Separate update for each stereo view. */
1405   for (int view = 0; view < 2; view++) {
1406     GPUViewport *viewport = WM_draw_region_get_viewport(ar, view);
1407     if (!viewport) {
1408       continue;
1409     }
1410
1411     /* XXX Really nasty locking. But else this could
1412      * be executed by the material previews thread
1413      * while rendering a viewport. */
1414     BLI_ticket_mutex_lock(DST.gl_context_mutex);
1415
1416     /* Reset before using it. */
1417     drw_state_prepare_clean_for_draw(&DST);
1418
1419     DST.viewport = viewport;
1420     DST.draw_ctx = (DRWContextState){
1421         .ar = ar,
1422         .rv3d = rv3d,
1423         .v3d = v3d,
1424         .scene = scene,
1425         .view_layer = view_layer,
1426         .obact = OBACT(view_layer),
1427         .engine_type = engine_type,
1428         .depsgraph = depsgraph,
1429         .object_mode = OB_MODE_OBJECT,
1430     };
1431
1432     drw_engines_enable(view_layer, engine_type);
1433
1434     for (LinkData *link = DST.enabled_engines.first; link; link = link->next) {
1435       DrawEngineType *draw_engine = link->data;
1436       ViewportEngineData *data = drw_viewport_engine_data_ensure(draw_engine);
1437
1438       if (draw_engine->view_update) {
1439         draw_engine->view_update(data);
1440       }
1441     }
1442
1443     DST.viewport = NULL;
1444
1445     drw_engines_disable();
1446
1447     BLI_ticket_mutex_unlock(DST.gl_context_mutex);
1448   }
1449 }
1450
1451 /** \} */
1452
1453 /* -------------------------------------------------------------------- */
1454 /** \name Main Draw Loops (DRW_draw)
1455  * \{ */
1456
1457 /* Everything starts here.
1458  * This function takes care of calling all cache and rendering functions
1459  * for each relevant engine / mode engine. */
1460 void DRW_draw_view(const bContext *C)
1461 {
1462   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1463   ARegion *ar = CTX_wm_region(C);
1464   View3D *v3d = CTX_wm_view3d(C);
1465   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1466   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
1467   GPUViewport *viewport = WM_draw_region_get_bound_viewport(ar);
1468
1469   /* Reset before using it. */
1470   drw_state_prepare_clean_for_draw(&DST);
1471   DST.options.draw_text = ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0 &&
1472                            (v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) != 0);
1473   DRW_draw_render_loop_ex(depsgraph, engine_type, ar, v3d, viewport, C);
1474 }
1475
1476 /**
1477  * Used for both regular and off-screen drawing.
1478  * Need to reset DST before calling this function
1479  */
1480 void DRW_draw_render_loop_ex(struct Depsgraph *depsgraph,
1481                              RenderEngineType *engine_type,
1482                              ARegion *ar,
1483                              View3D *v3d,
1484                              GPUViewport *viewport,
1485                              const bContext *evil_C)
1486 {
1487
1488   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1489   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
1490   RegionView3D *rv3d = ar->regiondata;
1491   const bool do_annotations = (((v3d->flag2 & V3D_SHOW_ANNOTATION) != 0) &&
1492                                ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0));
1493   const bool do_camera_frame = !DST.options.is_image_render;
1494
1495   DST.draw_ctx.evil_C = evil_C;
1496   DST.viewport = viewport;
1497
1498   /* Setup viewport */
1499   GPU_viewport_engines_data_validate(DST.viewport, DRW_engines_get_hash());
1500
1501   DST.draw_ctx = (DRWContextState){
1502       .ar = ar,
1503       .rv3d = rv3d,
1504       .v3d = v3d,
1505       .scene = scene,
1506       .view_layer = view_layer,
1507       .obact = OBACT(view_layer),
1508       .engine_type = engine_type,
1509       .depsgraph = depsgraph,
1510
1511       /* reuse if caller sets */
1512       .evil_C = DST.draw_ctx.evil_C,
1513   };
1514   drw_context_state_init();
1515   drw_viewport_var_init();
1516
1517   /* Get list of enabled engines */
1518   drw_engines_enable(view_layer, engine_type);
1519
1520   /* Update ubos */
1521   DRW_globals_update();
1522
1523   drw_debug_init();
1524   DRW_hair_init();
1525
1526   /* No framebuffer allowed before drawing. */
1527   BLI_assert(GPU_framebuffer_active_get() == NULL);
1528
1529   /* Init engines */
1530   drw_engines_init();
1531
1532   /* Cache filling */
1533   {
1534     PROFILE_START(stime);
1535     drw_engines_cache_init();
1536     drw_engines_world_update(scene);
1537
1538     const int object_type_exclude_viewport = v3d->object_type_exclude_viewport;
1539     DEG_OBJECT_ITER_BEGIN (depsgraph,
1540                            ob,
1541                            DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
1542                                DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET | DEG_ITER_OBJECT_FLAG_VISIBLE |
1543                                DEG_ITER_OBJECT_FLAG_DUPLI) {
1544       if ((object_type_exclude_viewport & (1 << ob->type)) != 0) {
1545         continue;
1546       }
1547       if (v3d->localvd && ((v3d->local_view_uuid & ob->base_local_view_bits) == 0)) {
1548         continue;
1549       }
1550       DST.dupli_parent = data_.dupli_parent;
1551       DST.dupli_source = data_.dupli_object_current;
1552       drw_engines_cache_populate(ob);
1553     }
1554     DEG_OBJECT_ITER_END;
1555
1556     drw_engines_cache_finish();
1557
1558     DRW_render_instance_buffer_finish();
1559
1560 #ifdef USE_PROFILE
1561     double *cache_time = GPU_viewport_cache_time_get(DST.viewport);
1562     PROFILE_END_UPDATE(*cache_time, stime);
1563 #endif
1564   }
1565
1566   DRW_stats_begin();
1567
1568   GPU_framebuffer_bind(DST.default_framebuffer);
1569
1570   /* Start Drawing */
1571   DRW_state_reset();
1572
1573   DRW_hair_update();
1574
1575   drw_engines_draw_background();
1576
1577   /* WIP, single image drawn over the camera view (replace) */
1578   bool do_bg_image = false;
1579   if (rv3d->persp == RV3D_CAMOB) {
1580     Object *cam_ob = v3d->camera;
1581     if (cam_ob && cam_ob->type == OB_CAMERA) {
1582       Camera *cam = cam_ob->data;
1583       if (!BLI_listbase_is_empty(&cam->bg_images)) {
1584         do_bg_image = true;
1585       }
1586     }
1587   }
1588
1589   GPU_framebuffer_bind(DST.default_framebuffer);
1590
1591   if (do_bg_image) {
1592     ED_view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, false, do_camera_frame);
1593   }
1594
1595   DRW_draw_callbacks_pre_scene();
1596   if (DST.draw_ctx.evil_C) {
1597     ED_region_draw_cb_draw(DST.draw_ctx.evil_C, DST.draw_ctx.ar, REGION_DRAW_PRE_VIEW);
1598   }
1599
1600   drw_engines_draw_scene();
1601
1602 #ifdef __APPLE__
1603   /* Fix 3D view being "laggy" on macos. (See T56996) */
1604   GPU_flush();
1605 #endif
1606
1607   /* annotations - temporary drawing buffer (3d space) */
1608   /* XXX: Or should we use a proper draw/overlay engine for this case? */
1609   if (do_annotations) {
1610     GPU_depth_test(false);
1611     /* XXX: as scene->gpd is not copied for COW yet */
1612     ED_annotation_draw_view3d(DEG_get_input_scene(depsgraph), depsgraph, v3d, ar, true);
1613     GPU_depth_test(true);
1614   }
1615
1616   DRW_draw_callbacks_post_scene();
1617   if (DST.draw_ctx.evil_C) {
1618     DRW_state_reset();
1619     ED_region_draw_cb_draw(DST.draw_ctx.evil_C, DST.draw_ctx.ar, REGION_DRAW_POST_VIEW);
1620     /* Callback can be nasty and do whatever they want with the state.
1621      * Don't trust them! */
1622     DRW_state_reset();
1623   }
1624
1625   DRW_state_reset();
1626
1627   drw_debug_draw();
1628
1629   GPU_depth_test(false);
1630   drw_engines_draw_text();
1631   GPU_depth_test(true);
1632
1633   if (DST.draw_ctx.evil_C) {
1634     /* needed so gizmo isn't obscured */
1635     if ((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) {
1636       glDisable(GL_DEPTH_TEST);
1637       DRW_draw_gizmo_3d();
1638     }
1639
1640     DRW_draw_region_info();
1641
1642     /* annotations - temporary drawing buffer (screenspace) */
1643     /* XXX: Or should we use a proper draw/overlay engine for this case? */
1644     if (((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0) && (do_annotations)) {
1645       GPU_depth_test(false);
1646       /* XXX: as scene->gpd is not copied for COW yet */
1647       ED_annotation_draw_view3d(DEG_get_input_scene(depsgraph), depsgraph, v3d, ar, false);
1648       GPU_depth_test(true);
1649     }
1650
1651     if ((v3d->gizmo_flag & V3D_GIZMO_HIDE) == 0) {
1652       /* Draw 2D after region info so we can draw on top of the camera passepartout overlay.
1653        * 'DRW_draw_region_info' sets the projection in pixel-space. */
1654       GPU_depth_test(false);
1655       DRW_draw_gizmo_2d();
1656       GPU_depth_test(true);
1657     }
1658   }
1659
1660   DRW_stats_reset();
1661
1662   if (do_bg_image) {
1663     ED_view3d_draw_bgpic_test(scene, depsgraph, ar, v3d, true, do_camera_frame);
1664   }
1665
1666   if (G.debug_value > 20 && G.debug_value < 30) {
1667     GPU_depth_test(false);
1668     rcti rect; /* local coordinate visible rect inside region, to accommodate overlapping ui */
1669     ED_region_visible_rect(DST.draw_ctx.ar, &rect);
1670     DRW_stats_draw(&rect);
1671     GPU_depth_test(true);
1672   }
1673
1674   if (WM_draw_region_get_bound_viewport(ar)) {
1675     /* Don't unbind the framebuffer yet in this case and let
1676      * GPU_viewport_unbind do it, so that we can still do further
1677      * drawing of action zones on top. */
1678   }
1679   else {
1680     GPU_framebuffer_restore();
1681   }
1682
1683   DRW_state_reset();
1684   drw_engines_disable();
1685
1686   drw_viewport_cache_resize();
1687
1688 #ifdef DEBUG
1689   /* Avoid accidental reuse. */
1690   drw_state_ensure_not_reused(&DST);
1691 #endif
1692 }
1693
1694 void DRW_draw_render_loop(struct Depsgraph *depsgraph,
1695                           ARegion *ar,
1696                           View3D *v3d,
1697                           GPUViewport *viewport)
1698 {
1699   /* Reset before using it. */
1700   drw_state_prepare_clean_for_draw(&DST);
1701
1702   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1703   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
1704
1705   DRW_draw_render_loop_ex(depsgraph, engine_type, ar, v3d, viewport, NULL);
1706 }
1707
1708 /* @viewport CAN be NULL, in this case we create one. */
1709 void DRW_draw_render_loop_offscreen(struct Depsgraph *depsgraph,
1710                                     RenderEngineType *engine_type,
1711                                     ARegion *ar,
1712                                     View3D *v3d,
1713                                     const bool draw_background,
1714                                     const bool do_color_management,
1715                                     GPUOffScreen *ofs,
1716                                     GPUViewport *viewport)
1717 {
1718   /* Create temporary viewport if needed. */
1719   GPUViewport *render_viewport = viewport;
1720   if (viewport == NULL) {
1721     render_viewport = GPU_viewport_create_from_offscreen(ofs);
1722   }
1723
1724   GPU_framebuffer_restore();
1725
1726   /* Reset before using it. */
1727   drw_state_prepare_clean_for_draw(&DST);
1728   /* WATCH: Force color management to output CManaged byte buffer by
1729    * forcing is_image_render to false. */
1730   DST.options.is_image_render = !do_color_management;
1731   DST.options.draw_background = draw_background;
1732   DRW_draw_render_loop_ex(depsgraph, engine_type, ar, v3d, render_viewport, NULL);
1733
1734   /* Free temporary viewport. */
1735   if (viewport == NULL) {
1736     /* don't free data owned by 'ofs' */
1737     GPU_viewport_clear_from_offscreen(render_viewport);
1738     GPU_viewport_free(render_viewport);
1739   }
1740
1741   /* we need to re-bind (annoying!) */
1742   GPU_offscreen_bind(ofs, false);
1743 }
1744
1745 /* Helper to check if exit object type to render. */
1746 bool DRW_render_check_grease_pencil(Depsgraph *depsgraph)
1747 {
1748   DEG_OBJECT_ITER_FOR_RENDER_ENGINE_BEGIN (depsgraph, ob) {
1749     if (ob->type == OB_GPENCIL) {
1750       if (DRW_object_visibility_in_active_context(ob) & OB_VISIBLE_SELF) {
1751         return true;
1752       }
1753     }
1754   }
1755   DEG_OBJECT_ITER_FOR_RENDER_ENGINE_END;
1756
1757   return false;
1758 }
1759
1760 static void DRW_render_gpencil_to_image(RenderEngine *engine,
1761                                         struct RenderLayer *render_layer,
1762                                         const rcti *rect)
1763 {
1764   if (draw_engine_gpencil_type.render_to_image) {
1765     ViewportEngineData *gpdata = drw_viewport_engine_data_ensure(&draw_engine_gpencil_type);
1766     draw_engine_gpencil_type.render_to_image(gpdata, engine, render_layer, rect);
1767   }
1768 }
1769
1770 void DRW_render_gpencil(struct RenderEngine *engine, struct Depsgraph *depsgraph)
1771 {
1772   /* This function is only valid for Cycles
1773    * Eevee done all work in the Eevee render directly.
1774    * Maybe it can be done equal for both engines?
1775    */
1776   if (STREQ(engine->type->name, "Eevee")) {
1777     return;
1778   }
1779
1780   /* Early out if there are no grease pencil objects, especially important
1781    * to avoid failing in in background renders without OpenGL context. */
1782   if (!DRW_render_check_grease_pencil(depsgraph)) {
1783     return;
1784   }
1785
1786   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1787   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
1788   RenderEngineType *engine_type = engine->type;
1789   RenderData *r = &scene->r;
1790   Render *render = engine->re;
1791   /* Changing Context */
1792   if (G.background && DST.gl_context == NULL) {
1793     WM_init_opengl(G_MAIN);
1794   }
1795
1796   void *re_gl_context = RE_gl_context_get(render);
1797   void *re_gpu_context = NULL;
1798
1799   /* Changing Context */
1800   if (re_gl_context != NULL) {
1801     DRW_opengl_render_context_enable(re_gl_context);
1802     /* We need to query gpu context after a gl context has been bound. */
1803     re_gpu_context = RE_gpu_context_get(render);
1804     DRW_gawain_render_context_enable(re_gpu_context);
1805   }
1806   else {
1807     DRW_opengl_context_enable();
1808   }
1809
1810   /* Reset before using it. */
1811   drw_state_prepare_clean_for_draw(&DST);
1812   DST.options.is_image_render = true;
1813   DST.options.is_scene_render = true;
1814   DST.options.draw_background = scene->r.alphamode == R_ADDSKY;
1815   DST.buffer_finish_called = true;
1816
1817   DST.draw_ctx = (DRWContextState){
1818       .scene = scene,
1819       .view_layer = view_layer,
1820       .engine_type = engine_type,
1821       .depsgraph = depsgraph,
1822       .object_mode = OB_MODE_OBJECT,
1823   };
1824   drw_context_state_init();
1825
1826   DST.viewport = GPU_viewport_create();
1827   const int size[2] = {(r->size * r->xsch) / 100, (r->size * r->ysch) / 100};
1828   GPU_viewport_size_set(DST.viewport, size);
1829
1830   drw_viewport_var_init();
1831
1832   /* Main rendering. */
1833   rctf view_rect;
1834   rcti render_rect;
1835   RE_GetViewPlane(render, &view_rect, &render_rect);
1836   if (BLI_rcti_is_empty(&render_rect)) {
1837     BLI_rcti_init(&render_rect, 0, size[0], 0, size[1]);
1838   }
1839
1840   RenderResult *render_result = RE_engine_get_result(engine);
1841   RenderLayer *render_layer = render_result->layers.first;
1842
1843   DRW_render_gpencil_to_image(engine, render_layer, &render_rect);
1844
1845   /* Force cache to reset. */
1846   drw_viewport_cache_resize();
1847   GPU_viewport_free(DST.viewport);
1848   DRW_state_reset();
1849
1850   glDisable(GL_DEPTH_TEST);
1851
1852   /* Restore Drawing area. */
1853   GPU_framebuffer_restore();
1854
1855   /* Changing Context */
1856   /* GPXX Review this context */
1857   DRW_opengl_context_disable();
1858
1859   DST.buffer_finish_called = false;
1860 }
1861
1862 void DRW_render_to_image(RenderEngine *engine, struct Depsgraph *depsgraph)
1863 {
1864   Scene *scene = DEG_get_evaluated_scene(depsgraph);
1865   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
1866   RenderEngineType *engine_type = engine->type;
1867   DrawEngineType *draw_engine_type = engine_type->draw_engine;
1868   Render *render = engine->re;
1869
1870   if (G.background && DST.gl_context == NULL) {
1871     WM_init_opengl(G_MAIN);
1872   }
1873
1874   void *re_gl_context = RE_gl_context_get(render);
1875   void *re_gpu_context = NULL;
1876
1877   /* Changing Context */
1878   if (re_gl_context != NULL) {
1879     DRW_opengl_render_context_enable(re_gl_context);
1880     /* We need to query gpu context after a gl context has been bound. */
1881     re_gpu_context = RE_gpu_context_get(render);
1882     DRW_gawain_render_context_enable(re_gpu_context);
1883   }
1884   else {
1885     DRW_opengl_context_enable();
1886   }
1887
1888   /* IMPORTANT: We dont support immediate mode in render mode!
1889    * This shall remain in effect until immediate mode supports
1890    * multiple threads. */
1891
1892   /* Reset before using it. */
1893   drw_state_prepare_clean_for_draw(&DST);
1894   DST.options.is_image_render = true;
1895   DST.options.is_scene_render = true;
1896   DST.options.draw_background = scene->r.alphamode == R_ADDSKY;
1897
1898   DST.draw_ctx = (DRWContextState){
1899       .scene = scene,
1900       .view_layer = view_layer,
1901       .engine_type = engine_type,
1902       .depsgraph = depsgraph,
1903       .object_mode = OB_MODE_OBJECT,
1904   };
1905   drw_context_state_init();
1906
1907   DST.viewport = GPU_viewport_create();
1908   const int size[2] = {engine->resolution_x, engine->resolution_y};
1909   GPU_viewport_size_set(DST.viewport, size);
1910
1911   drw_viewport_var_init();
1912
1913   ViewportEngineData *data = drw_viewport_engine_data_ensure(draw_engine_type);
1914
1915   /* set default viewport */
1916   glViewport(0, 0, size[0], size[1]);
1917
1918   /* Main rendering. */
1919   rctf view_rect;
1920   rcti render_rect;
1921   RE_GetViewPlane(render, &view_rect, &render_rect);
1922   if (BLI_rcti_is_empty(&render_rect)) {
1923     BLI_rcti_init(&render_rect, 0, size[0], 0, size[1]);
1924   }
1925
1926   /* Reset state before drawing */
1927   DRW_state_reset();
1928
1929   /* Init render result. */
1930   RenderResult *render_result = RE_engine_begin_result(engine,
1931                                                        0,
1932                                                        0,
1933                                                        (int)size[0],
1934                                                        (int)size[1],
1935                                                        view_layer->name,
1936                                                        /* RR_ALL_VIEWS */ NULL);
1937
1938   RenderLayer *render_layer = render_result->layers.first;
1939   for (RenderView *render_view = render_result->views.first; render_view != NULL;
1940        render_view = render_view->next) {
1941     RE_SetActiveRenderView(render, render_view->name);
1942     engine_type->draw_engine->render_to_image(data, engine, render_layer, &render_rect);
1943     /* grease pencil: render result is merged in the previous render result. */
1944     if (DRW_render_check_grease_pencil(depsgraph)) {
1945       DRW_state_reset();
1946       DRW_render_gpencil_to_image(engine, render_layer, &render_rect);
1947     }
1948     DST.buffer_finish_called = false;
1949   }
1950
1951   RE_engine_end_result(engine, render_result, false, false, false);
1952
1953   /* Force cache to reset. */
1954   drw_viewport_cache_resize();
1955
1956   GPU_viewport_free(DST.viewport);
1957   GPU_framebuffer_restore();
1958
1959 #ifdef DEBUG
1960   /* Avoid accidental reuse. */
1961   drw_state_ensure_not_reused(&DST);
1962 #endif
1963
1964   /* Reset state after drawing */
1965   DRW_state_reset();
1966
1967   /* Changing Context */
1968   if (re_gl_context != NULL) {
1969     DRW_gawain_render_context_disable(re_gpu_context);
1970     DRW_opengl_render_context_disable(re_gl_context);
1971   }
1972   else {
1973     DRW_opengl_context_disable();
1974   }
1975 }
1976
1977 void DRW_render_object_iter(
1978     void *vedata,
1979     RenderEngine *engine,
1980     struct Depsgraph *depsgraph,
1981     void (*callback)(void *vedata, Object *ob, RenderEngine *engine, struct Depsgraph *depsgraph))
1982 {
1983   const DRWContextState *draw_ctx = DRW_context_state_get();
1984
1985   DRW_hair_init();
1986
1987   const int object_type_exclude_viewport = draw_ctx->v3d ?
1988                                                draw_ctx->v3d->object_type_exclude_viewport :
1989                                                0;
1990   DEG_OBJECT_ITER_BEGIN (depsgraph,
1991                          ob,
1992                          DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
1993                              DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET | DEG_ITER_OBJECT_FLAG_VISIBLE |
1994                              DEG_ITER_OBJECT_FLAG_DUPLI) {
1995     if ((object_type_exclude_viewport & (1 << ob->type)) == 0) {
1996       DST.dupli_parent = data_.dupli_parent;
1997       DST.dupli_source = data_.dupli_object_current;
1998       DST.ob_state = NULL;
1999       callback(vedata, ob, engine, depsgraph);
2000
2001       drw_batch_cache_generate_requested(ob);
2002     }
2003   }
2004   DEG_OBJECT_ITER_END;
2005 }
2006
2007 /* Assume a valid gl context is bound (and that the gl_context_mutex has been acquired).
2008  * This function only setup DST and execute the given function.
2009  * Warning: similar to DRW_render_to_image you cannot use default lists (dfbl & dtxl). */
2010 void DRW_custom_pipeline(DrawEngineType *draw_engine_type,
2011                          struct Depsgraph *depsgraph,
2012                          void (*callback)(void *vedata, void *user_data),
2013                          void *user_data)
2014 {
2015   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2016   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2017
2018   /* Reset before using it. */
2019   drw_state_prepare_clean_for_draw(&DST);
2020   DST.options.is_image_render = true;
2021   DST.options.is_scene_render = true;
2022   DST.options.draw_background = false;
2023
2024   DST.draw_ctx = (DRWContextState){
2025       .scene = scene,
2026       .view_layer = view_layer,
2027       .engine_type = NULL,
2028       .depsgraph = depsgraph,
2029       .object_mode = OB_MODE_OBJECT,
2030   };
2031   drw_context_state_init();
2032
2033   DST.viewport = GPU_viewport_create();
2034   const int size[2] = {1, 1};
2035   GPU_viewport_size_set(DST.viewport, size);
2036
2037   drw_viewport_var_init();
2038
2039   DRW_hair_init();
2040
2041   ViewportEngineData *data = drw_viewport_engine_data_ensure(draw_engine_type);
2042
2043   /* Execute the callback */
2044   callback(data, user_data);
2045   DST.buffer_finish_called = false;
2046
2047   GPU_viewport_free(DST.viewport);
2048   GPU_framebuffer_restore();
2049
2050   /* The use of custom pipeline in other thread using the same
2051    * resources as the main thread (viewport) may lead to data
2052    * races and undefined behavior on certain drivers. Using
2053    * GPU_finish to sync seems to fix the issue. (see T62997) */
2054   GPU_finish();
2055
2056 #ifdef DEBUG
2057   /* Avoid accidental reuse. */
2058   drw_state_ensure_not_reused(&DST);
2059 #endif
2060 }
2061
2062 static struct DRWSelectBuffer {
2063   struct GPUFrameBuffer *framebuffer_depth_only;
2064   struct GPUFrameBuffer *framebuffer_select_id;
2065   struct GPUTexture *texture_depth;
2066   struct GPUTexture *texture_u32;
2067 } g_select_buffer = {NULL};
2068
2069 static void draw_select_framebuffer_depth_only_setup(const int size[2])
2070 {
2071   if (g_select_buffer.framebuffer_depth_only == NULL) {
2072     g_select_buffer.framebuffer_depth_only = GPU_framebuffer_create();
2073     g_select_buffer.framebuffer_select_id = GPU_framebuffer_create();
2074   }
2075
2076   if ((g_select_buffer.texture_depth != NULL) &&
2077       ((GPU_texture_width(g_select_buffer.texture_depth) != size[0]) ||
2078        (GPU_texture_height(g_select_buffer.texture_depth) != size[1]))) {
2079     GPU_texture_free(g_select_buffer.texture_depth);
2080     g_select_buffer.texture_depth = NULL;
2081   }
2082
2083   if (g_select_buffer.texture_depth == NULL) {
2084     g_select_buffer.texture_depth = GPU_texture_create_2d(
2085         size[0], size[1], GPU_DEPTH_COMPONENT24, NULL, NULL);
2086
2087     GPU_framebuffer_texture_attach(
2088         g_select_buffer.framebuffer_depth_only, g_select_buffer.texture_depth, 0, 0);
2089
2090     GPU_framebuffer_texture_attach(
2091         g_select_buffer.framebuffer_select_id, g_select_buffer.texture_depth, 0, 0);
2092
2093     GPU_framebuffer_check_valid(g_select_buffer.framebuffer_depth_only, NULL);
2094     GPU_framebuffer_check_valid(g_select_buffer.framebuffer_select_id, NULL);
2095   }
2096 }
2097
2098 static void draw_select_framebuffer_select_id_setup(const int size[2])
2099 {
2100   draw_select_framebuffer_depth_only_setup(size);
2101
2102   if ((g_select_buffer.texture_u32 != NULL) &&
2103       ((GPU_texture_width(g_select_buffer.texture_u32) != size[0]) ||
2104        (GPU_texture_height(g_select_buffer.texture_u32) != size[1]))) {
2105     GPU_texture_free(g_select_buffer.texture_u32);
2106     g_select_buffer.texture_u32 = NULL;
2107   }
2108
2109   if (g_select_buffer.texture_u32 == NULL) {
2110     g_select_buffer.texture_u32 = GPU_texture_create_2d(size[0], size[1], GPU_R32UI, NULL, NULL);
2111
2112     GPU_framebuffer_texture_attach(
2113         g_select_buffer.framebuffer_select_id, g_select_buffer.texture_u32, 0, 0);
2114
2115     GPU_framebuffer_check_valid(g_select_buffer.framebuffer_select_id, NULL);
2116   }
2117 }
2118
2119 /* Must run after all instance datas have been added. */
2120 void DRW_render_instance_buffer_finish(void)
2121 {
2122   BLI_assert(!DST.buffer_finish_called && "DRW_render_instance_buffer_finish called twice!");
2123   DST.buffer_finish_called = true;
2124   DRW_instance_buffer_finish(DST.idatalist);
2125 }
2126
2127 /**
2128  * object mode select-loop, see: ED_view3d_draw_select_loop (legacy drawing).
2129  */
2130 void DRW_draw_select_loop(struct Depsgraph *depsgraph,
2131                           ARegion *ar,
2132                           View3D *v3d,
2133                           bool UNUSED(use_obedit_skip),
2134                           bool draw_surface,
2135                           bool UNUSED(use_nearest),
2136                           const rcti *rect,
2137                           DRW_SelectPassFn select_pass_fn,
2138                           void *select_pass_user_data,
2139                           DRW_ObjectFilterFn object_filter_fn,
2140                           void *object_filter_user_data)
2141 {
2142   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2143   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
2144   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2145   Object *obact = OBACT(view_layer);
2146   Object *obedit = OBEDIT_FROM_OBACT(obact);
2147 #ifndef USE_GPU_SELECT
2148   UNUSED_VARS(vc, scene, view_layer, v3d, ar, rect);
2149 #else
2150   RegionView3D *rv3d = ar->regiondata;
2151
2152   /* Reset before using it. */
2153   drw_state_prepare_clean_for_draw(&DST);
2154
2155   bool use_obedit = false;
2156   int obedit_mode = 0;
2157   if (obedit != NULL) {
2158     if (obedit->type == OB_MBALL) {
2159       use_obedit = true;
2160       obedit_mode = CTX_MODE_EDIT_METABALL;
2161     }
2162     else if (obedit->type == OB_ARMATURE) {
2163       use_obedit = true;
2164       obedit_mode = CTX_MODE_EDIT_ARMATURE;
2165     }
2166   }
2167   if (v3d->overlay.flag & V3D_OVERLAY_BONE_SELECT) {
2168     if (!(v3d->flag2 & V3D_HIDE_OVERLAYS)) {
2169       /* Note: don't use "BKE_object_pose_armature_get" here, it breaks selection. */
2170       Object *obpose = OBPOSE_FROM_OBACT(obact);
2171       if (obpose) {
2172         use_obedit = true;
2173         obedit_mode = CTX_MODE_POSE;
2174       }
2175     }
2176   }
2177
2178   int viewport_size[2] = {BLI_rcti_size_x(rect), BLI_rcti_size_y(rect)};
2179   struct GPUViewport *viewport = GPU_viewport_create();
2180   GPU_viewport_size_set(viewport, viewport_size);
2181
2182   DST.viewport = viewport;
2183   DST.options.is_select = true;
2184
2185   /* Get list of enabled engines */
2186   if (use_obedit) {
2187     drw_engines_enable_from_paint_mode(obedit_mode);
2188     drw_engines_enable_from_mode(obedit_mode);
2189   }
2190   else if (!draw_surface) {
2191     /* grease pencil selection */
2192     use_drw_engine(&draw_engine_gpencil_type);
2193
2194     drw_engines_enable_from_overlays(v3d->overlay.flag);
2195     drw_engines_enable_from_object_mode();
2196   }
2197   else {
2198     drw_engines_enable_basic();
2199     /* grease pencil selection */
2200     use_drw_engine(&draw_engine_gpencil_type);
2201
2202     drw_engines_enable_from_overlays(v3d->overlay.flag);
2203     drw_engines_enable_from_object_mode();
2204   }
2205
2206   /* Setup viewport */
2207
2208   /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2209   DST.draw_ctx = (DRWContextState){
2210       .ar = ar,
2211       .rv3d = rv3d,
2212       .v3d = v3d,
2213       .scene = scene,
2214       .view_layer = view_layer,
2215       .obact = obact,
2216       .engine_type = engine_type,
2217       .depsgraph = depsgraph,
2218   };
2219   drw_context_state_init();
2220   drw_viewport_var_init();
2221
2222   /* Update ubos */
2223   DRW_globals_update();
2224
2225   /* Init engines */
2226   drw_engines_init();
2227   DRW_hair_init();
2228
2229   {
2230     drw_engines_cache_init();
2231     drw_engines_world_update(scene);
2232
2233     if (use_obedit) {
2234 #  if 0
2235       drw_engines_cache_populate(obact);
2236 #  else
2237       FOREACH_OBJECT_IN_MODE_BEGIN (view_layer, v3d, obact->type, obact->mode, ob_iter) {
2238         drw_engines_cache_populate(ob_iter);
2239       }
2240       FOREACH_OBJECT_IN_MODE_END;
2241 #  endif
2242     }
2243     else {
2244       const int object_type_exclude_select = (v3d->object_type_exclude_viewport |
2245                                               v3d->object_type_exclude_select);
2246       bool filter_exclude = false;
2247       DEG_OBJECT_ITER_BEGIN (depsgraph,
2248                              ob,
2249                              DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
2250                                  DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET |
2251                                  DEG_ITER_OBJECT_FLAG_VISIBLE | DEG_ITER_OBJECT_FLAG_DUPLI) {
2252         if (v3d->localvd && ((v3d->local_view_uuid & ob->base_local_view_bits) == 0)) {
2253           continue;
2254         }
2255
2256         if ((ob->base_flag & BASE_SELECTABLE) &&
2257             (object_type_exclude_select & (1 << ob->type)) == 0) {
2258           if (object_filter_fn != NULL) {
2259             if (ob->base_flag & BASE_FROM_DUPLI) {
2260               /* pass (use previous filter_exclude value) */
2261             }
2262             else {
2263               filter_exclude = (object_filter_fn(ob, object_filter_user_data) == false);
2264             }
2265             if (filter_exclude) {
2266               continue;
2267             }
2268           }
2269
2270           /* This relies on dupli instances being after their instancing object. */
2271           if ((ob->base_flag & BASE_FROM_DUPLI) == 0) {
2272             Object *ob_orig = DEG_get_original_object(ob);
2273             DRW_select_load_id(ob_orig->select_id);
2274           }
2275           DST.dupli_parent = data_.dupli_parent;
2276           DST.dupli_source = data_.dupli_object_current;
2277           drw_engines_cache_populate(ob);
2278         }
2279       }
2280       DEG_OBJECT_ITER_END;
2281     }
2282
2283     drw_engines_cache_finish();
2284
2285     DRW_render_instance_buffer_finish();
2286   }
2287
2288   /* Setup framebuffer */
2289   draw_select_framebuffer_depth_only_setup(viewport_size);
2290   GPU_framebuffer_bind(g_select_buffer.framebuffer_depth_only);
2291   GPU_framebuffer_clear_depth(g_select_buffer.framebuffer_depth_only, 1.0f);
2292
2293   /* Start Drawing */
2294   DRW_state_reset();
2295   DRW_draw_callbacks_pre_scene();
2296
2297   DRW_hair_update();
2298
2299   DRW_state_lock(DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_ALWAYS | DRW_STATE_DEPTH_LESS_EQUAL |
2300                  DRW_STATE_DEPTH_EQUAL | DRW_STATE_DEPTH_GREATER | DRW_STATE_DEPTH_ALWAYS);
2301
2302   /* Only 1-2 passes. */
2303   while (true) {
2304     if (!select_pass_fn(DRW_SELECT_PASS_PRE, select_pass_user_data)) {
2305       break;
2306     }
2307
2308     drw_engines_draw_scene();
2309
2310     if (!select_pass_fn(DRW_SELECT_PASS_POST, select_pass_user_data)) {
2311       break;
2312     }
2313   }
2314
2315   DRW_state_lock(0);
2316
2317   DRW_draw_callbacks_post_scene();
2318
2319   DRW_state_reset();
2320   drw_engines_disable();
2321
2322 #  ifdef DEBUG
2323   /* Avoid accidental reuse. */
2324   drw_state_ensure_not_reused(&DST);
2325 #  endif
2326   GPU_framebuffer_restore();
2327
2328   /* Cleanup for selection state */
2329   GPU_viewport_free(viewport);
2330 #endif /* USE_GPU_SELECT */
2331 }
2332
2333 /**
2334  * object mode select-loop, see: ED_view3d_draw_depth_loop (legacy drawing).
2335  */
2336 static void drw_draw_depth_loop_imp(void)
2337 {
2338   DRW_opengl_context_enable();
2339
2340   /* Setup framebuffer */
2341   DefaultFramebufferList *fbl = (DefaultFramebufferList *)GPU_viewport_framebuffer_list_get(
2342       DST.viewport);
2343   GPU_framebuffer_bind(fbl->depth_only_fb);
2344   GPU_framebuffer_clear_depth(fbl->depth_only_fb, 1.0f);
2345
2346   /* Setup viewport */
2347   drw_context_state_init();
2348   drw_viewport_var_init();
2349
2350   /* Update ubos */
2351   DRW_globals_update();
2352
2353   /* Init engines */
2354   drw_engines_init();
2355   DRW_hair_init();
2356
2357   {
2358     drw_engines_cache_init();
2359     drw_engines_world_update(DST.draw_ctx.scene);
2360
2361     View3D *v3d = DST.draw_ctx.v3d;
2362     const int object_type_exclude_viewport = v3d->object_type_exclude_viewport;
2363     DEG_OBJECT_ITER_BEGIN (DST.draw_ctx.depsgraph,
2364                            ob,
2365                            DEG_ITER_OBJECT_FLAG_LINKED_DIRECTLY |
2366                                DEG_ITER_OBJECT_FLAG_LINKED_VIA_SET | DEG_ITER_OBJECT_FLAG_VISIBLE |
2367                                DEG_ITER_OBJECT_FLAG_DUPLI) {
2368       if ((object_type_exclude_viewport & (1 << ob->type)) != 0) {
2369         continue;
2370       }
2371
2372       if (v3d->localvd && ((v3d->local_view_uuid & ob->base_local_view_bits) == 0)) {
2373         continue;
2374       }
2375
2376       DST.dupli_parent = data_.dupli_parent;
2377       DST.dupli_source = data_.dupli_object_current;
2378       drw_engines_cache_populate(ob);
2379     }
2380     DEG_OBJECT_ITER_END;
2381
2382     drw_engines_cache_finish();
2383
2384     DRW_render_instance_buffer_finish();
2385   }
2386
2387   /* Start Drawing */
2388   DRW_state_reset();
2389
2390   DRW_hair_update();
2391
2392   DRW_draw_callbacks_pre_scene();
2393   drw_engines_draw_scene();
2394   DRW_draw_callbacks_post_scene();
2395
2396   DRW_state_reset();
2397
2398   /* TODO: Reading depth for operators should be done here. */
2399
2400   GPU_framebuffer_restore();
2401
2402   /* Changin context */
2403   DRW_opengl_context_disable();
2404 }
2405
2406 /**
2407  * object mode select-loop, see: ED_view3d_draw_depth_loop (legacy drawing).
2408  */
2409 void DRW_draw_depth_loop(struct Depsgraph *depsgraph,
2410                          ARegion *ar,
2411                          View3D *v3d,
2412                          GPUViewport *viewport)
2413 {
2414   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2415   RenderEngineType *engine_type = ED_view3d_engine_type(scene, v3d->shading.type);
2416   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2417   RegionView3D *rv3d = ar->regiondata;
2418
2419   /* Reset before using it. */
2420   drw_state_prepare_clean_for_draw(&DST);
2421
2422   DST.viewport = viewport;
2423   DST.options.is_depth = true;
2424
2425   /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2426   DST.draw_ctx = (DRWContextState){
2427       .ar = ar,
2428       .rv3d = rv3d,
2429       .v3d = v3d,
2430       .scene = scene,
2431       .view_layer = view_layer,
2432       .obact = OBACT(view_layer),
2433       .engine_type = engine_type,
2434       .depsgraph = depsgraph,
2435   };
2436
2437   /* Get list of enabled engines */
2438   {
2439     drw_engines_enable_basic();
2440     if (DRW_state_draw_support()) {
2441       drw_engines_enable_from_object_mode();
2442     }
2443   }
2444
2445   drw_draw_depth_loop_imp();
2446
2447   drw_engines_disable();
2448
2449 #ifdef DEBUG
2450   /* Avoid accidental reuse. */
2451   drw_state_ensure_not_reused(&DST);
2452 #endif
2453 }
2454
2455 /**
2456  * Converted from ED_view3d_draw_depth_gpencil (legacy drawing).
2457  */
2458 void DRW_draw_depth_loop_gpencil(struct Depsgraph *depsgraph,
2459                                  ARegion *ar,
2460                                  View3D *v3d,
2461                                  GPUViewport *viewport)
2462 {
2463   Scene *scene = DEG_get_evaluated_scene(depsgraph);
2464   ViewLayer *view_layer = DEG_get_evaluated_view_layer(depsgraph);
2465   RegionView3D *rv3d = ar->regiondata;
2466
2467   /* Reset before using it. */
2468   drw_state_prepare_clean_for_draw(&DST);
2469
2470   DST.viewport = viewport;
2471   DST.options.is_depth = true;
2472
2473   /* Instead of 'DRW_context_state_init(C, &DST.draw_ctx)', assign from args */
2474   DST.draw_ctx = (DRWContextState){
2475       .ar = ar,
2476       .rv3d = rv3d,
2477       .v3d = v3d,
2478       .scene = scene,
2479       .view_layer = view_layer,
2480       .obact = OBACT(view_layer),
2481       .depsgraph = depsgraph,
2482   };
2483
2484   use_drw_engine(&draw_engine_gpencil_type);
2485   drw_draw_depth_loop_imp();
2486   drw_engines_disable();
2487
2488 #ifdef DEBUG
2489   /* Avoid accidental reuse. */
2490   drw_state_ensure_not_reused(&DST);
2491 #endif
2492 }
2493
2494 /**
2495  * Clears the Depth Buffer and draws only the specified object.
2496  */
2497 void DRW_draw_depth_object(ARegion *ar, GPUViewport *viewport, Object *object)
2498 {
2499   RegionView3D *rv3d = ar->regiondata;
2500
2501   DRW_opengl_context_enable();
2502
2503   /* Setup framebuffer */
2504   DefaultFramebufferList *fbl = GPU_viewport_framebuffer_list_get(viewport);
2505
2506   GPU_framebuffer_bind(fbl->depth_only_fb);
2507   GPU_framebuffer_clear_depth(fbl->depth_only_fb, 1.0f);
2508   GPU_depth_test(true);
2509   GPU_matrix_mul(object->obmat);
2510
2511   const float(*world_clip_planes)[4] = NULL;
2512   if (rv3d->rflag & RV3D_CLIPPING) {
2513     ED_view3d_clipping_set(rv3d);
2514     ED_view3d_clipping_local(rv3d, object->obmat);
2515     world_clip_planes = rv3d->clip_local;
2516   }
2517
2518   switch (object->type) {
2519     case OB_MESH: {
2520       GPUBatch *batch;
2521
2522       Mesh *me = object->data;
2523
2524       if (object->mode & OB_MODE_EDIT) {
2525         batch = DRW_mesh_batch_cache_get_edit_triangles(me);
2526       }
2527       else {
2528         batch = DRW_mesh_batch_cache_get_surface(me);
2529       }
2530
2531       DRW_mesh_batch_cache_create_requested(object, me, NULL, false, true);
2532
2533       const eGPUShaderConfig sh_cfg = world_clip_planes ? GPU_SHADER_CFG_CLIPPED :
2534                                                           GPU_SHADER_CFG_DEFAULT;
2535       GPU_batch_program_set_builtin_with_config(batch, GPU_SHADER_3D_DEPTH_ONLY, sh_cfg);
2536       if (world_clip_planes != NULL) {
2537         GPU_batch_uniform_4fv_array(batch, "WorldClipPlanes", 6, world_clip_planes[0]);
2538       }
2539
2540       GPU_batch_draw(batch);
2541     } break;
2542     case OB_CURVE:
2543     case OB_SURF:
2544       break;
2545   }
2546
2547   if (rv3d->rflag & RV3D_CLIPPING) {
2548     ED_view3d_clipping_disable();
2549   }
2550
2551   GPU_matrix_set(rv3d->viewmat);
2552   GPU_depth_test(false);
2553   GPU_framebuffer_restore();
2554   DRW_opengl_context_disable();
2555 }
2556
2557 /* Set an opengl context to be used with shaders that draw on U32 colors. */
2558 void DRW_framebuffer_select_id_setup(ARegion *ar, const bool clear)
2559 {
2560   RegionView3D *rv3d = ar->regiondata;
2561
2562   DRW_opengl_context_enable();
2563
2564   /* Setup framebuffer */
2565   int viewport_size[2] = {ar->winx, ar->winy};
2566   draw_select_framebuffer_select_id_setup(viewport_size);
2567   GPU_framebuffer_bind(g_select_buffer.framebuffer_select_id);
2568
2569   /* dithering and AA break color coding, so disable */
2570   glDisable(GL_DITHER);
2571
2572   GPU_depth_test(true);
2573   glDisable(GL_SCISSOR_TEST);
2574
2575   if (clear) {
2576     GPU_framebuffer_clear_color_depth(
2577         g_select_buffer.framebuffer_select_id, (const float[4]){0.0f}, 1.0f);
2578   }
2579
2580   if (rv3d->rflag & RV3D_CLIPPING) {
2581     ED_view3d_clipping_set(rv3d);
2582   }
2583 }
2584
2585 /* Ends the context for selection and restoring the previous one. */
2586 void DRW_framebuffer_select_id_release(ARegion *ar)
2587 {
2588   RegionView3D *rv3d = ar->regiondata;
2589
2590   if (rv3d->rflag & RV3D_CLIPPING) {
2591     ED_view3d_clipping_disable();
2592   }
2593
2594   GPU_depth_test(false);
2595
2596   GPU_framebuffer_restore();
2597
2598   DRW_opengl_context_disable();
2599 }
2600
2601 /* Read a block of pixels from the select frame buffer. */
2602 void DRW_framebuffer_select_id_read(const rcti *rect, uint *r_buf)
2603 {
2604   /* clamp rect by texture */
2605   rcti r = {
2606       .xmin = 0,
2607       .xmax = GPU_texture_width(g_select_buffer.texture_u32),
2608       .ymin = 0,
2609       .ymax = GPU_texture_height(g_select_buffer.texture_u32),
2610   };
2611
2612   rcti rect_clamp = *rect;
2613   if (BLI_rcti_isect(&r, &rect_clamp, &rect_clamp)) {
2614     GPU_texture_read_rect(g_select_buffer.texture_u32, GPU_DATA_UNSIGNED_INT, &rect_clamp, r_buf);
2615
2616     if (!BLI_rcti_compare(rect, &rect_clamp)) {
2617       GPU_select_buffer_stride_realign(rect, &rect_clamp, r_buf);
2618     }
2619   }
2620   else {
2621     size_t buf_size = BLI_rcti_size_x(rect) * BLI_rcti_size_y(rect) * sizeof(*r_buf);
2622
2623     memset(r_buf, 0, buf_size);
2624   }
2625 }
2626
2627 /** \} */
2628
2629 /* -------------------------------------------------------------------- */
2630 /** \name Draw Manager State (DRW_state)
2631  * \{ */
2632
2633 void DRW_state_dfdy_factors_get(float dfdyfac[2])
2634 {
2635   GPU_get_dfdy_factors(dfdyfac);
2636 }
2637
2638 /**
2639  * When false, drawing doesn't output to a pixel buffer
2640  * eg: Occlusion queries, or when we have setup a context to draw in already.
2641  */
2642 bool DRW_state_is_fbo(void)
2643 {
2644   return ((DST.default_framebuffer != NULL) || DST.options.is_image_render);
2645 }
2646
2647 /**
2648  * For when engines need to know if this is drawing for selection or not.
2649  */
2650 bool DRW_state_is_select(void)
2651 {
2652   return DST.options.is_select;
2653 }
2654
2655 bool DRW_state_is_depth(void)
2656 {
2657   return DST.options.is_depth;
2658 }
2659
2660 /**
2661  * Whether we are rendering for an image
2662  */
2663 bool DRW_state_is_image_render(void)
2664 {
2665   return DST.options.is_image_render;
2666 }
2667
2668 /**
2669  * Whether we are rendering only the render engine,
2670  * or if we should also render the mode engines.
2671  */
2672 bool DRW_state_is_scene_render(void)
2673 {
2674   BLI_assert(DST.options.is_scene_render ? DST.options.is_image_render : true);
2675   return DST.options.is_scene_render;
2676 }
2677
2678 /**
2679  * Whether we are rendering simple opengl render
2680  */
2681 bool DRW_state_is_opengl_render(void)
2682 {
2683   return DST.options.is_image_render && !DST.options.is_scene_render;
2684 }
2685
2686 bool DRW_state_is_playback(void)
2687 {
2688   if (DST.draw_ctx.evil_C != NULL) {
2689     struct wmWindowManager *wm = CTX_wm_manager(DST.draw_ctx.evil_C);
2690     return ED_screen_animation_playing(wm) != NULL;
2691   }
2692   return false;
2693 }
2694
2695 /**
2696  * Should text draw in this mode?
2697  */
2698 bool DRW_state_show_text(void)
2699 {
2700   return (DST.options.is_select) == 0 && (DST.options.is_depth) == 0 &&
2701          (DST.options.is_scene_render) == 0 && (DST.options.draw_text) == 0;
2702 }
2703
2704 /**
2705  * Should draw support elements
2706  * Objects center, selection outline, probe data, ...
2707  */
2708 bool DRW_state_draw_support(void)
2709 {
2710   View3D *v3d = DST.draw_ctx.v3d;
2711   return (DRW_state_is_scene_render() == false) && (v3d != NULL) &&
2712          ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0);
2713 }
2714
2715 /**
2716  * Whether we should render the background
2717  */
2718 bool DRW_state_draw_background(void)
2719 {
2720   if (DRW_state_is_image_render() == false) {
2721     return true;
2722   }
2723   return DST.options.draw_background;
2724 }
2725
2726 /** \} */
2727
2728 /* -------------------------------------------------------------------- */
2729 /** \name Context State (DRW_context_state)
2730  * \{ */
2731
2732 const DRWContextState *DRW_context_state_get(void)
2733 {
2734   return &DST.draw_ctx;
2735 }
2736
2737 /** \} */
2738
2739 /* -------------------------------------------------------------------- */
2740 /** \name Init/Exit (DRW_engines)
2741  * \{ */
2742
2743 bool DRW_engine_render_support(DrawEngineType *draw_engine_type)
2744 {
2745   return draw_engine_type->render_to_image;
2746 }
2747
2748 void DRW_engine_register(DrawEngineType *draw_engine_type)
2749 {
2750   BLI_addtail(&DRW_engines, draw_engine_type);
2751 }
2752
2753 void DRW_engines_register(void)
2754 {
2755   RE_engines_register(&DRW_engine_viewport_eevee_type);
2756   RE_engines_register(&DRW_engine_viewport_workbench_type);
2757
2758   DRW_engine_register(&draw_engine_workbench_solid);
2759   DRW_engine_register(&draw_engine_workbench_transparent);
2760
2761   DRW_engine_register(&draw_engine_object_type);
2762   DRW_engine_register(&draw_engine_edit_armature_type);
2763   DRW_engine_register(&draw_engine_edit_curve_type);
2764   DRW_engine_register(&draw_engine_edit_lattice_type);
2765   DRW_engine_register(&draw_engine_edit_mesh_type);
2766   DRW_engine_register(&draw_engine_edit_metaball_type);
2767   DRW_engine_register(&draw_engine_edit_text_type);
2768   DRW_engine_register(&draw_engine_motion_path_type);
2769   DRW_engine_register(&draw_engine_overlay_type);
2770   DRW_engine_register(&draw_engine_paint_texture_type);
2771   DRW_engine_register(&draw_engine_paint_vertex_type);
2772   DRW_engine_register(&draw_engine_particle_type);
2773   DRW_engine_register(&draw_engine_pose_type);
2774   DRW_engine_register(&draw_engine_sculpt_type);
2775   DRW_engine_register(&draw_engine_gpencil_type);
2776
2777   /* setup callbacks */
2778   {
2779     BKE_mball_batch_cache_dirty_tag_cb = DRW_mball_batch_cache_dirty_tag;
2780     BKE_mball_batch_cache_free_cb = DRW_mball_batch_cache_free;
2781
2782     BKE_curve_batch_cache_dirty_tag_cb = DRW_curve_batch_cache_dirty_tag;
2783     BKE_curve_batch_cache_free_cb = DRW_curve_batch_cache_free;
2784
2785     BKE_mesh_batch_cache_dirty_tag_cb = DRW_mesh_batch_cache_dirty_tag;
2786     BKE_mesh_batch_cache_free_cb = DRW_mesh_batch_cache_free;
2787
2788     BKE_lattice_batch_cache_dirty_tag_cb = DRW_lattice_batch_cache_dirty_tag;
2789     BKE_lattice_batch_cache_free_cb = DRW_lattice_batch_cache_free;
2790
2791     BKE_particle_batch_cache_dirty_tag_cb = DRW_particle_batch_cache_dirty_tag;
2792     BKE_particle_batch_cache_free_cb = DRW_particle_batch_cache_free;
2793
2794     BKE_gpencil_batch_cache_dirty_tag_cb = DRW_gpencil_batch_cache_dirty_tag;
2795     BKE_gpencil_batch_cache_free_cb = DRW_gpencil_batch_cache_free;
2796   }
2797 }
2798
2799 void DRW_engines_free(void)
2800 {
2801   if (DST.gl_context == NULL) {
2802     /* Nothing has been setup. Nothing to clear.
2803      * Otherwise, DRW_opengl_context_enable can
2804      * create a context in background mode. (see T62355) */
2805     return;
2806   }
2807
2808   DRW_opengl_context_enable();
2809
2810   DRW_TEXTURE_FREE_SAFE(g_select_buffer.texture_u32);
2811   DRW_TEXTURE_FREE_SAFE(g_select_buffer.texture_depth);
2812   GPU_FRAMEBUFFER_FREE_SAFE(g_select_buffer.framebuffer_select_id);
2813   GPU_FRAMEBUFFER_FREE_SAFE(g_select_buffer.framebuffer_depth_only);
2814
2815   DRW_hair_free();
2816   DRW_shape_cache_free();
2817   DRW_stats_free();
2818   DRW_globals_free();
2819
2820   DrawEngineType *next;
2821   for (DrawEngineType *type = DRW_engines.first; type; type = next) {
2822     next = type->next;
2823     BLI_remlink(&R_engines, type);
2824
2825     if (type->engine_free) {
2826       type->engine_free();
2827     }
2828   }
2829
2830   DRW_UBO_FREE_SAFE(G_draw.block_ubo);
2831   DRW_UBO_FREE_SAFE(G_draw.view_ubo);
2832   DRW_TEXTURE_FREE_SAFE(G_draw.ramp);
2833   DRW_TEXTURE_FREE_SAFE(G_draw.weight_ramp);
2834   MEM_SAFE_FREE(g_pos_format);
2835
2836   MEM_SAFE_FREE(DST.uniform_names.buffer);
2837
2838   DRW_opengl_context_disable();
2839 }
2840
2841 /** \} */
2842
2843 /** \name Init/Exit (DRW_opengl_ctx)
2844  * \{ */
2845
2846 void DRW_opengl_context_create(void)
2847 {
2848   BLI_assert(DST.gl_context == NULL); /* Ensure it's called once */
2849
2850   DST.gl_context_mutex = BLI_ticket_mutex_alloc();
2851   if (!G.background) {
2852     immDeactivate();
2853   }
2854   /* This changes the active context. */
2855   DST.gl_context = WM_opengl_context_create();
2856   WM_opengl_context_activate(DST.gl_context);
2857   /* Be sure to create gawain.context too. */
2858   DST.gpu_context = GPU_context_create();
2859   if (!G.background) {
2860     immActivate();
2861   }
2862   /* Set default Blender OpenGL state */
2863   GPU_state_init();
2864   /* So we activate the window's one afterwards. */
2865   wm_window_reset_drawable();
2866 }
2867
2868 void DRW_opengl_context_destroy(void)
2869 {
2870   BLI_assert(BLI_thread_is_main());
2871   if (DST.gl_context != NULL) {
2872     WM_opengl_context_activate(DST.gl_context);
2873     GPU_context_active_set(DST.gpu_context);
2874     GPU_context_discard(DST.gpu_context);
2875     WM_opengl_context_dispose(DST.gl_context);
2876     BLI_ticket_mutex_free(DST.gl_context_mutex);
2877   }
2878 }
2879
2880 void DRW_opengl_context_enable_ex(bool restore)
2881 {
2882   if (DST.gl_context != NULL) {
2883     /* IMPORTANT: We dont support immediate mode in render mode!
2884      * This shall remain in effect until immediate mode supports
2885      * multiple threads. */
2886     BLI_ticket_mutex_lock(DST.gl_context_mutex);
2887     if (BLI_thread_is_main() && restore) {
2888       if (!G.background) {
2889         immDeactivate();
2890       }
2891     }
2892     WM_opengl_context_activate(DST.gl_context);
2893     GPU_context_active_set(DST.gpu_context);
2894     if (BLI_thread_is_main() && restore) {
2895       if (!G.background) {
2896         immActivate();
2897       }
2898       BLF_batch_reset();
2899     }
2900   }
2901 }
2902
2903 void DRW_opengl_context_disable_ex(bool restore)
2904 {
2905   if (DST.gl_context != NULL) {
2906 #ifdef __APPLE__
2907     /* Need to flush before disabling draw context, otherwise it does not
2908      * always finish drawing and viewport can be empty or partially drawn */
2909     GPU_flush();
2910 #endif
2911
2912     if (BLI_thread_is_main() && restore) {
2913       wm_window_reset_drawable();
2914     }
2915     else {
2916       WM_opengl_context_release(DST.gl_context);
2917       GPU_context_active_set(NULL);
2918     }
2919
2920     BLI_ticket_mutex_unlock(DST.gl_context_mutex);
2921   }
2922 }
2923
2924 void DRW_opengl_context_enable(void)
2925 {
2926   if (G.background && DST.gl_context == NULL) {
2927     WM_init_opengl(G_MAIN);
2928   }
2929   DRW_opengl_context_enable_ex(true);
2930 }
2931
2932 void DRW_opengl_context_disable(void)
2933 {
2934   DRW_opengl_context_disable_ex(true);
2935 }
2936
2937 void DRW_opengl_render_context_enable(void *re_gl_context)
2938 {
2939   /* If thread is main you should use DRW_opengl_context_enable(). */
2940   BLI_assert(!BLI_thread_is_main());
2941
2942   /* TODO get rid of the blocking. Only here because of the static global DST. */
2943   BLI_ticket_mutex_lock(DST.gl_context_mutex);
2944   WM_opengl_context_activate(re_gl_context);
2945 }
2946
2947 void DRW_opengl_render_context_disable(void *re_gl_context)
2948 {
2949   GPU_flush();
2950   WM_opengl_context_release(re_gl_context);
2951   /* TODO get rid of the blocking. */
2952   BLI_ticket_mutex_unlock(DST.gl_context_mutex);
2953 }
2954
2955 /* Needs to be called AFTER DRW_opengl_render_context_enable() */
2956 void DRW_gawain_render_context_enable(void *re_gpu_context)
2957 {
2958   /* If thread is main you should use DRW_opengl_context_enable(). */
2959   BLI_assert(!BLI_thread_is_main());
2960
2961   GPU_context_active_set(re_gpu_context);
2962   DRW_shape_cache_reset(); /* XXX fix that too. */
2963 }
2964
2965 /* Needs to be called BEFORE DRW_opengl_render_context_disable() */
2966 void DRW_gawain_render_context_disable(void *UNUSED(re_gpu_context))
2967 {
2968   DRW_shape_cache_reset(); /* XXX fix that too. */
2969   GPU_context_active_set(NULL);
2970 }
2971
2972 /** \} */