UI: Move Scene Statistics to the 3D Viewport
[blender-staging.git] / source / blender / editors / space_view3d / view3d_draw.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  * The Original Code is Copyright (C) 2008 Blender Foundation.
17  * All rights reserved.
18  */
19
20 /** \file
21  * \ingroup spview3d
22  */
23
24 #include <math.h>
25
26 #include "BLI_jitter_2d.h"
27 #include "BLI_listbase.h"
28 #include "BLI_math.h"
29 #include "BLI_rect.h"
30 #include "BLI_string.h"
31 #include "BLI_string_utils.h"
32 #include "BLI_threads.h"
33
34 #include "BKE_camera.h"
35 #include "BKE_collection.h"
36 #include "BKE_context.h"
37 #include "BKE_customdata.h"
38 #include "BKE_global.h"
39 #include "BKE_key.h"
40 #include "BKE_layer.h"
41 #include "BKE_main.h"
42 #include "BKE_object.h"
43 #include "BKE_paint.h"
44 #include "BKE_scene.h"
45 #include "BKE_studiolight.h"
46 #include "BKE_unit.h"
47
48 #include "BLF_api.h"
49
50 #include "BLT_translation.h"
51
52 #include "DNA_armature_types.h"
53 #include "DNA_brush_types.h"
54 #include "DNA_camera_types.h"
55 #include "DNA_key_types.h"
56 #include "DNA_mesh_types.h"
57 #include "DNA_object_types.h"
58 #include "DNA_view3d_types.h"
59 #include "DNA_windowmanager_types.h"
60
61 #include "DRW_engine.h"
62 #include "DRW_select_buffer.h"
63
64 #include "ED_armature.h"
65 #include "ED_gpencil.h"
66 #include "ED_info.h"
67 #include "ED_keyframing.h"
68 #include "ED_screen.h"
69 #include "ED_screen_types.h"
70 #include "ED_transform.h"
71 #include "ED_view3d_offscreen.h"
72
73 #include "DEG_depsgraph_query.h"
74
75 #include "GPU_batch.h"
76 #include "GPU_batch_presets.h"
77 #include "GPU_draw.h"
78 #include "GPU_framebuffer.h"
79 #include "GPU_immediate.h"
80 #include "GPU_immediate_util.h"
81 #include "GPU_material.h"
82 #include "GPU_matrix.h"
83 #include "GPU_state.h"
84 #include "GPU_viewport.h"
85
86 #include "MEM_guardedalloc.h"
87
88 #include "UI_interface.h"
89 #include "UI_resources.h"
90
91 #include "RE_engine.h"
92
93 #include "WM_api.h"
94 #include "WM_types.h"
95
96 #include "RNA_access.h"
97
98 #include "IMB_imbuf.h"
99 #include "IMB_imbuf_types.h"
100
101 #include "view3d_intern.h" /* own include */
102
103 #define M_GOLDEN_RATIO_CONJUGATE 0.618033988749895f
104
105 #define VIEW3D_OVERLAY_LINEHEIGHT (0.8f * U.widget_unit)
106
107 /* -------------------------------------------------------------------- */
108 /** \name General Functions
109  * \{ */
110
111 /**
112  * \note keep this synced with #ED_view3d_mats_rv3d_backup/#ED_view3d_mats_rv3d_restore
113  */
114 void ED_view3d_update_viewmat(Depsgraph *depsgraph,
115                               const Scene *scene,
116                               View3D *v3d,
117                               ARegion *region,
118                               float viewmat[4][4],
119                               float winmat[4][4],
120                               const rcti *rect,
121                               bool offscreen)
122 {
123   RegionView3D *rv3d = region->regiondata;
124
125   /* setup window matrices */
126   if (winmat) {
127     copy_m4_m4(rv3d->winmat, winmat);
128   }
129   else {
130     view3d_winmatrix_set(depsgraph, region, v3d, rect);
131   }
132
133   /* setup view matrix */
134   if (viewmat) {
135     copy_m4_m4(rv3d->viewmat, viewmat);
136   }
137   else {
138     float rect_scale[2];
139     if (rect) {
140       rect_scale[0] = (float)BLI_rcti_size_x(rect) / (float)region->winx;
141       rect_scale[1] = (float)BLI_rcti_size_y(rect) / (float)region->winy;
142     }
143     /* note: calls BKE_object_where_is_calc for camera... */
144     view3d_viewmatrix_set(depsgraph, scene, v3d, rv3d, rect ? rect_scale : NULL);
145   }
146   /* update utility matrices */
147   mul_m4_m4m4(rv3d->persmat, rv3d->winmat, rv3d->viewmat);
148   invert_m4_m4(rv3d->persinv, rv3d->persmat);
149   invert_m4_m4(rv3d->viewinv, rv3d->viewmat);
150
151   /* calculate GLSL view dependent values */
152
153   /* store window coordinates scaling/offset */
154   if (!offscreen && rv3d->persp == RV3D_CAMOB && v3d->camera) {
155     rctf cameraborder;
156     ED_view3d_calc_camera_border(scene, depsgraph, region, v3d, rv3d, &cameraborder, false);
157     rv3d->viewcamtexcofac[0] = (float)region->winx / BLI_rctf_size_x(&cameraborder);
158     rv3d->viewcamtexcofac[1] = (float)region->winy / BLI_rctf_size_y(&cameraborder);
159
160     rv3d->viewcamtexcofac[2] = -rv3d->viewcamtexcofac[0] * cameraborder.xmin / (float)region->winx;
161     rv3d->viewcamtexcofac[3] = -rv3d->viewcamtexcofac[1] * cameraborder.ymin / (float)region->winy;
162   }
163   else {
164     rv3d->viewcamtexcofac[0] = rv3d->viewcamtexcofac[1] = 1.0f;
165     rv3d->viewcamtexcofac[2] = rv3d->viewcamtexcofac[3] = 0.0f;
166   }
167
168   /* calculate pixelsize factor once, is used for lights and obcenters */
169   {
170     /* note:  '1.0f / len_v3(v1)'  replaced  'len_v3(rv3d->viewmat[0])'
171      * because of float point precision problems at large values [#23908] */
172     float v1[3], v2[3];
173     float len_px, len_sc;
174
175     v1[0] = rv3d->persmat[0][0];
176     v1[1] = rv3d->persmat[1][0];
177     v1[2] = rv3d->persmat[2][0];
178
179     v2[0] = rv3d->persmat[0][1];
180     v2[1] = rv3d->persmat[1][1];
181     v2[2] = rv3d->persmat[2][1];
182
183     len_px = 2.0f / sqrtf(min_ff(len_squared_v3(v1), len_squared_v3(v2)));
184
185     if (rect) {
186       len_sc = (float)max_ii(BLI_rcti_size_x(rect), BLI_rcti_size_y(rect));
187     }
188     else {
189       len_sc = (float)MAX2(region->winx, region->winy);
190     }
191
192     rv3d->pixsize = len_px / len_sc;
193   }
194 }
195
196 static void view3d_main_region_setup_view(Depsgraph *depsgraph,
197                                           Scene *scene,
198                                           View3D *v3d,
199                                           ARegion *region,
200                                           float viewmat[4][4],
201                                           float winmat[4][4],
202                                           const rcti *rect)
203 {
204   RegionView3D *rv3d = region->regiondata;
205
206   ED_view3d_update_viewmat(depsgraph, scene, v3d, region, viewmat, winmat, rect, false);
207
208   /* set for opengl */
209   GPU_matrix_projection_set(rv3d->winmat);
210   GPU_matrix_set(rv3d->viewmat);
211 }
212
213 static void view3d_main_region_setup_offscreen(Depsgraph *depsgraph,
214                                                const Scene *scene,
215                                                View3D *v3d,
216                                                ARegion *region,
217                                                float viewmat[4][4],
218                                                float winmat[4][4])
219 {
220   RegionView3D *rv3d = region->regiondata;
221   ED_view3d_update_viewmat(depsgraph, scene, v3d, region, viewmat, winmat, NULL, true);
222
223   /* set for opengl */
224   GPU_matrix_projection_set(rv3d->winmat);
225   GPU_matrix_set(rv3d->viewmat);
226 }
227
228 static bool view3d_stereo3d_active(wmWindow *win,
229                                    const Scene *scene,
230                                    View3D *v3d,
231                                    RegionView3D *rv3d)
232 {
233   if ((scene->r.scemode & R_MULTIVIEW) == 0) {
234     return false;
235   }
236
237   if ((v3d->camera == NULL) || (v3d->camera->type != OB_CAMERA) || rv3d->persp != RV3D_CAMOB) {
238     return false;
239   }
240
241   switch (v3d->stereo3d_camera) {
242     case STEREO_MONO_ID:
243       return false;
244       break;
245     case STEREO_3D_ID:
246       /* win will be NULL when calling this from the selection or draw loop. */
247       if ((win == NULL) || (WM_stereo3d_enabled(win, true) == false)) {
248         return false;
249       }
250       if (((scene->r.views_format & SCE_VIEWS_FORMAT_MULTIVIEW) != 0) &&
251           !BKE_scene_multiview_is_stereo3d(&scene->r)) {
252         return false;
253       }
254       break;
255     /* We always need the stereo calculation for left and right cameras. */
256     case STEREO_LEFT_ID:
257     case STEREO_RIGHT_ID:
258     default:
259       break;
260   }
261   return true;
262 }
263
264 /* setup the view and win matrices for the multiview cameras
265  *
266  * unlike view3d_stereo3d_setup_offscreen, when view3d_stereo3d_setup is called
267  * we have no winmatrix (i.e., projection matrix) defined at that time.
268  * Since the camera and the camera shift are needed for the winmat calculation
269  * we do a small hack to replace it temporarily so we don't need to change the
270  * view3d)main_region_setup_view() code to account for that.
271  */
272 static void view3d_stereo3d_setup(
273     Depsgraph *depsgraph, Scene *scene, View3D *v3d, ARegion *region, const rcti *rect)
274 {
275   bool is_left;
276   const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
277   const char *viewname;
278
279   /* show only left or right camera */
280   if (v3d->stereo3d_camera != STEREO_3D_ID) {
281     v3d->multiview_eye = v3d->stereo3d_camera;
282   }
283
284   is_left = v3d->multiview_eye == STEREO_LEFT_ID;
285   viewname = names[is_left ? STEREO_LEFT_ID : STEREO_RIGHT_ID];
286
287   /* update the viewport matrices with the new camera */
288   if (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D) {
289     Camera *data, *data_eval;
290     float viewmat[4][4];
291     float shiftx;
292
293     data = (Camera *)v3d->camera->data;
294     data_eval = (Camera *)DEG_get_evaluated_id(depsgraph, &data->id);
295
296     shiftx = data_eval->shiftx;
297
298     BLI_thread_lock(LOCK_VIEW3D);
299     data_eval->shiftx = BKE_camera_multiview_shift_x(&scene->r, v3d->camera, viewname);
300
301     BKE_camera_multiview_view_matrix(&scene->r, v3d->camera, is_left, viewmat);
302     view3d_main_region_setup_view(depsgraph, scene, v3d, region, viewmat, NULL, rect);
303
304     data_eval->shiftx = shiftx;
305     BLI_thread_unlock(LOCK_VIEW3D);
306   }
307   else { /* SCE_VIEWS_FORMAT_MULTIVIEW */
308     float viewmat[4][4];
309     Object *view_ob = v3d->camera;
310     Object *camera = BKE_camera_multiview_render(scene, v3d->camera, viewname);
311
312     BLI_thread_lock(LOCK_VIEW3D);
313     v3d->camera = camera;
314
315     BKE_camera_multiview_view_matrix(&scene->r, camera, false, viewmat);
316     view3d_main_region_setup_view(depsgraph, scene, v3d, region, viewmat, NULL, rect);
317
318     v3d->camera = view_ob;
319     BLI_thread_unlock(LOCK_VIEW3D);
320   }
321 }
322
323 #ifdef WITH_XR_OPENXR
324 static void view3d_xr_mirror_setup(const wmWindowManager *wm,
325                                    Depsgraph *depsgraph,
326                                    Scene *scene,
327                                    View3D *v3d,
328                                    ARegion *region,
329                                    const rcti *rect)
330 {
331   RegionView3D *rv3d = region->regiondata;
332   float viewmat[4][4];
333   const float lens_old = v3d->lens;
334
335   if (!WM_xr_session_state_viewer_pose_matrix_info_get(&wm->xr, viewmat, &v3d->lens)) {
336     /* Can't get info from XR session, use fallback values. */
337     copy_m4_m4(viewmat, rv3d->viewmat);
338     v3d->lens = lens_old;
339   }
340   view3d_main_region_setup_view(depsgraph, scene, v3d, region, viewmat, NULL, rect);
341
342   /* Reset overridden View3D data */
343   v3d->lens = lens_old;
344 }
345 #endif /* WITH_XR_OPENXR */
346
347 /**
348  * Set the correct matrices
349  */
350 void ED_view3d_draw_setup_view(const wmWindowManager *wm,
351                                wmWindow *win,
352                                Depsgraph *depsgraph,
353                                Scene *scene,
354                                ARegion *region,
355                                View3D *v3d,
356                                float viewmat[4][4],
357                                float winmat[4][4],
358                                const rcti *rect)
359 {
360   RegionView3D *rv3d = region->regiondata;
361
362 #ifdef WITH_XR_OPENXR
363   /* Setup the view matrix. */
364   if (ED_view3d_is_region_xr_mirror_active(wm, v3d, region)) {
365     view3d_xr_mirror_setup(wm, depsgraph, scene, v3d, region, rect);
366   }
367   else
368 #endif
369       if (view3d_stereo3d_active(win, scene, v3d, rv3d)) {
370     view3d_stereo3d_setup(depsgraph, scene, v3d, region, rect);
371   }
372   else {
373     view3d_main_region_setup_view(depsgraph, scene, v3d, region, viewmat, winmat, rect);
374   }
375
376 #ifndef WITH_XR_OPENXR
377   UNUSED_VARS(wm);
378 #endif
379 }
380
381 /** \} */
382
383 /* -------------------------------------------------------------------- */
384 /** \name Draw View Border
385  * \{ */
386
387 static void view3d_camera_border(const Scene *scene,
388                                  struct Depsgraph *depsgraph,
389                                  const ARegion *region,
390                                  const View3D *v3d,
391                                  const RegionView3D *rv3d,
392                                  rctf *r_viewborder,
393                                  const bool no_shift,
394                                  const bool no_zoom)
395 {
396   CameraParams params;
397   rctf rect_view, rect_camera;
398   Object *camera_eval = DEG_get_evaluated_object(depsgraph, v3d->camera);
399
400   /* get viewport viewplane */
401   BKE_camera_params_init(&params);
402   BKE_camera_params_from_view3d(&params, depsgraph, v3d, rv3d);
403   if (no_zoom) {
404     params.zoom = 1.0f;
405   }
406   BKE_camera_params_compute_viewplane(&params, region->winx, region->winy, 1.0f, 1.0f);
407   rect_view = params.viewplane;
408
409   /* get camera viewplane */
410   BKE_camera_params_init(&params);
411   /* fallback for non camera objects */
412   params.clip_start = v3d->clip_start;
413   params.clip_end = v3d->clip_end;
414   BKE_camera_params_from_object(&params, camera_eval);
415   if (no_shift) {
416     params.shiftx = 0.0f;
417     params.shifty = 0.0f;
418   }
419   BKE_camera_params_compute_viewplane(
420       &params, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
421   rect_camera = params.viewplane;
422
423   /* get camera border within viewport */
424   r_viewborder->xmin = ((rect_camera.xmin - rect_view.xmin) / BLI_rctf_size_x(&rect_view)) *
425                        region->winx;
426   r_viewborder->xmax = ((rect_camera.xmax - rect_view.xmin) / BLI_rctf_size_x(&rect_view)) *
427                        region->winx;
428   r_viewborder->ymin = ((rect_camera.ymin - rect_view.ymin) / BLI_rctf_size_y(&rect_view)) *
429                        region->winy;
430   r_viewborder->ymax = ((rect_camera.ymax - rect_view.ymin) / BLI_rctf_size_y(&rect_view)) *
431                        region->winy;
432 }
433
434 void ED_view3d_calc_camera_border_size(const Scene *scene,
435                                        Depsgraph *depsgraph,
436                                        const ARegion *region,
437                                        const View3D *v3d,
438                                        const RegionView3D *rv3d,
439                                        float r_size[2])
440 {
441   rctf viewborder;
442
443   view3d_camera_border(scene, depsgraph, region, v3d, rv3d, &viewborder, true, true);
444   r_size[0] = BLI_rctf_size_x(&viewborder);
445   r_size[1] = BLI_rctf_size_y(&viewborder);
446 }
447
448 void ED_view3d_calc_camera_border(const Scene *scene,
449                                   Depsgraph *depsgraph,
450                                   const ARegion *region,
451                                   const View3D *v3d,
452                                   const RegionView3D *rv3d,
453                                   rctf *r_viewborder,
454                                   const bool no_shift)
455 {
456   view3d_camera_border(scene, depsgraph, region, v3d, rv3d, r_viewborder, no_shift, false);
457 }
458
459 static void drawviewborder_grid3(uint shdr_pos, float x1, float x2, float y1, float y2, float fac)
460 {
461   float x3, y3, x4, y4;
462
463   x3 = x1 + fac * (x2 - x1);
464   y3 = y1 + fac * (y2 - y1);
465   x4 = x1 + (1.0f - fac) * (x2 - x1);
466   y4 = y1 + (1.0f - fac) * (y2 - y1);
467
468   immBegin(GPU_PRIM_LINES, 8);
469
470   immVertex2f(shdr_pos, x1, y3);
471   immVertex2f(shdr_pos, x2, y3);
472
473   immVertex2f(shdr_pos, x1, y4);
474   immVertex2f(shdr_pos, x2, y4);
475
476   immVertex2f(shdr_pos, x3, y1);
477   immVertex2f(shdr_pos, x3, y2);
478
479   immVertex2f(shdr_pos, x4, y1);
480   immVertex2f(shdr_pos, x4, y2);
481
482   immEnd();
483 }
484
485 /* harmonious triangle */
486 static void drawviewborder_triangle(
487     uint shdr_pos, float x1, float x2, float y1, float y2, const char golden, const char dir)
488 {
489   float ofs;
490   float w = x2 - x1;
491   float h = y2 - y1;
492
493   immBegin(GPU_PRIM_LINES, 6);
494
495   if (w > h) {
496     if (golden) {
497       ofs = w * (1.0f - M_GOLDEN_RATIO_CONJUGATE);
498     }
499     else {
500       ofs = h * (h / w);
501     }
502     if (dir == 'B') {
503       SWAP(float, y1, y2);
504     }
505
506     immVertex2f(shdr_pos, x1, y1);
507     immVertex2f(shdr_pos, x2, y2);
508
509     immVertex2f(shdr_pos, x2, y1);
510     immVertex2f(shdr_pos, x1 + (w - ofs), y2);
511
512     immVertex2f(shdr_pos, x1, y2);
513     immVertex2f(shdr_pos, x1 + ofs, y1);
514   }
515   else {
516     if (golden) {
517       ofs = h * (1.0f - M_GOLDEN_RATIO_CONJUGATE);
518     }
519     else {
520       ofs = w * (w / h);
521     }
522     if (dir == 'B') {
523       SWAP(float, x1, x2);
524     }
525
526     immVertex2f(shdr_pos, x1, y1);
527     immVertex2f(shdr_pos, x2, y2);
528
529     immVertex2f(shdr_pos, x2, y1);
530     immVertex2f(shdr_pos, x1, y1 + ofs);
531
532     immVertex2f(shdr_pos, x1, y2);
533     immVertex2f(shdr_pos, x2, y1 + (h - ofs));
534   }
535
536   immEnd();
537 }
538
539 static void drawviewborder(Scene *scene, Depsgraph *depsgraph, ARegion *region, View3D *v3d)
540 {
541   float x1, x2, y1, y2;
542   float x1i, x2i, y1i, y2i;
543
544   rctf viewborder;
545   Camera *ca = NULL;
546   RegionView3D *rv3d = region->regiondata;
547
548   if (v3d->camera == NULL) {
549     return;
550   }
551   if (v3d->camera->type == OB_CAMERA) {
552     ca = v3d->camera->data;
553   }
554
555   ED_view3d_calc_camera_border(scene, depsgraph, region, v3d, rv3d, &viewborder, false);
556   /* the offsets */
557   x1 = viewborder.xmin;
558   y1 = viewborder.ymin;
559   x2 = viewborder.xmax;
560   y2 = viewborder.ymax;
561
562   GPU_line_width(1.0f);
563
564   /* apply offsets so the real 3D camera shows through */
565
566   /* note: quite un-scientific but without this bit extra
567    * 0.0001 on the lower left the 2D border sometimes
568    * obscures the 3D camera border */
569   /* note: with VIEW3D_CAMERA_BORDER_HACK defined this error isn't noticeable
570    * but keep it here in case we need to remove the workaround */
571   x1i = (int)(x1 - 1.0001f);
572   y1i = (int)(y1 - 1.0001f);
573   x2i = (int)(x2 + (1.0f - 0.0001f));
574   y2i = (int)(y2 + (1.0f - 0.0001f));
575
576   uint shdr_pos = GPU_vertformat_attr_add(
577       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
578
579   /* First, solid lines. */
580   {
581     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
582
583     /* passepartout, specified in camera edit buttons */
584     if (ca && (ca->flag & CAM_SHOWPASSEPARTOUT) && ca->passepartalpha > 0.000001f) {
585       const float winx = (region->winx + 1);
586       const float winy = (region->winy + 1);
587
588       float alpha = 1.0f;
589
590       if (ca->passepartalpha != 1.0f) {
591         GPU_blend_set_func_separate(
592             GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
593         GPU_blend(true);
594         alpha = ca->passepartalpha;
595       }
596
597       immUniformColor4f(0.0f, 0.0f, 0.0f, alpha);
598
599       if (x1i > 0.0f) {
600         immRectf(shdr_pos, 0.0f, winy, x1i, 0.0f);
601       }
602       if (x2i < winx) {
603         immRectf(shdr_pos, x2i, winy, winx, 0.0f);
604       }
605       if (y2i < winy) {
606         immRectf(shdr_pos, x1i, winy, x2i, y2i);
607       }
608       if (y2i > 0.0f) {
609         immRectf(shdr_pos, x1i, y1i, x2i, 0.0f);
610       }
611
612       GPU_blend(false);
613     }
614
615     immUniformThemeColor3(TH_BACK);
616     imm_draw_box_wire_2d(shdr_pos, x1i, y1i, x2i, y2i);
617
618 #ifdef VIEW3D_CAMERA_BORDER_HACK
619     if (view3d_camera_border_hack_test == true) {
620       immUniformColor3ubv(view3d_camera_border_hack_col);
621       imm_draw_box_wire_2d(shdr_pos, x1i + 1, y1i + 1, x2i - 1, y2i - 1);
622       view3d_camera_border_hack_test = false;
623     }
624 #endif
625
626     immUnbindProgram();
627   }
628
629   /* When overlays are disabled, only show camera outline & passepartout. */
630   if (v3d->flag2 & V3D_HIDE_OVERLAYS) {
631     return;
632   }
633
634   /* And now, the dashed lines! */
635   immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
636
637   {
638     float viewport_size[4];
639     GPU_viewport_size_get_f(viewport_size);
640     immUniform2f("viewport_size", viewport_size[2], viewport_size[3]);
641
642     immUniform1i("colors_len", 0); /* "simple" mode */
643     immUniform1f("dash_width", 6.0f);
644     immUniform1f("dash_factor", 0.5f);
645
646     /* outer line not to confuse with object selection */
647     if (v3d->flag2 & V3D_LOCK_CAMERA) {
648       immUniformThemeColor(TH_REDALERT);
649       imm_draw_box_wire_2d(shdr_pos, x1i - 1, y1i - 1, x2i + 1, y2i + 1);
650     }
651
652     immUniformThemeColor3(TH_VIEW_OVERLAY);
653     imm_draw_box_wire_2d(shdr_pos, x1i, y1i, x2i, y2i);
654   }
655
656   /* Render Border. */
657   if (scene->r.mode & R_BORDER) {
658     float x3, y3, x4, y4;
659
660     x3 = floorf(x1 + (scene->r.border.xmin * (x2 - x1))) - 1;
661     y3 = floorf(y1 + (scene->r.border.ymin * (y2 - y1))) - 1;
662     x4 = floorf(x1 + (scene->r.border.xmax * (x2 - x1))) + (U.pixelsize - 1);
663     y4 = floorf(y1 + (scene->r.border.ymax * (y2 - y1))) + (U.pixelsize - 1);
664
665     immUniformColor3f(1.0f, 0.25f, 0.25f);
666     imm_draw_box_wire_2d(shdr_pos, x3, y3, x4, y4);
667   }
668
669   /* safety border */
670   if (ca) {
671     immUniformThemeColorBlend(TH_VIEW_OVERLAY, TH_BACK, 0.25f);
672
673     if (ca->dtx & CAM_DTX_CENTER) {
674       float x3, y3;
675
676       x3 = x1 + 0.5f * (x2 - x1);
677       y3 = y1 + 0.5f * (y2 - y1);
678
679       immBegin(GPU_PRIM_LINES, 4);
680
681       immVertex2f(shdr_pos, x1, y3);
682       immVertex2f(shdr_pos, x2, y3);
683
684       immVertex2f(shdr_pos, x3, y1);
685       immVertex2f(shdr_pos, x3, y2);
686
687       immEnd();
688     }
689
690     if (ca->dtx & CAM_DTX_CENTER_DIAG) {
691       immBegin(GPU_PRIM_LINES, 4);
692
693       immVertex2f(shdr_pos, x1, y1);
694       immVertex2f(shdr_pos, x2, y2);
695
696       immVertex2f(shdr_pos, x1, y2);
697       immVertex2f(shdr_pos, x2, y1);
698
699       immEnd();
700     }
701
702     if (ca->dtx & CAM_DTX_THIRDS) {
703       drawviewborder_grid3(shdr_pos, x1, x2, y1, y2, 1.0f / 3.0f);
704     }
705
706     if (ca->dtx & CAM_DTX_GOLDEN) {
707       drawviewborder_grid3(shdr_pos, x1, x2, y1, y2, 1.0f - M_GOLDEN_RATIO_CONJUGATE);
708     }
709
710     if (ca->dtx & CAM_DTX_GOLDEN_TRI_A) {
711       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 0, 'A');
712     }
713
714     if (ca->dtx & CAM_DTX_GOLDEN_TRI_B) {
715       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 0, 'B');
716     }
717
718     if (ca->dtx & CAM_DTX_HARMONY_TRI_A) {
719       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 1, 'A');
720     }
721
722     if (ca->dtx & CAM_DTX_HARMONY_TRI_B) {
723       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 1, 'B');
724     }
725
726     if (ca->flag & CAM_SHOW_SAFE_MARGINS) {
727       UI_draw_safe_areas(
728           shdr_pos, x1, x2, y1, y2, scene->safe_areas.title, scene->safe_areas.action);
729
730       if (ca->flag & CAM_SHOW_SAFE_CENTER) {
731         UI_draw_safe_areas(shdr_pos,
732                            x1,
733                            x2,
734                            y1,
735                            y2,
736                            scene->safe_areas.title_center,
737                            scene->safe_areas.action_center);
738       }
739     }
740
741     if (ca->flag & CAM_SHOWSENSOR) {
742       /* determine sensor fit, and get sensor x/y, for auto fit we
743        * assume and square sensor and only use sensor_x */
744       float sizex = scene->r.xsch * scene->r.xasp;
745       float sizey = scene->r.ysch * scene->r.yasp;
746       int sensor_fit = BKE_camera_sensor_fit(ca->sensor_fit, sizex, sizey);
747       float sensor_x = ca->sensor_x;
748       float sensor_y = (ca->sensor_fit == CAMERA_SENSOR_FIT_AUTO) ? ca->sensor_x : ca->sensor_y;
749
750       /* determine sensor plane */
751       rctf rect;
752
753       if (sensor_fit == CAMERA_SENSOR_FIT_HOR) {
754         float sensor_scale = (x2i - x1i) / sensor_x;
755         float sensor_height = sensor_scale * sensor_y;
756
757         rect.xmin = x1i;
758         rect.xmax = x2i;
759         rect.ymin = (y1i + y2i) * 0.5f - sensor_height * 0.5f;
760         rect.ymax = rect.ymin + sensor_height;
761       }
762       else {
763         float sensor_scale = (y2i - y1i) / sensor_y;
764         float sensor_width = sensor_scale * sensor_x;
765
766         rect.xmin = (x1i + x2i) * 0.5f - sensor_width * 0.5f;
767         rect.xmax = rect.xmin + sensor_width;
768         rect.ymin = y1i;
769         rect.ymax = y2i;
770       }
771
772       /* draw */
773       immUniformThemeColorShade(TH_VIEW_OVERLAY, 100);
774
775       /* TODO Was using:
776        * UI_draw_roundbox_4fv(false, rect.xmin, rect.ymin, rect.xmax, rect.ymax, 2.0f, color);
777        * We'll probably need a new imm_draw_line_roundbox_dashed dor that - though in practice the
778        * 2.0f round corner effect was nearly not visible anyway... */
779       imm_draw_box_wire_2d(shdr_pos, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
780     }
781   }
782
783   immUnbindProgram();
784   /* end dashed lines */
785
786   /* camera name - draw in highlighted text color */
787   if (ca && ((v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) == 0) && (ca->flag & CAM_SHOWNAME)) {
788     UI_FontThemeColor(BLF_default(), TH_TEXT_HI);
789     BLF_draw_default(x1i,
790                      y1i - (0.7f * U.widget_unit),
791                      0.0f,
792                      v3d->camera->id.name + 2,
793                      sizeof(v3d->camera->id.name) - 2);
794   }
795 }
796
797 static void drawrenderborder(ARegion *region, View3D *v3d)
798 {
799   /* use the same program for everything */
800   uint shdr_pos = GPU_vertformat_attr_add(
801       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
802
803   GPU_line_width(1.0f);
804
805   immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
806
807   float viewport_size[4];
808   GPU_viewport_size_get_f(viewport_size);
809   immUniform2f("viewport_size", viewport_size[2], viewport_size[3]);
810
811   immUniform1i("colors_len", 0); /* "simple" mode */
812   immUniform4f("color", 1.0f, 0.25f, 0.25f, 1.0f);
813   immUniform1f("dash_width", 6.0f);
814   immUniform1f("dash_factor", 0.5f);
815
816   imm_draw_box_wire_2d(shdr_pos,
817                        v3d->render_border.xmin * region->winx,
818                        v3d->render_border.ymin * region->winy,
819                        v3d->render_border.xmax * region->winx,
820                        v3d->render_border.ymax * region->winy);
821
822   immUnbindProgram();
823 }
824
825 void ED_view3d_draw_depth(Depsgraph *depsgraph, ARegion *region, View3D *v3d, bool alphaoverride)
826 {
827   struct bThemeState theme_state;
828   Scene *scene = DEG_get_evaluated_scene(depsgraph);
829   RegionView3D *rv3d = region->regiondata;
830
831   short flag = v3d->flag;
832   float glalphaclip = U.glalphaclip;
833   /* temp set drawtype to solid */
834   /* Setting these temporarily is not nice */
835   v3d->flag &= ~V3D_SELECT_OUTLINE;
836
837   /* not that nice but means we wont zoom into billboards */
838   U.glalphaclip = alphaoverride ? 0.5f : glalphaclip;
839
840   /* Tools may request depth outside of regular drawing code. */
841   UI_Theme_Store(&theme_state);
842   UI_SetTheme(SPACE_VIEW3D, RGN_TYPE_WINDOW);
843
844   ED_view3d_draw_setup_view(
845       G_MAIN->wm.first, NULL, depsgraph, scene, region, v3d, NULL, NULL, NULL);
846
847   GPU_clear(GPU_DEPTH_BIT);
848
849   if (RV3D_CLIPPING_ENABLED(v3d, rv3d)) {
850     ED_view3d_clipping_set(rv3d);
851   }
852   /* get surface depth without bias */
853   rv3d->rflag |= RV3D_ZOFFSET_DISABLED;
854
855   GPU_depth_test(true);
856
857   /* Needed in cases the view-port isn't already setup. */
858   WM_draw_region_viewport_ensure(region, SPACE_VIEW3D);
859   WM_draw_region_viewport_bind(region);
860
861   GPUViewport *viewport = WM_draw_region_get_viewport(region);
862   /* When Blender is starting, a click event can trigger a depth test while the viewport is not
863    * yet available. */
864   if (viewport != NULL) {
865     DRW_draw_depth_loop(depsgraph, region, v3d, viewport, false);
866   }
867
868   WM_draw_region_viewport_unbind(region);
869
870   if (RV3D_CLIPPING_ENABLED(v3d, rv3d)) {
871     ED_view3d_clipping_disable();
872   }
873   rv3d->rflag &= ~RV3D_ZOFFSET_DISABLED;
874
875   /* Reset default for UI */
876   GPU_depth_test(false);
877
878   U.glalphaclip = glalphaclip;
879   v3d->flag = flag;
880
881   UI_Theme_Restore(&theme_state);
882 }
883
884 /* ******************** other elements ***************** */
885
886 /** could move this elsewhere, but tied into #ED_view3d_grid_scale */
887 float ED_scene_grid_scale(const Scene *scene, const char **r_grid_unit)
888 {
889   /* apply units */
890   if (scene->unit.system) {
891     const void *usys;
892     int len;
893
894     bUnit_GetSystem(scene->unit.system, B_UNIT_LENGTH, &usys, &len);
895
896     if (usys) {
897       int i = bUnit_GetBaseUnit(usys);
898       if (r_grid_unit) {
899         *r_grid_unit = bUnit_GetNameDisplay(usys, i);
900       }
901       return (float)bUnit_GetScaler(usys, i) / scene->unit.scale_length;
902     }
903   }
904
905   return 1.0f;
906 }
907
908 float ED_view3d_grid_scale(const Scene *scene, View3D *v3d, const char **r_grid_unit)
909 {
910   return v3d->grid * ED_scene_grid_scale(scene, r_grid_unit);
911 }
912
913 #define STEPS_LEN 8
914 void ED_view3d_grid_steps(const Scene *scene,
915                           View3D *v3d,
916                           RegionView3D *rv3d,
917                           float r_grid_steps[STEPS_LEN])
918 {
919   const void *usys;
920   int i, len;
921   bUnit_GetSystem(scene->unit.system, B_UNIT_LENGTH, &usys, &len);
922   float grid_scale = v3d->grid;
923   BLI_assert(STEPS_LEN >= len);
924
925   if (usys) {
926     if (rv3d->view == RV3D_VIEW_USER) {
927       /* Skip steps */
928       len = bUnit_GetBaseUnit(usys) + 1;
929     }
930
931     grid_scale /= scene->unit.scale_length;
932
933     for (i = 0; i < len; i++) {
934       r_grid_steps[i] = (float)bUnit_GetScaler(usys, len - 1 - i) * grid_scale;
935     }
936     for (; i < STEPS_LEN; i++) {
937       /* Fill last slots */
938       r_grid_steps[i] = 10.0f * r_grid_steps[i - 1];
939     }
940   }
941   else {
942     if (rv3d->view != RV3D_VIEW_USER) {
943       /* Allow 3 more subdivisions. */
944       grid_scale /= powf(v3d->gridsubdiv, 3);
945     }
946     int subdiv = 1;
947     for (i = 0;; i++) {
948       r_grid_steps[i] = grid_scale * subdiv;
949
950       if (i == STEPS_LEN - 1) {
951         break;
952       }
953       subdiv *= v3d->gridsubdiv;
954     }
955   }
956 }
957
958 /* Simulates the grid scale that is actually viewed.
959  * The actual code is seen in `object_grid_frag.glsl` (see `grid_res`).
960  * Currently the simulation is only done when RV3D_VIEW_IS_AXIS. */
961 float ED_view3d_grid_view_scale(Scene *scene,
962                                 View3D *v3d,
963                                 RegionView3D *rv3d,
964                                 const char **r_grid_unit)
965 {
966   float grid_scale;
967   if (!rv3d->is_persp && RV3D_VIEW_IS_AXIS(rv3d->view)) {
968     /* Decrease the distance between grid snap points depending on zoom. */
969     /* `0.38` was a value visually obtained in order to get a snap distance
970      * that matches previous versions Blender.*/
971     float min_dist = 0.38f * (rv3d->dist / v3d->lens);
972     float grid_steps[STEPS_LEN];
973     ED_view3d_grid_steps(scene, v3d, rv3d, grid_steps);
974     /* Skip last item, in case the 'mid_dist' is greater than the largest unit. */
975     int i;
976     for (i = 0; i < ARRAY_SIZE(grid_steps) - 1; i++) {
977       grid_scale = grid_steps[i];
978       if (grid_scale > min_dist) {
979         break;
980       }
981     }
982
983     if (r_grid_unit) {
984       const void *usys;
985       int len;
986       bUnit_GetSystem(scene->unit.system, B_UNIT_LENGTH, &usys, &len);
987
988       if (usys) {
989         *r_grid_unit = bUnit_GetNameDisplay(usys, len - i - 1);
990       }
991     }
992   }
993   else {
994     grid_scale = ED_view3d_grid_scale(scene, v3d, r_grid_unit);
995   }
996
997   return grid_scale;
998 }
999
1000 #undef STEPS_LEN
1001
1002 static void draw_view_axis(RegionView3D *rv3d, const rcti *rect)
1003 {
1004   const float k = U.rvisize * U.pixelsize; /* axis size */
1005   /* axis alpha offset (rvibright has range 0-10) */
1006   const int bright = -20 * (10 - U.rvibright);
1007
1008   /* Axis center in screen coordinates.
1009    *
1010    * - Unit size offset so small text doesn't draw outside the screen
1011    * - Extra X offset because of the panel expander.
1012    */
1013   const float startx = rect->xmax - (k + UI_UNIT_X * 1.5);
1014   const float starty = rect->ymax - (k + UI_UNIT_Y);
1015
1016   float axis_pos[3][2];
1017   uchar axis_col[3][4];
1018
1019   int axis_order[3] = {0, 1, 2};
1020   axis_sort_v3(rv3d->viewinv[2], axis_order);
1021
1022   for (int axis_i = 0; axis_i < 3; axis_i++) {
1023     int i = axis_order[axis_i];
1024
1025     /* get position of each axis tip on screen */
1026     float vec[3] = {0.0f};
1027     vec[i] = 1.0f;
1028     mul_qt_v3(rv3d->viewquat, vec);
1029     axis_pos[i][0] = startx + vec[0] * k;
1030     axis_pos[i][1] = starty + vec[1] * k;
1031
1032     /* get color of each axis */
1033     UI_GetThemeColorShade3ubv(TH_AXIS_X + i, bright, axis_col[i]); /* rgb */
1034     axis_col[i][3] = 255 * hypotf(vec[0], vec[1]);                 /* alpha */
1035   }
1036
1037   /* draw axis lines */
1038   GPU_line_width(2.0f);
1039   GPU_line_smooth(true);
1040   GPU_blend(true);
1041   GPU_blend_set_func_separate(
1042       GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
1043
1044   GPUVertFormat *format = immVertexFormat();
1045   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
1046   uint col = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
1047
1048   immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
1049   immBegin(GPU_PRIM_LINES, 6);
1050
1051   for (int axis_i = 0; axis_i < 3; axis_i++) {
1052     int i = axis_order[axis_i];
1053
1054     immAttr4ubv(col, axis_col[i]);
1055     immVertex2f(pos, startx, starty);
1056     immAttr4ubv(col, axis_col[i]);
1057     immVertex2fv(pos, axis_pos[i]);
1058   }
1059
1060   immEnd();
1061   immUnbindProgram();
1062   GPU_line_smooth(false);
1063
1064   /* draw axis names */
1065   for (int axis_i = 0; axis_i < 3; axis_i++) {
1066     int i = axis_order[axis_i];
1067
1068     const char axis_text[2] = {'x' + i, '\0'};
1069     BLF_color4ubv(BLF_default(), axis_col[i]);
1070     BLF_draw_default_ascii(axis_pos[i][0] + 2, axis_pos[i][1] + 2, 0.0f, axis_text, 1);
1071   }
1072 }
1073
1074 #ifdef WITH_INPUT_NDOF
1075 /* draw center and axis of rotation for ongoing 3D mouse navigation */
1076 static void draw_rotation_guide(const RegionView3D *rv3d)
1077 {
1078   float o[3];   /* center of rotation */
1079   float end[3]; /* endpoints for drawing */
1080
1081   GLubyte color[4] = {0, 108, 255, 255}; /* bright blue so it matches device LEDs */
1082
1083   negate_v3_v3(o, rv3d->ofs);
1084
1085   GPU_blend(true);
1086   GPU_blend_set_func_separate(
1087       GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
1088   glDepthMask(GL_FALSE); /* don't overwrite zbuf */
1089
1090   GPUVertFormat *format = immVertexFormat();
1091   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
1092   uint col = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
1093
1094   immBindBuiltinProgram(GPU_SHADER_3D_SMOOTH_COLOR);
1095
1096   if (rv3d->rot_angle != 0.0f) {
1097     /* -- draw rotation axis -- */
1098     float scaled_axis[3];
1099     const float scale = rv3d->dist;
1100     mul_v3_v3fl(scaled_axis, rv3d->rot_axis, scale);
1101
1102     immBegin(GPU_PRIM_LINE_STRIP, 3);
1103     color[3] = 0; /* more transparent toward the ends */
1104     immAttr4ubv(col, color);
1105     add_v3_v3v3(end, o, scaled_axis);
1106     immVertex3fv(pos, end);
1107
1108 #  if 0
1109     color[3] = 0.2f + fabsf(rv3d->rot_angle); /* modulate opacity with angle */
1110     /* ^^ neat idea, but angle is frame-rate dependent, so it's usually close to 0.2 */
1111 #  endif
1112
1113     color[3] = 127; /* more opaque toward the center */
1114     immAttr4ubv(col, color);
1115     immVertex3fv(pos, o);
1116
1117     color[3] = 0;
1118     immAttr4ubv(col, color);
1119     sub_v3_v3v3(end, o, scaled_axis);
1120     immVertex3fv(pos, end);
1121     immEnd();
1122
1123     /* -- draw ring around rotation center -- */
1124     {
1125 #  define ROT_AXIS_DETAIL 13
1126
1127       const float s = 0.05f * scale;
1128       const float step = 2.0f * (float)(M_PI / ROT_AXIS_DETAIL);
1129
1130       float q[4]; /* rotate ring so it's perpendicular to axis */
1131       const int upright = fabsf(rv3d->rot_axis[2]) >= 0.95f;
1132       if (!upright) {
1133         const float up[3] = {0.0f, 0.0f, 1.0f};
1134         float vis_angle, vis_axis[3];
1135
1136         cross_v3_v3v3(vis_axis, up, rv3d->rot_axis);
1137         vis_angle = acosf(dot_v3v3(up, rv3d->rot_axis));
1138         axis_angle_to_quat(q, vis_axis, vis_angle);
1139       }
1140
1141       immBegin(GPU_PRIM_LINE_LOOP, ROT_AXIS_DETAIL);
1142       color[3] = 63; /* somewhat faint */
1143       immAttr4ubv(col, color);
1144       float angle = 0.0f;
1145       for (int i = 0; i < ROT_AXIS_DETAIL; i++, angle += step) {
1146         float p[3] = {s * cosf(angle), s * sinf(angle), 0.0f};
1147
1148         if (!upright) {
1149           mul_qt_v3(q, p);
1150         }
1151
1152         add_v3_v3(p, o);
1153         immVertex3fv(pos, p);
1154       }
1155       immEnd();
1156
1157 #  undef ROT_AXIS_DETAIL
1158     }
1159
1160     color[3] = 255; /* solid dot */
1161   }
1162   else {
1163     color[3] = 127; /* see-through dot */
1164   }
1165
1166   immUnbindProgram();
1167
1168   /* -- draw rotation center -- */
1169   immBindBuiltinProgram(GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR);
1170   GPU_point_size(5.0f);
1171   immBegin(GPU_PRIM_POINTS, 1);
1172   immAttr4ubv(col, color);
1173   immVertex3fv(pos, o);
1174   immEnd();
1175   immUnbindProgram();
1176
1177   GPU_blend(false);
1178   glDepthMask(GL_TRUE);
1179 }
1180 #endif /* WITH_INPUT_NDOF */
1181
1182 /**
1183  * Render and camera border
1184  */
1185 static void view3d_draw_border(const bContext *C, ARegion *region)
1186 {
1187   Scene *scene = CTX_data_scene(C);
1188   Depsgraph *depsgraph = CTX_data_expect_evaluated_depsgraph(C);
1189   RegionView3D *rv3d = region->regiondata;
1190   View3D *v3d = CTX_wm_view3d(C);
1191
1192   if (rv3d->persp == RV3D_CAMOB) {
1193     drawviewborder(scene, depsgraph, region, v3d);
1194   }
1195   else if (v3d->flag2 & V3D_RENDER_BORDER) {
1196     drawrenderborder(region, v3d);
1197   }
1198 }
1199
1200 /** \} */
1201
1202 /* -------------------------------------------------------------------- */
1203 /** \name Draw Text & Info
1204  * \{ */
1205
1206 /**
1207  * Draw Info
1208  */
1209 static void view3d_draw_grease_pencil(const bContext *UNUSED(C))
1210 {
1211   /* TODO viewport */
1212 }
1213
1214 /**
1215  * Viewport Name
1216  */
1217 static const char *view3d_get_name(View3D *v3d, RegionView3D *rv3d)
1218 {
1219   const char *name = NULL;
1220
1221   switch (rv3d->view) {
1222     case RV3D_VIEW_FRONT:
1223       if (rv3d->persp == RV3D_ORTHO) {
1224         name = IFACE_("Front Orthographic");
1225       }
1226       else {
1227         name = IFACE_("Front Perspective");
1228       }
1229       break;
1230     case RV3D_VIEW_BACK:
1231       if (rv3d->persp == RV3D_ORTHO) {
1232         name = IFACE_("Back Orthographic");
1233       }
1234       else {
1235         name = IFACE_("Back Perspective");
1236       }
1237       break;
1238     case RV3D_VIEW_TOP:
1239       if (rv3d->persp == RV3D_ORTHO) {
1240         name = IFACE_("Top Orthographic");
1241       }
1242       else {
1243         name = IFACE_("Top Perspective");
1244       }
1245       break;
1246     case RV3D_VIEW_BOTTOM:
1247       if (rv3d->persp == RV3D_ORTHO) {
1248         name = IFACE_("Bottom Orthographic");
1249       }
1250       else {
1251         name = IFACE_("Bottom Perspective");
1252       }
1253       break;
1254     case RV3D_VIEW_RIGHT:
1255       if (rv3d->persp == RV3D_ORTHO) {
1256         name = IFACE_("Right Orthographic");
1257       }
1258       else {
1259         name = IFACE_("Right Perspective");
1260       }
1261       break;
1262     case RV3D_VIEW_LEFT:
1263       if (rv3d->persp == RV3D_ORTHO) {
1264         name = IFACE_("Left Orthographic");
1265       }
1266       else {
1267         name = IFACE_("Left Perspective");
1268       }
1269       break;
1270
1271     default:
1272       if (rv3d->persp == RV3D_CAMOB) {
1273         if ((v3d->camera) && (v3d->camera->type == OB_CAMERA)) {
1274           Camera *cam;
1275           cam = v3d->camera->data;
1276           if (cam->type == CAM_PERSP) {
1277             name = IFACE_("Camera Perspective");
1278           }
1279           else if (cam->type == CAM_ORTHO) {
1280             name = IFACE_("Camera Orthographic");
1281           }
1282           else {
1283             BLI_assert(cam->type == CAM_PANO);
1284             name = IFACE_("Camera Panoramic");
1285           }
1286         }
1287         else {
1288           name = IFACE_("Object as Camera");
1289         }
1290       }
1291       else {
1292         name = (rv3d->persp == RV3D_ORTHO) ? IFACE_("User Orthographic") :
1293                                              IFACE_("User Perspective");
1294       }
1295   }
1296
1297   return name;
1298 }
1299
1300 static void draw_viewport_name(ARegion *region, View3D *v3d, int xoffset, int *yoffset)
1301 {
1302   RegionView3D *rv3d = region->regiondata;
1303   const char *name = view3d_get_name(v3d, rv3d);
1304   const char *name_array[3] = {name, NULL, NULL};
1305   int name_array_len = 1;
1306   const int font_id = BLF_default();
1307
1308   /* 6 is the maximum size of the axis roll text. */
1309   /* increase size for unicode languages (Chinese in utf-8...) */
1310 #ifdef WITH_INTERNATIONAL
1311   char tmpstr[96 + 6];
1312 #else
1313   char tmpstr[32 + 6];
1314 #endif
1315
1316   BLF_enable(font_id, BLF_SHADOW);
1317   BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1318   BLF_shadow_offset(font_id, 1, -1);
1319
1320   if (RV3D_VIEW_IS_AXIS(rv3d->view) && (rv3d->view_axis_roll != RV3D_VIEW_AXIS_ROLL_0)) {
1321     const char *axis_roll;
1322     switch (rv3d->view_axis_roll) {
1323       case RV3D_VIEW_AXIS_ROLL_90:
1324         axis_roll = " 90\xC2\xB0";
1325         break;
1326       case RV3D_VIEW_AXIS_ROLL_180:
1327         axis_roll = " 180\xC2\xB0";
1328         break;
1329       default:
1330         axis_roll = " -90\xC2\xB0";
1331         break;
1332     }
1333     name_array[name_array_len++] = axis_roll;
1334   }
1335
1336   if (v3d->localvd) {
1337     name_array[name_array_len++] = IFACE_(" (Local)");
1338   }
1339
1340   if (name_array_len > 1) {
1341     BLI_string_join_array(tmpstr, sizeof(tmpstr), name_array, name_array_len);
1342     name = tmpstr;
1343   }
1344
1345   UI_FontThemeColor(BLF_default(), TH_TEXT_HI);
1346
1347   *yoffset -= VIEW3D_OVERLAY_LINEHEIGHT;
1348
1349   BLF_draw_default(xoffset, *yoffset, 0.0f, name, sizeof(tmpstr));
1350
1351   BLF_disable(font_id, BLF_SHADOW);
1352 }
1353
1354 /**
1355  * Draw info beside axes in bottom left-corner:
1356  * frame-number, collection, object name, bone name (if available), marker name (if available).
1357  */
1358
1359 static void draw_selected_name(
1360     Scene *scene, ViewLayer *view_layer, Object *ob, int xoffset, int *yoffset)
1361 {
1362   const int cfra = CFRA;
1363   const char *msg_pin = " (Pinned)";
1364   const char *msg_sep = " : ";
1365
1366   const int font_id = BLF_default();
1367
1368   char info[300];
1369   char *s = info;
1370
1371   s += sprintf(s, "(%d)", cfra);
1372
1373   if ((ob == NULL) || (ob->mode == OB_MODE_OBJECT)) {
1374     LayerCollection *layer_collection = view_layer->active_collection;
1375     s += sprintf(s,
1376                  " %s%s",
1377                  BKE_collection_ui_name_get(layer_collection->collection),
1378                  (ob == NULL) ? "" : " |");
1379   }
1380
1381   /*
1382    * info can contain:
1383    * - a frame (7 + 2)
1384    * - a collection name (MAX_NAME + 3)
1385    * - 3 object names (MAX_NAME)
1386    * - 2 BREAD_CRUMB_SEPARATORs (6)
1387    * - a SHAPE_KEY_PINNED marker and a trailing '\0' (9+1) - translated, so give some room!
1388    * - a marker name (MAX_NAME + 3)
1389    */
1390
1391   /* get name of marker on current frame (if available) */
1392   const char *markern = BKE_scene_find_marker_name(scene, cfra);
1393
1394   /* check if there is an object */
1395   if (ob) {
1396     *s++ = ' ';
1397     s += BLI_strcpy_rlen(s, ob->id.name + 2);
1398
1399     /* name(s) to display depends on type of object */
1400     if (ob->type == OB_ARMATURE) {
1401       bArmature *arm = ob->data;
1402
1403       /* show name of active bone too (if possible) */
1404       if (arm->edbo) {
1405         if (arm->act_edbone) {
1406           s += BLI_strcpy_rlen(s, msg_sep);
1407           s += BLI_strcpy_rlen(s, arm->act_edbone->name);
1408         }
1409       }
1410       else if (ob->mode & OB_MODE_POSE) {
1411         if (arm->act_bone) {
1412
1413           if (arm->act_bone->layer & arm->layer) {
1414             s += BLI_strcpy_rlen(s, msg_sep);
1415             s += BLI_strcpy_rlen(s, arm->act_bone->name);
1416           }
1417         }
1418       }
1419     }
1420     else if (ELEM(ob->type, OB_MESH, OB_LATTICE, OB_CURVE)) {
1421       /* try to display active bone and active shapekey too (if they exist) */
1422
1423       if (ob->type == OB_MESH && ob->mode & OB_MODE_WEIGHT_PAINT) {
1424         Object *armobj = BKE_object_pose_armature_get(ob);
1425         if (armobj && armobj->mode & OB_MODE_POSE) {
1426           bArmature *arm = armobj->data;
1427           if (arm->act_bone) {
1428             if (arm->act_bone->layer & arm->layer) {
1429               s += BLI_strcpy_rlen(s, msg_sep);
1430               s += BLI_strcpy_rlen(s, arm->act_bone->name);
1431             }
1432           }
1433         }
1434       }
1435
1436       Key *key = BKE_key_from_object(ob);
1437       if (key) {
1438         KeyBlock *kb = BLI_findlink(&key->block, ob->shapenr - 1);
1439         if (kb) {
1440           s += BLI_strcpy_rlen(s, msg_sep);
1441           s += BLI_strcpy_rlen(s, kb->name);
1442           if (ob->shapeflag & OB_SHAPE_LOCK) {
1443             s += BLI_strcpy_rlen(s, IFACE_(msg_pin));
1444           }
1445         }
1446       }
1447     }
1448
1449     /* color depends on whether there is a keyframe */
1450     if (id_frame_has_keyframe(
1451             (ID *)ob, /* BKE_scene_frame_get(scene) */ (float)cfra, ANIMFILTER_KEYS_LOCAL)) {
1452       UI_FontThemeColor(font_id, TH_TIME_KEYFRAME);
1453     }
1454     else if (ED_gpencil_has_keyframe_v3d(scene, ob, cfra)) {
1455       UI_FontThemeColor(font_id, TH_TIME_GP_KEYFRAME);
1456     }
1457     else {
1458       UI_FontThemeColor(font_id, TH_TEXT_HI);
1459     }
1460   }
1461   else {
1462     /* no object */
1463     if (ED_gpencil_has_keyframe_v3d(scene, NULL, cfra)) {
1464       UI_FontThemeColor(font_id, TH_TIME_GP_KEYFRAME);
1465     }
1466     else {
1467       UI_FontThemeColor(font_id, TH_TEXT_HI);
1468     }
1469   }
1470
1471   if (markern) {
1472     s += sprintf(s, " <%s>", markern);
1473   }
1474
1475   BLF_enable(font_id, BLF_SHADOW);
1476   BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1477   BLF_shadow_offset(font_id, 1, -1);
1478
1479   *yoffset -= VIEW3D_OVERLAY_LINEHEIGHT;
1480   BLF_draw_default(xoffset, *yoffset, 0.0f, info, sizeof(info));
1481
1482   BLF_disable(font_id, BLF_SHADOW);
1483 }
1484
1485 static void draw_grid_unit_name(
1486     Scene *scene, RegionView3D *rv3d, View3D *v3d, int xoffset, int *yoffset)
1487 {
1488   if (!rv3d->is_persp && RV3D_VIEW_IS_AXIS(rv3d->view)) {
1489     const char *grid_unit = NULL;
1490     int font_id = BLF_default();
1491     ED_view3d_grid_view_scale(scene, v3d, rv3d, &grid_unit);
1492
1493     if (grid_unit) {
1494       char numstr[32] = "";
1495       UI_FontThemeColor(font_id, TH_TEXT_HI);
1496       if (v3d->grid != 1.0f) {
1497         BLI_snprintf(numstr, sizeof(numstr), "%s x %.4g", grid_unit, v3d->grid);
1498       }
1499
1500       *yoffset -= VIEW3D_OVERLAY_LINEHEIGHT;
1501       BLF_enable(font_id, BLF_SHADOW);
1502       BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1503       BLF_shadow_offset(font_id, 1, -1);
1504       BLF_draw_default_ascii(
1505           xoffset, *yoffset, 0.0f, numstr[0] ? numstr : grid_unit, sizeof(numstr));
1506
1507       BLF_disable(font_id, BLF_SHADOW);
1508     }
1509   }
1510 }
1511
1512 /**
1513  * Information drawn on top of the solid plates and composed data
1514  */
1515 void view3d_draw_region_info(const bContext *C, ARegion *region)
1516 {
1517   RegionView3D *rv3d = region->regiondata;
1518   View3D *v3d = CTX_wm_view3d(C);
1519   Scene *scene = CTX_data_scene(C);
1520   wmWindowManager *wm = CTX_wm_manager(C);
1521   Main *bmain = CTX_data_main(C);
1522   ViewLayer *view_layer = CTX_data_view_layer(C);
1523
1524 #ifdef WITH_INPUT_NDOF
1525   if ((U.ndof_flag & NDOF_SHOW_GUIDE) && ((RV3D_LOCK_FLAGS(rv3d) & RV3D_LOCK_ROTATION) == 0) &&
1526       (rv3d->persp != RV3D_CAMOB)) {
1527     /* TODO: draw something else (but not this) during fly mode */
1528     draw_rotation_guide(rv3d);
1529   }
1530 #endif
1531
1532   /* correct projection matrix */
1533   ED_region_pixelspace(region);
1534
1535   /* local coordinate visible rect inside region, to accommodate overlapping ui */
1536   const rcti *rect = ED_region_visible_rect(region);
1537
1538   view3d_draw_border(C, region);
1539   view3d_draw_grease_pencil(C);
1540
1541   BLF_batch_draw_begin();
1542
1543   if (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_NAVIGATE)) {
1544     /* pass */
1545   }
1546   else {
1547     switch ((eUserpref_MiniAxisType)U.mini_axis_type) {
1548       case USER_MINI_AXIS_TYPE_GIZMO:
1549         /* The gizmo handles it's own drawing. */
1550         break;
1551       case USER_MINI_AXIS_TYPE_MINIMAL:
1552         draw_view_axis(rv3d, rect);
1553       case USER_MINI_AXIS_TYPE_NONE:
1554         break;
1555     }
1556   }
1557
1558   int xoffset = rect->xmin + (0.5f * U.widget_unit);
1559   int yoffset = rect->ymax - (0.1f * U.widget_unit);
1560
1561   if ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0 && (v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) == 0) {
1562     if ((U.uiflag & USER_SHOW_FPS) && ED_screen_animation_no_scrub(wm)) {
1563       ED_scene_draw_fps(scene, xoffset, &yoffset);
1564     }
1565     else if (U.uiflag & USER_SHOW_VIEWPORTNAME) {
1566       draw_viewport_name(region, v3d, xoffset, &yoffset);
1567     }
1568
1569     if (U.uiflag & USER_DRAWVIEWINFO) {
1570       Object *ob = OBACT(view_layer);
1571       draw_selected_name(scene, view_layer, ob, xoffset, &yoffset);
1572     }
1573
1574     if (v3d->gridflag & (V3D_SHOW_FLOOR | V3D_SHOW_X | V3D_SHOW_Y | V3D_SHOW_Z)) {
1575       /* draw below the viewport name */
1576       draw_grid_unit_name(scene, rv3d, v3d, xoffset, &yoffset);
1577     }
1578
1579     DRW_draw_region_engine_info(xoffset, yoffset);
1580   }
1581
1582   if ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0 && (v3d->overlay.flag & V3D_OVERLAY_STATS)) {
1583     ED_info_draw_stats(bmain, scene, view_layer, xoffset, &yoffset, VIEW3D_OVERLAY_LINEHEIGHT);
1584   }
1585
1586   BLF_batch_draw_end();
1587 }
1588
1589 /** \} */
1590
1591 /* -------------------------------------------------------------------- */
1592 /** \name Draw Viewport Contents
1593  * \{ */
1594
1595 static void view3d_draw_view(const bContext *C, ARegion *region)
1596 {
1597   ED_view3d_draw_setup_view(CTX_wm_manager(C),
1598                             CTX_wm_window(C),
1599                             CTX_data_expect_evaluated_depsgraph(C),
1600                             CTX_data_scene(C),
1601                             region,
1602                             CTX_wm_view3d(C),
1603                             NULL,
1604                             NULL,
1605                             NULL);
1606
1607   /* Only 100% compliant on new spec goes below */
1608   DRW_draw_view(C);
1609 }
1610
1611 RenderEngineType *ED_view3d_engine_type(const Scene *scene, int drawtype)
1612 {
1613   /*
1614    * Temporary viewport draw modes until we have a proper system.
1615    * all modes are done in the draw manager, except external render
1616    * engines like Cycles.
1617    */
1618   RenderEngineType *type = RE_engines_find(scene->r.engine);
1619   if (drawtype == OB_MATERIAL && (type->flag & RE_USE_EEVEE_VIEWPORT)) {
1620     return RE_engines_find(RE_engine_id_BLENDER_EEVEE);
1621   }
1622   else {
1623     return type;
1624   }
1625 }
1626
1627 void view3d_main_region_draw(const bContext *C, ARegion *region)
1628 {
1629   Main *bmain = CTX_data_main(C);
1630   View3D *v3d = CTX_wm_view3d(C);
1631
1632   view3d_draw_view(C, region);
1633
1634   DRW_cache_free_old_batches(bmain);
1635   GPU_free_images_old(bmain);
1636   GPU_pass_cache_garbage_collect();
1637
1638   /* XXX This is in order to draw UI batches with the DRW
1639    * old context since we now use it for drawing the entire area. */
1640   gpu_batch_presets_reset();
1641
1642   /* No depth test for drawing action zones afterwards. */
1643   GPU_depth_test(false);
1644
1645   v3d->flag |= V3D_INVALID_BACKBUF;
1646 }
1647
1648 /** \} */
1649
1650 /* -------------------------------------------------------------------- */
1651 /** \name Offscreen Drawing
1652  * \{ */
1653
1654 static void view3d_stereo3d_setup_offscreen(Depsgraph *depsgraph,
1655                                             const Scene *scene,
1656                                             View3D *v3d,
1657                                             ARegion *region,
1658                                             float winmat[4][4],
1659                                             const char *viewname)
1660 {
1661   /* update the viewport matrices with the new camera */
1662   if (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D) {
1663     float viewmat[4][4];
1664     const bool is_left = STREQ(viewname, STEREO_LEFT_NAME);
1665
1666     BKE_camera_multiview_view_matrix(&scene->r, v3d->camera, is_left, viewmat);
1667     view3d_main_region_setup_offscreen(depsgraph, scene, v3d, region, viewmat, winmat);
1668   }
1669   else { /* SCE_VIEWS_FORMAT_MULTIVIEW */
1670     float viewmat[4][4];
1671     Object *camera = BKE_camera_multiview_render(scene, v3d->camera, viewname);
1672
1673     BKE_camera_multiview_view_matrix(&scene->r, camera, false, viewmat);
1674     view3d_main_region_setup_offscreen(depsgraph, scene, v3d, region, viewmat, winmat);
1675   }
1676 }
1677
1678 void ED_view3d_draw_offscreen(Depsgraph *depsgraph,
1679                               const Scene *scene,
1680                               eDrawType drawtype,
1681                               View3D *v3d,
1682                               ARegion *region,
1683                               int winx,
1684                               int winy,
1685                               float viewmat[4][4],
1686                               float winmat[4][4],
1687                               bool is_image_render,
1688                               bool do_sky,
1689                               bool UNUSED(is_persp),
1690                               const char *viewname,
1691                               const bool do_color_management,
1692                               GPUOffScreen *ofs,
1693                               GPUViewport *viewport)
1694 {
1695   RegionView3D *rv3d = region->regiondata;
1696   RenderEngineType *engine_type = ED_view3d_engine_type(scene, drawtype);
1697
1698   /* set temporary new size */
1699   int bwinx = region->winx;
1700   int bwiny = region->winy;
1701   rcti brect = region->winrct;
1702
1703   region->winx = winx;
1704   region->winy = winy;
1705   region->winrct.xmin = 0;
1706   region->winrct.ymin = 0;
1707   region->winrct.xmax = winx;
1708   region->winrct.ymax = winy;
1709
1710   struct bThemeState theme_state;
1711   UI_Theme_Store(&theme_state);
1712   UI_SetTheme(SPACE_VIEW3D, RGN_TYPE_WINDOW);
1713
1714   /* set flags */
1715   G.f |= G_FLAG_RENDER_VIEWPORT;
1716
1717   {
1718     /* free images which can have changed on frame-change
1719      * warning! can be slow so only free animated images - campbell */
1720     GPU_free_images_anim(G.main); /* XXX :((( */
1721   }
1722
1723   GPU_matrix_push_projection();
1724   GPU_matrix_identity_set();
1725   GPU_matrix_push();
1726   GPU_matrix_identity_set();
1727
1728   if ((viewname != NULL && viewname[0] != '\0') && (viewmat == NULL) &&
1729       rv3d->persp == RV3D_CAMOB && v3d->camera) {
1730     view3d_stereo3d_setup_offscreen(depsgraph, scene, v3d, region, winmat, viewname);
1731   }
1732   else {
1733     view3d_main_region_setup_offscreen(depsgraph, scene, v3d, region, viewmat, winmat);
1734   }
1735
1736   /* main drawing call */
1737   DRW_draw_render_loop_offscreen(depsgraph,
1738                                  engine_type,
1739                                  region,
1740                                  v3d,
1741                                  is_image_render,
1742                                  do_sky,
1743                                  do_color_management,
1744                                  ofs,
1745                                  viewport);
1746
1747   /* restore size */
1748   region->winx = bwinx;
1749   region->winy = bwiny;
1750   region->winrct = brect;
1751
1752   GPU_matrix_pop_projection();
1753   GPU_matrix_pop();
1754
1755   UI_Theme_Restore(&theme_state);
1756
1757   G.f &= ~G_FLAG_RENDER_VIEWPORT;
1758 }
1759
1760 /**
1761  * Creates own fake 3d views (wrapping #ED_view3d_draw_offscreen). Similar too
1762  * #ED_view_draw_offscreen_imbuf_simple, but takes view/projection matrices as arguments.
1763  */
1764 void ED_view3d_draw_offscreen_simple(Depsgraph *depsgraph,
1765                                      Scene *scene,
1766                                      View3DShading *shading_override,
1767                                      int drawtype,
1768                                      int winx,
1769                                      int winy,
1770                                      uint draw_flags,
1771                                      float viewmat[4][4],
1772                                      float winmat[4][4],
1773                                      float clip_start,
1774                                      float clip_end,
1775                                      bool is_image_render,
1776                                      bool do_sky,
1777                                      bool is_persp,
1778                                      const char *viewname,
1779                                      const bool do_color_management,
1780                                      GPUOffScreen *ofs,
1781                                      GPUViewport *viewport)
1782 {
1783   View3D v3d = {NULL};
1784   ARegion ar = {NULL};
1785   RegionView3D rv3d = {{{0}}};
1786
1787   v3d.regionbase.first = v3d.regionbase.last = &ar;
1788   ar.regiondata = &rv3d;
1789   ar.regiontype = RGN_TYPE_WINDOW;
1790
1791   View3DShading *source_shading_settings = &scene->display.shading;
1792   if (draw_flags & V3D_OFSDRAW_OVERRIDE_SCENE_SETTINGS && shading_override != NULL) {
1793     source_shading_settings = shading_override;
1794   }
1795   memcpy(&v3d.shading, source_shading_settings, sizeof(View3DShading));
1796   v3d.shading.type = drawtype;
1797
1798   if (shading_override) {
1799     /* Pass. */
1800   }
1801   else if (drawtype == OB_MATERIAL) {
1802     v3d.shading.flag = V3D_SHADING_SCENE_WORLD | V3D_SHADING_SCENE_LIGHTS;
1803   }
1804
1805   if (draw_flags & V3D_OFSDRAW_SHOW_ANNOTATION) {
1806     v3d.flag2 |= V3D_SHOW_ANNOTATION;
1807   }
1808   if (draw_flags & V3D_OFSDRAW_SHOW_GRIDFLOOR) {
1809     v3d.gridflag |= V3D_SHOW_FLOOR | V3D_SHOW_X | V3D_SHOW_Y;
1810     v3d.grid = 1.0f;
1811     v3d.gridlines = 16;
1812     v3d.gridsubdiv = 10;
1813
1814     /* Show grid, disable other overlays (set all available _HIDE_ flags). */
1815     v3d.overlay.flag |= V3D_OVERLAY_HIDE_CURSOR | V3D_OVERLAY_HIDE_TEXT |
1816                         V3D_OVERLAY_HIDE_MOTION_PATHS | V3D_OVERLAY_HIDE_BONES |
1817                         V3D_OVERLAY_HIDE_OBJECT_XTRAS | V3D_OVERLAY_HIDE_OBJECT_ORIGINS;
1818     v3d.flag |= V3D_HIDE_HELPLINES;
1819   }
1820   else {
1821     v3d.flag2 = V3D_HIDE_OVERLAYS;
1822   }
1823
1824   rv3d.persp = RV3D_PERSP;
1825   v3d.clip_start = clip_start;
1826   v3d.clip_end = clip_end;
1827   /* Actually not used since we pass in the projection matrix. */
1828   v3d.lens = 0;
1829
1830   ED_view3d_draw_offscreen(depsgraph,
1831                            scene,
1832                            drawtype,
1833                            &v3d,
1834                            &ar,
1835                            winx,
1836                            winy,
1837                            viewmat,
1838                            winmat,
1839                            is_image_render,
1840                            do_sky,
1841                            is_persp,
1842                            viewname,
1843                            do_color_management,
1844                            ofs,
1845                            viewport);
1846 }
1847
1848 /**
1849  * Utility func for ED_view3d_draw_offscreen
1850  *
1851  * \param ofs: Optional off-screen buffer, can be NULL.
1852  * (avoids re-creating when doing multiple GL renders).
1853  */
1854 ImBuf *ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph,
1855                                       Scene *scene,
1856                                       eDrawType drawtype,
1857                                       View3D *v3d,
1858                                       ARegion *region,
1859                                       int sizex,
1860                                       int sizey,
1861                                       eImBufFlags imbuf_flag,
1862                                       int alpha_mode,
1863                                       const char *viewname,
1864                                       /* output vars */
1865                                       GPUOffScreen *ofs,
1866                                       char err_out[256])
1867 {
1868   RegionView3D *rv3d = region->regiondata;
1869   const bool draw_sky = (alpha_mode == R_ADDSKY);
1870
1871   /* view state */
1872   bool is_ortho = false;
1873   float winmat[4][4];
1874
1875   if (ofs && ((GPU_offscreen_width(ofs) != sizex) || (GPU_offscreen_height(ofs) != sizey))) {
1876     /* sizes differ, can't reuse */
1877     ofs = NULL;
1878   }
1879
1880   GPUFrameBuffer *old_fb = GPU_framebuffer_active_get();
1881
1882   if (old_fb) {
1883     GPU_framebuffer_restore();
1884   }
1885
1886   const bool own_ofs = (ofs == NULL);
1887   DRW_opengl_context_enable();
1888
1889   if (own_ofs) {
1890     /* bind */
1891     ofs = GPU_offscreen_create(sizex, sizey, 0, true, false, err_out);
1892     if (ofs == NULL) {
1893       DRW_opengl_context_disable();
1894       return NULL;
1895     }
1896   }
1897
1898   GPU_offscreen_bind(ofs, true);
1899
1900   /* read in pixels & stamp */
1901   ImBuf *ibuf = IMB_allocImBuf(sizex, sizey, 32, imbuf_flag);
1902
1903   /* render 3d view */
1904   if (rv3d->persp == RV3D_CAMOB && v3d->camera) {
1905     CameraParams params;
1906     Object *camera = BKE_camera_multiview_render(scene, v3d->camera, viewname);
1907     const Object *camera_eval = DEG_get_evaluated_object(depsgraph, camera);
1908
1909     BKE_camera_params_init(&params);
1910     /* fallback for non camera objects */
1911     params.clip_start = v3d->clip_start;
1912     params.clip_end = v3d->clip_end;
1913     BKE_camera_params_from_object(&params, camera_eval);
1914     BKE_camera_multiview_params(&scene->r, &params, camera_eval, viewname);
1915     BKE_camera_params_compute_viewplane(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
1916     BKE_camera_params_compute_matrix(&params);
1917
1918     is_ortho = params.is_ortho;
1919     copy_m4_m4(winmat, params.winmat);
1920   }
1921   else {
1922     rctf viewplane;
1923     float clip_start, clipend;
1924
1925     is_ortho = ED_view3d_viewplane_get(
1926         depsgraph, v3d, rv3d, sizex, sizey, &viewplane, &clip_start, &clipend, NULL);
1927     if (is_ortho) {
1928       orthographic_m4(winmat,
1929                       viewplane.xmin,
1930                       viewplane.xmax,
1931                       viewplane.ymin,
1932                       viewplane.ymax,
1933                       -clipend,
1934                       clipend);
1935     }
1936     else {
1937       perspective_m4(winmat,
1938                      viewplane.xmin,
1939                      viewplane.xmax,
1940                      viewplane.ymin,
1941                      viewplane.ymax,
1942                      clip_start,
1943                      clipend);
1944     }
1945   }
1946
1947   const bool do_color_management = (ibuf->rect_float == NULL);
1948   ED_view3d_draw_offscreen(depsgraph,
1949                            scene,
1950                            drawtype,
1951                            v3d,
1952                            region,
1953                            sizex,
1954                            sizey,
1955                            NULL,
1956                            winmat,
1957                            true,
1958                            draw_sky,
1959                            !is_ortho,
1960                            viewname,
1961                            do_color_management,
1962                            ofs,
1963                            NULL);
1964
1965   if (ibuf->rect_float) {
1966     GPU_offscreen_read_pixels(ofs, GL_FLOAT, ibuf->rect_float);
1967   }
1968   else if (ibuf->rect) {
1969     GPU_offscreen_read_pixels(ofs, GL_UNSIGNED_BYTE, ibuf->rect);
1970   }
1971
1972   /* unbind */
1973   GPU_offscreen_unbind(ofs, true);
1974
1975   if (own_ofs) {
1976     GPU_offscreen_free(ofs);
1977   }
1978
1979   DRW_opengl_context_disable();
1980
1981   if (old_fb) {
1982     GPU_framebuffer_bind(old_fb);
1983   }
1984
1985   if (ibuf->rect_float && ibuf->rect) {
1986     IMB_rect_from_float(ibuf);
1987   }
1988
1989   return ibuf;
1990 }
1991
1992 /**
1993  * Creates own fake 3d views (wrapping #ED_view3d_draw_offscreen_imbuf)
1994  *
1995  * \param ofs: Optional off-screen buffer can be NULL.
1996  * (avoids re-creating when doing multiple GL renders).
1997  *
1998  * \note used by the sequencer
1999  */
2000 ImBuf *ED_view3d_draw_offscreen_imbuf_simple(Depsgraph *depsgraph,
2001                                              Scene *scene,
2002                                              View3DShading *shading_override,
2003                                              eDrawType drawtype,
2004                                              Object *camera,
2005                                              int width,
2006                                              int height,
2007                                              eImBufFlags imbuf_flag,
2008                                              eV3DOffscreenDrawFlag draw_flags,
2009                                              int alpha_mode,
2010                                              const char *viewname,
2011                                              GPUOffScreen *ofs,
2012                                              char err_out[256])
2013 {
2014   View3D v3d = {NULL};
2015   ARegion region = {NULL};
2016   RegionView3D rv3d = {{{0}}};
2017
2018   /* connect data */
2019   v3d.regionbase.first = v3d.regionbase.last = &region;
2020   region.regiondata = &rv3d;
2021   region.regiontype = RGN_TYPE_WINDOW;
2022
2023   v3d.camera = camera;
2024   View3DShading *source_shading_settings = &scene->display.shading;
2025   if (draw_flags & V3D_OFSDRAW_OVERRIDE_SCENE_SETTINGS && shading_override != NULL) {
2026     source_shading_settings = shading_override;
2027   }
2028   memcpy(&v3d.shading, source_shading_settings, sizeof(View3DShading));
2029   v3d.shading.type = drawtype;
2030
2031   if (drawtype == OB_MATERIAL) {
2032     v3d.shading.flag = V3D_SHADING_SCENE_WORLD | V3D_SHADING_SCENE_LIGHTS;
2033     v3d.shading.render_pass = SCE_PASS_COMBINED;
2034   }
2035   else if (drawtype == OB_RENDER) {
2036     v3d.shading.flag = V3D_SHADING_SCENE_WORLD_RENDER | V3D_SHADING_SCENE_LIGHTS_RENDER;
2037     v3d.shading.render_pass = SCE_PASS_COMBINED;
2038   }
2039
2040   v3d.flag2 = V3D_HIDE_OVERLAYS;
2041
2042   if (draw_flags & V3D_OFSDRAW_SHOW_ANNOTATION) {
2043     v3d.flag2 |= V3D_SHOW_ANNOTATION;
2044   }
2045   if (draw_flags & V3D_OFSDRAW_SHOW_GRIDFLOOR) {
2046     v3d.gridflag |= V3D_SHOW_FLOOR | V3D_SHOW_X | V3D_SHOW_Y;
2047   }
2048
2049   v3d.shading.background_type = V3D_SHADING_BACKGROUND_WORLD;
2050
2051   rv3d.persp = RV3D_CAMOB;
2052
2053   copy_m4_m4(rv3d.viewinv, v3d.camera->obmat);
2054   normalize_m4(rv3d.viewinv);
2055   invert_m4_m4(rv3d.viewmat, rv3d.viewinv);
2056
2057   {
2058     CameraParams params;
2059     const Object *view_camera_eval = DEG_get_evaluated_object(
2060         depsgraph, BKE_camera_multiview_render(scene, v3d.camera, viewname));
2061
2062     BKE_camera_params_init(&params);
2063     BKE_camera_params_from_object(&params, view_camera_eval);
2064     BKE_camera_multiview_params(&scene->r, &params, view_camera_eval, viewname);
2065     BKE_camera_params_compute_viewplane(&params, width, height, scene->r.xasp, scene->r.yasp);
2066     BKE_camera_params_compute_matrix(&params);
2067
2068     copy_m4_m4(rv3d.winmat, params.winmat);
2069     v3d.clip_start = params.clip_start;
2070     v3d.clip_end = params.clip_end;
2071     v3d.lens = params.lens;
2072   }
2073
2074   mul_m4_m4m4(rv3d.persmat, rv3d.winmat, rv3d.viewmat);
2075   invert_m4_m4(rv3d.persinv, rv3d.viewinv);
2076
2077   return ED_view3d_draw_offscreen_imbuf(depsgraph,
2078                                         scene,
2079                                         drawtype,
2080                                         &v3d,
2081                                         &region,
2082                                         width,
2083                                         height,
2084                                         imbuf_flag,
2085                                         alpha_mode,
2086                                         viewname,
2087                                         ofs,
2088                                         err_out);
2089 }
2090
2091 /** \} */
2092
2093 /* -------------------------------------------------------------------- */
2094 /** \name Viewport Clipping
2095  * \{ */
2096
2097 static bool view3d_clipping_test(const float co[3], const float clip[6][4])
2098 {
2099   if (plane_point_side_v3(clip[0], co) > 0.0f) {
2100     if (plane_point_side_v3(clip[1], co) > 0.0f) {
2101       if (plane_point_side_v3(clip[2], co) > 0.0f) {
2102         if (plane_point_side_v3(clip[3], co) > 0.0f) {
2103           return false;
2104         }
2105       }
2106     }
2107   }
2108
2109   return true;
2110 }
2111
2112 /* For 'local' ED_view3d_clipping_local must run first
2113  * then all comparisons can be done in localspace. */
2114 bool ED_view3d_clipping_test(const RegionView3D *rv3d, const float co[3], const bool is_local)
2115 {
2116   return view3d_clipping_test(co, is_local ? rv3d->clip_local : rv3d->clip);
2117 }
2118
2119 void ED_view3d_clipping_set(RegionView3D *UNUSED(rv3d))
2120 {
2121   for (uint a = 0; a < 6; a++) {
2122     glEnable(GL_CLIP_DISTANCE0 + a);
2123   }
2124 }
2125
2126 /* Use these to temp disable/enable clipping when 'rv3d->rflag & RV3D_CLIPPING' is set. */
2127 void ED_view3d_clipping_disable(void)
2128 {
2129   for (uint a = 0; a < 6; a++) {
2130     glDisable(GL_CLIP_DISTANCE0 + a);
2131   }
2132 }
2133 void ED_view3d_clipping_enable(void)
2134 {
2135   for (uint a = 0; a < 6; a++) {
2136     glEnable(GL_CLIP_DISTANCE0 + a);
2137   }
2138 }
2139
2140 /* *********************** backdraw for selection *************** */
2141
2142 /**
2143  * \note Only use in object mode.
2144  */
2145 static void validate_object_select_id(struct Depsgraph *depsgraph,
2146                                       ViewLayer *view_layer,
2147                                       ARegion *region,
2148                                       View3D *v3d,
2149                                       Object *obact)
2150 {
2151   Object *obact_eval = DEG_get_evaluated_object(depsgraph, obact);
2152
2153   BLI_assert(region->regiontype == RGN_TYPE_WINDOW);
2154   UNUSED_VARS_NDEBUG(region);
2155
2156   if (obact_eval && (obact_eval->mode & (OB_MODE_VERTEX_PAINT | OB_MODE_WEIGHT_PAINT) ||
2157                      BKE_paint_select_face_test(obact_eval))) {
2158     /* do nothing */
2159   }
2160   /* texture paint mode sampling */
2161   else if (obact_eval && (obact_eval->mode & OB_MODE_TEXTURE_PAINT) &&
2162            (v3d->shading.type > OB_WIRE)) {
2163     /* do nothing */
2164   }
2165   else if ((obact_eval && (obact_eval->mode & OB_MODE_PARTICLE_EDIT)) && !XRAY_ENABLED(v3d)) {
2166     /* do nothing */
2167   }
2168   else {
2169     v3d->flag &= ~V3D_INVALID_BACKBUF;
2170     return;
2171   }
2172
2173   if (!(v3d->flag & V3D_INVALID_BACKBUF)) {
2174     return;
2175   }
2176
2177   if (obact_eval && ((obact_eval->base_flag & BASE_VISIBLE_DEPSGRAPH) != 0)) {
2178     Base *base = BKE_view_layer_base_find(view_layer, obact);
2179     DRW_select_buffer_context_create(&base, 1, -1);
2180   }
2181
2182   /* TODO: Create a flag in `DRW_manager` because the drawing is no longer
2183    *       made on the backbuffer in this case. */
2184   v3d->flag &= ~V3D_INVALID_BACKBUF;
2185 }
2186
2187 /* TODO: Creating, attaching texture, and destroying a framebuffer is quite slow.
2188  *       Calling this function should be avoided during interactive drawing. */
2189 static void view3d_opengl_read_Z_pixels(GPUViewport *viewport, rcti *rect, void *data)
2190 {
2191   DefaultTextureList *dtxl = (DefaultTextureList *)GPU_viewport_texture_list_get(viewport);
2192
2193   GPUFrameBuffer *tmp_fb = GPU_framebuffer_create();
2194   GPU_framebuffer_texture_attach(tmp_fb, dtxl->depth, 0, 0);
2195   GPU_framebuffer_bind(tmp_fb);
2196
2197   glReadPixels(rect->xmin,
2198                rect->ymin,
2199                BLI_rcti_size_x(rect),
2200                BLI_rcti_size_y(rect),
2201                GL_DEPTH_COMPONENT,
2202                GL_FLOAT,
2203                data);
2204
2205   GPU_framebuffer_restore();
2206   GPU_framebuffer_free(tmp_fb);
2207 }
2208
2209 void ED_view3d_select_id_validate(ViewContext *vc)
2210 {
2211   /* TODO: Create a flag in `DRW_manager` because the drawing is no longer
2212    *       made on the backbuffer in this case. */
2213   if (vc->v3d->flag & V3D_INVALID_BACKBUF) {
2214     validate_object_select_id(vc->depsgraph, vc->view_layer, vc->region, vc->v3d, vc->obact);
2215   }
2216 }
2217
2218 void ED_view3d_backbuf_depth_validate(ViewContext *vc)
2219 {
2220   if (vc->v3d->flag & V3D_INVALID_BACKBUF) {
2221     ARegion *region = vc->region;
2222     Object *obact_eval = DEG_get_evaluated_object(vc->depsgraph, vc->obact);
2223
2224     if (obact_eval && ((obact_eval->base_flag & BASE_VISIBLE_DEPSGRAPH) != 0)) {
2225       GPUViewport *viewport = WM_draw_region_get_viewport(region);
2226       DRW_draw_depth_object(vc->region, vc->v3d, viewport, obact_eval);
2227     }
2228
2229     vc->v3d->flag &= ~V3D_INVALID_BACKBUF;
2230   }
2231 }
2232
2233 /**
2234  * allow for small values [0.5 - 2.5],
2235  * and large values, FLT_MAX by clamping by the area size
2236  */
2237 int ED_view3d_backbuf_sample_size_clamp(ARegion *region, const float dist)
2238 {
2239   return (int)min_ff(ceilf(dist), (float)max_ii(region->winx, region->winx));
2240 }
2241
2242 /* *********************** */
2243
2244 void view3d_update_depths_rect(ARegion *region, ViewDepths *d, rcti *rect)
2245 {
2246   /* clamp rect by region */
2247   rcti r = {
2248       .xmin = 0,
2249       .xmax = region->winx - 1,
2250       .ymin = 0,
2251       .ymax = region->winy - 1,
2252   };
2253
2254   /* Constrain rect to depth bounds */
2255   BLI_rcti_isect(&r, rect, rect);
2256
2257   /* assign values to compare with the ViewDepths */
2258   int x = rect->xmin;
2259   int y = rect->ymin;
2260
2261   int w = BLI_rcti_size_x(rect);
2262   int h = BLI_rcti_size_y(rect);
2263
2264   if (w <= 0 || h <= 0) {
2265     if (d->depths) {
2266       MEM_freeN(d->depths);
2267     }
2268     d->depths = NULL;
2269
2270     d->damaged = false;
2271   }
2272   else if (d->w != w || d->h != h || d->x != x || d->y != y || d->depths == NULL) {
2273     d->x = x;
2274     d->y = y;
2275     d->w = w;
2276     d->h = h;
2277
2278     if (d->depths) {
2279       MEM_freeN(d->depths);
2280     }
2281
2282     d->depths = MEM_mallocN(sizeof(float) * d->w * d->h, "View depths Subset");
2283
2284     d->damaged = true;
2285   }
2286
2287   if (d->damaged) {
2288     GPUViewport *viewport = WM_draw_region_get_viewport(region);
2289     view3d_opengl_read_Z_pixels(viewport, rect, d->depths);
2290     glGetDoublev(GL_DEPTH_RANGE, d->depth_range);
2291     d->damaged = false;
2292   }
2293 }
2294
2295 /* Note, with nouveau drivers the glReadPixels() is very slow. [#24339]. */
2296 void ED_view3d_depth_update(ARegion *region)
2297 {
2298   RegionView3D *rv3d = region->regiondata;
2299
2300   /* Create storage for, and, if necessary, copy depth buffer. */
2301   if (!rv3d->depths) {
2302     rv3d->depths = MEM_callocN(sizeof(ViewDepths), "ViewDepths");
2303   }
2304   if (rv3d->depths) {
2305     ViewDepths *d = rv3d->depths;
2306     if (d->w != region->winx || d->h != region->winy || !d->depths) {
2307       d->w = region->winx;
2308       d->h = region->winy;
2309       if (d->depths) {
2310         MEM_freeN(d->depths);
2311       }
2312       d->depths = MEM_mallocN(sizeof(float) * d->w * d->h, "View depths");
2313       d->damaged = true;
2314     }
2315
2316     if (d->damaged) {
2317       GPUViewport *viewport = WM_draw_region_get_viewport(region);
2318       rcti r = {
2319           .xmin = 0,
2320           .xmax = d->w,
2321           .ymin = 0,
2322           .ymax = d->h,
2323       };
2324       view3d_opengl_read_Z_pixels(viewport, &r, d->depths);
2325       glGetDoublev(GL_DEPTH_RANGE, d->depth_range);
2326       d->damaged = false;
2327     }
2328   }
2329 }
2330
2331 /* Utility function to find the closest Z value, use for autodepth. */
2332 float view3d_depth_near(ViewDepths *d)
2333 {
2334   /* Convert to float for comparisons. */
2335   const float near = (float)d->depth_range[0];
2336   const float far_real = (float)d->depth_range[1];
2337   float far = far_real;
2338
2339   const float *depths = d->depths;
2340   float depth = FLT_MAX;
2341   int i = (int)d->w * (int)d->h; /* Cast to avoid short overflow. */
2342
2343   /* Far is both the starting 'far' value
2344    * and the closest value found. */
2345   while (i--) {
2346     depth = *depths++;
2347     if ((depth < far) && (depth > near)) {
2348       far = depth;
2349     }
2350   }
2351
2352   return far == far_real ? FLT_MAX : far;
2353 }
2354
2355 void ED_view3d_draw_depth_gpencil(Depsgraph *depsgraph, Scene *scene, ARegion *region, View3D *v3d)
2356 {
2357   /* Setup view matrix. */
2358   ED_view3d_draw_setup_view(NULL, NULL, depsgraph, scene, region, v3d, NULL, NULL, NULL);
2359
2360   GPU_clear(GPU_DEPTH_BIT);
2361
2362   GPU_depth_test(true);
2363
2364   GPUViewport *viewport = WM_draw_region_get_viewport(region);
2365   DRW_draw_depth_loop_gpencil(depsgraph, region, v3d, viewport);
2366
2367   GPU_depth_test(false);
2368 }
2369
2370 /* *********************** customdata **************** */
2371
2372 void ED_view3d_datamask(const bContext *C,
2373                         const Scene *UNUSED(scene),
2374                         const View3D *v3d,
2375                         CustomData_MeshMasks *r_cddata_masks)
2376 {
2377   if (ELEM(v3d->shading.type, OB_TEXTURE, OB_MATERIAL, OB_RENDER)) {
2378     r_cddata_masks->lmask |= CD_MASK_MLOOPUV | CD_MASK_MLOOPCOL;
2379     r_cddata_masks->vmask |= CD_MASK_ORCO;
2380   }
2381   else if (v3d->shading.type == OB_SOLID) {
2382     if (v3d->shading.color_type == V3D_SHADING_TEXTURE_COLOR) {
2383       r_cddata_masks->lmask |= CD_MASK_MLOOPUV;
2384     }
2385     if (v3d->shading.color_type == V3D_SHADING_VERTEX_COLOR) {
2386       r_cddata_masks->lmask |= CD_MASK_MLOOPCOL;
2387     }
2388   }
2389
2390   if ((CTX_data_mode_enum(C) == CTX_MODE_EDIT_MESH) &&
2391       (v3d->overlay.edit_flag & V3D_OVERLAY_EDIT_WEIGHT)) {
2392     r_cddata_masks->vmask |= CD_MASK_MDEFORMVERT;
2393   }
2394 }
2395
2396 /* Goes over all modes and view3d settings. */
2397 void ED_view3d_screen_datamask(const bContext *C,
2398                                const Scene *scene,
2399                                const bScreen *screen,
2400                                CustomData_MeshMasks *r_cddata_masks)
2401 {
2402   CustomData_MeshMasks_update(r_cddata_masks, &CD_MASK_BAREMESH);
2403
2404   /* Check if we need tfaces & mcols due to view mode. */
2405   LISTBASE_FOREACH (const ScrArea *, area, &screen->areabase) {
2406     if (area->spacetype == SPACE_VIEW3D) {
2407       ED_view3d_datamask(C, scene, area->spacedata.first, r_cddata_masks);
2408     }
2409   }
2410 }
2411
2412 /**
2413  * Store values from #RegionView3D, set when drawing.
2414  * This is needed when we draw with to a viewport using a different matrix
2415  * (offscreen drawing for example).
2416  *
2417  * Values set by #ED_view3d_update_viewmat should be handled here.
2418  */
2419 struct RV3DMatrixStore {
2420   float winmat[4][4];
2421   float viewmat[4][4];
2422   float viewinv[4][4];
2423   float persmat[4][4];
2424   float persinv[4][4];
2425   float viewcamtexcofac[4];
2426   float pixsize;
2427 };
2428
2429 struct RV3DMatrixStore *ED_view3d_mats_rv3d_backup(struct RegionView3D *rv3d)
2430 {
2431   struct RV3DMatrixStore *rv3dmat = MEM_mallocN(sizeof(*rv3dmat), __func__);
2432   copy_m4_m4(rv3dmat->winmat, rv3d->winmat);
2433   copy_m4_m4(rv3dmat->viewmat, rv3d->viewmat);
2434   copy_m4_m4(rv3dmat->persmat, rv3d->persmat);
2435   copy_m4_m4(rv3dmat->persinv, rv3d->persinv);
2436   copy_m4_m4(rv3dmat->viewinv, rv3d->viewinv);
2437   copy_v4_v4(rv3dmat->viewcamtexcofac, rv3d->viewcamtexcofac);
2438   rv3dmat->pixsize = rv3d->pixsize;
2439   return (void *)rv3dmat;
2440 }
2441
2442 void ED_view3d_mats_rv3d_restore(struct RegionView3D *rv3d, struct RV3DMatrixStore *rv3dmat_pt)
2443 {
2444   struct RV3DMatrixStore *rv3dmat = rv3dmat_pt;
2445   copy_m4_m4(rv3d->winmat, rv3dmat->winmat);
2446   copy_m4_m4(rv3d->viewmat, rv3dmat->viewmat);
2447   copy_m4_m4(rv3d->persmat, rv3dmat->persmat);
2448   copy_m4_m4(rv3d->persinv, rv3dmat->persinv);
2449   copy_m4_m4(rv3d->viewinv, rv3dmat->viewinv);
2450   copy_v4_v4(rv3d->viewcamtexcofac, rv3dmat->viewcamtexcofac);
2451   rv3d->pixsize = rv3dmat->pixsize;
2452 }
2453
2454 /**
2455  * \note The info that this uses is updated in #ED_refresh_viewport_fps,
2456  * which currently gets called during #SCREEN_OT_animation_step.
2457  */
2458 void ED_scene_draw_fps(const Scene *scene, int xoffset, int *yoffset)
2459 {
2460   ScreenFrameRateInfo *fpsi = scene->fps_info;
2461   char printable[16];
2462
2463   if (!fpsi || !fpsi->lredrawtime || !fpsi->redrawtime) {
2464     return;
2465   }
2466
2467   printable[0] = '\0';
2468
2469   /* Doing an average for a more robust calculation. */
2470   fpsi->redrawtimes_fps[fpsi->redrawtime_index] = (float)(1.0 /
2471                                                           (fpsi->lredrawtime - fpsi->redrawtime));
2472
2473   float fps = 0.0f;
2474   int tot = 0;
2475   for (int i = 0; i < REDRAW_FRAME_AVERAGE; i++) {
2476     if (fpsi->redrawtimes_fps[i]) {
2477       fps += fpsi->redrawtimes_fps[i];
2478       tot++;
2479     }
2480   }
2481   if (tot) {
2482     fpsi->redrawtime_index = (fpsi->redrawtime_index + 1) % REDRAW_FRAME_AVERAGE;
2483     fps = fps / tot;
2484   }
2485
2486   const int font_id = BLF_default();
2487
2488   /* Is this more than half a frame behind? */
2489   if (fps + 0.5f < (float)(FPS)) {
2490     UI_FontThemeColor(font_id, TH_REDALERT);
2491     BLI_snprintf(printable, sizeof(printable), IFACE_("fps: %.2f"), fps);
2492   }
2493   else {
2494     UI_FontThemeColor(font_id, TH_TEXT_HI);
2495     BLI_snprintf(printable, sizeof(printable), IFACE_("fps: %i"), (int)(fps + 0.5f));
2496   }
2497
2498   BLF_enable(font_id, BLF_SHADOW);
2499   BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
2500   BLF_shadow_offset(font_id, 1, -1);
2501
2502   *yoffset -= VIEW3D_OVERLAY_LINEHEIGHT;
2503
2504 #ifdef WITH_INTERNATIONAL
2505   BLF_draw_default(xoffset, *yoffset, 0.0f, printable, sizeof(printable));
2506 #else
2507   BLF_draw_default_ascii(xoffset, *yoffset, 0.0f, printable, sizeof(printable));
2508 #endif
2509
2510   BLF_disable(font_id, BLF_SHADOW);
2511 }
2512
2513 static bool view3d_main_region_do_render_draw(const Scene *scene)
2514 {
2515   RenderEngineType *type = RE_engines_find(scene->r.engine);
2516   return (type && type->view_update && type->view_draw);
2517 }
2518
2519 bool ED_view3d_calc_render_border(
2520     const Scene *scene, Depsgraph *depsgraph, View3D *v3d, ARegion *region, rcti *rect)
2521 {
2522   RegionView3D *rv3d = region->regiondata;
2523   bool use_border;
2524
2525   /* Test if there is a 3d view rendering. */
2526   if (v3d->shading.type != OB_RENDER || !view3d_main_region_do_render_draw(scene)) {
2527     return false;
2528   }
2529
2530   /* Test if there is a border render. */
2531   if (rv3d->persp == RV3D_CAMOB) {
2532     use_border = (scene->r.mode & R_BORDER) != 0;
2533   }
2534   else {
2535     use_border = (v3d->flag2 & V3D_RENDER_BORDER) != 0;
2536   }
2537
2538   if (!use_border) {
2539     return false;
2540   }
2541
2542   /* Compute border. */
2543   if (rv3d->persp == RV3D_CAMOB) {
2544     rctf viewborder;
2545     ED_view3d_calc_camera_border(scene, depsgraph, region, v3d, rv3d, &viewborder, false);
2546
2547     rect->xmin = viewborder.xmin + scene->r.border.xmin * BLI_rctf_size_x(&viewborder);
2548     rect->ymin = viewborder.ymin + scene->r.border.ymin * BLI_rctf_size_y(&viewborder);
2549     rect->xmax = viewborder.xmin + scene->r.border.xmax * BLI_rctf_size_x(&viewborder);
2550     rect->ymax = viewborder.ymin + scene->r.border.ymax * BLI_rctf_size_y(&viewborder);
2551   }
2552   else {
2553     rect->xmin = v3d->render_border.xmin * region->winx;
2554     rect->xmax = v3d->render_border.xmax * region->winx;
2555     rect->ymin = v3d->render_border.ymin * region->winy;
2556     rect->ymax = v3d->render_border.ymax * region->winy;
2557   }
2558
2559   BLI_rcti_translate(rect, region->winrct.xmin, region->winrct.ymin);
2560   BLI_rcti_isect(&region->winrct, rect, rect);
2561
2562   return true;
2563 }
2564
2565 /** \} */