54955c83ad90c8e41133bd6d75a15e807b0b6e47
[blender.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_listbase.h"
27 #include "BLI_math.h"
28 #include "BLI_rect.h"
29 #include "BLI_string.h"
30 #include "BLI_threads.h"
31 #include "BLI_jitter_2d.h"
32
33 #include "BKE_camera.h"
34 #include "BKE_collection.h"
35 #include "BKE_context.h"
36 #include "BKE_global.h"
37 #include "BKE_key.h"
38 #include "BKE_main.h"
39 #include "BKE_scene.h"
40 #include "BKE_object.h"
41 #include "BKE_paint.h"
42 #include "BKE_unit.h"
43
44 #include "BLF_api.h"
45
46 #include "BLT_translation.h"
47
48 #include "DNA_armature_types.h"
49 #include "DNA_brush_types.h"
50 #include "DNA_camera_types.h"
51 #include "DNA_key_types.h"
52 #include "DNA_mesh_types.h"
53 #include "DNA_object_types.h"
54 #include "DNA_view3d_types.h"
55 #include "DNA_windowmanager_types.h"
56
57 #include "DRW_engine.h"
58
59 #include "ED_armature.h"
60 #include "ED_keyframing.h"
61 #include "ED_gpencil.h"
62 #include "ED_screen.h"
63 #include "ED_transform.h"
64
65 #include "DEG_depsgraph_query.h"
66
67 #include "GPU_batch.h"
68 #include "GPU_batch_presets.h"
69 #include "GPU_draw.h"
70 #include "GPU_matrix.h"
71 #include "GPU_immediate.h"
72 #include "GPU_immediate_util.h"
73 #include "GPU_material.h"
74 #include "GPU_viewport.h"
75 #include "GPU_state.h"
76 #include "GPU_framebuffer.h"
77
78 #include "MEM_guardedalloc.h"
79
80 #include "UI_interface.h"
81 #include "UI_resources.h"
82
83 #include "RE_engine.h"
84
85 #include "WM_api.h"
86 #include "WM_types.h"
87
88 #include "RNA_access.h"
89
90 #include "IMB_imbuf.h"
91 #include "IMB_imbuf_types.h"
92
93 #include "view3d_intern.h" /* own include */
94
95 /* -------------------------------------------------------------------- */
96 /** \name General Functions
97  * \{ */
98
99 /**
100  * \note keep this synced with #ED_view3d_mats_rv3d_backup/#ED_view3d_mats_rv3d_restore
101  */
102 void ED_view3d_update_viewmat(Depsgraph *depsgraph,
103                               Scene *scene,
104                               View3D *v3d,
105                               ARegion *ar,
106                               float viewmat[4][4],
107                               float winmat[4][4],
108                               const rcti *rect,
109                               bool offscreen)
110 {
111   RegionView3D *rv3d = ar->regiondata;
112
113   /* setup window matrices */
114   if (winmat) {
115     copy_m4_m4(rv3d->winmat, winmat);
116   }
117   else {
118     view3d_winmatrix_set(depsgraph, ar, v3d, rect);
119   }
120
121   /* setup view matrix */
122   if (viewmat) {
123     copy_m4_m4(rv3d->viewmat, viewmat);
124   }
125   else {
126     float rect_scale[2];
127     if (rect) {
128       rect_scale[0] = (float)BLI_rcti_size_x(rect) / (float)ar->winx;
129       rect_scale[1] = (float)BLI_rcti_size_y(rect) / (float)ar->winy;
130     }
131     /* note: calls BKE_object_where_is_calc for camera... */
132     view3d_viewmatrix_set(depsgraph, scene, v3d, rv3d, rect ? rect_scale : NULL);
133   }
134   /* update utility matrices */
135   mul_m4_m4m4(rv3d->persmat, rv3d->winmat, rv3d->viewmat);
136   invert_m4_m4(rv3d->persinv, rv3d->persmat);
137   invert_m4_m4(rv3d->viewinv, rv3d->viewmat);
138
139   /* calculate GLSL view dependent values */
140
141   /* store window coordinates scaling/offset */
142   if (!offscreen && rv3d->persp == RV3D_CAMOB && v3d->camera) {
143     rctf cameraborder;
144     ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &cameraborder, false);
145     rv3d->viewcamtexcofac[0] = (float)ar->winx / BLI_rctf_size_x(&cameraborder);
146     rv3d->viewcamtexcofac[1] = (float)ar->winy / BLI_rctf_size_y(&cameraborder);
147
148     rv3d->viewcamtexcofac[2] = -rv3d->viewcamtexcofac[0] * cameraborder.xmin / (float)ar->winx;
149     rv3d->viewcamtexcofac[3] = -rv3d->viewcamtexcofac[1] * cameraborder.ymin / (float)ar->winy;
150   }
151   else {
152     rv3d->viewcamtexcofac[0] = rv3d->viewcamtexcofac[1] = 1.0f;
153     rv3d->viewcamtexcofac[2] = rv3d->viewcamtexcofac[3] = 0.0f;
154   }
155
156   /* calculate pixelsize factor once, is used for lights and obcenters */
157   {
158     /* note:  '1.0f / len_v3(v1)'  replaced  'len_v3(rv3d->viewmat[0])'
159      * because of float point precision problems at large values [#23908] */
160     float v1[3], v2[3];
161     float len_px, len_sc;
162
163     v1[0] = rv3d->persmat[0][0];
164     v1[1] = rv3d->persmat[1][0];
165     v1[2] = rv3d->persmat[2][0];
166
167     v2[0] = rv3d->persmat[0][1];
168     v2[1] = rv3d->persmat[1][1];
169     v2[2] = rv3d->persmat[2][1];
170
171     len_px = 2.0f / sqrtf(min_ff(len_squared_v3(v1), len_squared_v3(v2)));
172     len_sc = (float)MAX2(ar->winx, ar->winy);
173
174     rv3d->pixsize = len_px / len_sc;
175   }
176 }
177
178 static void view3d_main_region_setup_view(Depsgraph *depsgraph,
179                                           Scene *scene,
180                                           View3D *v3d,
181                                           ARegion *ar,
182                                           float viewmat[4][4],
183                                           float winmat[4][4],
184                                           const rcti *rect)
185 {
186   RegionView3D *rv3d = ar->regiondata;
187
188   ED_view3d_update_viewmat(depsgraph, scene, v3d, ar, viewmat, winmat, rect, false);
189
190   /* set for opengl */
191   GPU_matrix_projection_set(rv3d->winmat);
192   GPU_matrix_set(rv3d->viewmat);
193 }
194
195 static void view3d_main_region_setup_offscreen(Depsgraph *depsgraph,
196                                                Scene *scene,
197                                                View3D *v3d,
198                                                ARegion *ar,
199                                                float viewmat[4][4],
200                                                float winmat[4][4])
201 {
202   RegionView3D *rv3d = ar->regiondata;
203   ED_view3d_update_viewmat(depsgraph, scene, v3d, ar, viewmat, winmat, NULL, true);
204
205   /* set for opengl */
206   GPU_matrix_projection_set(rv3d->winmat);
207   GPU_matrix_set(rv3d->viewmat);
208 }
209
210 static bool view3d_stereo3d_active(wmWindow *win, Scene *scene, View3D *v3d, RegionView3D *rv3d)
211 {
212   if ((scene->r.scemode & R_MULTIVIEW) == 0) {
213     return false;
214   }
215
216   if ((v3d->camera == NULL) || (v3d->camera->type != OB_CAMERA) || rv3d->persp != RV3D_CAMOB) {
217     return false;
218   }
219
220   switch (v3d->stereo3d_camera) {
221     case STEREO_MONO_ID:
222       return false;
223       break;
224     case STEREO_3D_ID:
225       /* win will be NULL when calling this from the selection or draw loop. */
226       if ((win == NULL) || (WM_stereo3d_enabled(win, true) == false)) {
227         return false;
228       }
229       if (((scene->r.views_format & SCE_VIEWS_FORMAT_MULTIVIEW) != 0) &&
230           !BKE_scene_multiview_is_stereo3d(&scene->r)) {
231         return false;
232       }
233       break;
234     /* We always need the stereo calculation for left and right cameras. */
235     case STEREO_LEFT_ID:
236     case STEREO_RIGHT_ID:
237     default:
238       break;
239   }
240   return true;
241 }
242
243 /* setup the view and win matrices for the multiview cameras
244  *
245  * unlike view3d_stereo3d_setup_offscreen, when view3d_stereo3d_setup is called
246  * we have no winmatrix (i.e., projection matrix) defined at that time.
247  * Since the camera and the camera shift are needed for the winmat calculation
248  * we do a small hack to replace it temporarily so we don't need to change the
249  * view3d)main_region_setup_view() code to account for that.
250  */
251 static void view3d_stereo3d_setup(
252     Depsgraph *depsgraph, Scene *scene, View3D *v3d, ARegion *ar, const rcti *rect)
253 {
254   bool is_left;
255   const char *names[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
256   const char *viewname;
257
258   /* show only left or right camera */
259   if (v3d->stereo3d_camera != STEREO_3D_ID) {
260     v3d->multiview_eye = v3d->stereo3d_camera;
261   }
262
263   is_left = v3d->multiview_eye == STEREO_LEFT_ID;
264   viewname = names[is_left ? STEREO_LEFT_ID : STEREO_RIGHT_ID];
265
266   /* update the viewport matrices with the new camera */
267   if (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D) {
268     Camera *data, *data_eval;
269     float viewmat[4][4];
270     float shiftx;
271
272     data = (Camera *)v3d->camera->data;
273     data_eval = (Camera *)DEG_get_evaluated_id(depsgraph, &data->id);
274
275     shiftx = data_eval->shiftx;
276
277     BLI_thread_lock(LOCK_VIEW3D);
278     data_eval->shiftx = BKE_camera_multiview_shift_x(&scene->r, v3d->camera, viewname);
279
280     BKE_camera_multiview_view_matrix(&scene->r, v3d->camera, is_left, viewmat);
281     view3d_main_region_setup_view(depsgraph, scene, v3d, ar, viewmat, NULL, rect);
282
283     data_eval->shiftx = shiftx;
284     BLI_thread_unlock(LOCK_VIEW3D);
285   }
286   else { /* SCE_VIEWS_FORMAT_MULTIVIEW */
287     float viewmat[4][4];
288     Object *view_ob = v3d->camera;
289     Object *camera = BKE_camera_multiview_render(scene, v3d->camera, viewname);
290
291     BLI_thread_lock(LOCK_VIEW3D);
292     v3d->camera = camera;
293
294     BKE_camera_multiview_view_matrix(&scene->r, camera, false, viewmat);
295     view3d_main_region_setup_view(depsgraph, scene, v3d, ar, viewmat, NULL, rect);
296
297     v3d->camera = view_ob;
298     BLI_thread_unlock(LOCK_VIEW3D);
299   }
300 }
301
302 /**
303  * Set the correct matrices
304  */
305 void ED_view3d_draw_setup_view(wmWindow *win,
306                                Depsgraph *depsgraph,
307                                Scene *scene,
308                                ARegion *ar,
309                                View3D *v3d,
310                                float viewmat[4][4],
311                                float winmat[4][4],
312                                const rcti *rect)
313 {
314   RegionView3D *rv3d = ar->regiondata;
315
316   /* Setup the view matrix. */
317   if (view3d_stereo3d_active(win, scene, v3d, rv3d)) {
318     view3d_stereo3d_setup(depsgraph, scene, v3d, ar, rect);
319   }
320   else {
321     view3d_main_region_setup_view(depsgraph, scene, v3d, ar, viewmat, winmat, rect);
322   }
323 }
324
325 /** \} */
326
327 /* -------------------------------------------------------------------- */
328 /** \name Draw View Border
329  * \{ */
330
331 static void view3d_camera_border(const Scene *scene,
332                                  struct Depsgraph *depsgraph,
333                                  const ARegion *ar,
334                                  const View3D *v3d,
335                                  const RegionView3D *rv3d,
336                                  rctf *r_viewborder,
337                                  const bool no_shift,
338                                  const bool no_zoom)
339 {
340   CameraParams params;
341   rctf rect_view, rect_camera;
342   Object *camera_eval = DEG_get_evaluated_object(depsgraph, v3d->camera);
343
344   /* get viewport viewplane */
345   BKE_camera_params_init(&params);
346   BKE_camera_params_from_view3d(&params, depsgraph, v3d, rv3d);
347   if (no_zoom) {
348     params.zoom = 1.0f;
349   }
350   BKE_camera_params_compute_viewplane(&params, ar->winx, ar->winy, 1.0f, 1.0f);
351   rect_view = params.viewplane;
352
353   /* get camera viewplane */
354   BKE_camera_params_init(&params);
355   /* fallback for non camera objects */
356   params.clip_start = v3d->clip_start;
357   params.clip_end = v3d->clip_end;
358   BKE_camera_params_from_object(&params, camera_eval);
359   if (no_shift) {
360     params.shiftx = 0.0f;
361     params.shifty = 0.0f;
362   }
363   BKE_camera_params_compute_viewplane(
364       &params, scene->r.xsch, scene->r.ysch, scene->r.xasp, scene->r.yasp);
365   rect_camera = params.viewplane;
366
367   /* get camera border within viewport */
368   r_viewborder->xmin = ((rect_camera.xmin - rect_view.xmin) / BLI_rctf_size_x(&rect_view)) *
369                        ar->winx;
370   r_viewborder->xmax = ((rect_camera.xmax - rect_view.xmin) / BLI_rctf_size_x(&rect_view)) *
371                        ar->winx;
372   r_viewborder->ymin = ((rect_camera.ymin - rect_view.ymin) / BLI_rctf_size_y(&rect_view)) *
373                        ar->winy;
374   r_viewborder->ymax = ((rect_camera.ymax - rect_view.ymin) / BLI_rctf_size_y(&rect_view)) *
375                        ar->winy;
376 }
377
378 void ED_view3d_calc_camera_border_size(const Scene *scene,
379                                        Depsgraph *depsgraph,
380                                        const ARegion *ar,
381                                        const View3D *v3d,
382                                        const RegionView3D *rv3d,
383                                        float r_size[2])
384 {
385   rctf viewborder;
386
387   view3d_camera_border(scene, depsgraph, ar, v3d, rv3d, &viewborder, true, true);
388   r_size[0] = BLI_rctf_size_x(&viewborder);
389   r_size[1] = BLI_rctf_size_y(&viewborder);
390 }
391
392 void ED_view3d_calc_camera_border(const Scene *scene,
393                                   Depsgraph *depsgraph,
394                                   const ARegion *ar,
395                                   const View3D *v3d,
396                                   const RegionView3D *rv3d,
397                                   rctf *r_viewborder,
398                                   const bool no_shift)
399 {
400   view3d_camera_border(scene, depsgraph, ar, v3d, rv3d, r_viewborder, no_shift, false);
401 }
402
403 static void drawviewborder_grid3(uint shdr_pos, float x1, float x2, float y1, float y2, float fac)
404 {
405   float x3, y3, x4, y4;
406
407   x3 = x1 + fac * (x2 - x1);
408   y3 = y1 + fac * (y2 - y1);
409   x4 = x1 + (1.0f - fac) * (x2 - x1);
410   y4 = y1 + (1.0f - fac) * (y2 - y1);
411
412   immBegin(GPU_PRIM_LINES, 8);
413
414   immVertex2f(shdr_pos, x1, y3);
415   immVertex2f(shdr_pos, x2, y3);
416
417   immVertex2f(shdr_pos, x1, y4);
418   immVertex2f(shdr_pos, x2, y4);
419
420   immVertex2f(shdr_pos, x3, y1);
421   immVertex2f(shdr_pos, x3, y2);
422
423   immVertex2f(shdr_pos, x4, y1);
424   immVertex2f(shdr_pos, x4, y2);
425
426   immEnd();
427 }
428
429 /* harmonious triangle */
430 static void drawviewborder_triangle(
431     uint shdr_pos, float x1, float x2, float y1, float y2, const char golden, const char dir)
432 {
433   float ofs;
434   float w = x2 - x1;
435   float h = y2 - y1;
436
437   immBegin(GPU_PRIM_LINES, 6);
438
439   if (w > h) {
440     if (golden) {
441       ofs = w * (1.0f - (1.0f / 1.61803399f));
442     }
443     else {
444       ofs = h * (h / w);
445     }
446     if (dir == 'B') {
447       SWAP(float, y1, y2);
448     }
449
450     immVertex2f(shdr_pos, x1, y1);
451     immVertex2f(shdr_pos, x2, y2);
452
453     immVertex2f(shdr_pos, x2, y1);
454     immVertex2f(shdr_pos, x1 + (w - ofs), y2);
455
456     immVertex2f(shdr_pos, x1, y2);
457     immVertex2f(shdr_pos, x1 + ofs, y1);
458   }
459   else {
460     if (golden) {
461       ofs = h * (1.0f - (1.0f / 1.61803399f));
462     }
463     else {
464       ofs = w * (w / h);
465     }
466     if (dir == 'B') {
467       SWAP(float, x1, x2);
468     }
469
470     immVertex2f(shdr_pos, x1, y1);
471     immVertex2f(shdr_pos, x2, y2);
472
473     immVertex2f(shdr_pos, x2, y1);
474     immVertex2f(shdr_pos, x1, y1 + ofs);
475
476     immVertex2f(shdr_pos, x1, y2);
477     immVertex2f(shdr_pos, x2, y1 + (h - ofs));
478   }
479
480   immEnd();
481 }
482
483 static void drawviewborder(Scene *scene, Depsgraph *depsgraph, ARegion *ar, View3D *v3d)
484 {
485   float x1, x2, y1, y2;
486   float x1i, x2i, y1i, y2i;
487
488   rctf viewborder;
489   Camera *ca = NULL;
490   RegionView3D *rv3d = ar->regiondata;
491
492   if (v3d->camera == NULL) {
493     return;
494   }
495   if (v3d->camera->type == OB_CAMERA) {
496     ca = v3d->camera->data;
497   }
498
499   ED_view3d_calc_camera_border(scene, depsgraph, ar, v3d, rv3d, &viewborder, false);
500   /* the offsets */
501   x1 = viewborder.xmin;
502   y1 = viewborder.ymin;
503   x2 = viewborder.xmax;
504   y2 = viewborder.ymax;
505
506   GPU_line_width(1.0f);
507
508   /* apply offsets so the real 3D camera shows through */
509
510   /* note: quite un-scientific but without this bit extra
511    * 0.0001 on the lower left the 2D border sometimes
512    * obscures the 3D camera border */
513   /* note: with VIEW3D_CAMERA_BORDER_HACK defined this error isn't noticeable
514    * but keep it here in case we need to remove the workaround */
515   x1i = (int)(x1 - 1.0001f);
516   y1i = (int)(y1 - 1.0001f);
517   x2i = (int)(x2 + (1.0f - 0.0001f));
518   y2i = (int)(y2 + (1.0f - 0.0001f));
519
520   uint shdr_pos = GPU_vertformat_attr_add(
521       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
522
523   /* First, solid lines. */
524   {
525     immBindBuiltinProgram(GPU_SHADER_2D_UNIFORM_COLOR);
526
527     /* passepartout, specified in camera edit buttons */
528     if (ca && (ca->flag & CAM_SHOWPASSEPARTOUT) && ca->passepartalpha > 0.000001f) {
529       const float winx = (ar->winx + 1);
530       const float winy = (ar->winy + 1);
531
532       float alpha = 1.0f;
533
534       if (ca->passepartalpha != 1.0f) {
535         GPU_blend_set_func_separate(
536             GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
537         GPU_blend(true);
538         alpha = ca->passepartalpha;
539       }
540
541       immUniformColor4f(0.0f, 0.0f, 0.0f, alpha);
542
543       if (x1i > 0.0f) {
544         immRectf(shdr_pos, 0.0f, winy, x1i, 0.0f);
545       }
546       if (x2i < winx) {
547         immRectf(shdr_pos, x2i, winy, winx, 0.0f);
548       }
549       if (y2i < winy) {
550         immRectf(shdr_pos, x1i, winy, x2i, y2i);
551       }
552       if (y2i > 0.0f) {
553         immRectf(shdr_pos, x1i, y1i, x2i, 0.0f);
554       }
555
556       GPU_blend(false);
557     }
558
559     immUniformThemeColor(TH_BACK);
560     imm_draw_box_wire_2d(shdr_pos, x1i, y1i, x2i, y2i);
561
562 #ifdef VIEW3D_CAMERA_BORDER_HACK
563     if (view3d_camera_border_hack_test == true) {
564       immUniformColor3ubv(view3d_camera_border_hack_col);
565       imm_draw_box_wire_2d(shdr_pos, x1i + 1, y1i + 1, x2i - 1, y2i - 1);
566       view3d_camera_border_hack_test = false;
567     }
568 #endif
569
570     immUnbindProgram();
571   }
572
573   /* When overlays are disabled, only show camera outline & passepartout. */
574   if (v3d->flag2 & V3D_HIDE_OVERLAYS) {
575     return;
576   }
577
578   /* And now, the dashed lines! */
579   immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
580
581   {
582     float viewport_size[4];
583     GPU_viewport_size_get_f(viewport_size);
584     immUniform2f("viewport_size", viewport_size[2], viewport_size[3]);
585
586     immUniform1i("colors_len", 0); /* "simple" mode */
587     immUniform1f("dash_width", 6.0f);
588     immUniform1f("dash_factor", 0.5f);
589
590     /* outer line not to confuse with object selection */
591     if (v3d->flag2 & V3D_LOCK_CAMERA) {
592       immUniformThemeColor(TH_REDALERT);
593       imm_draw_box_wire_2d(shdr_pos, x1i - 1, y1i - 1, x2i + 1, y2i + 1);
594     }
595
596     immUniformThemeColor(TH_VIEW_OVERLAY);
597     imm_draw_box_wire_2d(shdr_pos, x1i, y1i, x2i, y2i);
598   }
599
600   /* Render Border. */
601   if (scene->r.mode & R_BORDER) {
602     float x3, y3, x4, y4;
603
604     x3 = floorf(x1 + (scene->r.border.xmin * (x2 - x1))) - 1;
605     y3 = floorf(y1 + (scene->r.border.ymin * (y2 - y1))) - 1;
606     x4 = floorf(x1 + (scene->r.border.xmax * (x2 - x1))) + (U.pixelsize - 1);
607     y4 = floorf(y1 + (scene->r.border.ymax * (y2 - y1))) + (U.pixelsize - 1);
608
609     immUniformColor3f(1.0f, 0.25f, 0.25f);
610     imm_draw_box_wire_2d(shdr_pos, x3, y3, x4, y4);
611   }
612
613   /* safety border */
614   if (ca) {
615     immUniformThemeColorBlend(TH_VIEW_OVERLAY, TH_BACK, 0.25f);
616
617     if (ca->dtx & CAM_DTX_CENTER) {
618       float x3, y3;
619
620       x3 = x1 + 0.5f * (x2 - x1);
621       y3 = y1 + 0.5f * (y2 - y1);
622
623       immBegin(GPU_PRIM_LINES, 4);
624
625       immVertex2f(shdr_pos, x1, y3);
626       immVertex2f(shdr_pos, x2, y3);
627
628       immVertex2f(shdr_pos, x3, y1);
629       immVertex2f(shdr_pos, x3, y2);
630
631       immEnd();
632     }
633
634     if (ca->dtx & CAM_DTX_CENTER_DIAG) {
635       immBegin(GPU_PRIM_LINES, 4);
636
637       immVertex2f(shdr_pos, x1, y1);
638       immVertex2f(shdr_pos, x2, y2);
639
640       immVertex2f(shdr_pos, x1, y2);
641       immVertex2f(shdr_pos, x2, y1);
642
643       immEnd();
644     }
645
646     if (ca->dtx & CAM_DTX_THIRDS) {
647       drawviewborder_grid3(shdr_pos, x1, x2, y1, y2, 1.0f / 3.0f);
648     }
649
650     if (ca->dtx & CAM_DTX_GOLDEN) {
651       drawviewborder_grid3(shdr_pos, x1, x2, y1, y2, 1.0f - (1.0f / 1.61803399f));
652     }
653
654     if (ca->dtx & CAM_DTX_GOLDEN_TRI_A) {
655       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 0, 'A');
656     }
657
658     if (ca->dtx & CAM_DTX_GOLDEN_TRI_B) {
659       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 0, 'B');
660     }
661
662     if (ca->dtx & CAM_DTX_HARMONY_TRI_A) {
663       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 1, 'A');
664     }
665
666     if (ca->dtx & CAM_DTX_HARMONY_TRI_B) {
667       drawviewborder_triangle(shdr_pos, x1, x2, y1, y2, 1, 'B');
668     }
669
670     if (ca->flag & CAM_SHOW_SAFE_MARGINS) {
671       UI_draw_safe_areas(
672           shdr_pos, x1, x2, y1, y2, scene->safe_areas.title, scene->safe_areas.action);
673
674       if (ca->flag & CAM_SHOW_SAFE_CENTER) {
675         UI_draw_safe_areas(shdr_pos,
676                            x1,
677                            x2,
678                            y1,
679                            y2,
680                            scene->safe_areas.title_center,
681                            scene->safe_areas.action_center);
682       }
683     }
684
685     if (ca->flag & CAM_SHOWSENSOR) {
686       /* determine sensor fit, and get sensor x/y, for auto fit we
687        * assume and square sensor and only use sensor_x */
688       float sizex = scene->r.xsch * scene->r.xasp;
689       float sizey = scene->r.ysch * scene->r.yasp;
690       int sensor_fit = BKE_camera_sensor_fit(ca->sensor_fit, sizex, sizey);
691       float sensor_x = ca->sensor_x;
692       float sensor_y = (ca->sensor_fit == CAMERA_SENSOR_FIT_AUTO) ? ca->sensor_x : ca->sensor_y;
693
694       /* determine sensor plane */
695       rctf rect;
696
697       if (sensor_fit == CAMERA_SENSOR_FIT_HOR) {
698         float sensor_scale = (x2i - x1i) / sensor_x;
699         float sensor_height = sensor_scale * sensor_y;
700
701         rect.xmin = x1i;
702         rect.xmax = x2i;
703         rect.ymin = (y1i + y2i) * 0.5f - sensor_height * 0.5f;
704         rect.ymax = rect.ymin + sensor_height;
705       }
706       else {
707         float sensor_scale = (y2i - y1i) / sensor_y;
708         float sensor_width = sensor_scale * sensor_x;
709
710         rect.xmin = (x1i + x2i) * 0.5f - sensor_width * 0.5f;
711         rect.xmax = rect.xmin + sensor_width;
712         rect.ymin = y1i;
713         rect.ymax = y2i;
714       }
715
716       /* draw */
717       immUniformThemeColorShade(TH_VIEW_OVERLAY, 100);
718
719       /* TODO Was using:
720        * UI_draw_roundbox_4fv(false, rect.xmin, rect.ymin, rect.xmax, rect.ymax, 2.0f, color);
721        * We'll probably need a new imm_draw_line_roundbox_dashed dor that - though in practice the
722        * 2.0f round corner effect was nearly not visible anyway... */
723       imm_draw_box_wire_2d(shdr_pos, rect.xmin, rect.ymin, rect.xmax, rect.ymax);
724     }
725   }
726
727   immUnbindProgram();
728   /* end dashed lines */
729
730   /* camera name - draw in highlighted text color */
731   if (ca && ((v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) == 0) && (ca->flag & CAM_SHOWNAME)) {
732     UI_FontThemeColor(BLF_default(), TH_TEXT_HI);
733     BLF_draw_default(x1i,
734                      y1i - (0.7f * U.widget_unit),
735                      0.0f,
736                      v3d->camera->id.name + 2,
737                      sizeof(v3d->camera->id.name) - 2);
738   }
739 }
740
741 static void drawrenderborder(ARegion *ar, View3D *v3d)
742 {
743   /* use the same program for everything */
744   uint shdr_pos = GPU_vertformat_attr_add(
745       immVertexFormat(), "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
746
747   GPU_line_width(1.0f);
748
749   immBindBuiltinProgram(GPU_SHADER_2D_LINE_DASHED_UNIFORM_COLOR);
750
751   float viewport_size[4];
752   GPU_viewport_size_get_f(viewport_size);
753   immUniform2f("viewport_size", viewport_size[2], viewport_size[3]);
754
755   immUniform1i("colors_len", 0); /* "simple" mode */
756   immUniform4f("color", 1.0f, 0.25f, 0.25f, 1.0f);
757   immUniform1f("dash_width", 6.0f);
758   immUniform1f("dash_factor", 0.5f);
759
760   imm_draw_box_wire_2d(shdr_pos,
761                        v3d->render_border.xmin * ar->winx,
762                        v3d->render_border.ymin * ar->winy,
763                        v3d->render_border.xmax * ar->winx,
764                        v3d->render_border.ymax * ar->winy);
765
766   immUnbindProgram();
767 }
768
769 void ED_view3d_draw_depth(Depsgraph *depsgraph, ARegion *ar, View3D *v3d, bool alphaoverride)
770 {
771   struct bThemeState theme_state;
772   Scene *scene = DEG_get_evaluated_scene(depsgraph);
773   RegionView3D *rv3d = ar->regiondata;
774
775   short flag = v3d->flag;
776   float glalphaclip = U.glalphaclip;
777   /* temp set drawtype to solid */
778   /* Setting these temporarily is not nice */
779   v3d->flag &= ~V3D_SELECT_OUTLINE;
780
781   /* not that nice but means we wont zoom into billboards */
782   U.glalphaclip = alphaoverride ? 0.5f : glalphaclip;
783
784   /* Tools may request depth outside of regular drawing code. */
785   UI_Theme_Store(&theme_state);
786   UI_SetTheme(SPACE_VIEW3D, RGN_TYPE_WINDOW);
787
788   ED_view3d_draw_setup_view(NULL, depsgraph, scene, ar, v3d, NULL, NULL, NULL);
789
790   GPU_clear(GPU_DEPTH_BIT);
791
792   if (rv3d->rflag & RV3D_CLIPPING) {
793     ED_view3d_clipping_set(rv3d);
794   }
795   /* get surface depth without bias */
796   rv3d->rflag |= RV3D_ZOFFSET_DISABLED;
797
798   GPU_depth_test(true);
799
800   GPUViewport *viewport = WM_draw_region_get_viewport(ar, 0);
801   DRW_draw_depth_loop(depsgraph, ar, v3d, viewport);
802
803   if (rv3d->rflag & RV3D_CLIPPING) {
804     ED_view3d_clipping_disable();
805   }
806   rv3d->rflag &= ~RV3D_ZOFFSET_DISABLED;
807
808   /* Reset default for UI */
809   GPU_depth_test(false);
810
811   U.glalphaclip = glalphaclip;
812   v3d->flag = flag;
813
814   UI_Theme_Restore(&theme_state);
815 }
816
817 /* ******************** other elements ***************** */
818
819 /** could move this elsewhere, but tied into #ED_view3d_grid_scale */
820 float ED_scene_grid_scale(Scene *scene, const char **grid_unit)
821 {
822   /* apply units */
823   if (scene->unit.system) {
824     const void *usys;
825     int len;
826
827     bUnit_GetSystem(scene->unit.system, B_UNIT_LENGTH, &usys, &len);
828
829     if (usys) {
830       int i = bUnit_GetBaseUnit(usys);
831       if (grid_unit) {
832         *grid_unit = bUnit_GetNameDisplay(usys, i);
833       }
834       return (float)bUnit_GetScaler(usys, i) / scene->unit.scale_length;
835     }
836   }
837
838   return 1.0f;
839 }
840
841 float ED_view3d_grid_scale(Scene *scene, View3D *v3d, const char **grid_unit)
842 {
843   return v3d->grid * ED_scene_grid_scale(scene, grid_unit);
844 }
845
846 /* Simulates the grid scale that is actually viewed.
847  * The actual code is seen in `object_grid_frag.glsl` (see `grid_res`).
848  * Currently the simulation is only done when RV3D_VIEW_IS_AXIS. */
849 float ED_view3d_grid_view_scale(Scene *scene,
850                                 View3D *v3d,
851                                 RegionView3D *rv3d,
852                                 const char **grid_unit)
853 {
854   float grid_scale = ED_view3d_grid_scale(scene, v3d, grid_unit);
855   if (!rv3d->is_persp && RV3D_VIEW_IS_AXIS(rv3d->view)) {
856     /* Decrease the distance between grid snap points depending on zoom. */
857     float grid_subdiv = v3d->gridsubdiv;
858     if (grid_subdiv > 1) {
859       /* Allow 3 more subdivisions (see OBJECT_engine_init). */
860       grid_scale /= powf(grid_subdiv, 3);
861
862       /* `3.0` was a value obtained by trial and error in order to get
863        * a nice snap distance.*/
864       float grid_res = 3.0 * (rv3d->dist / v3d->lens);
865       float lvl = (logf(grid_res / grid_scale) / logf(grid_subdiv));
866
867       CLAMP_MIN(lvl, 0.0f);
868
869       grid_scale *= pow(grid_subdiv, (int)lvl);
870     }
871   }
872
873   return grid_scale;
874 }
875
876 static void draw_view_axis(RegionView3D *rv3d, const rcti *rect)
877 {
878   const float k = U.rvisize * U.pixelsize; /* axis size */
879   /* axis alpha offset (rvibright has range 0-10) */
880   const int bright = -20 * (10 - U.rvibright);
881
882   /* Axis center in screen coordinates.
883    *
884    * - Unit size offset so small text doesn't draw outside the screen
885    * - Extra X offset because of the panel expander.
886    */
887   const float startx = rect->xmax - (k + UI_UNIT_X * 1.5);
888   const float starty = rect->ymax - (k + UI_UNIT_Y);
889
890   float axis_pos[3][2];
891   uchar axis_col[3][4];
892
893   int axis_order[3] = {0, 1, 2};
894   axis_sort_v3(rv3d->viewinv[2], axis_order);
895
896   for (int axis_i = 0; axis_i < 3; axis_i++) {
897     int i = axis_order[axis_i];
898
899     /* get position of each axis tip on screen */
900     float vec[3] = {0.0f};
901     vec[i] = 1.0f;
902     mul_qt_v3(rv3d->viewquat, vec);
903     axis_pos[i][0] = startx + vec[0] * k;
904     axis_pos[i][1] = starty + vec[1] * k;
905
906     /* get color of each axis */
907     UI_GetThemeColorShade3ubv(TH_AXIS_X + i, bright, axis_col[i]); /* rgb */
908     axis_col[i][3] = 255 * hypotf(vec[0], vec[1]);                 /* alpha */
909   }
910
911   /* draw axis lines */
912   GPU_line_width(2.0f);
913   GPU_line_smooth(true);
914   GPU_blend(true);
915   GPU_blend_set_func_separate(
916       GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
917
918   GPUVertFormat *format = immVertexFormat();
919   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 2, GPU_FETCH_FLOAT);
920   uint col = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
921
922   immBindBuiltinProgram(GPU_SHADER_2D_FLAT_COLOR);
923   immBegin(GPU_PRIM_LINES, 6);
924
925   for (int axis_i = 0; axis_i < 3; axis_i++) {
926     int i = axis_order[axis_i];
927
928     immAttr4ubv(col, axis_col[i]);
929     immVertex2f(pos, startx, starty);
930     immAttr4ubv(col, axis_col[i]);
931     immVertex2fv(pos, axis_pos[i]);
932   }
933
934   immEnd();
935   immUnbindProgram();
936   GPU_line_smooth(false);
937
938   /* draw axis names */
939   for (int axis_i = 0; axis_i < 3; axis_i++) {
940     int i = axis_order[axis_i];
941
942     const char axis_text[2] = {'x' + i, '\0'};
943     BLF_color4ubv(BLF_default(), axis_col[i]);
944     BLF_draw_default_ascii(axis_pos[i][0] + 2, axis_pos[i][1] + 2, 0.0f, axis_text, 1);
945   }
946 }
947
948 #ifdef WITH_INPUT_NDOF
949 /* draw center and axis of rotation for ongoing 3D mouse navigation */
950 static void draw_rotation_guide(const RegionView3D *rv3d)
951 {
952   float o[3];   /* center of rotation */
953   float end[3]; /* endpoints for drawing */
954
955   GLubyte color[4] = {0, 108, 255, 255}; /* bright blue so it matches device LEDs */
956
957   negate_v3_v3(o, rv3d->ofs);
958
959   GPU_blend(true);
960   GPU_blend_set_func_separate(
961       GPU_SRC_ALPHA, GPU_ONE_MINUS_SRC_ALPHA, GPU_ONE, GPU_ONE_MINUS_SRC_ALPHA);
962   glDepthMask(GL_FALSE); /* don't overwrite zbuf */
963
964   GPUVertFormat *format = immVertexFormat();
965   uint pos = GPU_vertformat_attr_add(format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
966   uint col = GPU_vertformat_attr_add(format, "color", GPU_COMP_U8, 4, GPU_FETCH_INT_TO_FLOAT_UNIT);
967
968   immBindBuiltinProgram(GPU_SHADER_3D_SMOOTH_COLOR);
969
970   if (rv3d->rot_angle != 0.0f) {
971     /* -- draw rotation axis -- */
972     float scaled_axis[3];
973     const float scale = rv3d->dist;
974     mul_v3_v3fl(scaled_axis, rv3d->rot_axis, scale);
975
976     immBegin(GPU_PRIM_LINE_STRIP, 3);
977     color[3] = 0; /* more transparent toward the ends */
978     immAttr4ubv(col, color);
979     add_v3_v3v3(end, o, scaled_axis);
980     immVertex3fv(pos, end);
981
982 #  if 0
983     color[3] = 0.2f + fabsf(rv3d->rot_angle); /* modulate opacity with angle */
984     /* ^^ neat idea, but angle is frame-rate dependent, so it's usually close to 0.2 */
985 #  endif
986
987     color[3] = 127; /* more opaque toward the center */
988     immAttr4ubv(col, color);
989     immVertex3fv(pos, o);
990
991     color[3] = 0;
992     immAttr4ubv(col, color);
993     sub_v3_v3v3(end, o, scaled_axis);
994     immVertex3fv(pos, end);
995     immEnd();
996
997     /* -- draw ring around rotation center -- */
998     {
999 #  define ROT_AXIS_DETAIL 13
1000
1001       const float s = 0.05f * scale;
1002       const float step = 2.0f * (float)(M_PI / ROT_AXIS_DETAIL);
1003
1004       float q[4]; /* rotate ring so it's perpendicular to axis */
1005       const int upright = fabsf(rv3d->rot_axis[2]) >= 0.95f;
1006       if (!upright) {
1007         const float up[3] = {0.0f, 0.0f, 1.0f};
1008         float vis_angle, vis_axis[3];
1009
1010         cross_v3_v3v3(vis_axis, up, rv3d->rot_axis);
1011         vis_angle = acosf(dot_v3v3(up, rv3d->rot_axis));
1012         axis_angle_to_quat(q, vis_axis, vis_angle);
1013       }
1014
1015       immBegin(GPU_PRIM_LINE_LOOP, ROT_AXIS_DETAIL);
1016       color[3] = 63; /* somewhat faint */
1017       immAttr4ubv(col, color);
1018       float angle = 0.0f;
1019       for (int i = 0; i < ROT_AXIS_DETAIL; ++i, angle += step) {
1020         float p[3] = {s * cosf(angle), s * sinf(angle), 0.0f};
1021
1022         if (!upright) {
1023           mul_qt_v3(q, p);
1024         }
1025
1026         add_v3_v3(p, o);
1027         immVertex3fv(pos, p);
1028       }
1029       immEnd();
1030
1031 #  undef ROT_AXIS_DETAIL
1032     }
1033
1034     color[3] = 255; /* solid dot */
1035   }
1036   else {
1037     color[3] = 127; /* see-through dot */
1038   }
1039
1040   immUnbindProgram();
1041
1042   /* -- draw rotation center -- */
1043   immBindBuiltinProgram(GPU_SHADER_3D_POINT_FIXED_SIZE_VARYING_COLOR);
1044   GPU_point_size(5.0f);
1045   immBegin(GPU_PRIM_POINTS, 1);
1046   immAttr4ubv(col, color);
1047   immVertex3fv(pos, o);
1048   immEnd();
1049   immUnbindProgram();
1050
1051 #  if 0
1052   /* find screen coordinates for rotation center, then draw pretty icon */
1053   mul_m4_v3(rv3d->persinv, rot_center);
1054   UI_icon_draw(rot_center[0], rot_center[1], ICON_NDOF_TURN);
1055   /* ^^ just playing around, does not work */
1056 #  endif
1057
1058   GPU_blend(false);
1059   glDepthMask(GL_TRUE);
1060 }
1061 #endif /* WITH_INPUT_NDOF */
1062
1063 /**
1064  * Render and camera border
1065  */
1066 static void view3d_draw_border(const bContext *C, ARegion *ar)
1067 {
1068   Scene *scene = CTX_data_scene(C);
1069   Depsgraph *depsgraph = CTX_data_depsgraph(C);
1070   RegionView3D *rv3d = ar->regiondata;
1071   View3D *v3d = CTX_wm_view3d(C);
1072
1073   if (rv3d->persp == RV3D_CAMOB) {
1074     drawviewborder(scene, depsgraph, ar, v3d);
1075   }
1076   else if (v3d->flag2 & V3D_RENDER_BORDER) {
1077     drawrenderborder(ar, v3d);
1078   }
1079 }
1080
1081 /** \} */
1082
1083 /* -------------------------------------------------------------------- */
1084 /** \name Draw Text & Info
1085  * \{ */
1086
1087 /**
1088  * Draw Info
1089  */
1090 static void view3d_draw_grease_pencil(const bContext *UNUSED(C))
1091 {
1092   /* TODO viewport */
1093 }
1094
1095 /**
1096  * Viewport Name
1097  */
1098 static const char *view3d_get_name(View3D *v3d, RegionView3D *rv3d)
1099 {
1100   const char *name = NULL;
1101
1102   switch (rv3d->view) {
1103     case RV3D_VIEW_FRONT:
1104       if (rv3d->persp == RV3D_ORTHO) {
1105         name = IFACE_("Front Orthographic");
1106       }
1107       else {
1108         name = IFACE_("Front Perspective");
1109       }
1110       break;
1111     case RV3D_VIEW_BACK:
1112       if (rv3d->persp == RV3D_ORTHO) {
1113         name = IFACE_("Back Orthographic");
1114       }
1115       else {
1116         name = IFACE_("Back Perspective");
1117       }
1118       break;
1119     case RV3D_VIEW_TOP:
1120       if (rv3d->persp == RV3D_ORTHO) {
1121         name = IFACE_("Top Orthographic");
1122       }
1123       else {
1124         name = IFACE_("Top Perspective");
1125       }
1126       break;
1127     case RV3D_VIEW_BOTTOM:
1128       if (rv3d->persp == RV3D_ORTHO) {
1129         name = IFACE_("Bottom Orthographic");
1130       }
1131       else {
1132         name = IFACE_("Bottom Perspective");
1133       }
1134       break;
1135     case RV3D_VIEW_RIGHT:
1136       if (rv3d->persp == RV3D_ORTHO) {
1137         name = IFACE_("Right Orthographic");
1138       }
1139       else {
1140         name = IFACE_("Right Perspective");
1141       }
1142       break;
1143     case RV3D_VIEW_LEFT:
1144       if (rv3d->persp == RV3D_ORTHO) {
1145         name = IFACE_("Left Orthographic");
1146       }
1147       else {
1148         name = IFACE_("Left Perspective");
1149       }
1150       break;
1151
1152     default:
1153       if (rv3d->persp == RV3D_CAMOB) {
1154         if ((v3d->camera) && (v3d->camera->type == OB_CAMERA)) {
1155           Camera *cam;
1156           cam = v3d->camera->data;
1157           if (cam->type == CAM_PERSP) {
1158             name = IFACE_("Camera Perspective");
1159           }
1160           else if (cam->type == CAM_ORTHO) {
1161             name = IFACE_("Camera Orthographic");
1162           }
1163           else {
1164             BLI_assert(cam->type == CAM_PANO);
1165             name = IFACE_("Camera Panoramic");
1166           }
1167         }
1168         else {
1169           name = IFACE_("Object as Camera");
1170         }
1171       }
1172       else {
1173         name = (rv3d->persp == RV3D_ORTHO) ? IFACE_("User Orthographic") :
1174                                              IFACE_("User Perspective");
1175       }
1176   }
1177
1178   return name;
1179 }
1180
1181 static void draw_viewport_name(ARegion *ar, View3D *v3d, int xoffset, int *yoffset)
1182 {
1183   RegionView3D *rv3d = ar->regiondata;
1184   const char *name = view3d_get_name(v3d, rv3d);
1185   const int font_id = BLF_default();
1186
1187   /* increase size for unicode languages (Chinese in utf-8...) */
1188 #ifdef WITH_INTERNATIONAL
1189   char tmpstr[96];
1190 #else
1191   char tmpstr[32];
1192 #endif
1193
1194   BLF_enable(font_id, BLF_SHADOW);
1195   BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1196   BLF_shadow_offset(font_id, 1, -1);
1197
1198   if (v3d->localvd) {
1199     BLI_snprintf(tmpstr, sizeof(tmpstr), IFACE_("%s (Local)"), name);
1200     name = tmpstr;
1201   }
1202
1203   UI_FontThemeColor(BLF_default(), TH_TEXT_HI);
1204
1205   *yoffset -= U.widget_unit;
1206
1207 #ifdef WITH_INTERNATIONAL
1208   BLF_draw_default(xoffset, *yoffset, 0.0f, name, sizeof(tmpstr));
1209 #else
1210   BLF_draw_default_ascii(xoffset, *yoffset, 0.0f, name, sizeof(tmpstr));
1211 #endif
1212
1213   BLF_disable(font_id, BLF_SHADOW);
1214 }
1215
1216 /**
1217  * draw info beside axes in bottom left-corner:
1218  * framenum, collection, object name, bone name (if available), marker name (if available)
1219  */
1220
1221 static void draw_selected_name(
1222     Scene *scene, ViewLayer *view_layer, Object *ob, int xoffset, int *yoffset)
1223 {
1224   const int cfra = CFRA;
1225   const char *msg_pin = " (Pinned)";
1226   const char *msg_sep = " : ";
1227
1228   const int font_id = BLF_default();
1229
1230   char info[300];
1231   char *s = info;
1232
1233   s += sprintf(s, "(%d)", cfra);
1234
1235   if ((ob == NULL) || (ob->mode == OB_MODE_OBJECT)) {
1236     LayerCollection *layer_collection = view_layer->active_collection;
1237     s += sprintf(s,
1238                  " %s%s",
1239                  BKE_collection_ui_name_get(layer_collection->collection),
1240                  (ob == NULL) ? "" : " |");
1241   }
1242
1243   /*
1244    * info can contain:
1245    * - a frame (7 + 2)
1246    * - a collection name (MAX_NAME + 3)
1247    * - 3 object names (MAX_NAME)
1248    * - 2 BREAD_CRUMB_SEPARATORs (6)
1249    * - a SHAPE_KEY_PINNED marker and a trailing '\0' (9+1) - translated, so give some room!
1250    * - a marker name (MAX_NAME + 3)
1251    */
1252
1253   /* get name of marker on current frame (if available) */
1254   const char *markern = BKE_scene_find_marker_name(scene, cfra);
1255
1256   /* check if there is an object */
1257   if (ob) {
1258     *s++ = ' ';
1259     s += BLI_strcpy_rlen(s, ob->id.name + 2);
1260
1261     /* name(s) to display depends on type of object */
1262     if (ob->type == OB_ARMATURE) {
1263       bArmature *arm = ob->data;
1264
1265       /* show name of active bone too (if possible) */
1266       if (arm->edbo) {
1267         if (arm->act_edbone) {
1268           s += BLI_strcpy_rlen(s, msg_sep);
1269           s += BLI_strcpy_rlen(s, arm->act_edbone->name);
1270         }
1271       }
1272       else if (ob->mode & OB_MODE_POSE) {
1273         if (arm->act_bone) {
1274
1275           if (arm->act_bone->layer & arm->layer) {
1276             s += BLI_strcpy_rlen(s, msg_sep);
1277             s += BLI_strcpy_rlen(s, arm->act_bone->name);
1278           }
1279         }
1280       }
1281     }
1282     else if (ELEM(ob->type, OB_MESH, OB_LATTICE, OB_CURVE)) {
1283       /* try to display active bone and active shapekey too (if they exist) */
1284
1285       if (ob->type == OB_MESH && ob->mode & OB_MODE_WEIGHT_PAINT) {
1286         Object *armobj = BKE_object_pose_armature_get(ob);
1287         if (armobj && armobj->mode & OB_MODE_POSE) {
1288           bArmature *arm = armobj->data;
1289           if (arm->act_bone) {
1290             if (arm->act_bone->layer & arm->layer) {
1291               s += BLI_strcpy_rlen(s, msg_sep);
1292               s += BLI_strcpy_rlen(s, arm->act_bone->name);
1293             }
1294           }
1295         }
1296       }
1297
1298       Key *key = BKE_key_from_object(ob);
1299       if (key) {
1300         KeyBlock *kb = BLI_findlink(&key->block, ob->shapenr - 1);
1301         if (kb) {
1302           s += BLI_strcpy_rlen(s, msg_sep);
1303           s += BLI_strcpy_rlen(s, kb->name);
1304           if (ob->shapeflag & OB_SHAPE_LOCK) {
1305             s += BLI_strcpy_rlen(s, IFACE_(msg_pin));
1306           }
1307         }
1308       }
1309     }
1310
1311     /* color depends on whether there is a keyframe */
1312     if (id_frame_has_keyframe(
1313             (ID *)ob, /* BKE_scene_frame_get(scene) */ (float)cfra, ANIMFILTER_KEYS_LOCAL)) {
1314       UI_FontThemeColor(font_id, TH_TIME_KEYFRAME);
1315     }
1316     else if (ED_gpencil_has_keyframe_v3d(scene, ob, cfra)) {
1317       UI_FontThemeColor(font_id, TH_TIME_GP_KEYFRAME);
1318     }
1319     else {
1320       UI_FontThemeColor(font_id, TH_TEXT_HI);
1321     }
1322   }
1323   else {
1324     /* no object */
1325     if (ED_gpencil_has_keyframe_v3d(scene, NULL, cfra)) {
1326       UI_FontThemeColor(font_id, TH_TIME_GP_KEYFRAME);
1327     }
1328     else {
1329       UI_FontThemeColor(font_id, TH_TEXT_HI);
1330     }
1331   }
1332
1333   if (markern) {
1334     s += sprintf(s, " <%s>", markern);
1335   }
1336
1337   BLF_enable(font_id, BLF_SHADOW);
1338   BLF_shadow(font_id, 5, (const float[4]){0.0f, 0.0f, 0.0f, 1.0f});
1339   BLF_shadow_offset(font_id, 1, -1);
1340
1341   *yoffset -= U.widget_unit;
1342   BLF_draw_default(xoffset, *yoffset, 0.0f, info, sizeof(info));
1343
1344   BLF_disable(font_id, BLF_SHADOW);
1345 }
1346
1347 /**
1348  * Information drawn on top of the solid plates and composed data
1349  */
1350 void view3d_draw_region_info(const bContext *C, ARegion *ar)
1351 {
1352   RegionView3D *rv3d = ar->regiondata;
1353   View3D *v3d = CTX_wm_view3d(C);
1354   Scene *scene = CTX_data_scene(C);
1355   wmWindowManager *wm = CTX_wm_manager(C);
1356
1357 #ifdef WITH_INPUT_NDOF
1358   if ((U.ndof_flag & NDOF_SHOW_GUIDE) && ((rv3d->viewlock & RV3D_LOCKED) == 0) &&
1359       (rv3d->persp != RV3D_CAMOB)) {
1360     /* TODO: draw something else (but not this) during fly mode */
1361     draw_rotation_guide(rv3d);
1362   }
1363 #endif
1364
1365   /* correct projection matrix */
1366   ED_region_pixelspace(ar);
1367
1368   /* local coordinate visible rect inside region, to accommodate overlapping ui */
1369   rcti rect;
1370   ED_region_visible_rect(ar, &rect);
1371
1372   view3d_draw_border(C, ar);
1373   view3d_draw_grease_pencil(C);
1374
1375   BLF_batch_draw_begin();
1376
1377   if ((U.uiflag & USER_SHOW_GIZMO_AXIS) ||
1378       /* No need to display gizmo and this info. */
1379       (v3d->gizmo_flag & (V3D_GIZMO_HIDE | V3D_GIZMO_HIDE_NAVIGATE))) {
1380     /* pass */
1381   }
1382   else {
1383     draw_view_axis(rv3d, &rect);
1384   }
1385
1386   int xoffset = rect.xmin + U.widget_unit;
1387   int yoffset = rect.ymax;
1388
1389   if ((v3d->flag2 & V3D_HIDE_OVERLAYS) == 0 && (v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) == 0) {
1390     if ((U.uiflag & USER_SHOW_FPS) && ED_screen_animation_no_scrub(wm)) {
1391       ED_scene_draw_fps(scene, xoffset, &yoffset);
1392     }
1393     else if (U.uiflag & USER_SHOW_VIEWPORTNAME) {
1394       draw_viewport_name(ar, v3d, xoffset, &yoffset);
1395     }
1396
1397     if (U.uiflag & USER_DRAWVIEWINFO) {
1398       ViewLayer *view_layer = CTX_data_view_layer(C);
1399       Object *ob = OBACT(view_layer);
1400       draw_selected_name(scene, view_layer, ob, xoffset, &yoffset);
1401     }
1402
1403 #if 0 /* TODO */
1404     if (grid_unit) { /* draw below the viewport name */
1405       char numstr[32] = "";
1406
1407       UI_FontThemeColor(BLF_default(), TH_TEXT_HI);
1408       if (v3d->grid != 1.0f) {
1409         BLI_snprintf(numstr, sizeof(numstr), "%s x %.4g", grid_unit, v3d->grid);
1410       }
1411
1412       *yoffset -= U.widget_unit;
1413       BLF_draw_default_ascii(xoffset, *yoffset, numstr[0] ? numstr : grid_unit, sizeof(numstr));
1414     }
1415 #endif
1416   }
1417
1418   if ((v3d->overlay.flag & V3D_OVERLAY_HIDE_TEXT) == 0) {
1419     DRW_draw_region_engine_info(xoffset, yoffset);
1420   }
1421
1422   BLF_batch_draw_end();
1423 }
1424
1425 /** \} */
1426
1427 /* -------------------------------------------------------------------- */
1428 /** \name Draw Viewport Contents
1429  * \{ */
1430
1431 static void view3d_draw_view(const bContext *C, ARegion *ar)
1432 {
1433   ED_view3d_draw_setup_view(CTX_wm_window(C),
1434                             CTX_data_depsgraph(C),
1435                             CTX_data_scene(C),
1436                             ar,
1437                             CTX_wm_view3d(C),
1438                             NULL,
1439                             NULL,
1440                             NULL);
1441
1442   /* Only 100% compliant on new spec goes below */
1443   DRW_draw_view(C);
1444 }
1445
1446 RenderEngineType *ED_view3d_engine_type(Scene *scene, int drawtype)
1447 {
1448   /*
1449    * Temporary viewport draw modes until we have a proper system.
1450    * all modes are done in the draw manager, except
1451    * cycles material as it is an external render engine.
1452    */
1453   if (strcmp(scene->r.engine, RE_engine_id_CYCLES) == 0 && drawtype == OB_MATERIAL) {
1454     return RE_engines_find(RE_engine_id_BLENDER_EEVEE);
1455   }
1456   return RE_engines_find(scene->r.engine);
1457 }
1458
1459 void view3d_main_region_draw(const bContext *C, ARegion *ar)
1460 {
1461   Main *bmain = CTX_data_main(C);
1462   View3D *v3d = CTX_wm_view3d(C);
1463
1464   view3d_draw_view(C, ar);
1465
1466   DRW_cache_free_old_batches(bmain);
1467   GPU_free_images_old(bmain);
1468   GPU_pass_cache_garbage_collect();
1469
1470   /* XXX This is in order to draw UI batches with the DRW
1471    * olg context since we now use it for drawing the entire area */
1472   gpu_batch_presets_reset();
1473
1474   /* No depth test for drawing action zones afterwards. */
1475   GPU_depth_test(false);
1476
1477   v3d->flag |= V3D_INVALID_BACKBUF;
1478 }
1479
1480 /** \} */
1481
1482 /* -------------------------------------------------------------------- */
1483 /** \name Offscreen Drawing
1484  * \{ */
1485
1486 static void view3d_stereo3d_setup_offscreen(Depsgraph *depsgraph,
1487                                             Scene *scene,
1488                                             View3D *v3d,
1489                                             ARegion *ar,
1490                                             float winmat[4][4],
1491                                             const char *viewname)
1492 {
1493   /* update the viewport matrices with the new camera */
1494   if (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D) {
1495     float viewmat[4][4];
1496     const bool is_left = STREQ(viewname, STEREO_LEFT_NAME);
1497
1498     BKE_camera_multiview_view_matrix(&scene->r, v3d->camera, is_left, viewmat);
1499     view3d_main_region_setup_offscreen(depsgraph, scene, v3d, ar, viewmat, winmat);
1500   }
1501   else { /* SCE_VIEWS_FORMAT_MULTIVIEW */
1502     float viewmat[4][4];
1503     Object *camera = BKE_camera_multiview_render(scene, v3d->camera, viewname);
1504
1505     BKE_camera_multiview_view_matrix(&scene->r, camera, false, viewmat);
1506     view3d_main_region_setup_offscreen(depsgraph, scene, v3d, ar, viewmat, winmat);
1507   }
1508 }
1509
1510 void ED_view3d_draw_offscreen(Depsgraph *depsgraph,
1511                               Scene *scene,
1512                               int drawtype,
1513                               View3D *v3d,
1514                               ARegion *ar,
1515                               int winx,
1516                               int winy,
1517                               float viewmat[4][4],
1518                               float winmat[4][4],
1519                               bool do_sky,
1520                               bool UNUSED(is_persp),
1521                               const char *viewname,
1522                               const bool do_color_management,
1523                               GPUOffScreen *ofs,
1524                               GPUViewport *viewport)
1525 {
1526   RegionView3D *rv3d = ar->regiondata;
1527   RenderEngineType *engine_type = ED_view3d_engine_type(scene, drawtype);
1528
1529   /* set temporary new size */
1530   int bwinx = ar->winx;
1531   int bwiny = ar->winy;
1532   rcti brect = ar->winrct;
1533
1534   ar->winx = winx;
1535   ar->winy = winy;
1536   ar->winrct.xmin = 0;
1537   ar->winrct.ymin = 0;
1538   ar->winrct.xmax = winx;
1539   ar->winrct.ymax = winy;
1540
1541   struct bThemeState theme_state;
1542   UI_Theme_Store(&theme_state);
1543   UI_SetTheme(SPACE_VIEW3D, RGN_TYPE_WINDOW);
1544
1545   /* set flags */
1546   G.f |= G_FLAG_RENDER_VIEWPORT;
1547
1548   {
1549     /* free images which can have changed on frame-change
1550      * warning! can be slow so only free animated images - campbell */
1551     GPU_free_images_anim(G.main); /* XXX :((( */
1552   }
1553
1554   GPU_matrix_push_projection();
1555   GPU_matrix_identity_set();
1556   GPU_matrix_push();
1557   GPU_matrix_identity_set();
1558
1559   if ((viewname != NULL && viewname[0] != '\0') && (viewmat == NULL) &&
1560       rv3d->persp == RV3D_CAMOB && v3d->camera) {
1561     view3d_stereo3d_setup_offscreen(depsgraph, scene, v3d, ar, winmat, viewname);
1562   }
1563   else {
1564     view3d_main_region_setup_offscreen(depsgraph, scene, v3d, ar, viewmat, winmat);
1565   }
1566
1567   /* main drawing call */
1568   DRW_draw_render_loop_offscreen(
1569       depsgraph, engine_type, ar, v3d, do_sky, do_color_management, ofs, viewport);
1570
1571   /* restore size */
1572   ar->winx = bwinx;
1573   ar->winy = bwiny;
1574   ar->winrct = brect;
1575
1576   GPU_matrix_pop_projection();
1577   GPU_matrix_pop();
1578
1579   UI_Theme_Restore(&theme_state);
1580
1581   G.f &= ~G_FLAG_RENDER_VIEWPORT;
1582 }
1583
1584 /**
1585  * Utility func for ED_view3d_draw_offscreen
1586  *
1587  * \param ofs: Optional off-screen buffer, can be NULL.
1588  * (avoids re-creating when doing multiple GL renders).
1589  */
1590 ImBuf *ED_view3d_draw_offscreen_imbuf(Depsgraph *depsgraph,
1591                                       Scene *scene,
1592                                       int drawtype,
1593                                       View3D *v3d,
1594                                       ARegion *ar,
1595                                       int sizex,
1596                                       int sizey,
1597                                       uint flag,
1598                                       uint draw_flags,
1599                                       int alpha_mode,
1600                                       int samples,
1601                                       const char *viewname,
1602                                       /* output vars */
1603                                       GPUOffScreen *ofs,
1604                                       char err_out[256])
1605 {
1606   RegionView3D *rv3d = ar->regiondata;
1607   const bool draw_sky = (alpha_mode == R_ADDSKY);
1608   const bool use_full_sample = (draw_flags & V3D_OFSDRAW_USE_FULL_SAMPLE);
1609
1610   /* view state */
1611   bool is_ortho = false;
1612   float winmat[4][4];
1613
1614   if (ofs && ((GPU_offscreen_width(ofs) != sizex) || (GPU_offscreen_height(ofs) != sizey))) {
1615     /* sizes differ, can't reuse */
1616     ofs = NULL;
1617   }
1618
1619   GPUFrameBuffer *old_fb = GPU_framebuffer_active_get();
1620
1621   if (old_fb) {
1622     GPU_framebuffer_restore();
1623   }
1624
1625   const bool own_ofs = (ofs == NULL);
1626   DRW_opengl_context_enable();
1627
1628   if (own_ofs) {
1629     /* bind */
1630     ofs = GPU_offscreen_create(sizex, sizey, use_full_sample ? 0 : samples, true, false, err_out);
1631     if (ofs == NULL) {
1632       DRW_opengl_context_disable();
1633       return NULL;
1634     }
1635   }
1636
1637   GPU_offscreen_bind(ofs, true);
1638
1639   /* read in pixels & stamp */
1640   ImBuf *ibuf = IMB_allocImBuf(sizex, sizey, 32, flag);
1641
1642   /* render 3d view */
1643   if (rv3d->persp == RV3D_CAMOB && v3d->camera) {
1644     CameraParams params;
1645     Object *camera = BKE_camera_multiview_render(scene, v3d->camera, viewname);
1646     const Object *camera_eval = DEG_get_evaluated_object(depsgraph, camera);
1647
1648     BKE_camera_params_init(&params);
1649     /* fallback for non camera objects */
1650     params.clip_start = v3d->clip_start;
1651     params.clip_end = v3d->clip_end;
1652     BKE_camera_params_from_object(&params, camera_eval);
1653     BKE_camera_multiview_params(&scene->r, &params, camera_eval, viewname);
1654     BKE_camera_params_compute_viewplane(&params, sizex, sizey, scene->r.xasp, scene->r.yasp);
1655     BKE_camera_params_compute_matrix(&params);
1656
1657     is_ortho = params.is_ortho;
1658     copy_m4_m4(winmat, params.winmat);
1659   }
1660   else {
1661     rctf viewplane;
1662     float clip_start, clipend;
1663
1664     is_ortho = ED_view3d_viewplane_get(
1665         depsgraph, v3d, rv3d, sizex, sizey, &viewplane, &clip_start, &clipend, NULL);
1666     if (is_ortho) {
1667       orthographic_m4(winmat,
1668                       viewplane.xmin,
1669                       viewplane.xmax,
1670                       viewplane.ymin,
1671                       viewplane.ymax,
1672                       -clipend,
1673                       clipend);
1674     }
1675     else {
1676       perspective_m4(winmat,
1677                      viewplane.xmin,
1678                      viewplane.xmax,
1679                      viewplane.ymin,
1680                      viewplane.ymax,
1681                      clip_start,
1682                      clipend);
1683     }
1684   }
1685
1686   if ((samples && use_full_sample) == 0) {
1687     const bool do_color_management = (ibuf->rect_float == NULL);
1688     /* Single-pass render, common case */
1689     ED_view3d_draw_offscreen(depsgraph,
1690                              scene,
1691                              drawtype,
1692                              v3d,
1693                              ar,
1694                              sizex,
1695                              sizey,
1696                              NULL,
1697                              winmat,
1698                              draw_sky,
1699                              !is_ortho,
1700                              viewname,
1701                              do_color_management,
1702                              ofs,
1703                              NULL);
1704
1705     if (ibuf->rect_float) {
1706       GPU_offscreen_read_pixels(ofs, GL_FLOAT, ibuf->rect_float);
1707     }
1708     else if (ibuf->rect) {
1709       GPU_offscreen_read_pixels(ofs, GL_UNSIGNED_BYTE, ibuf->rect);
1710     }
1711   }
1712   else {
1713     /* Multi-pass render, use accumulation buffer & jitter for 'full' oversampling.
1714      * Use because OpenGL may use a lower quality MSAA, and only over-sample edges. */
1715     static float jit_ofs[32][2];
1716     float winmat_jitter[4][4];
1717     float *rect_temp = (ibuf->rect_float) ?
1718                            ibuf->rect_float :
1719                            MEM_mallocN(sizex * sizey * sizeof(float[4]), "rect_temp");
1720     float *accum_buffer = MEM_mallocN(sizex * sizey * sizeof(float[4]), "accum_buffer");
1721     GPUViewport *viewport = GPU_viewport_create_from_offscreen(ofs);
1722
1723     BLI_jitter_init(jit_ofs, samples);
1724
1725     /* first sample buffer, also initializes 'rv3d->persmat' */
1726     ED_view3d_draw_offscreen(depsgraph,
1727                              scene,
1728                              drawtype,
1729                              v3d,
1730                              ar,
1731                              sizex,
1732                              sizey,
1733                              NULL,
1734                              winmat,
1735                              draw_sky,
1736                              !is_ortho,
1737                              viewname,
1738                              false,
1739                              ofs,
1740                              viewport);
1741     GPU_offscreen_read_pixels(ofs, GL_FLOAT, accum_buffer);
1742
1743     /* skip the first sample */
1744     for (int j = 1; j < samples; j++) {
1745       copy_m4_m4(winmat_jitter, winmat);
1746       window_translate_m4(winmat_jitter,
1747                           rv3d->persmat,
1748                           (jit_ofs[j][0] * 2.0f) / sizex,
1749                           (jit_ofs[j][1] * 2.0f) / sizey);
1750
1751       ED_view3d_draw_offscreen(depsgraph,
1752                                scene,
1753                                drawtype,
1754                                v3d,
1755                                ar,
1756                                sizex,
1757                                sizey,
1758                                NULL,
1759                                winmat_jitter,
1760                                draw_sky,
1761                                !is_ortho,
1762                                viewname,
1763                                false,
1764                                ofs,
1765                                viewport);
1766       GPU_offscreen_read_pixels(ofs, GL_FLOAT, rect_temp);
1767
1768       uint i = sizex * sizey * 4;
1769       while (i--) {
1770         accum_buffer[i] += rect_temp[i];
1771       }
1772     }
1773
1774     {
1775       /* don't free data owned by 'ofs' */
1776       GPU_viewport_clear_from_offscreen(viewport);
1777       GPU_viewport_free(viewport);
1778     }
1779
1780     if (ibuf->rect_float == NULL) {
1781       MEM_freeN(rect_temp);
1782     }
1783
1784     if (ibuf->rect_float) {
1785       float *rect_float = ibuf->rect_float;
1786       uint i = sizex * sizey * 4;
1787       while (i--) {
1788         rect_float[i] = accum_buffer[i] / samples;
1789       }
1790     }
1791     else {
1792       uchar *rect_ub = (uchar *)ibuf->rect;
1793       uint i = sizex * sizey * 4;
1794       while (i--) {
1795         rect_ub[i] = (uchar)(255.0f * accum_buffer[i] / samples);
1796       }
1797     }
1798
1799     MEM_freeN(accum_buffer);
1800   }
1801
1802   /* unbind */
1803   GPU_offscreen_unbind(ofs, true);
1804
1805   if (own_ofs) {
1806     GPU_offscreen_free(ofs);
1807   }
1808
1809   DRW_opengl_context_disable();
1810
1811   if (old_fb) {
1812     GPU_framebuffer_bind(old_fb);
1813   }
1814
1815   if (ibuf->rect_float && ibuf->rect) {
1816     IMB_rect_from_float(ibuf);
1817   }
1818
1819   return ibuf;
1820 }
1821
1822 /**
1823  * Creates own fake 3d views (wrapping #ED_view3d_draw_offscreen_imbuf)
1824  *
1825  * \param ofs: Optional off-screen buffer can be NULL.
1826  * (avoids re-creating when doing multiple GL renders).
1827  *
1828  * \note used by the sequencer
1829  */
1830 ImBuf *ED_view3d_draw_offscreen_imbuf_simple(Depsgraph *depsgraph,
1831                                              Scene *scene,
1832                                              View3DShading *shading_override,
1833                                              int drawtype,
1834                                              Object *camera,
1835                                              int width,
1836                                              int height,
1837                                              uint flag,
1838                                              uint draw_flags,
1839                                              int alpha_mode,
1840                                              int samples,
1841                                              const char *viewname,
1842                                              GPUOffScreen *ofs,
1843                                              char err_out[256])
1844 {
1845   View3D v3d = {NULL};
1846   ARegion ar = {NULL};
1847   RegionView3D rv3d = {{{0}}};
1848
1849   /* connect data */
1850   v3d.regionbase.first = v3d.regionbase.last = &ar;
1851   ar.regiondata = &rv3d;
1852   ar.regiontype = RGN_TYPE_WINDOW;
1853
1854   v3d.camera = camera;
1855   View3DShading *source_shading_settings = &scene->display.shading;
1856   if (draw_flags & V3D_OFSDRAW_OVERRIDE_SCENE_SETTINGS && shading_override != NULL) {
1857     source_shading_settings = shading_override;
1858   }
1859   memcpy(&v3d.shading, source_shading_settings, sizeof(View3DShading));
1860   v3d.shading.type = drawtype;
1861
1862   if (drawtype == OB_MATERIAL) {
1863     v3d.shading.flag = V3D_SHADING_SCENE_WORLD | V3D_SHADING_SCENE_LIGHTS;
1864   }
1865
1866   v3d.flag2 = V3D_HIDE_OVERLAYS;
1867
1868   if (draw_flags & V3D_OFSDRAW_SHOW_ANNOTATION) {
1869     v3d.flag2 |= V3D_SHOW_ANNOTATION;
1870   }
1871
1872   v3d.shading.background_type = V3D_SHADING_BACKGROUND_WORLD;
1873
1874   rv3d.persp = RV3D_CAMOB;
1875
1876   copy_m4_m4(rv3d.viewinv, v3d.camera->obmat);
1877   normalize_m4(rv3d.viewinv);
1878   invert_m4_m4(rv3d.viewmat, rv3d.viewinv);
1879
1880   {
1881     CameraParams params;
1882     const Object *view_camera_eval = DEG_get_evaluated_object(
1883         depsgraph, BKE_camera_multiview_render(scene, v3d.camera, viewname));
1884
1885     BKE_camera_params_init(&params);
1886     BKE_camera_params_from_object(&params, view_camera_eval);
1887     BKE_camera_multiview_params(&scene->r, &params, view_camera_eval, viewname);
1888     BKE_camera_params_compute_viewplane(&params, width, height, scene->r.xasp, scene->r.yasp);
1889     BKE_camera_params_compute_matrix(&params);
1890
1891     copy_m4_m4(rv3d.winmat, params.winmat);
1892     v3d.clip_start = params.clip_start;
1893     v3d.clip_end = params.clip_end;
1894     v3d.lens = params.lens;
1895   }
1896
1897   mul_m4_m4m4(rv3d.persmat, rv3d.winmat, rv3d.viewmat);
1898   invert_m4_m4(rv3d.persinv, rv3d.viewinv);
1899
1900   return ED_view3d_draw_offscreen_imbuf(depsgraph,
1901                                         scene,
1902                                         drawtype,
1903                                         &v3d,
1904                                         &ar,
1905                                         width,
1906                                         height,
1907                                         flag,
1908                                         draw_flags,
1909                                         alpha_mode,
1910                                         samples,
1911                                         viewname,
1912                                         ofs,
1913                                         err_out);
1914 }
1915
1916 /** \} */
1917
1918 /* -------------------------------------------------------------------- */
1919 /** \name Viewport Clipping
1920  * \{ */
1921
1922 static bool view3d_clipping_test(const float co[3], const float clip[6][4])
1923 {
1924   if (plane_point_side_v3(clip[0], co) > 0.0f) {
1925     if (plane_point_side_v3(clip[1], co) > 0.0f) {
1926       if (plane_point_side_v3(clip[2], co) > 0.0f) {
1927         if (plane_point_side_v3(clip[3], co) > 0.0f) {
1928           return false;
1929         }
1930       }
1931     }
1932   }
1933
1934   return true;
1935 }
1936
1937 /* for 'local' ED_view3d_clipping_local must run first
1938  * then all comparisons can be done in localspace */
1939 bool ED_view3d_clipping_test(const RegionView3D *rv3d, const float co[3], const bool is_local)
1940 {
1941   return view3d_clipping_test(co, is_local ? rv3d->clip_local : rv3d->clip);
1942 }
1943
1944 /** \} */