Cleanup: replace attrib w/ attr
[blender.git] / source / blender / draw / modes / object_mode.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * Copyright 2016, Blender Foundation.
19  * Contributor(s): Blender Institute
20  *
21  * ***** END GPL LICENSE BLOCK *****
22  *
23  */
24
25 /** \file blender/draw/modes/object_mode.c
26  *  \ingroup draw
27  */
28
29 #include "DRW_engine.h"
30 #include "DRW_render.h"
31
32 #include "DNA_userdef_types.h"
33 #include "DNA_armature_types.h"
34 #include "DNA_constraint_types.h"
35 #include "DNA_camera_types.h"
36 #include "DNA_curve_types.h"
37 #include "DNA_mesh_types.h"
38 #include "DNA_meta_types.h"
39 #include "DNA_modifier_types.h"
40 #include "DNA_object_force_types.h"
41 #include "DNA_lightprobe_types.h"
42 #include "DNA_particle_types.h"
43 #include "DNA_rigidbody_types.h"
44 #include "DNA_smoke_types.h"
45 #include "DNA_view3d_types.h"
46 #include "DNA_world_types.h"
47
48 #include "BKE_anim.h"
49 #include "BKE_camera.h"
50 #include "BKE_constraint.h"
51 #include "BKE_curve.h"
52 #include "BKE_editmesh.h"
53 #include "BKE_mball.h"
54 #include "BKE_mesh.h"
55 #include "BKE_modifier.h"
56 #include "BKE_movieclip.h"
57 #include "BKE_object.h"
58 #include "BKE_particle.h"
59 #include "BKE_tracking.h"
60
61 #include "ED_view3d.h"
62
63 #include "GPU_batch.h"
64 #include "GPU_draw.h"
65 #include "GPU_shader.h"
66 #include "GPU_texture.h"
67
68 #include "MEM_guardedalloc.h"
69
70 #include "UI_resources.h"
71
72 #include "draw_mode_engines.h"
73 #include "draw_manager_text.h"
74 #include "draw_common.h"
75 #include "draw_builtin_shader.h"
76
77 #include "DEG_depsgraph_query.h"
78
79 extern char datatoc_common_world_clip_lib_glsl[];
80 extern char datatoc_object_outline_prepass_vert_glsl[];
81 extern char datatoc_object_outline_prepass_geom_glsl[];
82 extern char datatoc_object_outline_prepass_frag_glsl[];
83 extern char datatoc_object_outline_resolve_frag_glsl[];
84 extern char datatoc_object_outline_detect_frag_glsl[];
85 extern char datatoc_object_outline_expand_frag_glsl[];
86 extern char datatoc_object_grid_frag_glsl[];
87 extern char datatoc_object_grid_vert_glsl[];
88 extern char datatoc_object_empty_image_frag_glsl[];
89 extern char datatoc_object_empty_image_vert_glsl[];
90 extern char datatoc_object_lightprobe_grid_vert_glsl[];
91 extern char datatoc_object_loose_points_frag_glsl[];
92 extern char datatoc_object_particle_prim_vert_glsl[];
93 extern char datatoc_object_particle_dot_vert_glsl[];
94 extern char datatoc_object_particle_dot_frag_glsl[];
95 extern char datatoc_common_globals_lib_glsl[];
96 extern char datatoc_common_fxaa_lib_glsl[];
97 extern char datatoc_gpu_shader_flat_color_frag_glsl[];
98 extern char datatoc_gpu_shader_flat_id_frag_glsl[];
99 extern char datatoc_common_fullscreen_vert_glsl[];
100 extern char datatoc_gpu_shader_uniform_color_frag_glsl[];
101 extern char datatoc_gpu_shader_3D_vert_glsl[];
102
103 /* *********** LISTS *********** */
104 typedef struct OBJECT_PassList {
105         struct DRWPass *non_meshes[2];
106         struct DRWPass *image_empties[2];
107         struct DRWPass *spot_shapes[2];
108         struct DRWPass *ob_center;
109         struct DRWPass *outlines;
110         struct DRWPass *outlines_search;
111         struct DRWPass *outlines_expand;
112         struct DRWPass *outlines_bleed;
113         struct DRWPass *outlines_resolve;
114         struct DRWPass *grid;
115         struct DRWPass *bone_solid[2];
116         struct DRWPass *bone_outline[2];
117         struct DRWPass *bone_wire[2];
118         struct DRWPass *bone_envelope[2];
119         struct DRWPass *bone_axes[2];
120         struct DRWPass *particle;
121         struct DRWPass *lightprobes;
122 } OBJECT_PassList;
123
124 typedef struct OBJECT_FramebufferList {
125         struct GPUFrameBuffer *outlines_fb;
126         struct GPUFrameBuffer *blur_fb;
127         struct GPUFrameBuffer *expand_fb;
128         struct GPUFrameBuffer *ghost_fb;
129 } OBJECT_FramebufferList;
130
131 typedef struct OBJECT_StorageList {
132         struct OBJECT_PrivateData *g_data;
133 } OBJECT_StorageList;
134
135 typedef struct OBJECT_Data {
136         void *engine_type;
137         OBJECT_FramebufferList *fbl;
138         DRWViewportEmptyList *txl;
139         OBJECT_PassList *psl;
140         OBJECT_StorageList *stl;
141 } OBJECT_Data;
142
143 typedef struct OBJECT_Shaders {
144         /* fullscreen shaders */
145         GPUShader *outline_prepass;
146         GPUShader *outline_prepass_wire;
147         GPUShader *outline_resolve;
148         GPUShader *outline_resolve_aa;
149         GPUShader *outline_detect;
150         GPUShader *outline_detect_wire;
151         GPUShader *outline_fade;
152         GPUShader *outline_fade_large;
153
154         /* regular shaders */
155         GPUShader *object_empty_image;
156         GPUShader *object_empty_image_wire;
157         GPUShader *grid;
158         GPUShader *part_dot;
159         GPUShader *part_prim;
160         GPUShader *part_axis;
161         GPUShader *lightprobe_grid;
162         GPUShader *loose_points;
163 } OBJECT_Shaders;
164
165 /* *********** STATIC *********** */
166
167 typedef struct OBJECT_ShadingGroupList {
168         /* Reference only */
169         struct DRWPass *non_meshes;
170         struct DRWPass *image_empties;
171         struct DRWPass *spot_shapes;
172         struct DRWPass *bone_solid;
173         struct DRWPass *bone_outline;
174         struct DRWPass *bone_wire;
175         struct DRWPass *bone_envelope;
176         struct DRWPass *bone_axes;
177
178         /* Empties */
179         DRWShadingGroup *plain_axes;
180         DRWShadingGroup *cube;
181         DRWShadingGroup *circle;
182         DRWShadingGroup *sphere;
183         DRWShadingGroup *sphere_solid;
184         DRWShadingGroup *cylinder;
185         DRWShadingGroup *capsule_cap;
186         DRWShadingGroup *capsule_body;
187         DRWShadingGroup *cone;
188         DRWShadingGroup *single_arrow;
189         DRWShadingGroup *single_arrow_line;
190         DRWShadingGroup *empty_axes;
191
192         /* Force Field */
193         DRWShadingGroup *field_wind;
194         DRWShadingGroup *field_force;
195         DRWShadingGroup *field_vortex;
196         DRWShadingGroup *field_curve_sta;
197         DRWShadingGroup *field_curve_end;
198         DRWShadingGroup *field_tube_limit;
199         DRWShadingGroup *field_cone_limit;
200
201         /* Grease Pencil */
202         DRWShadingGroup *gpencil_axes;
203
204         /* Speaker */
205         DRWShadingGroup *speaker;
206
207         /* Probe */
208         DRWShadingGroup *probe_cube;
209         DRWShadingGroup *probe_planar;
210         DRWShadingGroup *probe_grid;
211
212         /* MetaBalls */
213         DRWShadingGroup *mball_handle;
214
215         /* Lamps */
216         DRWShadingGroup *lamp_center;
217         DRWShadingGroup *lamp_groundpoint;
218         DRWShadingGroup *lamp_groundline;
219         DRWShadingGroup *lamp_circle;
220         DRWShadingGroup *lamp_circle_shadow;
221         DRWShadingGroup *lamp_sunrays;
222         DRWShadingGroup *lamp_distance;
223         DRWShadingGroup *lamp_buflimit;
224         DRWShadingGroup *lamp_buflimit_points;
225         DRWShadingGroup *lamp_area_sphere;
226         DRWShadingGroup *lamp_area_square;
227         DRWShadingGroup *lamp_area_disk;
228         DRWShadingGroup *lamp_hemi;
229         DRWShadingGroup *lamp_spot_cone;
230         DRWShadingGroup *lamp_spot_blend;
231         DRWShadingGroup *lamp_spot_pyramid;
232         DRWShadingGroup *lamp_spot_blend_rect;
233         DRWShadingGroup *lamp_spot_volume;
234         DRWShadingGroup *lamp_spot_volume_rect;
235         DRWShadingGroup *lamp_spot_volume_outside;
236         DRWShadingGroup *lamp_spot_volume_rect_outside;
237
238         /* Helpers */
239         DRWShadingGroup *relationship_lines;
240         DRWShadingGroup *constraint_lines;
241
242         /* Camera */
243         DRWShadingGroup *camera;
244         DRWShadingGroup *camera_frame;
245         DRWShadingGroup *camera_tria;
246         DRWShadingGroup *camera_focus;
247         DRWShadingGroup *camera_clip;
248         DRWShadingGroup *camera_clip_points;
249         DRWShadingGroup *camera_mist;
250         DRWShadingGroup *camera_mist_points;
251         DRWShadingGroup *camera_stereo_plane;
252         DRWShadingGroup *camera_stereo_volume;
253         DRWShadingGroup *camera_stereo_volume_wires;
254         ListBase camera_path;
255
256         /* Wire */
257         DRWShadingGroup *wire;
258         DRWShadingGroup *wire_active;
259         DRWShadingGroup *wire_select;
260         DRWShadingGroup *wire_transform;
261         /* Wire (duplicator) */
262         DRWShadingGroup *wire_dupli;
263         DRWShadingGroup *wire_dupli_select;
264
265         /* Points */
266         DRWShadingGroup *points;
267         DRWShadingGroup *points_active;
268         DRWShadingGroup *points_select;
269         DRWShadingGroup *points_transform;
270         /* Points (duplicator) */
271         DRWShadingGroup *points_dupli;
272         DRWShadingGroup *points_dupli_select;
273
274         /* Texture Space */
275         DRWShadingGroup *texspace;
276 } OBJECT_ShadingGroupList;
277
278 typedef struct OBJECT_PrivateData {
279         OBJECT_ShadingGroupList sgl;
280         OBJECT_ShadingGroupList sgl_ghost;
281
282         /* Outlines */
283         DRWShadingGroup *outlines_active;
284         DRWShadingGroup *outlines_select;
285         DRWShadingGroup *outlines_select_dupli;
286         DRWShadingGroup *outlines_transform;
287
288         /* Lightprobes */
289         DRWShadingGroup *lightprobes_cube_select;
290         DRWShadingGroup *lightprobes_cube_select_dupli;
291         DRWShadingGroup *lightprobes_cube_active;
292         DRWShadingGroup *lightprobes_cube_transform;
293
294         DRWShadingGroup *lightprobes_planar_select;
295         DRWShadingGroup *lightprobes_planar_select_dupli;
296         DRWShadingGroup *lightprobes_planar_active;
297         DRWShadingGroup *lightprobes_planar_transform;
298
299         /* Objects Centers */
300         DRWShadingGroup *center_active;
301         DRWShadingGroup *center_selected;
302         DRWShadingGroup *center_deselected;
303         DRWShadingGroup *center_selected_lib;
304         DRWShadingGroup *center_deselected_lib;
305
306         /* Outlines id offset (accessed as an array) */
307         int id_ofs_active;
308         int id_ofs_select;
309         int id_ofs_select_dupli;
310         int id_ofs_transform;
311
312         int id_ofs_prb_active;
313         int id_ofs_prb_select;
314         int id_ofs_prb_select_dupli;
315         int id_ofs_prb_transform;
316
317         bool xray_enabled;
318 } OBJECT_PrivateData; /* Transient data */
319
320 static struct {
321         /* Instance Data format */
322         struct GPUVertFormat *particle_format;
323         struct GPUVertFormat *empty_image_format;
324         struct GPUVertFormat *empty_image_wire_format;
325
326         OBJECT_Shaders sh_data[DRW_SHADER_SLOT_LEN];
327
328         float camera_pos[3];
329         float grid_settings[5];
330         float grid_mesh_size;
331         int grid_flag;
332         float grid_axes[3];
333         int zpos_flag;
334         int zneg_flag;
335         float zplane_axes[3];
336         float inv_viewport_size[2];
337         bool draw_grid;
338         /* Temp buffer textures */
339         struct GPUTexture *outlines_depth_tx;
340         struct GPUTexture *outlines_id_tx;
341         struct GPUTexture *outlines_color_tx;
342         struct GPUTexture *outlines_blur_tx;
343
344         ListBase smoke_domains;
345 } e_data = {NULL}; /* Engine data */
346
347
348 enum {
349         SHOW_AXIS_X  = (1 << 0),
350         SHOW_AXIS_Y  = (1 << 1),
351         SHOW_AXIS_Z  = (1 << 2),
352         SHOW_GRID    = (1 << 3),
353         PLANE_XY     = (1 << 4),
354         PLANE_XZ     = (1 << 5),
355         PLANE_YZ     = (1 << 6),
356         CLIP_ZPOS    = (1 << 7),
357         CLIP_ZNEG    = (1 << 8),
358         GRID_BACK    = (1 << 9),
359 };
360
361 /* Prototypes. */
362 static void DRW_shgroup_empty_ex(OBJECT_ShadingGroupList *sgl, float mat[4][4], float *draw_size, char draw_type, float *color);
363
364 /* *********** FUNCTIONS *********** */
365
366 static void OBJECT_engine_init(void *vedata)
367 {
368         OBJECT_FramebufferList *fbl = ((OBJECT_Data *)vedata)->fbl;
369
370         const float *viewport_size = DRW_viewport_size_get();
371         const int size[2] = {(int)viewport_size[0], (int)viewport_size[1]};
372
373         if (DRW_state_is_fbo()) {
374                 e_data.outlines_depth_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_DEPTH_COMPONENT24,
375                                                                      &draw_engine_object_type);
376                 /* XXX TODO GPU_R16UI can overflow, it would cause no harm
377                  * (only bad colored or missing outlines) but we should
378                  * use 32bits only if the scene have that many objects */
379                 e_data.outlines_id_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_R16UI,
380                                                                   &draw_engine_object_type);
381
382                 GPU_framebuffer_ensure_config(&fbl->outlines_fb, {
383                         GPU_ATTACHMENT_TEXTURE(e_data.outlines_depth_tx),
384                         GPU_ATTACHMENT_TEXTURE(e_data.outlines_id_tx)
385                 });
386
387                 e_data.outlines_color_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_RGBA8,
388                                                                      &draw_engine_object_type);
389
390                 GPU_framebuffer_ensure_config(&fbl->expand_fb, {
391                         GPU_ATTACHMENT_NONE,
392                         GPU_ATTACHMENT_TEXTURE(e_data.outlines_color_tx)
393                 });
394
395                 e_data.outlines_blur_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_RGBA8,
396                                                                     &draw_engine_object_type);
397
398                 GPU_framebuffer_ensure_config(&fbl->blur_fb, {
399                         GPU_ATTACHMENT_NONE,
400                         GPU_ATTACHMENT_TEXTURE(e_data.outlines_blur_tx)
401                 });
402         }
403
404         /* Shaders */
405         const DRWContextState *draw_ctx = DRW_context_state_get();
406         OBJECT_Shaders *sh_data = &e_data.sh_data[draw_ctx->shader_slot];
407
408         const bool is_clip = (draw_ctx->rv3d->rflag & RV3D_CLIPPING) != 0;
409         const char *world_clip_lib_or_empty = is_clip ? datatoc_common_world_clip_lib_glsl : "";
410         const char *world_clip_def_or_empty = is_clip ? "#define USE_WORLD_CLIP_PLANES\n" : "";
411
412         if (!sh_data->outline_resolve) {
413                 /* Outline */
414                 sh_data->outline_prepass = DRW_shader_create_from_arrays({
415                         .vert = (const char *[]){world_clip_lib_or_empty, datatoc_gpu_shader_3D_vert_glsl, NULL},
416                         .frag = (const char *[]){datatoc_object_outline_prepass_frag_glsl, NULL},
417                         .defs = (const char *[]){world_clip_def_or_empty, NULL}});
418                 sh_data->outline_prepass_wire = DRW_shader_create_from_arrays({
419                         .vert = (const char *[]){world_clip_lib_or_empty, datatoc_object_outline_prepass_vert_glsl, NULL},
420                         .geom = (const char *[]){world_clip_lib_or_empty, datatoc_object_outline_prepass_geom_glsl, NULL},
421                         .frag = (const char *[]){datatoc_object_outline_prepass_frag_glsl, NULL},
422                         .defs = (const char *[]){world_clip_def_or_empty, NULL}});
423
424                 sh_data->outline_resolve = DRW_shader_create_fullscreen(datatoc_object_outline_resolve_frag_glsl, NULL);
425
426                 sh_data->outline_resolve_aa = DRW_shader_create_with_lib(
427                             datatoc_common_fullscreen_vert_glsl, NULL,
428                             datatoc_object_outline_resolve_frag_glsl,
429                             datatoc_common_fxaa_lib_glsl,
430                             "#define FXAA_ALPHA\n"
431                             "#define USE_FXAA\n");
432
433                 sh_data->outline_detect = DRW_shader_create_with_lib(
434                             datatoc_common_fullscreen_vert_glsl, NULL,
435                             datatoc_object_outline_detect_frag_glsl,
436                             datatoc_common_globals_lib_glsl,
437                             NULL);
438
439                 sh_data->outline_detect_wire = DRW_shader_create_with_lib(
440                             datatoc_common_fullscreen_vert_glsl, NULL,
441                             datatoc_object_outline_detect_frag_glsl,
442                             datatoc_common_globals_lib_glsl,
443                             "#define WIRE\n");
444
445
446                 sh_data->outline_fade = DRW_shader_create_fullscreen(datatoc_object_outline_expand_frag_glsl, NULL);
447                 sh_data->outline_fade_large = DRW_shader_create_fullscreen(datatoc_object_outline_expand_frag_glsl, "#define LARGE_OUTLINE\n");
448
449                 /* Empty images */
450                 {
451                         const char *empty_image_defs = (
452                                 "#define DEPTH_UNCHANGED " STRINGIFY(OB_EMPTY_IMAGE_DEPTH_DEFAULT) "\n"
453                                 "#define DEPTH_FRONT " STRINGIFY(OB_EMPTY_IMAGE_DEPTH_FRONT) "\n"
454                                 "#define DEPTH_BACK " STRINGIFY(OB_EMPTY_IMAGE_DEPTH_BACK) "\n");
455
456                         sh_data->object_empty_image = DRW_shader_create_from_arrays({
457                                 .vert = (const char *[]){world_clip_lib_or_empty, datatoc_object_empty_image_vert_glsl, NULL},
458                                 .frag = (const char *[]){datatoc_object_empty_image_frag_glsl, NULL},
459                                 .defs = (const char *[]){world_clip_def_or_empty, empty_image_defs, NULL}});
460                         sh_data->object_empty_image_wire = DRW_shader_create_from_arrays({
461                                 .vert = (const char *[]){world_clip_lib_or_empty, datatoc_object_empty_image_vert_glsl, NULL},
462                                 .frag = (const char *[]){datatoc_object_empty_image_frag_glsl, NULL},
463                                 .defs = (const char *[]){world_clip_def_or_empty, "#define USE_WIRE\n", empty_image_defs, NULL}});
464                 }
465
466                 /* Grid */
467                 sh_data->grid = DRW_shader_create_with_lib(
468                         datatoc_object_grid_vert_glsl, NULL,
469                         datatoc_object_grid_frag_glsl,
470                         datatoc_common_globals_lib_glsl, NULL);
471
472                 /* Particles */
473                 sh_data->part_prim = DRW_shader_create(
474                         datatoc_object_particle_prim_vert_glsl, NULL, datatoc_gpu_shader_flat_color_frag_glsl, NULL);
475
476                 sh_data->part_axis = DRW_shader_create(
477                         datatoc_object_particle_prim_vert_glsl, NULL, datatoc_gpu_shader_flat_color_frag_glsl,
478                         "#define USE_AXIS\n");
479
480                 sh_data->part_dot = DRW_shader_create(
481                         datatoc_object_particle_dot_vert_glsl, NULL, datatoc_object_particle_dot_frag_glsl, NULL);
482
483                 /* Lightprobes */
484                 sh_data->lightprobe_grid = DRW_shader_create(
485                         datatoc_object_lightprobe_grid_vert_glsl, NULL, datatoc_gpu_shader_flat_id_frag_glsl, NULL);
486
487                 /* Loose Points */
488                 sh_data->loose_points = DRW_shader_create_from_arrays({
489                         .vert = (const char *[]){world_clip_lib_or_empty, datatoc_gpu_shader_3D_vert_glsl, NULL},
490                         .frag = (const char *[]){datatoc_object_loose_points_frag_glsl, NULL},
491                         .defs = (const char *[]){world_clip_def_or_empty, NULL}});
492         }
493
494         {
495                 /* Grid precompute */
496                 float invviewmat[4][4], invwinmat[4][4];
497                 float viewmat[4][4], winmat[4][4];
498                 View3D *v3d = draw_ctx->v3d;
499                 Scene *scene = draw_ctx->scene;
500                 RegionView3D *rv3d = draw_ctx->rv3d;
501                 float grid_scale = ED_view3d_grid_scale(scene, v3d, NULL);
502                 float grid_res;
503
504                 const bool show_axis_x = (v3d->gridflag & V3D_SHOW_X) != 0;
505                 const bool show_axis_y = (v3d->gridflag & V3D_SHOW_Y) != 0;
506                 const bool show_axis_z = (v3d->gridflag & V3D_SHOW_Z) != 0;
507                 const bool show_floor = (v3d->gridflag & V3D_SHOW_FLOOR) != 0;
508                 e_data.draw_grid = show_axis_x || show_axis_y || show_axis_z || show_floor;
509
510                 DRW_viewport_matrix_get(winmat, DRW_MAT_WIN);
511                 DRW_viewport_matrix_get(viewmat, DRW_MAT_VIEW);
512                 DRW_viewport_matrix_get(invwinmat, DRW_MAT_WININV);
513                 DRW_viewport_matrix_get(invviewmat, DRW_MAT_VIEWINV);
514
515                 /* Setup camera pos */
516                 copy_v3_v3(e_data.camera_pos, invviewmat[3]);
517
518                 /* if perps */
519                 if (winmat[3][3] == 0.0f) {
520                         float fov;
521                         float viewvecs[2][4] = {
522                             {1.0f, -1.0f, -1.0f, 1.0f},
523                             {-1.0f, 1.0f, -1.0f, 1.0f}
524                         };
525
526                         /* convert the view vectors to view space */
527                         for (int i = 0; i < 2; i++) {
528                                 mul_m4_v4(invwinmat, viewvecs[i]);
529                                 mul_v3_fl(viewvecs[i], 1.0f / viewvecs[i][2]); /* perspective divide */
530                         }
531
532                         fov = angle_v3v3(viewvecs[0], viewvecs[1]) / 2.0f;
533                         grid_res = fabsf(tanf(fov)) / grid_scale;
534
535                         e_data.grid_flag = (1 << 4); /* XY plane */
536                         if (show_axis_x) {
537                                 e_data.grid_flag |= SHOW_AXIS_X;
538                         }
539                         if (show_axis_y) {
540                                 e_data.grid_flag |= SHOW_AXIS_Y;
541                         }
542                         if (show_floor) {
543                                 e_data.grid_flag |= SHOW_GRID;
544                         }
545
546                 }
547                 else {
548                         if (rv3d->view != RV3D_VIEW_USER) {
549                                 /* Allow 3 more subdivisions. */
550                                 grid_scale /= powf(v3d->gridsubdiv, 3);
551                         }
552
553                         float viewdist = 1.0f / max_ff(fabsf(winmat[0][0]), fabsf(winmat[1][1]));
554                         grid_res = viewdist / grid_scale;
555
556                         if (ELEM(rv3d->view, RV3D_VIEW_RIGHT, RV3D_VIEW_LEFT)) {
557                                 e_data.grid_flag = PLANE_YZ | SHOW_AXIS_Y | SHOW_AXIS_Z | SHOW_GRID | GRID_BACK;
558                         }
559                         else if (ELEM(rv3d->view, RV3D_VIEW_TOP, RV3D_VIEW_BOTTOM)) {
560                                 e_data.grid_flag = PLANE_XY | SHOW_AXIS_X | SHOW_AXIS_Y | SHOW_GRID | GRID_BACK;
561                         }
562                         else if (ELEM(rv3d->view, RV3D_VIEW_FRONT, RV3D_VIEW_BACK)) {
563                                 e_data.grid_flag = PLANE_XZ | SHOW_AXIS_X | SHOW_AXIS_Z | SHOW_GRID | GRID_BACK;
564                         }
565                         else { /* RV3D_VIEW_USER */
566                                 e_data.grid_flag = PLANE_XY;
567                                 if (show_axis_x) {
568                                         e_data.grid_flag |= SHOW_AXIS_X;
569                                 }
570                                 if (show_axis_y) {
571                                         e_data.grid_flag |= SHOW_AXIS_Y;
572                                 }
573                                 if (show_floor) {
574                                         e_data.grid_flag |= SHOW_GRID;
575                                 }
576                         }
577                 }
578
579                 e_data.grid_axes[0] = (float)((e_data.grid_flag & (PLANE_XZ | PLANE_XY)) != 0);
580                 e_data.grid_axes[1] = (float)((e_data.grid_flag & (PLANE_YZ | PLANE_XY)) != 0);
581                 e_data.grid_axes[2] = (float)((e_data.grid_flag & (PLANE_YZ | PLANE_XZ)) != 0);
582
583                 /* Z axis if needed */
584                 if (((rv3d->view == RV3D_VIEW_USER) || (rv3d->persp != RV3D_ORTHO)) && show_axis_z) {
585                         e_data.zpos_flag = SHOW_AXIS_Z;
586
587                         float zvec[4] = {0.0f, 0.0f, -1.0f, 0.0f};
588                         mul_m4_v4(invviewmat, zvec);
589
590                         /* z axis : chose the most facing plane */
591                         if (fabsf(zvec[0]) < fabsf(zvec[1])) {
592                                 e_data.zpos_flag |= PLANE_XZ;
593                         }
594                         else {
595                                 e_data.zpos_flag |= PLANE_YZ;
596                         }
597
598                         e_data.zneg_flag = e_data.zpos_flag;
599
600                         /* Persp : If camera is below floor plane, we switch clipping
601                          * Ortho : If eye vector is looking up, we switch clipping */
602                         if (((winmat[3][3] == 0.0f) && (e_data.camera_pos[2] > 0.0f)) ||
603                             ((winmat[3][3] != 0.0f) && (zvec[2] < 0.0f)))
604                         {
605                                 e_data.zpos_flag |= CLIP_ZPOS;
606                                 e_data.zneg_flag |= CLIP_ZNEG;
607                         }
608                         else {
609                                 e_data.zpos_flag |= CLIP_ZNEG;
610                                 e_data.zneg_flag |= CLIP_ZPOS;
611                         }
612
613                         e_data.zplane_axes[0] = (float)((e_data.zpos_flag & (PLANE_XZ | PLANE_XY)) != 0);
614                         e_data.zplane_axes[1] = (float)((e_data.zpos_flag & (PLANE_YZ | PLANE_XY)) != 0);
615                         e_data.zplane_axes[2] = (float)((e_data.zpos_flag & (PLANE_YZ | PLANE_XZ)) != 0);
616
617                 }
618                 else {
619                         e_data.zneg_flag = e_data.zpos_flag = CLIP_ZNEG | CLIP_ZPOS;
620                 }
621
622                 float dist;
623                 if (rv3d->persp == RV3D_CAMOB && v3d->camera && v3d->camera->type == OB_CAMERA) {
624                         Object *camera_object = DEG_get_evaluated_object(draw_ctx->depsgraph, v3d->camera);
625                         dist = ((Camera *)(camera_object->data))->clipend;
626                 }
627                 else {
628                         dist = v3d->far;
629                 }
630
631                 e_data.grid_settings[0] = dist / 2.0f; /* gridDistance */
632                 e_data.grid_settings[1] = grid_res; /* gridResolution */
633                 e_data.grid_settings[2] = grid_scale; /* gridScale */
634                 e_data.grid_settings[3] = v3d->gridsubdiv; /* gridSubdiv */
635                 e_data.grid_settings[4] = (v3d->gridsubdiv > 1) ? 1.0f / logf(v3d->gridsubdiv) : 0.0f; /* 1/log(gridSubdiv) */
636
637                 if (winmat[3][3] == 0.0f) {
638                         e_data.grid_mesh_size = dist;
639                 }
640                 else {
641                         float viewdist = 1.0f / min_ff(fabsf(winmat[0][0]), fabsf(winmat[1][1]));
642                         e_data.grid_mesh_size = viewdist * dist;
643                 }
644         }
645
646         copy_v2_v2(e_data.inv_viewport_size, DRW_viewport_size_get());
647         invert_v2(e_data.inv_viewport_size);
648 }
649
650 static void OBJECT_engine_free(void)
651 {
652         MEM_SAFE_FREE(e_data.particle_format);
653         MEM_SAFE_FREE(e_data.empty_image_format);
654         MEM_SAFE_FREE(e_data.empty_image_wire_format);
655
656         for (int sh_data_index = 0; sh_data_index < ARRAY_SIZE(e_data.sh_data); sh_data_index++) {
657                 OBJECT_Shaders *sh_data = &e_data.sh_data[sh_data_index];
658                 GPUShader **sh_data_as_array = (GPUShader **)sh_data;
659                 for (int i = 0; i < (sizeof(OBJECT_Shaders) / sizeof(GPUShader *)); i++) {
660                         DRW_SHADER_FREE_SAFE(sh_data_as_array[i]);
661                 }
662         }
663 }
664
665 static DRWShadingGroup *shgroup_outline(DRWPass *pass, const int *ofs, GPUShader *sh, eDRW_ShaderSlot shader_slot)
666 {
667         DRWShadingGroup *grp = DRW_shgroup_create(sh, pass);
668         DRW_shgroup_uniform_int(grp, "baseId", ofs, 1);
669
670         if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
671                 DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
672         }
673         return grp;
674 }
675
676 /* currently same as 'shgroup_outline', new function to avoid confustion */
677 static DRWShadingGroup *shgroup_wire(DRWPass *pass, const float col[4], GPUShader *sh, eDRW_ShaderSlot shader_slot)
678 {
679         DRWShadingGroup *grp = DRW_shgroup_create(sh, pass);
680         DRW_shgroup_uniform_vec4(grp, "color", col, 1);
681
682         if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
683                 DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
684         }
685         return grp;
686 }
687
688 /* currently same as 'shgroup_outline', new function to avoid confustion */
689 static DRWShadingGroup *shgroup_points(DRWPass *pass, const float col[4], GPUShader *sh, eDRW_ShaderSlot shader_slot)
690 {
691         DRWShadingGroup *grp = DRW_shgroup_create(sh, pass);
692         DRW_shgroup_uniform_vec4(grp, "color", col, 1);
693         DRW_shgroup_uniform_vec4(grp, "innerColor", G_draw.block.colorEditMeshMiddle, 1);
694
695         if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
696                 DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
697         }
698         return grp;
699 }
700
701 static int *shgroup_theme_id_to_probe_outline_counter(
702         OBJECT_StorageList *stl, int theme_id, const int base_flag)
703 {
704         if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
705                 switch (theme_id) {
706                         case TH_ACTIVE:
707                         case TH_SELECT:
708                                 return &stl->g_data->id_ofs_prb_select_dupli;
709                         case TH_TRANSFORM:
710                         default:
711                                 return &stl->g_data->id_ofs_prb_transform;
712                 }
713         }
714
715         switch (theme_id) {
716                 case TH_ACTIVE:
717                         return &stl->g_data->id_ofs_prb_active;
718                 case TH_SELECT:
719                         return &stl->g_data->id_ofs_prb_select;
720                 case TH_TRANSFORM:
721                 default:
722                         return &stl->g_data->id_ofs_prb_transform;
723         }
724 }
725
726 static int *shgroup_theme_id_to_outline_counter(
727         OBJECT_StorageList *stl, int theme_id, const int base_flag)
728 {
729         if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
730                 switch (theme_id) {
731                         case TH_ACTIVE:
732                         case TH_SELECT:
733                                 return &stl->g_data->id_ofs_select_dupli;
734                         case TH_TRANSFORM:
735                         default:
736                                 return &stl->g_data->id_ofs_transform;
737                 }
738         }
739
740         switch (theme_id) {
741                 case TH_ACTIVE:
742                         return &stl->g_data->id_ofs_active;
743                 case TH_SELECT:
744                         return &stl->g_data->id_ofs_select;
745                 case TH_TRANSFORM:
746                 default:
747                         return &stl->g_data->id_ofs_transform;
748         }
749 }
750
751 static DRWShadingGroup *shgroup_theme_id_to_probe_planar_outline_shgrp(
752         OBJECT_StorageList *stl, int theme_id)
753 {
754         /* does not increment counter */
755         switch (theme_id) {
756                 case TH_ACTIVE:
757                         return stl->g_data->lightprobes_planar_active;
758                 case TH_SELECT:
759                         return stl->g_data->lightprobes_planar_select;
760                 case TH_TRANSFORM:
761                 default:
762                         return stl->g_data->lightprobes_planar_transform;
763         }
764 }
765
766 static DRWShadingGroup *shgroup_theme_id_to_probe_cube_outline_shgrp(
767         OBJECT_StorageList *stl, int theme_id, const int base_flag)
768 {
769         /* does not increment counter */
770         if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
771                 switch (theme_id) {
772                         case TH_ACTIVE:
773                         case TH_SELECT:
774                                 return stl->g_data->lightprobes_cube_select_dupli;
775                         case TH_TRANSFORM:
776                         default:
777                                 return stl->g_data->lightprobes_cube_transform;
778                 }
779         }
780
781         switch (theme_id) {
782                 case TH_ACTIVE:
783                         return stl->g_data->lightprobes_cube_active;
784                 case TH_SELECT:
785                         return stl->g_data->lightprobes_cube_select;
786                 case TH_TRANSFORM:
787                 default:
788                         return stl->g_data->lightprobes_cube_transform;
789         }
790 }
791
792 static DRWShadingGroup *shgroup_theme_id_to_outline_or_null(
793         OBJECT_StorageList *stl, int theme_id, const int base_flag)
794 {
795         int *counter = shgroup_theme_id_to_outline_counter(stl, theme_id, base_flag);
796         *counter += 1;
797
798         if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
799                 switch (theme_id) {
800                         case TH_ACTIVE:
801                         case TH_SELECT:
802                                 return stl->g_data->outlines_select_dupli;
803                         case TH_TRANSFORM:
804                                 return stl->g_data->outlines_transform;
805                         default:
806                                 return NULL;
807                 }
808         }
809
810         switch (theme_id) {
811                 case TH_ACTIVE:
812                         return stl->g_data->outlines_active;
813                 case TH_SELECT:
814                         return stl->g_data->outlines_select;
815                 case TH_TRANSFORM:
816                         return stl->g_data->outlines_transform;
817                 default:
818                         return NULL;
819         }
820 }
821
822 static DRWShadingGroup *shgroup_theme_id_to_wire(
823         OBJECT_ShadingGroupList *sgl, int theme_id, const short base_flag)
824 {
825         if (UNLIKELY(base_flag & BASE_FROM_SET)) {
826                 return sgl->wire_dupli;
827         }
828         else if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
829                 switch (theme_id) {
830                         case TH_ACTIVE:
831                         case TH_SELECT:
832                                 return sgl->wire_dupli_select;
833                         case TH_TRANSFORM:
834                                 return sgl->wire_transform;
835                         default:
836                                 return sgl->wire_dupli;
837                 }
838         }
839
840         switch (theme_id) {
841                 case TH_ACTIVE:
842                         return sgl->wire_active;
843                 case TH_SELECT:
844                         return sgl->wire_select;
845                 case TH_TRANSFORM:
846                         return sgl->wire_transform;
847                 default:
848                         return sgl->wire;
849         }
850 }
851
852 static DRWShadingGroup *shgroup_theme_id_to_point(
853         OBJECT_ShadingGroupList *sgl, int theme_id, const short base_flag)
854 {
855         if (UNLIKELY(base_flag & BASE_FROM_SET)) {
856                 return sgl->points_dupli;
857         }
858         else if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
859                 switch (theme_id) {
860                         case TH_ACTIVE:
861                         case TH_SELECT:
862                                 return sgl->points_dupli_select;
863                         case TH_TRANSFORM:
864                                 return sgl->points_transform;
865                         default:
866                                 return sgl->points_dupli;
867                 }
868         }
869
870         switch (theme_id) {
871                 case TH_ACTIVE:
872                         return sgl->points_active;
873                 case TH_SELECT:
874                         return sgl->points_select;
875                 case TH_TRANSFORM:
876                         return sgl->points_transform;
877                 default:
878                         return sgl->points;
879         }
880 }
881
882 static void image_calc_aspect(Image *ima, const int size[2], float r_image_aspect[2])
883 {
884         float ima_x, ima_y;
885         if (ima) {
886                 ima_x = size[0];
887                 ima_y = size[1];
888         }
889         else {
890                 /* if no image, make it a 1x1 empty square, honor scale & offset */
891                 ima_x = ima_y = 1.0f;
892         }
893         /* Get the image aspect even if the buffer is invalid */
894         float sca_x = 1.0f, sca_y = 1.0f;
895         if (ima) {
896                 if (ima->aspx > ima->aspy) {
897                         sca_y = ima->aspy / ima->aspx;
898                 }
899                 else if (ima->aspx < ima->aspy) {
900                         sca_x = ima->aspx / ima->aspy;
901                 }
902         }
903
904         const float scale_x_inv = ima_x * sca_x;
905         const float scale_y_inv = ima_y * sca_y;
906         if (scale_x_inv > scale_y_inv) {
907                 r_image_aspect[0] = 1.0f;
908                 r_image_aspect[1] = scale_y_inv / scale_x_inv;
909         }
910         else {
911                 r_image_aspect[0] = scale_x_inv / scale_y_inv;
912                 r_image_aspect[1] = 1.0f;
913         }
914 }
915
916 static void DRW_shgroup_empty_image(
917         OBJECT_Shaders *sh_data, OBJECT_ShadingGroupList *sgl,
918         Object *ob, const float color[3], RegionView3D *rv3d, eDRW_ShaderSlot shader_slot)
919 {
920         /* TODO: 'StereoViews', see draw_empty_image. */
921
922         if (!BKE_object_empty_image_is_visible_in_view3d(ob, rv3d)) {
923                 return;
924         }
925
926         /* Calling 'BKE_image_get_size' may free the texture. Get the size from 'tex' instead, see: T59347 */
927         int size[2] = {0};
928
929         GPUTexture *tex = NULL;
930
931         if (ob->data != NULL) {
932                 tex = GPU_texture_from_blender(ob->data, ob->iuser, GL_TEXTURE_2D, false, 0.0f);
933                 if (tex) {
934                         size[0] = GPU_texture_width(tex);
935                         size[1] = GPU_texture_height(tex);
936                 }
937         }
938
939         CLAMP_MIN(size[0], 1);
940         CLAMP_MIN(size[1], 1);
941
942         float image_aspect[2];
943         image_calc_aspect(ob->data, size, image_aspect);
944
945         /* OPTI(fclem) We need sorting only for transparent images. If an image as no alpha channel and
946          * ob->col[3] == 1.0f,  we could remove it from the sorting pass. */
947
948         if (tex && (ob->col[3] > 0.0f)) {
949                 DRWShadingGroup *grp = DRW_shgroup_create(sh_data->object_empty_image, sgl->image_empties);
950                 DRW_shgroup_uniform_texture(grp, "image", tex);
951                 /* TODO(fclem) implement DRW_shgroup_uniform_vec2_copy */
952                 DRW_shgroup_uniform_float_copy(grp, "aspectX", image_aspect[0]);
953                 DRW_shgroup_uniform_float_copy(grp, "aspectY", image_aspect[1]);
954                 DRW_shgroup_uniform_int_copy(grp, "depthMode", ob->empty_image_depth);
955                 DRW_shgroup_uniform_float(grp, "size", &ob->empty_drawsize, 1);
956                 DRW_shgroup_uniform_vec2(grp, "offset", ob->ima_ofs, 1);
957                 DRW_shgroup_uniform_vec4(grp, "objectColor", ob->col, 1);
958                 if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
959                         DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
960                 }
961                 DRW_shgroup_call_add(grp, DRW_cache_image_plane_get(), ob->obmat);
962         }
963
964         {
965                 DRWShadingGroup *grp = DRW_shgroup_create(sh_data->object_empty_image_wire, sgl->non_meshes);
966                 /* TODO(fclem) implement DRW_shgroup_uniform_vec2_copy */
967                 DRW_shgroup_uniform_float_copy(grp, "aspectX", image_aspect[0]);
968                 DRW_shgroup_uniform_float_copy(grp, "aspectY", image_aspect[1]);
969                 DRW_shgroup_uniform_int_copy(grp, "depthMode", ob->empty_image_depth);
970                 DRW_shgroup_uniform_float(grp, "size", &ob->empty_drawsize, 1);
971                 DRW_shgroup_uniform_vec2(grp, "offset", ob->ima_ofs, 1);
972                 DRW_shgroup_uniform_vec3(grp, "color", color, 1);
973                 if (shader_slot == DRW_SHADER_SLOT_CLIPPED) {
974                         DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
975                 }
976                 DRW_shgroup_call_add(grp, DRW_cache_image_plane_wire_get(), ob->obmat);
977         }
978 }
979
980 static void OBJECT_cache_init(void *vedata)
981 {
982         const GlobalsUboStorage *gb = &G_draw.block;
983         OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl;
984         OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl;
985         DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
986         OBJECT_PrivateData *g_data;
987         const DRWContextState *draw_ctx = DRW_context_state_get();
988         OBJECT_Shaders *sh_data = &e_data.sh_data[draw_ctx->shader_slot];
989
990         const float outline_width = UI_GetThemeValuef(TH_OUTLINE_WIDTH);
991         const bool do_outline_expand = (U.pixelsize > 1.0) || (outline_width > 2.0f);
992         const bool do_large_expand = ((U.pixelsize > 1.0) && (outline_width > 2.0f)) || (outline_width > 4.0f);
993
994         if (!stl->g_data) {
995                 /* Alloc transient pointers */
996                 stl->g_data = MEM_mallocN(sizeof(*stl->g_data), __func__);
997         }
998
999         g_data = stl->g_data;
1000         g_data->xray_enabled = XRAY_ENABLED(draw_ctx->v3d) && (draw_ctx->v3d->shading.type < OB_MATERIAL);
1001
1002         {
1003                 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_WIRE;
1004                 psl->outlines = DRW_pass_create("Outlines Depth Pass", state);
1005
1006                 GPUShader *sh = sh_data->outline_prepass;
1007
1008                 if (g_data->xray_enabled) {
1009                         sh = sh_data->outline_prepass_wire;
1010                 }
1011
1012                 g_data->outlines_select = shgroup_outline(psl->outlines, &g_data->id_ofs_select, sh, draw_ctx->shader_slot);
1013                 g_data->outlines_select_dupli = shgroup_outline(psl->outlines, &g_data->id_ofs_select_dupli, sh, draw_ctx->shader_slot);
1014                 g_data->outlines_transform = shgroup_outline(psl->outlines, &g_data->id_ofs_transform, sh, draw_ctx->shader_slot);
1015                 g_data->outlines_active = shgroup_outline(psl->outlines, &g_data->id_ofs_active, sh, draw_ctx->shader_slot);
1016
1017                 g_data->id_ofs_select = 0;
1018                 g_data->id_ofs_select_dupli = 0;
1019                 g_data->id_ofs_active = 0;
1020                 g_data->id_ofs_transform = 0;
1021         }
1022
1023         {
1024                 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_POINT;
1025                 DRWPass *pass = psl->lightprobes = DRW_pass_create("Object Probe Pass", state);
1026                 struct GPUBatch *sphere = DRW_cache_sphere_get();
1027                 struct GPUBatch *quad = DRW_cache_quad_get();
1028
1029                 /* Cubemap */
1030                 g_data->lightprobes_cube_select       = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_select);
1031                 g_data->lightprobes_cube_select_dupli = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_select_dupli);
1032                 g_data->lightprobes_cube_active       = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_active);
1033                 g_data->lightprobes_cube_transform    = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_transform);
1034
1035                 /* Planar */
1036                 g_data->lightprobes_planar_select       = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_select);
1037                 g_data->lightprobes_planar_select_dupli = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_select_dupli);
1038                 g_data->lightprobes_planar_active       = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_active);
1039                 g_data->lightprobes_planar_transform    = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_transform);
1040
1041                 g_data->id_ofs_prb_select = 0;
1042                 g_data->id_ofs_prb_select_dupli = 0;
1043                 g_data->id_ofs_prb_active = 0;
1044                 g_data->id_ofs_prb_transform = 0;
1045         }
1046
1047         {
1048                 DRWState state = DRW_STATE_WRITE_COLOR;
1049                 struct GPUBatch *quad = DRW_cache_fullscreen_quad_get();
1050                 /* Don't occlude the "outline" detection pass if in xray mode (too much flickering). */
1051                 float alphaOcclu = (g_data->xray_enabled) ? 1.0f : 0.35f;
1052
1053                 psl->outlines_search = DRW_pass_create("Outlines Detect Pass", state);
1054
1055                 GPUShader *sh = (g_data->xray_enabled) ? sh_data->outline_detect_wire : sh_data->outline_detect;
1056                 DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->outlines_search);
1057                 DRW_shgroup_uniform_texture_ref(grp, "outlineId", &e_data.outlines_id_tx);
1058                 DRW_shgroup_uniform_texture_ref(grp, "outlineDepth", &e_data.outlines_depth_tx);
1059                 DRW_shgroup_uniform_texture_ref(grp, "sceneDepth", &dtxl->depth);
1060                 DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
1061                 DRW_shgroup_uniform_float_copy(grp, "alphaOcclu", alphaOcclu);
1062                 DRW_shgroup_uniform_int(grp, "idOffsets", &stl->g_data->id_ofs_active, 4);
1063                 DRW_shgroup_call_add(grp, quad, NULL);
1064
1065                 /* This is the bleed pass if do_outline_expand is false. */
1066                 GPUShader *fade_sh = (do_large_expand) ? sh_data->outline_fade_large : sh_data->outline_fade;
1067                 psl->outlines_expand = DRW_pass_create("Outlines Expand Pass", state);
1068
1069                 grp = DRW_shgroup_create(fade_sh, psl->outlines_expand);
1070                 DRW_shgroup_uniform_texture_ref(grp, "outlineColor", &e_data.outlines_blur_tx);
1071                 DRW_shgroup_uniform_bool_copy(grp, "doExpand", do_outline_expand);
1072                 DRW_shgroup_call_add(grp, quad, NULL);
1073
1074                 psl->outlines_bleed = DRW_pass_create("Outlines Bleed Pass", state);
1075
1076                 if (do_outline_expand) {
1077                         grp = DRW_shgroup_create(sh_data->outline_fade, psl->outlines_bleed);
1078                         DRW_shgroup_uniform_texture_ref(grp, "outlineColor", &e_data.outlines_color_tx);
1079                         DRW_shgroup_uniform_bool_copy(grp, "doExpand", false);
1080                         DRW_shgroup_call_add(grp, quad, NULL);
1081                 }
1082         }
1083
1084         {
1085                 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND;
1086                 psl->outlines_resolve = DRW_pass_create("Outlines Resolve Pass", state);
1087
1088                 struct GPUBatch *quad = DRW_cache_fullscreen_quad_get();
1089                 GPUTexture **outline_tx = (do_outline_expand) ? &e_data.outlines_blur_tx : &e_data.outlines_color_tx;
1090
1091                 DRWShadingGroup *grp = DRW_shgroup_create(sh_data->outline_resolve_aa, psl->outlines_resolve);
1092                 DRW_shgroup_uniform_texture_ref(grp, "outlineBluredColor", outline_tx);
1093                 DRW_shgroup_uniform_vec2(grp, "rcpDimensions", e_data.inv_viewport_size, 1);
1094                 DRW_shgroup_call_add(grp, quad, NULL);
1095         }
1096
1097         {
1098                 /* Grid pass */
1099                 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND;
1100                 psl->grid = DRW_pass_create("Infinite Grid Pass", state);
1101
1102                 struct GPUBatch *geom = DRW_cache_grid_get();
1103                 float grid_line_size = max_ff(0.0f, U.pixelsize - 1.0f) * 0.5f;
1104                 static float mat[4][4];
1105                 unit_m4(mat);
1106
1107                 /* Create 3 quads to render ordered transparency Z axis */
1108                 DRWShadingGroup *grp = DRW_shgroup_create(sh_data->grid, psl->grid);
1109                 DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zneg_flag, 1);
1110                 DRW_shgroup_uniform_vec3(grp, "planeAxes", e_data.zplane_axes, 1);
1111                 DRW_shgroup_uniform_vec3(grp, "cameraPos", e_data.camera_pos, 1);
1112                 DRW_shgroup_uniform_vec4(grp, "gridSettings", e_data.grid_settings, 1);
1113                 DRW_shgroup_uniform_float_copy(grp, "lineKernel", grid_line_size);
1114                 DRW_shgroup_uniform_float_copy(grp, "meshSize", e_data.grid_mesh_size);
1115                 DRW_shgroup_uniform_float(grp, "gridOneOverLogSubdiv", &e_data.grid_settings[4], 1);
1116                 DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
1117                 DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
1118                 DRW_shgroup_call_add(grp, geom, mat);
1119
1120                 grp = DRW_shgroup_create(sh_data->grid, psl->grid);
1121                 DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.grid_flag, 1);
1122                 DRW_shgroup_uniform_vec3(grp, "planeAxes", e_data.grid_axes, 1);
1123                 DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
1124                 DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
1125                 DRW_shgroup_call_add(grp, geom, mat);
1126
1127                 grp = DRW_shgroup_create(sh_data->grid, psl->grid);
1128                 DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zpos_flag, 1);
1129                 DRW_shgroup_uniform_vec3(grp, "planeAxes", e_data.zplane_axes, 1);
1130                 DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
1131                 DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
1132                 DRW_shgroup_call_add(grp, geom, mat);
1133         }
1134
1135         for (int i = 0; i < 2; ++i) {
1136                 OBJECT_ShadingGroupList *sgl = (i == 1) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
1137
1138                 /* Solid bones */
1139                 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL;
1140                 sgl->bone_solid = psl->bone_solid[i] = DRW_pass_create("Bone Solid Pass", state);
1141                 sgl->bone_outline = psl->bone_outline[i] = DRW_pass_create("Bone Outline Pass", state);
1142
1143                 /* Wire bones */
1144                 state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND;
1145                 sgl->bone_wire = psl->bone_wire[i] = DRW_pass_create("Bone Wire Pass", state);
1146
1147                 /* distance outline around envelope bones */
1148                 state = DRW_STATE_ADDITIVE | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_CULL_FRONT;
1149                 sgl->bone_envelope = psl->bone_envelope[i] = DRW_pass_create("Bone Envelope Outline Pass", state);
1150
1151                 state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_WIRE;
1152                 sgl->bone_axes = psl->bone_axes[i] = DRW_pass_create("Bone Axes Pass", state);
1153         }
1154
1155         for (int i = 0; i < 2; ++i) {
1156                 OBJECT_ShadingGroupList *sgl = (i == 1) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
1157
1158                 /* Non Meshes Pass (Camera, empties, lamps ...) */
1159                 struct GPUBatch *geom;
1160                 struct GPUShader *sh;
1161
1162                 DRWState state =
1163                         DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH |
1164                         DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND | DRW_STATE_POINT | DRW_STATE_WIRE;
1165                 sgl->non_meshes = psl->non_meshes[i] = DRW_pass_create("Non Meshes Pass", state);
1166
1167                 state = DRW_STATE_WRITE_COLOR |
1168                         DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND | DRW_STATE_WIRE;
1169                 sgl->image_empties = psl->image_empties[i] = DRW_pass_create("Image Empties", state);
1170
1171                 /* Empties */
1172                 geom = DRW_cache_plain_axes_get();
1173                 sgl->plain_axes = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1174
1175                 geom = DRW_cache_empty_cube_get();
1176                 sgl->cube = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1177
1178                 geom = DRW_cache_circle_get();
1179                 sgl->circle = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1180
1181                 geom = DRW_cache_empty_sphere_get();
1182                 sgl->sphere = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1183
1184                 geom = DRW_cache_sphere_get();
1185                 sgl->sphere_solid = shgroup_instance_solid(sgl->non_meshes, geom);
1186
1187                 geom = DRW_cache_empty_cylinder_get();
1188                 sgl->cylinder = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1189
1190                 geom = DRW_cache_empty_capsule_cap_get();
1191                 sgl->capsule_cap = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1192
1193                 geom = DRW_cache_empty_capsule_body_get();
1194                 sgl->capsule_body = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1195
1196                 geom = DRW_cache_empty_cone_get();
1197                 sgl->cone = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1198
1199                 geom = DRW_cache_single_arrow_get();
1200                 sgl->single_arrow = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1201
1202                 geom = DRW_cache_single_line_get();
1203                 sgl->single_arrow_line = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1204
1205                 geom = DRW_cache_bone_arrows_get();
1206                 sgl->empty_axes = shgroup_instance_empty_axes(sgl->non_meshes, geom, draw_ctx->shader_slot);
1207
1208                 /* Force Field */
1209                 geom = DRW_cache_field_wind_get();
1210                 sgl->field_wind = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->shader_slot);
1211
1212                 geom = DRW_cache_field_force_get();
1213                 sgl->field_force = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->shader_slot);
1214
1215                 geom = DRW_cache_field_vortex_get();
1216                 sgl->field_vortex = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->shader_slot);
1217
1218                 geom = DRW_cache_screenspace_circle_get();
1219                 sgl->field_curve_sta = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->shader_slot);
1220
1221                 /* Grease Pencil */
1222                 geom = DRW_cache_gpencil_axes_get();
1223                 sgl->gpencil_axes = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1224
1225                 /* Speaker */
1226                 geom = DRW_cache_speaker_get();
1227                 sgl->speaker = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1228
1229                 /* Probe */
1230                 static float probeSize = 14.0f;
1231                 geom = DRW_cache_lightprobe_cube_get();
1232                 sgl->probe_cube = shgroup_instance_screenspace(sgl->non_meshes, geom, &probeSize, draw_ctx->shader_slot);
1233
1234                 geom = DRW_cache_lightprobe_grid_get();
1235                 sgl->probe_grid = shgroup_instance_screenspace(sgl->non_meshes, geom, &probeSize, draw_ctx->shader_slot);
1236
1237                 static float probePlanarSize = 20.0f;
1238                 geom = DRW_cache_lightprobe_planar_get();
1239                 sgl->probe_planar = shgroup_instance_screenspace(sgl->non_meshes, geom, &probePlanarSize, draw_ctx->shader_slot);
1240
1241                 /* Camera */
1242                 geom = DRW_cache_camera_get();
1243                 sgl->camera = shgroup_camera_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1244
1245                 geom = DRW_cache_camera_frame_get();
1246                 sgl->camera_frame = shgroup_camera_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1247
1248                 geom = DRW_cache_camera_tria_get();
1249                 sgl->camera_tria = shgroup_camera_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1250
1251                 geom = DRW_cache_plain_axes_get();
1252                 sgl->camera_focus = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1253
1254                 geom = DRW_cache_single_line_get();
1255                 sgl->camera_clip = shgroup_distance_lines_instance(sgl->non_meshes, geom);
1256                 sgl->camera_mist = shgroup_distance_lines_instance(sgl->non_meshes, geom);
1257
1258                 geom = DRW_cache_single_line_endpoints_get();
1259                 sgl->camera_clip_points = shgroup_distance_lines_instance(sgl->non_meshes, geom);
1260                 sgl->camera_mist_points = shgroup_distance_lines_instance(sgl->non_meshes, geom);
1261
1262                 geom = DRW_cache_quad_get();
1263                 sgl->camera_stereo_plane = shgroup_instance_alpha(sgl->non_meshes, geom, draw_ctx->shader_slot);
1264
1265                 geom = DRW_cache_cube_get();
1266                 sgl->camera_stereo_volume = shgroup_instance_alpha(sgl->non_meshes, geom, draw_ctx->shader_slot);
1267
1268                 geom = DRW_cache_empty_cube_get();
1269                 sgl->camera_stereo_volume_wires = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1270
1271                 BLI_listbase_clear(&sgl->camera_path);
1272
1273                 /* Texture Space */
1274                 geom = DRW_cache_empty_cube_get();
1275                 sgl->texspace = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1276
1277                 /* Wires (for loose edges) */
1278                 sh = DRW_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR, draw_ctx->shader_slot);
1279                 sgl->wire = shgroup_wire(sgl->non_meshes, gb->colorWire, sh, draw_ctx->shader_slot);
1280                 sgl->wire_select = shgroup_wire(sgl->non_meshes, gb->colorSelect, sh, draw_ctx->shader_slot);
1281                 sgl->wire_transform = shgroup_wire(sgl->non_meshes, gb->colorTransform, sh, draw_ctx->shader_slot);
1282                 sgl->wire_active = shgroup_wire(sgl->non_meshes, gb->colorActive, sh, draw_ctx->shader_slot);
1283                 /* Wire (duplicator) */
1284                 sgl->wire_dupli = shgroup_wire(sgl->non_meshes, gb->colorDupli, sh, draw_ctx->shader_slot);
1285                 sgl->wire_dupli_select = shgroup_wire(sgl->non_meshes, gb->colorDupliSelect, sh, draw_ctx->shader_slot);
1286
1287                 /* Points (loose points) */
1288                 sh = sh_data->loose_points;
1289                 sgl->points = shgroup_points(sgl->non_meshes, gb->colorWire, sh, draw_ctx->shader_slot);
1290                 sgl->points_select = shgroup_points(sgl->non_meshes, gb->colorSelect, sh, draw_ctx->shader_slot);
1291                 sgl->points_transform = shgroup_points(sgl->non_meshes, gb->colorTransform, sh, draw_ctx->shader_slot);
1292                 sgl->points_active = shgroup_points(sgl->non_meshes, gb->colorActive, sh, draw_ctx->shader_slot);
1293                 /* Points (duplicator) */
1294                 sgl->points_dupli = shgroup_points(sgl->non_meshes, gb->colorDupli, sh, draw_ctx->shader_slot);
1295                 sgl->points_dupli_select = shgroup_points(sgl->non_meshes, gb->colorDupliSelect, sh, draw_ctx->shader_slot);
1296                 DRW_shgroup_state_disable(sgl->points, DRW_STATE_BLEND);
1297                 DRW_shgroup_state_disable(sgl->points_select, DRW_STATE_BLEND);
1298                 DRW_shgroup_state_disable(sgl->points_transform, DRW_STATE_BLEND);
1299                 DRW_shgroup_state_disable(sgl->points_active, DRW_STATE_BLEND);
1300                 DRW_shgroup_state_disable(sgl->points_dupli, DRW_STATE_BLEND);
1301                 DRW_shgroup_state_disable(sgl->points_dupli_select, DRW_STATE_BLEND);
1302
1303                 /* Metaballs Handles */
1304                 sgl->mball_handle = shgroup_instance_mball_handles(sgl->non_meshes);
1305
1306                 /* Lamps */
1307                 /* TODO
1308                  * for now we create multiple times the same VBO with only lamp center coordinates
1309                  * but ideally we would only create it once */
1310
1311                 /* start with buflimit because we don't want stipples */
1312                 geom = DRW_cache_single_line_get();
1313                 sgl->lamp_buflimit = shgroup_distance_lines_instance(sgl->non_meshes, geom);
1314
1315                 sgl->lamp_center = shgroup_dynpoints_uniform_color(sgl->non_meshes, gb->colorLampNoAlpha, &gb->sizeLampCenter, draw_ctx->shader_slot);
1316
1317                 geom = DRW_cache_lamp_get();
1318                 sgl->lamp_circle = shgroup_instance_screenspace(sgl->non_meshes, geom, &gb->sizeLampCircle, draw_ctx->shader_slot);
1319                 geom = DRW_cache_lamp_shadows_get();
1320                 sgl->lamp_circle_shadow = shgroup_instance_screenspace(sgl->non_meshes, geom, &gb->sizeLampCircleShadow, draw_ctx->shader_slot);
1321
1322                 geom = DRW_cache_lamp_sunrays_get();
1323                 sgl->lamp_sunrays = shgroup_instance_screenspace(sgl->non_meshes, geom, &gb->sizeLampCircle, draw_ctx->shader_slot);
1324
1325                 sgl->lamp_groundline = shgroup_groundlines_uniform_color(sgl->non_meshes, gb->colorLamp);
1326                 sgl->lamp_groundpoint = shgroup_groundpoints_uniform_color(sgl->non_meshes, gb->colorLamp);
1327
1328                 geom = DRW_cache_screenspace_circle_get();
1329                 sgl->lamp_area_sphere = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->shader_slot);
1330
1331                 geom = DRW_cache_lamp_area_square_get();
1332                 sgl->lamp_area_square = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1333
1334                 geom = DRW_cache_lamp_area_disk_get();
1335                 sgl->lamp_area_disk = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1336
1337                 geom = DRW_cache_lamp_hemi_get();
1338                 sgl->lamp_hemi = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1339
1340                 geom = DRW_cache_single_line_get();
1341                 sgl->lamp_distance = shgroup_distance_lines_instance(sgl->non_meshes, geom);
1342
1343                 geom = DRW_cache_single_line_endpoints_get();
1344                 sgl->lamp_buflimit_points = shgroup_distance_lines_instance(sgl->non_meshes, geom);
1345
1346                 geom = DRW_cache_lamp_spot_get();
1347                 sgl->lamp_spot_cone = shgroup_spot_instance(sgl->non_meshes, geom);
1348
1349                 geom = DRW_cache_circle_get();
1350                 sgl->lamp_spot_blend = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1351
1352                 geom = DRW_cache_lamp_spot_square_get();
1353                 sgl->lamp_spot_pyramid = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1354
1355                 geom = DRW_cache_square_get();
1356                 sgl->lamp_spot_blend_rect = shgroup_instance(sgl->non_meshes, geom, draw_ctx->shader_slot);
1357
1358                 /* -------- STIPPLES ------- */
1359
1360                 /* Relationship Lines */
1361                 sgl->relationship_lines = shgroup_dynlines_dashed_uniform_color(sgl->non_meshes, gb->colorWire);
1362                 sgl->constraint_lines = shgroup_dynlines_dashed_uniform_color(sgl->non_meshes, gb->colorGridAxisZ);
1363
1364                 /* Force Field Curve Guide End (here because of stipple) */
1365                 /* TODO port to shader stipple */
1366                 geom = DRW_cache_screenspace_circle_get();
1367                 sgl->field_curve_end = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->shader_slot);
1368
1369                 /* Force Field Limits */
1370                 /* TODO port to shader stipple */
1371                 geom = DRW_cache_field_tube_limit_get();
1372                 sgl->field_tube_limit = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->shader_slot);
1373
1374                 /* TODO port to shader stipple */
1375                 geom = DRW_cache_field_cone_limit_get();
1376                 sgl->field_cone_limit = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->shader_slot);
1377
1378                 /* Spot shapes */
1379                 state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND | DRW_STATE_CULL_FRONT;
1380                 sgl->spot_shapes = psl->spot_shapes[i] = DRW_pass_create("Spot Shape Pass", state);
1381
1382                 geom = DRW_cache_lamp_spot_volume_get();
1383                 sgl->lamp_spot_volume = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->shader_slot);
1384
1385                 geom = DRW_cache_lamp_spot_square_volume_get();
1386                 sgl->lamp_spot_volume_rect = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->shader_slot);
1387
1388                 geom = DRW_cache_lamp_spot_volume_get();
1389                 sgl->lamp_spot_volume_outside = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->shader_slot);
1390                 DRW_shgroup_state_disable(sgl->lamp_spot_volume_outside, DRW_STATE_CULL_FRONT);
1391                 DRW_shgroup_state_enable(sgl->lamp_spot_volume_outside, DRW_STATE_CULL_BACK);
1392
1393                 geom = DRW_cache_lamp_spot_square_volume_get();
1394                 sgl->lamp_spot_volume_rect_outside = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->shader_slot);
1395                 DRW_shgroup_state_disable(sgl->lamp_spot_volume_rect_outside, DRW_STATE_CULL_FRONT);
1396                 DRW_shgroup_state_enable(sgl->lamp_spot_volume_rect_outside, DRW_STATE_CULL_BACK);
1397         }
1398
1399         {
1400                 /* Object Center pass grouped by State */
1401                 DRWShadingGroup *grp;
1402                 static float outlineWidth, size;
1403
1404                 DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND | DRW_STATE_POINT;
1405                 psl->ob_center = DRW_pass_create("Obj Center Pass", state);
1406
1407                 outlineWidth = 1.0f * U.pixelsize;
1408                 size = U.obcenter_dia * U.pixelsize + outlineWidth;
1409
1410                 GPUShader *sh = DRW_shader_get_builtin_shader(
1411                         GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA, draw_ctx->shader_slot);
1412
1413                 /* Active */
1414                 grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
1415                 DRW_shgroup_uniform_float(grp, "size", &size, 1);
1416                 DRW_shgroup_uniform_float(grp, "outlineWidth", &outlineWidth, 1);
1417                 DRW_shgroup_uniform_vec4(grp, "color", gb->colorActive, 1);
1418                 DRW_shgroup_uniform_vec4(grp, "outlineColor", gb->colorOutline, 1);
1419                 if (draw_ctx->shader_slot == DRW_SHADER_SLOT_CLIPPED) {
1420                         DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
1421                 }
1422                 stl->g_data->center_active = grp;
1423
1424                 /* Select */
1425                 grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
1426                 DRW_shgroup_uniform_vec4(grp, "color", gb->colorSelect, 1);
1427                 if (draw_ctx->shader_slot == DRW_SHADER_SLOT_CLIPPED) {
1428                         DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
1429                 }
1430                 stl->g_data->center_selected = grp;
1431
1432                 /* Deselect */
1433                 grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
1434                 DRW_shgroup_uniform_vec4(grp, "color", gb->colorDeselect, 1);
1435                 if (draw_ctx->shader_slot == DRW_SHADER_SLOT_CLIPPED) {
1436                         DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
1437                 }
1438                 stl->g_data->center_deselected = grp;
1439
1440                 /* Select (library) */
1441                 grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
1442                 DRW_shgroup_uniform_vec4(grp, "color", gb->colorLibrarySelect, 1);
1443                 if (draw_ctx->shader_slot == DRW_SHADER_SLOT_CLIPPED) {
1444                         DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
1445                 }
1446                 stl->g_data->center_selected_lib = grp;
1447
1448                 /* Deselect (library) */
1449                 grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
1450                 DRW_shgroup_uniform_vec4(grp, "color", gb->colorLibrary, 1);
1451                 if (draw_ctx->shader_slot == DRW_SHADER_SLOT_CLIPPED) {
1452                         DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
1453                 }
1454                 stl->g_data->center_deselected_lib = grp;
1455         }
1456
1457         {
1458                 /* Particle Pass */
1459                 psl->particle = DRW_pass_create(
1460                         "Particle Pass",
1461                         DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL |
1462                         DRW_STATE_POINT | DRW_STATE_BLEND);
1463         }
1464 }
1465
1466 static void DRW_shgroup_mball_handles(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
1467 {
1468         MetaBall *mb = ob->data;
1469
1470         float *color;
1471         DRW_object_wire_theme_get(ob, view_layer, &color);
1472
1473         float draw_scale_xform[3][4]; /* Matrix of Scale and Translation */
1474         {
1475                 float scamat[3][3];
1476                 copy_m3_m4(scamat, ob->obmat);
1477                 /* Get the normalized inverse matrix to extract only
1478                  * the scale of Scamat */
1479                 float iscamat[3][3];
1480                 invert_m3_m3(iscamat, scamat);
1481                 normalize_m3(iscamat);
1482                 mul_m3_m3_post(scamat, iscamat);
1483
1484                 copy_v3_v3(draw_scale_xform[0], scamat[0]);
1485                 copy_v3_v3(draw_scale_xform[1], scamat[1]);
1486                 copy_v3_v3(draw_scale_xform[2], scamat[2]);
1487         }
1488
1489         for (MetaElem *ml = mb->elems.first; ml != NULL; ml = ml->next) {
1490                 /* draw radius */
1491                 float world_pos[3];
1492                 mul_v3_m4v3(world_pos, ob->obmat, &ml->x);
1493                 draw_scale_xform[0][3] = world_pos[0];
1494                 draw_scale_xform[1][3] = world_pos[1];
1495                 draw_scale_xform[2][3] = world_pos[2];
1496
1497                 DRW_shgroup_call_dynamic_add(sgl->mball_handle, draw_scale_xform, &ml->rad, color);
1498         }
1499 }
1500
1501 static void DRW_shgroup_lamp(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
1502 {
1503         Lamp *la = ob->data;
1504         float *color;
1505         int theme_id = DRW_object_wire_theme_get(ob, view_layer, &color);
1506         static float zero = 0.0f;
1507
1508         typedef struct LampEngineData {
1509                 DrawData dd;
1510                 float shape_mat[4][4];
1511                 float spot_blend_mat[4][4];
1512         } LampEngineData;
1513
1514         LampEngineData *lamp_engine_data =
1515                 (LampEngineData *)DRW_drawdata_ensure(
1516                         &ob->id,
1517                         &draw_engine_object_type,
1518                         sizeof(LampEngineData),
1519                         NULL,
1520                         NULL);
1521
1522         float (*shapemat)[4] = lamp_engine_data->shape_mat;
1523         float (*spotblendmat)[4] = lamp_engine_data->spot_blend_mat;
1524
1525         if ((ob->base_flag & (BASE_FROM_SET | BASE_FROM_DUPLI)) == 0) {
1526                 /* Don't draw the center if it's selected or active */
1527                 if (theme_id == TH_LAMP) {
1528                         DRW_shgroup_call_dynamic_add(sgl->lamp_center, ob->obmat[3]);
1529                 }
1530         }
1531
1532         /* First circle */
1533         DRW_shgroup_call_dynamic_add(sgl->lamp_circle, ob->obmat[3], color);
1534
1535         /* draw dashed outer circle for shadow */
1536         DRW_shgroup_call_dynamic_add(sgl->lamp_circle_shadow, ob->obmat[3], color);
1537
1538         /* Distance */
1539         if (ELEM(la->type, LA_SUN, LA_AREA)) {
1540                 DRW_shgroup_call_dynamic_add(sgl->lamp_distance, color, &zero, &la->dist, ob->obmat);
1541         }
1542
1543         copy_m4_m4(shapemat, ob->obmat);
1544
1545         if (la->type == LA_SUN) {
1546                 DRW_shgroup_call_dynamic_add(sgl->lamp_sunrays, ob->obmat[3], color);
1547         }
1548         else if (la->type == LA_SPOT) {
1549                 float size[3], sizemat[4][4];
1550                 static float one = 1.0f;
1551                 float cone_inside[4] = {0.0f, 0.0f, 0.0f, 0.5f};
1552                 float cone_outside[4] = {1.0f, 1.0f, 1.0f, 0.3f};
1553                 float blend = 1.0f - pow2f(la->spotblend);
1554                 size[0] = size[1] = sinf(la->spotsize * 0.5f) * la->dist;
1555                 size[2] = cosf(la->spotsize * 0.5f) * la->dist;
1556
1557                 size_to_mat4(sizemat, size);
1558                 mul_m4_m4m4(shapemat, ob->obmat, sizemat);
1559
1560                 size[0] = size[1] = blend; size[2] = 1.0f;
1561                 size_to_mat4(sizemat, size);
1562                 translate_m4(sizemat, 0.0f, 0.0f, -1.0f);
1563                 rotate_m4(sizemat, 'X', (float)(M_PI / 2));
1564                 mul_m4_m4m4(spotblendmat, shapemat, sizemat);
1565
1566                 if (la->mode & LA_SQUARE) {
1567                         DRW_shgroup_call_dynamic_add(sgl->lamp_spot_pyramid, color, &one, shapemat);
1568
1569                         /* hide line if it is zero size or overlaps with outer border,
1570                          * previously it adjusted to always to show it but that seems
1571                          * confusing because it doesn't show the actual blend size */
1572                         if (blend != 0.0f && blend != 1.0f) {
1573                                 DRW_shgroup_call_dynamic_add(sgl->lamp_spot_blend_rect, color, &one, spotblendmat);
1574                         }
1575
1576                         if (la->mode & LA_SHOW_CONE) {
1577
1578                                 DRW_shgroup_call_dynamic_add(sgl->lamp_spot_volume_rect, cone_inside, &one, shapemat);
1579                                 DRW_shgroup_call_dynamic_add(sgl->lamp_spot_volume_rect_outside, cone_outside, &one, shapemat);
1580                         }
1581                 }
1582                 else {
1583                         DRW_shgroup_call_dynamic_add(sgl->lamp_spot_cone, color, shapemat);
1584
1585                         /* hide line if it is zero size or overlaps with outer border,
1586                          * previously it adjusted to always to show it but that seems
1587                          * confusing because it doesn't show the actual blend size */
1588                         if (blend != 0.0f && blend != 1.0f) {
1589                                 DRW_shgroup_call_dynamic_add(sgl->lamp_spot_blend, color, &one, spotblendmat);
1590                         }
1591
1592                         if (la->mode & LA_SHOW_CONE) {
1593                                 DRW_shgroup_call_dynamic_add(sgl->lamp_spot_volume, cone_inside, &one, shapemat);
1594                                 DRW_shgroup_call_dynamic_add(sgl->lamp_spot_volume_outside, cone_outside, &one, shapemat);
1595                         }
1596                 }
1597
1598                 DRW_shgroup_call_dynamic_add(sgl->lamp_buflimit, color, &la->clipsta, &la->clipend, ob->obmat);
1599                 DRW_shgroup_call_dynamic_add(sgl->lamp_buflimit_points, color, &la->clipsta, &la->clipend, ob->obmat);
1600         }
1601         else if (la->type == LA_AREA) {
1602                 float size[3] = {1.0f, 1.0f, 1.0f}, sizemat[4][4];
1603
1604                 if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_ELLIPSE)) {
1605                         size[1] = la->area_sizey / la->area_size;
1606                         size_to_mat4(sizemat, size);
1607                         mul_m4_m4m4(shapemat, shapemat, sizemat);
1608                 }
1609
1610                 if (ELEM(la->area_shape, LA_AREA_DISK, LA_AREA_ELLIPSE)) {
1611                         DRW_shgroup_call_dynamic_add(sgl->lamp_area_disk, color, &la->area_size, shapemat);
1612                 }
1613                 else {
1614                         DRW_shgroup_call_dynamic_add(sgl->lamp_area_square, color, &la->area_size, shapemat);
1615                 }
1616         }
1617
1618         if (ELEM(la->type, LA_LOCAL, LA_SPOT)) {
1619                 /* We only want position not scale. */
1620                 shapemat[0][0] = shapemat[1][1] = shapemat[2][2] = 1.0f;
1621                 shapemat[0][1] = shapemat[0][2] = 0.0f;
1622                 shapemat[1][0] = shapemat[1][2] = 0.0f;
1623                 shapemat[2][0] = shapemat[2][1] = 0.0f;
1624                 DRW_shgroup_call_dynamic_add(sgl->lamp_area_sphere, color, &la->area_size, shapemat);
1625         }
1626
1627         /* Line and point going to the ground */
1628         DRW_shgroup_call_dynamic_add(sgl->lamp_groundline, ob->obmat[3]);
1629         DRW_shgroup_call_dynamic_add(sgl->lamp_groundpoint, ob->obmat[3]);
1630 }
1631
1632 static GPUBatch *batch_camera_path_get(
1633         ListBase *camera_paths, const MovieTrackingReconstruction *reconstruction)
1634 {
1635         GPUBatch *geom;
1636         static GPUVertFormat format = { 0 };
1637         static struct { uint pos; } attr_id;
1638         if (format.attr_len == 0) {
1639                 attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
1640         }
1641         GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
1642         GPU_vertbuf_data_alloc(vbo, reconstruction->camnr);
1643
1644         MovieReconstructedCamera *camera = reconstruction->cameras;
1645         for (int a = 0; a < reconstruction->camnr; a++, camera++) {
1646                 GPU_vertbuf_attr_set(vbo, attr_id.pos, a, camera->mat[3]);
1647         }
1648
1649         geom = GPU_batch_create_ex(GPU_PRIM_LINE_STRIP, vbo, NULL, GPU_BATCH_OWNS_VBO);
1650
1651         /* Store the batch to do cleanup after drawing. */
1652         BLI_addtail(camera_paths, BLI_genericNodeN(geom));
1653         return geom;
1654 }
1655
1656 static void batch_camera_path_free(ListBase *camera_paths)
1657 {
1658         LinkData *link;
1659         while ((link = BLI_pophead(camera_paths))) {
1660                 GPUBatch *camera_path = link->data;
1661                 GPU_batch_discard(camera_path);
1662                 MEM_freeN(link);
1663         }
1664 }
1665
1666 static bool camera_view3d_is_stereo3d(Scene *scene, View3D *v3d)
1667 {
1668         return (scene->r.scemode & R_MULTIVIEW) != 0 &&
1669                (v3d->stereo3d_flag);
1670 }
1671
1672 static void camera_stereo3d(
1673         OBJECT_ShadingGroupList *sgl,
1674         Scene *scene, ViewLayer *view_layer, View3D *v3d,
1675         Object *ob, Camera *cam,
1676         const float vec[4][3], float drawsize, const float scale[3])
1677 {
1678         const bool is_select = DRW_state_is_select();
1679         static float drwtria_dummy[2][2][2] = {{{0}}};
1680         const float fac = (cam->stereo.pivot == CAM_S3D_PIVOT_CENTER) ? 2.0f : 1.0f;
1681         float origin[2][3] = {{0}};
1682         const char *viewnames[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
1683
1684         const bool is_stereo3d_cameras = (v3d->stereo3d_flag & V3D_S3D_DISPCAMERAS) && (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D);
1685         const bool is_stereo3d_plane = (v3d->stereo3d_flag & V3D_S3D_DISPPLANE) && (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D);
1686         const bool is_stereo3d_volume = (v3d->stereo3d_flag & V3D_S3D_DISPVOLUME);
1687
1688         float *color;
1689         DRW_object_wire_theme_get(ob, view_layer, &color);
1690
1691         for (int eye = 0; eye < 2; eye++) {
1692                 float obmat[4][4];
1693                 ob = BKE_camera_multiview_render(scene, ob, viewnames[eye]);
1694
1695                 BKE_camera_multiview_model_matrix_scaled(&scene->r, ob, viewnames[eye], obmat);
1696
1697                 copy_v2_v2(cam->drwcorners[eye][0], vec[0]);
1698                 copy_v2_v2(cam->drwcorners[eye][1], vec[1]);
1699                 copy_v2_v2(cam->drwcorners[eye][2], vec[2]);
1700                 copy_v2_v2(cam->drwcorners[eye][3], vec[3]);
1701
1702                 cam->drwdepth[eye] = vec[0][2];
1703
1704                 if (cam->stereo.convergence_mode == CAM_S3D_OFFAXIS) {
1705                         const float shift_x =
1706                                 ((BKE_camera_multiview_shift_x(&scene->r, ob, viewnames[eye]) - cam->shiftx) *
1707                                 (drawsize * scale[0] * fac));
1708
1709                         for (int i = 0; i < 4; i++) {
1710                                 cam->drwcorners[eye][i][0] += shift_x;
1711                         }
1712                 }
1713
1714                 /* Dummy triangle, draw on top of existent lines so it is invisible. */
1715                 copy_v2_v2(drwtria_dummy[eye][0], cam->drwcorners[eye][0]);
1716                 copy_v2_v2(drwtria_dummy[eye][1], cam->drwcorners[eye][0]);
1717
1718                 if (is_stereo3d_cameras) {
1719                         DRW_shgroup_call_dynamic_add(
1720                                 sgl->camera_frame, color, cam->drwcorners[eye],
1721                                 &cam->drwdepth[eye], cam->drwtria, obmat);
1722
1723                         DRW_shgroup_call_dynamic_add(
1724                                 sgl->camera, color, cam->drwcorners[eye],
1725                                 &cam->drwdepth[eye], drwtria_dummy[eye], obmat);
1726                 }
1727
1728                 /* Connecting line. */
1729                 mul_m4_v3(obmat, origin[eye]);
1730         }
1731
1732         /* Draw connecting lines. */
1733         if (is_stereo3d_cameras) {
1734                 DRW_shgroup_call_dynamic_add(sgl->relationship_lines, origin[0]);
1735                 DRW_shgroup_call_dynamic_add(sgl->relationship_lines, origin[1]);
1736         }
1737
1738         /* Draw convergence plane. */
1739         if (is_stereo3d_plane && !is_select) {
1740                 static float convergence_distance_neg;
1741                 float axis_center[3];
1742                 float convergence_plane[4][2];
1743                 float offset;
1744
1745                 mid_v3_v3v3(axis_center, origin[0], origin[1]);
1746
1747                 for (int i = 0; i < 4; i++) {
1748                         mid_v2_v2v2(convergence_plane[i], cam->drwcorners[0][i], cam->drwcorners[1][i]);
1749                 }
1750
1751                 offset = cam->stereo.convergence_distance / cam->drwdepth[0];
1752
1753                 for (int i = 0; i < 4; i++) {
1754                         convergence_plane[i][0] -= 2.0f * cam->shiftx;
1755                         convergence_plane[i][1] -= 2.0f * cam->shifty;
1756                         mul_v2_fl(convergence_plane[i], offset);
1757                 }
1758
1759                 convergence_distance_neg = -cam->stereo.convergence_distance;
1760                 DRW_shgroup_call_dynamic_add(
1761                         sgl->camera_frame, color, convergence_plane,
1762                         &convergence_distance_neg, cam->drwtria, cam->drwnormalmat);
1763
1764                 if (v3d->stereo3d_convergence_alpha > 0.0f) {
1765                         /* We are using a -1,1 quad for this shading group, so we need to
1766                          * scale and transform it to match the convergence plane border. */
1767                         static float one = 1.0f;
1768                         float plane_mat[4][4], scale_mat[4][4];
1769                         float scale_factor[3] = {1.0f, 1.0f, 1.0f};
1770                         float color_plane[4] = {0.0f, 0.0f, 0.0f, v3d->stereo3d_convergence_alpha};
1771
1772                         const float height = convergence_plane[1][1] - convergence_plane[0][1];
1773                         const float width = convergence_plane[2][0] - convergence_plane[0][0];
1774
1775                         scale_factor[0] = width * 0.5f;
1776                         scale_factor[1] = height * 0.5f;
1777
1778                         copy_m4_m4(plane_mat, cam->drwnormalmat);
1779                         translate_m4(plane_mat, 0.0f, 0.0f, -cam->stereo.convergence_distance);
1780                         size_to_mat4(scale_mat, scale_factor);
1781                         mul_m4_m4_post(plane_mat, scale_mat);
1782
1783                         DRW_shgroup_call_dynamic_add(sgl->camera_stereo_plane, color_plane, &one, plane_mat);
1784                 }
1785         }
1786
1787         /* Draw convergence volume. */
1788         if (is_stereo3d_volume && !is_select) {
1789                 static float one = 1.0f;
1790                 float color_volume[3][4] = {{0.0f, 1.0f, 1.0f, v3d->stereo3d_volume_alpha},
1791                                             {1.0f, 0.0f, 0.0f, v3d->stereo3d_volume_alpha},
1792                                             {0.0f, 0.0f, 0.0f, 0.0f}};
1793
1794                 for (int eye = 0; eye < 2; eye++) {
1795                         float winmat[4][4], viewinv[4][4], viewmat[4][4], persmat[4][4], persinv[4][4];
1796                         ob = BKE_camera_multiview_render(scene, ob, viewnames[eye]);
1797
1798                         BKE_camera_multiview_window_matrix(&scene->r, ob, viewnames[eye], winmat);
1799                         BKE_camera_multiview_model_matrix(&scene->r, ob, viewnames[eye], viewinv);
1800
1801                         invert_m4_m4(viewmat, viewinv);
1802                         mul_m4_m4m4(persmat, winmat, viewmat);
1803                         invert_m4_m4(persinv, persmat);
1804
1805                         DRW_shgroup_call_dynamic_add(sgl->camera_stereo_volume, color_volume[eye], &one, persinv);
1806                         DRW_shgroup_call_dynamic_add(sgl->camera_stereo_volume_wires, color_volume[2], &one, persinv);
1807                 }
1808         }
1809 }
1810
1811 static void DRW_shgroup_camera(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
1812 {
1813         const DRWContextState *draw_ctx = DRW_context_state_get();
1814         View3D *v3d = draw_ctx->v3d;
1815         Scene *scene = draw_ctx->scene;
1816         RegionView3D *rv3d = draw_ctx->rv3d;
1817
1818         Camera *cam = ob->data;
1819         const  Object *camera_object = DEG_get_evaluated_object(draw_ctx->depsgraph, v3d->camera);
1820         const bool is_select = DRW_state_is_select();
1821         const bool is_active = (ob == camera_object);
1822         const bool look_through = (is_active && (rv3d->persp == RV3D_CAMOB));
1823         const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
1824         const bool is_stereo3d = is_active && camera_view3d_is_stereo3d(scene, v3d);
1825         const bool is_stereo3d_view = (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D);
1826         const bool is_stereo3d_cameras = (ob == scene->camera) &&
1827                                          is_multiview &&
1828                                          is_stereo3d_view &&
1829                                          (v3d->stereo3d_flag & V3D_S3D_DISPCAMERAS);
1830         const bool is_selection_camera_stereo = is_select &&
1831                                                 look_through && is_multiview &&
1832                                                 is_stereo3d_view;
1833
1834         float *color;
1835         DRW_object_wire_theme_get(ob, view_layer, &color);
1836
1837         float vec[4][3], asp[2], shift[2], scale[3], drawsize;
1838
1839         /* BKE_camera_multiview_model_matrix already accounts for scale, don't do it here. */
1840         if (is_selection_camera_stereo) {
1841                 scale[0] = 1.0f;
1842                 scale[1] = 1.0f;
1843                 scale[2] = 1.0f;
1844         }
1845         else {
1846                 scale[0] = 1.0f / len_v3(ob->obmat[0]);
1847                 scale[1] = 1.0f / len_v3(ob->obmat[1]);
1848                 scale[2] = 1.0f / len_v3(ob->obmat[2]);
1849         }
1850
1851         BKE_camera_view_frame_ex(scene, cam, cam->drawsize, false, scale,
1852                                  asp, shift, &drawsize, vec);
1853
1854         /* Frame coords */
1855         copy_v2_v2(cam->drwcorners[0][0], vec[0]);
1856         copy_v2_v2(cam->drwcorners[0][1], vec[1]);
1857         copy_v2_v2(cam->drwcorners[0][2], vec[2]);
1858         copy_v2_v2(cam->drwcorners[0][3], vec[3]);
1859
1860         /* depth */
1861         cam->drwdepth[0] = vec[0][2];
1862
1863         /* tria */
1864         cam->drwtria[0][0] = shift[0] + ((0.7f * drawsize) * scale[0]);
1865         cam->drwtria[0][1] = shift[1] + ((drawsize * (asp[1] + 0.1f)) * scale[1]);
1866         cam->drwtria[1][0] = shift[0];
1867         cam->drwtria[1][1] = shift[1] + ((1.1f * drawsize * (asp[1] + 0.7f)) * scale[1]);
1868
1869         if (look_through && !is_stereo3d_cameras) {
1870                 /* Only draw the frame. */
1871                 float mat[4][4];
1872                 if (is_selection_camera_stereo) {
1873                         /* Make sure selection uses the same matrix for camera as the one used while viewing. */
1874                         const bool is_left = v3d->multiview_eye == STEREO_LEFT_ID;
1875                         BKE_camera_multiview_model_matrix(&scene->r, ob, is_left ? STEREO_LEFT_NAME : STEREO_RIGHT_NAME, mat);
1876                 }
1877                 else {
1878                         copy_m4_m4(mat, ob->obmat);
1879                 }
1880
1881                 /* TODO (dfelinto): Disabling this for now since it is extremely wrong.
1882                  * Besides selection and multiview still works bad even on its finest day. */
1883                 if (!is_multiview) {
1884                         DRW_shgroup_call_dynamic_add(
1885                                 sgl->camera_frame, color, cam->drwcorners[0],
1886                                 &cam->drwdepth[0], cam->drwtria, mat);
1887                 }
1888         }
1889         else if (!look_through) {
1890                 if (!is_stereo3d_cameras) {
1891                         DRW_shgroup_call_dynamic_add(
1892                                 sgl->camera, color, cam->drwcorners[0],
1893                                 &cam->drwdepth[0], cam->drwtria, ob->obmat);
1894                 }
1895
1896                 /* Active cam */
1897                 if (is_active) {
1898                         DRW_shgroup_call_dynamic_add(
1899                                 sgl->camera_tria, color,
1900                                 cam->drwcorners[0], &cam->drwdepth[0], cam->drwtria, ob->obmat);
1901                 }
1902         }
1903
1904         /* draw the rest in normalize object space */
1905         normalize_m4_m4(cam->drwnormalmat, ob->obmat);
1906
1907         if (cam->flag & CAM_SHOWLIMITS) {
1908                 static float col[3] = {0.5f, 0.5f, 0.25f}, col_hi[3] = {1.0f, 1.0f, 0.5f};
1909                 float sizemat[4][4], size[3] = {1.0f, 1.0f, 0.0f};
1910                 float focusdist = BKE_camera_object_dof_distance(ob);
1911
1912                 copy_m4_m4(cam->drwfocusmat, cam->drwnormalmat);
1913                 translate_m4(cam->drwfocusmat, 0.0f, 0.0f, -focusdist);
1914                 size_to_mat4(sizemat, size);
1915                 mul_m4_m4m4(cam->drwfocusmat, cam->drwfocusmat, sizemat);
1916
1917                 DRW_shgroup_call_dynamic_add(
1918                         sgl->camera_focus, (is_active ? col_hi : col),
1919                         &cam->drawsize, cam->drwfocusmat);
1920
1921                 DRW_shgroup_call_dynamic_add(
1922                         sgl->camera_clip, color,
1923                         &cam->clipsta, &cam->clipend, cam->drwnormalmat);
1924                 DRW_shgroup_call_dynamic_add(
1925                         sgl->camera_clip_points, (is_active ? col_hi : col),
1926                         &cam->clipsta, &cam->clipend, cam->drwnormalmat);
1927         }
1928
1929         if (cam->flag & CAM_SHOWMIST) {
1930                 World *world = scene->world;
1931
1932                 if (world) {
1933                         static float col[3] = {0.5f, 0.5f, 0.5f}, col_hi[3] = {1.0f, 1.0f, 1.0f};
1934                         world->mistend = world->miststa + world->mistdist;
1935                         DRW_shgroup_call_dynamic_add(
1936                                 sgl->camera_mist, color,
1937                                 &world->miststa, &world->mistend, cam->drwnormalmat);
1938                         DRW_shgroup_call_dynamic_add(
1939                                 sgl->camera_mist_points, (is_active ? col_hi : col),
1940                                 &world->miststa, &world->mistend, cam->drwnormalmat);
1941                 }
1942         }
1943
1944         /* Stereo cameras drawing. */
1945         if (is_stereo3d) {
1946                 camera_stereo3d(sgl, scene, view_layer, v3d, ob, cam, vec, drawsize, scale);
1947         }
1948
1949         /* Motion Tracking. */
1950         MovieClip *clip = BKE_object_movieclip_get(scene, ob, false);
1951         if ((v3d->flag2 & V3D_SHOW_RECONSTRUCTION) && (clip != NULL)) {
1952                 BLI_assert(BLI_listbase_is_empty(&sgl->camera_path));
1953                 const bool is_solid_bundle = (v3d->bundle_drawtype == OB_EMPTY_SPHERE) &&
1954                                              ((v3d->shading.type != OB_SOLID) ||
1955                                               ((v3d->shading.flag & XRAY_FLAG(v3d)) == 0));
1956
1957                 MovieTracking *tracking = &clip->tracking;
1958                 /* Index must start in 1, to mimic BKE_tracking_track_get_indexed. */
1959                 int track_index = 1;
1960
1961                 uchar text_color_selected[4], text_color_unselected[4];
1962                 float bundle_color_unselected[4], bundle_color_solid[4];
1963
1964                 UI_GetThemeColor4ubv(TH_SELECT, text_color_selected);
1965                 UI_GetThemeColor4ubv(TH_TEXT, text_color_unselected);
1966                 UI_GetThemeColor4fv(TH_WIRE, bundle_color_unselected);
1967                 UI_GetThemeColor4fv(TH_BUNDLE_SOLID, bundle_color_solid);
1968
1969                 float camera_mat[4][4];
1970                 BKE_tracking_get_camera_object_matrix(scene, ob, camera_mat);
1971
1972                 float bundle_scale_mat[4][4];
1973                 if (is_solid_bundle) {
1974                         scale_m4_fl(bundle_scale_mat, v3d->bundle_size);
1975                 }
1976
1977                 for (MovieTrackingObject *tracking_object = tracking->objects.first;
1978                      tracking_object != NULL;
1979                      tracking_object = tracking_object->next)
1980                 {
1981                         float tracking_object_mat[4][4];
1982
1983                         if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
1984                                 copy_m4_m4(tracking_object_mat, camera_mat);
1985                         }
1986                         else {
1987                                 const int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, DEG_get_ctime(draw_ctx->depsgraph));
1988                                 float object_mat[4][4];
1989                                 BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, object_mat);
1990
1991                                 invert_m4(object_mat);
1992                                 mul_m4_m4m4(tracking_object_mat, cam->drwnormalmat, object_mat);
1993                         }
1994
1995                         ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
1996                         for (MovieTrackingTrack *track = tracksbase->first; track; track = track->next) {
1997
1998                                 if ((track->flag & TRACK_HAS_BUNDLE) == 0) {
1999                                         continue;
2000                                 }
2001
2002                                 bool is_selected = TRACK_SELECTED(track);
2003
2004                                 float bundle_mat[4][4];
2005                                 copy_m4_m4(bundle_mat, tracking_object_mat);
2006                                 translate_m4(bundle_mat, track->bundle_pos[0], track->bundle_pos[1], track->bundle_pos[2]);
2007
2008                                 float *bundle_color;
2009                                 if (track->flag & TRACK_CUSTOMCOLOR) {
2010                                         bundle_color = track->color;
2011                                 }
2012                                 else if (is_solid_bundle) {
2013                                         bundle_color = bundle_color_solid;
2014                                 }
2015                                 else if (is_selected) {
2016                                         bundle_color = color;
2017                                 }
2018                                 else {
2019                                         bundle_color = bundle_color_unselected;
2020                                 }
2021
2022                                 if (is_select) {
2023                                         DRW_select_load_id(camera_object->select_color | (track_index << 16));
2024                                         track_index++;
2025                                 }
2026
2027                                 if (is_solid_bundle) {
2028
2029                                         if (is_selected) {
2030                                                 DRW_shgroup_empty_ex(sgl,
2031                                                                      bundle_mat,
2032                                                                      &v3d->bundle_size,
2033                                                                      v3d->bundle_drawtype,
2034                                                                      color);
2035                                         }
2036
2037                                         float bundle_color_v4[4] = {
2038                                             bundle_color[0],
2039                                             bundle_color[1],
2040                                             bundle_color[2],
2041                                             1.0f,
2042                                         };
2043
2044                                         mul_m4_m4m4(bundle_mat, bundle_mat, bundle_scale_mat);
2045                                         DRW_shgroup_call_dynamic_add(sgl->sphere_solid,
2046                                                                      bundle_mat,
2047                                                                      bundle_color_v4);
2048                                 }
2049                                 else {
2050                                         DRW_shgroup_empty_ex(sgl,
2051                                                              bundle_mat,
2052                                                              &v3d->bundle_size,
2053                                                              v3d->bundle_drawtype,
2054                                                              bundle_color);
2055                                 }
2056
2057                                 if ((v3d->flag2 & V3D_SHOW_BUNDLENAME) && !is_select) {
2058                                         struct DRWTextStore *dt = DRW_text_cache_ensure();
2059
2060                                         DRW_text_cache_add(dt,
2061                                                            bundle_mat[3],
2062                                                            track->name,
2063                                                            strlen(track->name),
2064                                                            10, 0,
2065                                                            DRW_TEXT_CACHE_GLOBALSPACE | DRW_TEXT_CACHE_STRING_PTR,
2066                                                            is_selected ? text_color_selected : text_color_unselected);
2067                                 }
2068                         }
2069
2070                         if ((v3d->flag2 & V3D_SHOW_CAMERAPATH) && (tracking_object->flag & TRACKING_OBJECT_CAMERA) && !is_select) {
2071                                 MovieTrackingReconstruction *reconstruction;
2072                                 reconstruction = BKE_tracking_object_get_reconstruction(tracking, tracking_object);
2073
2074                                 if (reconstruction->camnr) {
2075                                         static float camera_path_color[4];
2076                                         UI_GetThemeColor4fv(TH_CAMERA_PATH, camera_path_color);
2077
2078                                         GPUBatch *geom = batch_camera_path_get(&sgl->camera_path, reconstruction);
2079                                         GPUShader *shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR);
2080                                         DRWShadingGroup *shading_group = DRW_shgroup_create(shader, sgl->non_meshes);
2081                                         DRW_shgroup_uniform_vec4(shading_group, "color", camera_path_color, 1);
2082                                         DRW_shgroup_call_add(shading_group, geom, camera_mat);
2083                                 }
2084                         }
2085                 }
2086         }
2087 }
2088
2089 static void DRW_shgroup_empty_ex(
2090         OBJECT_ShadingGroupList *sgl, float mat[4][4], float *draw_size, char draw_type, float *color)
2091 {
2092         switch (draw_type) {
2093                 case OB_PLAINAXES:
2094                         DRW_shgroup_call_dynamic_add(sgl->plain_axes, color, draw_size, mat);
2095                         break;
2096                 case OB_SINGLE_ARROW:
2097                         DRW_shgroup_call_dynamic_add(sgl->single_arrow, color, draw_size, mat);
2098                         DRW_shgroup_call_dynamic_add(sgl->single_arrow_line, color, draw_size, mat);
2099                         break;
2100                 case OB_CUBE:
2101                         DRW_shgroup_call_dynamic_add(sgl->cube, color, draw_size, mat);
2102                         break;
2103                 case OB_CIRCLE:
2104                         DRW_shgroup_call_dynamic_add(sgl->circle, color, draw_size, mat);
2105                         break;
2106                 case OB_EMPTY_SPHERE:
2107                         DRW_shgroup_call_dynamic_add(sgl->sphere, color, draw_size, mat);
2108                         break;
2109                 case OB_EMPTY_CONE:
2110                         DRW_shgroup_call_dynamic_add(sgl->cone, color, draw_size, mat);
2111                         break;
2112                 case OB_ARROWS:
2113                         DRW_shgroup_call_dynamic_add(sgl->empty_axes, color, draw_size, mat);
2114                         break;
2115                 case OB_EMPTY_IMAGE:
2116                         BLI_assert(!"Should never happen, use DRW_shgroup_empty instead.");
2117                         break;
2118         }
2119 }
2120
2121 static void DRW_shgroup_empty(
2122         OBJECT_Shaders *sh_data, OBJECT_ShadingGroupList *sgl,
2123         Object *ob, ViewLayer *view_layer, RegionView3D *rv3d, eDRW_ShaderSlot shader_slot)
2124 {
2125         float *color;
2126         DRW_object_wire_theme_get(ob, view_layer, &color);
2127
2128         switch (ob->empty_drawtype) {
2129                 case OB_PLAINAXES:
2130                 case OB_SINGLE_ARROW:
2131                 case OB_CUBE:
2132                 case OB_CIRCLE:
2133                 case OB_EMPTY_SPHERE:
2134                 case OB_EMPTY_CONE:
2135                 case OB_ARROWS:
2136                         DRW_shgroup_empty_ex(sgl, ob->obmat, &ob->empty_drawsize, ob->empty_drawtype, color);
2137                         break;
2138                 case OB_EMPTY_IMAGE:
2139                         DRW_shgroup_empty_image(sh_data, sgl, ob, color, rv3d, shader_slot);
2140                         break;
2141         }
2142 }
2143
2144 static void DRW_shgroup_forcefield(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
2145 {
2146         int theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
2147         float *color = DRW_color_background_blend_get(theme_id);
2148         PartDeflect *pd = ob->pd;
2149         Curve *cu = (ob->type == OB_CURVE) ? ob->data : NULL;
2150
2151         /* TODO Move this to depsgraph */
2152         float tmp[3];
2153         copy_v3_fl(pd->drawvec1, ob->empty_drawsize);
2154
2155         switch (pd->forcefield) {
2156                 case PFIELD_WIND:
2157                         pd->drawvec1[2] = pd->f_strength;
2158                         break;
2159                 case PFIELD_VORTEX:
2160                         if (pd->f_strength < 0.0f) {
2161                                 pd->drawvec1[1] = -pd->drawvec1[1];
2162                         }
2163                         break;
2164                 case PFIELD_GUIDE:
2165                         if (cu && (cu->flag & CU_PATH) && ob->runtime.curve_cache->path && ob->runtime.curve_cache->path->data) {
2166                                 where_on_path(ob, 0.0f, pd->drawvec1, tmp, NULL, NULL, NULL);
2167                                 where_on_path(ob, 1.0f, pd->drawvec2, tmp, NULL, NULL, NULL);
2168                         }
2169                         break;
2170         }
2171
2172         if (pd->falloff == PFIELD_FALL_TUBE) {
2173                 pd->drawvec_falloff_max[0] = pd->drawvec_falloff_max[1] = (pd->flag & PFIELD_USEMAXR) ? pd->maxrad : 1.0f;
2174                 pd->drawvec_falloff_max[2] = (pd->flag & PFIELD_USEMAX) ? pd->maxdist : 0.0f;
2175
2176                 pd->drawvec_falloff_min[0] = pd->drawvec_falloff_min[1] = (pd->flag & PFIELD_USEMINR) ? pd->minrad : 1.0f;
2177                 pd->drawvec_falloff_min[2] = (pd->flag & PFIELD_USEMIN) ? pd->mindist : 0.0f;
2178         }
2179         else if (pd->falloff == PFIELD_FALL_CONE) {
2180                 float radius, distance;
2181
2182                 radius = DEG2RADF((pd->flag & PFIELD_USEMAXR) ? pd->maxrad : 1.0f);
2183                 distance = (pd->flag & PFIELD_USEMAX) ? pd->maxdist : 0.0f;
2184                 pd->drawvec_falloff_max[0] = pd->drawvec_falloff_max[1] = distance * sinf(radius);
2185                 pd->drawvec_falloff_max[2] = distance * cosf(radius);
2186
2187                 radius = DEG2RADF((pd->flag & PFIELD_USEMINR) ? pd->minrad : 1.0f);
2188                 distance = (pd->flag & PFIELD_USEMIN) ? pd->mindist : 0.0f;
2189
2190                 pd->drawvec_falloff_min[0] = pd->drawvec_falloff_min[1] = distance * sinf(radius);
2191                 pd->drawvec_falloff_min[2] = distance * cosf(radius);
2192         }
2193         /* End of things that should go to depthgraph */
2194
2195         switch (pd->forcefield) {
2196                 case PFIELD_WIND:
2197                         DRW_shgroup_call_dynamic_add(sgl->field_wind, color, &pd->drawvec1, ob->obmat);
2198                         break;
2199                 case PFIELD_FORCE:
2200                         DRW_shgroup_call_dynamic_add(sgl->field_force, color, &pd->drawvec1, ob->obmat);
2201                         break;
2202                 case PFIELD_VORTEX:
2203                         DRW_shgroup_call_dynamic_add(sgl->field_vortex, color, &pd->drawvec1, ob->obmat);
2204                         break;
2205                 case PFIELD_GUIDE:
2206                         if (cu && (cu->flag & CU_PATH) && ob->runtime.curve_cache->path && ob->runtime.curve_cache->path->data) {
2207                                 DRW_shgroup_call_dynamic_add(sgl->field_curve_sta, color, &pd->f_strength, ob->obmat);
2208                                 DRW_shgroup_call_dynamic_add(sgl->field_curve_end, color, &pd->f_strength, ob->obmat);
2209                         }
2210                         break;
2211         }
2212
2213         if (pd->falloff == PFIELD_FALL_SPHERE) {
2214                 /* as last, guide curve alters it */
2215                 if ((pd->flag & PFIELD_USEMAX) != 0) {
2216                         DRW_shgroup_call_dynamic_add(sgl->field_curve_end, color, &pd->maxdist, ob->obmat);
2217                 }
2218
2219                 if ((pd->flag & PFIELD_USEMIN) != 0) {
2220                         DRW_shgroup_call_dynamic_add(sgl->field_curve_end, color, &pd->mindist, ob->obmat);
2221                 }
2222         }
2223         else if (pd->falloff == PFIELD_FALL_TUBE) {
2224                 if (pd->flag & (PFIELD_USEMAX | PFIELD_USEMAXR)) {
2225                         DRW_shgroup_call_dynamic_add(sgl->field_tube_limit, color, &pd->drawvec_falloff_max, ob->obmat);
2226                 }
2227
2228                 if (pd->flag & (PFIELD_USEMIN | PFIELD_USEMINR)) {
2229                         DRW_shgroup_call_dynamic_add(sgl->field_tube_limit, color, &pd->drawvec_falloff_min, ob->obmat);
2230                 }
2231         }
2232         else if (pd->falloff == PFIELD_FALL_CONE) {
2233                 if (pd->flag & (PFIELD_USEMAX | PFIELD_USEMAXR)) {
2234                         DRW_shgroup_call_dynamic_add(sgl->field_cone_limit, color, &pd->drawvec_falloff_max, ob->obmat);
2235                 }
2236
2237                 if (pd->flag & (PFIELD_USEMIN | PFIELD_USEMINR)) {
2238                         DRW_shgroup_call_dynamic_add(sgl->field_cone_limit, color, &pd->drawvec_falloff_min, ob->obmat);
2239                 }
2240         }
2241 }
2242
2243 static void DRW_shgroup_volume_extra(
2244         OBJECT_ShadingGroupList *sgl,
2245         Object *ob, ViewLayer *view_layer, Scene *scene, ModifierData *md)
2246 {
2247         SmokeModifierData *smd = (SmokeModifierData *)md;
2248         SmokeDomainSettings *sds = smd->domain;
2249         float *color;
2250         float one = 1.0f;
2251
2252         if (sds == NULL) {
2253                 return;
2254         }
2255
2256         DRW_object_wire_theme_get(ob, view_layer, &color);
2257
2258         /* Small cube showing voxel size. */
2259         float voxel_cubemat[4][4] = {{0.0f}};
2260         voxel_cubemat[0][0] = 1.0f / (float)sds->res[0];
2261         voxel_cubemat[1][1] = 1.0f / (float)sds->res[1];
2262         voxel_cubemat[2][2] = 1.0f / (float)sds->res[2];
2263         voxel_cubemat[3][0] = voxel_cubemat[3][1] = voxel_cubemat[3][2] = -1.0f;
2264         voxel_cubemat[3][3] = 1.0f;
2265         translate_m4(voxel_cubemat, 1.0f, 1.0f, 1.0f);
2266         mul_m4_m4m4(voxel_cubemat, ob->obmat, voxel_cubemat);
2267
2268         DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, voxel_cubemat);
2269
2270         /* Don't show smoke before simulation starts, this could be made an option in the future. */
2271         if (!sds->draw_velocity || !sds->fluid || CFRA < sds->point_cache[0]->startframe) {
2272                 return;
2273         }
2274
2275         const bool use_needle = (sds->vector_draw_type == VECTOR_DRAW_NEEDLE);
2276         int line_count = (use_needle) ? 6 : 1;
2277         int slice_axis = -1;
2278         line_count *= sds->res[0] * sds->res[1] * sds->res[2];
2279
2280         if (sds->slice_method == MOD_SMOKE_SLICE_AXIS_ALIGNED &&
2281             sds->axis_slice_method == AXIS_SLICE_SINGLE)
2282         {
2283                 float invviewmat[4][4];
2284                 DRW_viewport_matrix_get(invviewmat, DRW_MAT_VIEWINV);
2285
2286                 const int axis = (sds->slice_axis == SLICE_AXIS_AUTO)
2287                                   ? axis_dominant_v3_single(invviewmat[2])
2288                                   : sds->slice_axis - 1;
2289                 slice_axis = axis;
2290                 line_count /= sds->res[axis];
2291         }
2292
2293         GPU_create_smoke_velocity(smd);
2294
2295         DRWShadingGroup *grp = DRW_shgroup_create(volume_velocity_shader_get(use_needle), sgl->non_meshes);
2296         DRW_shgroup_uniform_texture(grp, "velocityX", sds->tex_velocity_x);
2297         DRW_shgroup_uniform_texture(grp, "velocityY", sds->tex_velocity_y);
2298         DRW_shgroup_uniform_texture(grp, "velocityZ", sds->tex_velocity_z);
2299         DRW_shgroup_uniform_float_copy(grp, "displaySize", sds->vector_scale);
2300         DRW_shgroup_uniform_float_copy(grp, "slicePosition", sds->slice_depth);
2301         DRW_shgroup_uniform_int_copy(grp, "sliceAxis", slice_axis);
2302         DRW_shgroup_call_procedural_lines_add(grp, line_count, ob->obmat);
2303
2304         BLI_addtail(&e_data.smoke_domains, BLI_genericNodeN(smd));
2305 }
2306
2307 static void volumes_free_smoke_textures(void)
2308 {
2309         /* Free Smoke Textures after rendering */
2310         /* XXX This is a waste of processing and GPU bandwidth if nothing
2311          * is updated. But the problem is since Textures are stored in the
2312          * modifier we don't want them to take precious VRAM if the
2313          * modifier is not used for display. We should share them for
2314          * all viewport in a redraw at least. */
2315         for (LinkData *link = e_data.smoke_domains.first; link; link = link->next) {
2316                 SmokeModifierData *smd = (SmokeModifierData *)link->data;
2317                 GPU_free_smoke_velocity(smd);
2318         }
2319         BLI_freelistN(&e_data.smoke_domains);
2320 }
2321
2322 static void DRW_shgroup_gpencil(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
2323 {
2324         float *color;
2325         DRW_object_wire_theme_get(ob, view_layer, &color);
2326
2327         DRW_shgroup_call_dynamic_add(sgl->gpencil_axes, color, &ob->empty_drawsize, ob->obmat);
2328 }
2329
2330 static void DRW_shgroup_speaker(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
2331 {
2332         float *color;
2333         static float one = 1.0f;
2334         DRW_object_wire_theme_get(ob, view_layer, &color);
2335
2336         DRW_shgroup_call_dynamic_add(sgl->speaker, color, &one, ob->obmat);
2337 }
2338
2339 typedef struct OBJECT_LightProbeEngineData {
2340         DrawData dd;
2341
2342         float increment_x[3];
2343         float increment_y[3];
2344         float increment_z[3];
2345         float corner[3];
2346 } OBJECT_LightProbeEngineData;
2347
2348 static void DRW_shgroup_lightprobe(
2349         OBJECT_Shaders *sh_data, OBJECT_StorageList *stl, OBJECT_PassList *psl,
2350         Object *ob, ViewLayer *view_layer)
2351 {
2352         float *color;
2353         static float one = 1.0f;
2354         LightProbe *prb = (LightProbe *)ob->data;
2355         bool do_outlines = ((ob->base_flag & BASE_SELECTED) != 0);
2356         int theme_id = DRW_object_wire_theme_get(ob, view_layer, &color);
2357
2358         OBJECT_ShadingGroupList *sgl = (ob->dtx & OB_DRAWXRAY) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
2359
2360         OBJECT_LightProbeEngineData *prb_data = (OBJECT_LightProbeEngineData *)DRW_drawdata_ensure(
2361                 &ob->id,
2362                 &draw_engine_object_type,
2363                 sizeof(OBJECT_LightProbeEngineData),
2364                 NULL,
2365                 NULL);
2366
2367         if ((DRW_state_is_select() || do_outlines) && ((prb->flag & LIGHTPROBE_FLAG_SHOW_DATA) != 0)) {
2368                 int *call_id = shgroup_theme_id_to_probe_outline_counter(stl, theme_id, ob->base_flag);
2369
2370                 if (prb->type == LIGHTPROBE_TYPE_GRID) {
2371                         /* Update transforms */
2372                         float cell_dim[3], half_cell_dim[3];
2373                         cell_dim[0] = 2.0f / (float)(prb->grid_resolution_x);
2374                         cell_dim[1] = 2.0f / (float)(prb->grid_resolution_y);
2375                         cell_dim[2] = 2.0f / (float)(prb->grid_resolution_z);
2376
2377                         mul_v3_v3fl(half_cell_dim, cell_dim, 0.5f);
2378
2379                         /* First cell. */
2380                         copy_v3_fl(prb_data->corner, -1.0f);
2381                         add_v3_v3(prb_data->corner, half_cell_dim);
2382                         mul_m4_v3(ob->obmat, prb_data->corner);
2383
2384                         /* Opposite neighbor cell. */
2385                         copy_v3_fl3(prb_data->increment_x, cell_dim[0], 0.0f, 0.0f);
2386                         add_v3_v3(prb_data->increment_x, half_cell_dim);
2387                         add_v3_fl(prb_data->increment_x, -1.0f);
2388                         mul_m4_v3(ob->obmat, prb_data->increment_x);
2389                         sub_v3_v3(prb_data->increment_x, prb_data->corner);
2390
2391                         copy_v3_fl3(prb_data->increment_y, 0.0f, cell_dim[1], 0.0f);
2392                         add_v3_v3(prb_data->increment_y, half_cell_dim);
2393                         add_v3_fl(prb_data->increment_y, -1.0f);
2394                         mul_m4_v3(ob->obmat, prb_data->increment_y);
2395                         sub_v3_v3(prb_data->increment_y, prb_data->corner);
2396
2397                         copy_v3_fl3(prb_data->increment_z, 0.0f, 0.0f, cell_dim[2]);
2398                         add_v3_v3(prb_data->increment_z, half_cell_dim);
2399                         add_v3_fl(prb_data->increment_z, -1.0f);
2400                         mul_m4_v3(ob->obmat, prb_data->increment_z);
2401                         sub_v3_v3(prb_data->increment_z, prb_data->corner);
2402
2403                         uint cell_count = prb->grid_resolution_x * prb->grid_resolution_y * prb->grid_resolution_z;
2404                         DRWShadingGroup *grp = DRW_shgroup_create(sh_data->lightprobe_grid, psl->lightprobes);
2405                         DRW_shgroup_uniform_int_copy(grp, "call_id", *call_id);
2406                         DRW_shgroup_uniform_int(grp, "baseId", call_id, 1); /* that's correct */
2407                         DRW_shgroup_uniform_vec3(grp, "corner", prb_data->corner, 1);
2408                         DRW_shgroup_uniform_vec3(grp, "increment_x", prb_data->increment_x, 1);
2409                         DRW_shgroup_uniform_vec3(grp, "increment_y", prb_data->increment_y, 1);
2410                         DRW_shgroup_uniform_vec3(grp, "increment_z", prb_data->increment_z, 1);
2411                         DRW_shgroup_uniform_ivec3(grp, "grid_resolution", &prb->grid_resolution_x, 1);
2412                         DRW_shgroup_call_procedural_points_add(grp, cell_count, NULL);
2413                 }
2414                 else if (prb->type == LIGHTPROBE_TYPE_CUBE) {
2415                         float draw_size = 1.0f;
2416                         float probe_cube_mat[4][4];
2417                         // prb_data->draw_size = prb->data_draw_size * 0.1f;
2418                         // unit_m4(prb_data->probe_cube_mat);
2419                         // copy_v3_v3(prb_data->probe_cube_mat[3], ob->obmat[3]);
2420
2421                         DRWShadingGroup *grp = shgroup_theme_id_to_probe_cube_outline_shgrp(stl, theme_id, ob->base_flag);
2422                         /* TODO remove or change the drawing of the cube probes. Theses line draws nothing on purpose
2423                          * to keep the call ids correct. */
2424                         zero_m4(probe_cube_mat);
2425                         DRW_shgroup_call_dynamic_add(grp, call_id, &draw_size, probe_cube_mat);
2426                 }
2427                 else {
2428                         float draw_size = 1.0f;
2429                         DRWShadingGroup *grp = shgroup_theme_id_to_probe_planar_outline_shgrp(stl, theme_id);
2430                         DRW_shgroup_call_dynamic_add(grp, call_id, &draw_size, ob->obmat);
2431                 }
2432
2433                 *call_id += 1;
2434         }
2435
2436         switch (prb->type) {
2437                 case LIGHTPROBE_TYPE_PLANAR:
2438                         DRW_shgroup_call_dynamic_add(sgl->probe_planar, ob->obmat[3], color);
2439                         break;
2440                 case LIGHTPROBE_TYPE_GRID:
2441                         DRW_shgroup_call_dynamic_add(sgl->probe_grid, ob->obmat[3], color);
2442                         break;
2443                 case LIGHTPROBE_TYPE_CUBE:
2444                 default:
2445                         DRW_shgroup_call_dynamic_add(sgl->probe_cube, ob->obmat[3], color);
2446                         break;
2447         }
2448
2449
2450
2451         if (prb->type == LIGHTPROBE_TYPE_PLANAR) {
2452                 float mat[4][4];
2453                 copy_m4_m4(mat, ob->obmat);
2454                 normalize_m4(mat);
2455
2456                 DRW_shgroup_call_dynamic_add(sgl->single_arrow, color, &ob->empty_drawsize, mat);
2457                 DRW_shgroup_call_dynamic_add(sgl->single_arrow_line, color, &ob->empty_drawsize, mat);
2458
2459                 copy_m4_m4(mat, ob->obmat);
2460                 zero_v3(mat[2]);
2461
2462                 DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, mat);
2463         }
2464
2465         if ((prb->flag & LIGHTPROBE_FLAG_SHOW_INFLUENCE) != 0) {
2466
2467                 prb->distfalloff = (1.0f - prb->falloff) * prb->distinf;
2468                 prb->distgridinf = prb->distinf;
2469
2470                 if (prb->type == LIGHTPROBE_TYPE_GRID) {
2471                         prb->distfalloff += 1.0f;
2472                         prb->distgridinf += 1.0f;
2473                 }
2474
2475                 if (prb->type == LIGHTPROBE_TYPE_GRID ||
2476                     prb->attenuation_type == LIGHTPROBE_SHAPE_BOX)
2477                 {
2478                         DRW_shgroup_call_dynamic_add(sgl->cube, color, &prb->distgridinf, ob->obmat);
2479                         DRW_shgroup_call_dynamic_add(sgl->cube, color, &prb->distfalloff, ob->obmat);
2480                 }
2481                 else if (prb->type == LIGHTPROBE_TYPE_PLANAR) {
2482                         float rangemat[4][4];
2483                         copy_m4_m4(rangemat, ob->obmat);
2484                         normalize_v3(rangemat[2]);
2485                         mul_v3_fl(rangemat[2], prb->distinf);
2486
2487                         DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, rangemat);
2488
2489                         copy_m4_m4(rangemat, ob->obmat);
2490                         normalize_v3(rangemat[2]);
2491                         mul_v3_fl(rangemat[2], prb->distfalloff);
2492
2493                         DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, rangemat);
2494                 }
2495                 else {
2496                         DRW_shgroup_call_dynamic_add(sgl->sphere, color, &prb->distgridinf, ob->obmat);
2497                         DRW_shgroup_call_dynamic_add(sgl->sphere, color, &prb->distfalloff, ob->obmat);
2498                 }
2499         }
2500
2501         if ((prb->flag & LIGHTPROBE_FLAG_SHOW_PARALLAX) != 0) {
2502                 if (prb->type != LIGHTPROBE_TYPE_PLANAR) {
2503                         float (*obmat)[4], *dist;
2504
2505                         if ((prb->flag & LIGHTPROBE_FLAG_CUSTOM_PARALLAX) != 0) {
2506                                 dist = &prb->distpar;
2507                                 /* TODO object parallax */
2508                                 obmat = ob->obmat;
2509                         }
2510                         else {
2511                                 dist = &prb->distinf;
2512                                 obmat = ob->obmat;
2513                         }
2514
2515                         if (prb->parallax_type == LIGHTPROBE_SHAPE_BOX) {
2516                                 DRW_shgroup_call_dynamic_add(sgl->cube, color, dist, obmat);
2517                         }
2518                         else {
2519                                 DRW_shgroup_call_dynamic_add(sgl->sphere, color, dist, obmat);
2520                         }
2521                 }
2522         }
2523
2524         if ((prb->flag & LIGHTPROBE_FLAG_SHOW_CLIP_DIST) != 0) {
2525                 if (prb->type != LIGHTPROBE_TYPE_PLANAR) {
2526                         static const float cubefacemat[6][4][4] = {
2527                                 {{0.0, 0.0, -1.0, 0.0}, {0.0, -1.0, 0.0, 0.0}, {-1.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 1.0}},
2528                                 {{0.0, 0.0, 1.0, 0.0}, {0.0, -1.0, 0.0, 0.0}, {1.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 1.0}},
2529                                 {{1.0, 0.0, 0.0, 0.0}, {0.0, 0.0, -1.0, 0.0}, {0.0, 1.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 1.0}},
2530                                 {{1.0, 0.0, 0.0, 0.0}, {0.0, 0.0, 1.0, 0.0}, {0.0, -1.0, 0.0, 0.0}, {0.0, 0.0, 0.0, 1.0}},
2531                                 {{1.0, 0.0, 0.0, 0.0}, {0.0, -1.0, 0.0, 0.0}, {0.0, 0.0, -1.0, 0.0}, {0.0, 0.0, 0.0, 1.0}},
2532                                 {{-1.0, 0.0, 0.0, 0.0}, {0.0, -1.0, 0.0, 0.0}, {0.0, 0.0, 1.0, 0.0}, {0.0, 0.0, 0.0, 1.0}},
2533                         };
2534
2535                         for (int i = 0; i < 6; ++i) {
2536                                 float clipmat[4][4];
2537                                 normalize_m4_m4(clipmat, ob->obmat);
2538                                 mul_m4_m4m4(clipmat, clipmat, cubefacemat[i]);
2539
2540                                 DRW_shgroup_call_dynamic_add(sgl->lamp_buflimit, color, &prb->clipsta, &prb->clipend, clipmat);
2541                                 DRW_shgroup_call_dynamic_add(sgl->lamp_buflimit_points, color, &prb->clipsta, &prb->clipend, clipmat);
2542                         }
2543                 }
2544         }
2545
2546         /* Line and point going to the ground */
2547         if (prb->type == LIGHTPROBE_TYPE_CUBE) {
2548                 DRW_shgroup_call_dynamic_add(sgl->lamp_groundline, ob->obmat[3]);
2549                 DRW_shgroup_call_dynamic_add(sgl->lamp_groundpoint, ob->obmat[3]);
2550         }
2551 }
2552
2553 static void DRW_shgroup_relationship_lines(
2554         OBJECT_ShadingGroupList *sgl,
2555         Depsgraph *depsgraph,
2556         Scene *scene,
2557         Object *ob)
2558 {
2559         if (ob->parent && (DRW_object_visibility_in_active_context(ob->parent) & OB_VISIBLE_SELF)) {
2560                 DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->orig);
2561                 DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->obmat[3]);
2562         }
2563
2564         if (ob->rigidbody_constraint) {
2565                 Object *rbc_ob1 = ob->rigidbody_constraint->ob1;
2566                 Object *rbc_ob2 = ob->rigidbody_constraint->ob2;
2567                 if (rbc_ob1 && (DRW_object_visibility_in_active_context(rbc_ob1) & OB_VISIBLE_SELF)) {
2568                         DRW_shgroup_call_dynamic_add(sgl->relationship_lines, rbc_ob1->obmat[3]);
2569                         DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->obmat[3]);
2570                 }
2571                 if (rbc_ob2 && (DRW_object_visibility_in_active_context(rbc_ob2) & OB_VISIBLE_SELF)) {
2572                         DRW_shgroup_call_dynamic_add(sgl->relationship_lines, rbc_ob2->obmat[3]);
2573                         DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->obmat[3]);
2574                 }
2575         }
2576
2577         /* Drawing the constraint lines */
2578         if (!BLI_listbase_is_empty(&ob->constraints)) {
2579                 bConstraint *curcon;
2580                 bConstraintOb *cob;
2581                 ListBase *list = &ob->constraints;
2582
2583                 cob = BKE_constraints_make_evalob(depsgraph, scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
2584
2585                 for (curcon = list->first; curcon; curcon = curcon->next) {
2586                         if (ELEM(curcon->type, CONSTRAINT_TYPE_FOLLOWTRACK, CONSTRAINT_TYPE_OBJECTSOLVER)) {
2587                                 /* special case for object solver and follow track constraints because they don't fill
2588                                  * constraint targets properly (design limitation -- scene is needed for their target
2589                                  * but it can't be accessed from get_targets callback) */
2590
2591                                 Object *camob = NULL;
2592
2593                                 if (curcon->type == CONSTRAINT_TYPE_FOLLOWTRACK) {
2594                                         bFollowTrackConstraint *data = (bFollowTrackConstraint *)curcon->data;
2595
2596                                         camob = data->camera ? data->camera : scene->camera;
2597                                 }
2598                                 else if (curcon->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
2599                                         bObjectSolverConstraint *data = (bObjectSolverConstraint *)curcon->data;
2600
2601                                         camob = data->camera ? data->camera : scene->camera;
2602                                 }
2603
2604                                 if (camob) {
2605                                         DRW_shgroup_call_dynamic_add(sgl->constraint_lines, camob->obmat[3]);
2606                                         DRW_shgroup_call_dynamic_add(sgl->constraint_lines, ob->obmat[3]);
2607                                 }
2608                         }
2609                         else {
2610                                 const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(curcon);
2611
2612                                 if ((cti && cti->get_constraint_targets) && (curcon->flag & CONSTRAINT_EXPAND)) {
2613                                         ListBase targets = {NULL, NULL};
2614                                         bConstraintTarget *ct;
2615
2616                                         cti->get_constraint_targets(curcon, &targets);
2617
2618                                         for (ct = targets.first; ct; ct = ct->next) {
2619                                                 /* calculate target's matrix */
2620                                                 if (cti->get_target_matrix) {
2621                                                         cti->get_target_matrix(depsgraph,
2622                                                                                curcon,
2623                                                                                cob,
2624                                                                                ct,
2625                                                                                DEG_get_ctime(depsgraph));
2626                                                 }
2627                                                 else {
2628                                                         unit_m4(ct->matrix);
2629                                                 }
2630
2631                                                 DRW_shgroup_call_dynamic_add(sgl->constraint_lines, ct->matrix[3]);
2632                                                 DRW_shgroup_call_dynamic_add(sgl->constraint_lines, ob->obmat[3]);
2633                                         }
2634
2635                                         if (cti->flush_constraint_targets) {
2636                                                 cti->flush_constraint_targets(curcon, &targets, 1);
2637                                         }
2638                                 }
2639                         }
2640                 }
2641
2642                 BKE_constraints_clear_evalob(cob);
2643         }
2644 }
2645
2646 static void DRW_shgroup_object_center(OBJECT_StorageList *stl, Object *ob, ViewLayer *view_layer, View3D *v3d)
2647 {
2648         if (v3d->overlay.flag & V3D_OVERLAY_HIDE_OBJECT_ORIGINS) {
2649                 return;
2650         }
2651         const bool is_library = ob->id.us > 1 || ID_IS_LINKED(ob);
2652         DRWShadingGroup *shgroup;
2653
2654         if (ob == OBACT(view_layer)) {
2655                 shgroup = stl->g_data->center_active;
2656         }
2657         else if (ob->base_flag & BASE_SELECTED) {
2658                 if (is_library) {
2659                         shgroup = stl->g_data->center_selected_lib;
2660                 }
2661                 else {
2662                         shgroup = stl->g_data->center_selected;
2663                 }
2664         }
2665         else if (v3d->flag & V3D_DRAW_CENTERS) {
2666                 if (is_library) {
2667                         shgroup = stl->g_data->center_deselected_lib;
2668                 }
2669                 else {
2670                         shgroup = stl->g_data->center_deselected;
2671                 }
2672         }
2673         else {
2674                 return;
2675         }
2676
2677         DRW_shgroup_call_dynamic_add(shgroup, ob->obmat[3]);
2678 }
2679
2680 static void DRW_shgroup_texture_space(OBJECT_ShadingGroupList *sgl, Object *ob, int theme_id)
2681 {
2682         if (ob->data == NULL) {
2683                 return;
2684         }
2685
2686         ID *ob_data = ob->data;
2687         float *texcoloc = NULL;
2688         float *texcosize = NULL;
2689
2690         switch (GS(ob_data->name)) {
2691                 case ID_ME:
2692                         BKE_mesh_texspace_get_reference((Mesh *)ob_data, NULL, &texcoloc, NULL, &texcosize);
2693                         break;
2694                 case ID_CU:
2695                 {
2696                         Curve *cu = (Curve *)ob_data;
2697                         if (cu->bb == NULL || (cu->bb->flag & BOUNDBOX_DIRTY)) {
2698                                 BKE_curve_texspace_calc(cu);
2699                         }
2700                         texcoloc = cu->loc;
2701                         texcosize = cu->size;
2702                         break;
2703                 }
2704                 case ID_MB:
2705                 {
2706                         MetaBall *mb = (MetaBall *)ob_data;
2707                         texcoloc = mb->loc;
2708                         texcosize = mb->size;
2709                         break;
2710                 }
2711                 default:
2712                         BLI_assert(0);
2713         }
2714
2715         float tmp[4][4] = {{0.0f}}, one = 1.0f;
2716         tmp[0][0] = texcosize[0];
2717         tmp[1][1] = texcosize[1];
2718         tmp[2][2] = texcosize[2];
2719         tmp[3][0] = texcoloc[0];
2720         tmp[3][1] = texcoloc[1];
2721         tmp[3][2] = texcoloc[2];
2722         tmp[3][3] = 1.0f;
2723
2724         mul_m4_m4m4(tmp, ob->obmat, tmp);
2725
2726         float color[4];
2727         UI_GetThemeColor4fv(theme_id, color);
2728
2729         DRW_shgroup_call_dynamic_add(sgl->texspace, color, &one, tmp);
2730 }
2731
2732 static void DRW_shgroup_bounds(OBJECT_ShadingGroupList *sgl, Object *ob, int theme_id)
2733 {
2734         float color[4], center[3], size[3], tmp[4][4], final_mat[4][4], one = 1.0f;
2735         BoundBox  bb_local;
2736
2737         if (ob->type == OB_MBALL && !BKE_mball_is_basis(ob)) {
2738                 return;
2739         }
2740
2741         BoundBox *bb = BKE_object_boundbox_get(ob);
2742
2743         if (!ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT,
2744                             OB_MBALL, OB_ARMATURE, OB_LATTICE))
2745         {
2746                 const float min[3] = {-1.0f, -1.0f, -1.0f}, max[3] = {1.0f, 1.0f, 1.0f};
2747                 bb = &bb_local;
2748                 BKE_boundbox_init_from_minmax(bb, min, max);
2749         }
2750
2751         UI_GetThemeColor4fv(theme_id, color);
2752         BKE_boundbox_calc_center_aabb(bb, center);
2753         BKE_boundbox_calc_size_aabb(bb, size);
2754
2755         switch (ob->boundtype) {
2756                 case OB_BOUND_BOX:
2757                         size_to_mat4(tmp, size);
2758                         copy_v3_v3(tmp[3], center);
2759                         mul_m4_m4m4(tmp, ob->obmat, tmp);
2760                         DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, tmp);
2761                         break;
2762                 case OB_BOUND_SPHERE:
2763                         size[0] = max_fff(size[0], size[1], size[2]);
2764                         size[1] = size[2] = size[0];
2765                         size_to_mat4(tmp, size);
2766                         copy_v3_v3(tmp[3], center);
2767                         mul_m4_m4m4(tmp, ob->obmat, tmp);
2768                         DRW_shgroup_call_dynamic_add(sgl->sphere, color, &one, tmp);
2769                         break;
2770                 case OB_BOUND_CYLINDER:
2771                         size[0] = max_ff(size[0], size[1]);
2772                         size[1] = size[0];
2773                         size_to_mat4(tmp, size);
2774                         copy_v3_v3(tmp[3], center);
2775                         mul_m4_m4m4(tmp, ob->obmat, tmp);
2776                         DRW_shgroup_call_dynamic_add(sgl->cylinder, color, &one, tmp);
2777                         break;
2778                 case OB_BOUND_CONE:
2779                         size[0] = max_ff(size[0], size[1]);
2780                         size[1] = size[0];
2781                         size_to_mat4(tmp, size);
2782                         copy_v3_v3(tmp[3], center);
2783                         /* Cone batch has base at 0 and is pointing towards +Y. */
2784                         swap_v3_v3(tmp[1], tmp[2]);
2785                         tmp[3][2] -= size[2];
2786                         mul_m4_m4m4(tmp, ob->obmat, tmp);
2787                         DRW_shgroup_call_dynamic_add(sgl->cone, color, &one, tmp);
2788                         break;
2789                 case OB_BOUND_CAPSULE:
2790                         size[0] = max_ff(size[0], size[1]);
2791                         size[1] = size[0];
2792                         scale_m4_fl(tmp, size[0]);
2793                         copy_v2_v2(tmp[3], center);
2794                         tmp[3][2] = center[2] + max_ff(0.0f, size[2] - size[0]);
2795                         mul_m4_m4m4(final_mat, ob->obmat, tmp);
2796                         DRW_shgroup_call_dynamic_add(sgl->capsule_cap, color, &one, final_mat);
2797                         negate_v3(tmp[2]);
2798                         tmp[3][2] = center[2] - max_ff(0.0f, size[2] - size[0]);
2799                         mul_m4_m4m4(final_mat, ob->obmat, tmp);
2800                         DRW_shgroup_call_dynamic_add(sgl->capsule_cap, color, &one, final_mat);
2801                         tmp[2][2] = max_ff(0.0f, size[2] * 2.0f - size[0] * 2.0f);
2802                         mul_m4_m4m4(final_mat, ob->obmat, tmp);
2803                         DRW_shgroup_call_dynamic_add(sgl->capsule_body, color, &one, final_mat);
2804                         break;
2805         }
2806 }
2807
2808 static void OBJECT_cache_populate_particles(
2809         OBJECT_Shaders *sh_data,
2810         Object *ob,
2811         OBJECT_PassList *psl)
2812 {
2813         for (ParticleSystem *psys = ob->particlesystem.first; psys; psys = psys->next) {
2814                 if (!psys_check_enabled(ob, psys, false)) {
2815                         continue;
2816                 }
2817                 if (!DRW_object_is_visible_psys_in_active_context(ob, psys)) {
2818                         continue;
2819                 }
2820
2821                 ParticleSettings *part = psys->part;
2822                 int draw_as = (part->draw_as == PART_DRAW_REND) ? part->ren_as : part->draw_as;
2823
2824                 static float mat[4][4];
2825                 unit_m4(mat);
2826
2827                 if (draw_as != PART_DRAW_PATH) {
2828                         struct GPUBatch *geom = DRW_cache_particles_get_dots(ob, psys);
2829                         DRWShadingGroup *shgrp = NULL;
2830                         static int screen_space[2] = {0, 1};
2831                         static float def_prim_col[3] = {0.5f, 0.5f, 0.5f};
2832                         static float def_sec_col[3] = {1.0f, 1.0f, 1.0f};
2833
2834                         /* Dummy particle format for instancing to work. */
2835                         DRW_shgroup_instance_format(e_data.particle_format, {{"dummy", DRW_ATTR_FLOAT, 1}});
2836
2837                         Material *ma = give_current_material(ob, part->omat);
2838
2839                         switch (draw_as) {
2840                                 case PART_DRAW_DOT:
2841                                         shgrp = DRW_shgroup_create(sh_data->part_dot, psl->particle);
2842                                         DRW_shgroup_uniform_vec3(shgrp, "color", ma ? &ma->r : def_prim_col, 1);
2843                                         DRW_shgroup_uniform_vec3(shgrp, "outlineColor", ma ? &ma->specr : def_sec_col, 1);
2844                                         DRW_shgroup_uniform_float(shgrp, "pixel_size", DRW_viewport_pixelsize_get(), 1);
2845                                         DRW_shgroup_uniform_float(shgrp, "size", &part->draw_size, 1);
2846                                         DRW_shgroup_uniform_texture(shgrp, "ramp", G_draw.ramp);
2847                                         DRW_shgroup_call_add(shgrp, geom, mat);
2848                                         break;
2849                                 case PART_DRAW_CROSS:
2850                                         shgrp = DRW_shgroup_instance_create(
2851                                                 sh_data->part_prim, psl->particle, DRW_cache_particles_get_prim(PART_DRAW_CROSS),
2852                                                 e_data.particle_format);
2853                                         DRW_shgroup_uniform_texture(shgrp, "ramp", G_draw.ramp);
2854                                         DRW_shgroup_uniform_vec3(shgrp, "color", ma ? &ma->r : def_prim_col, 1);
2855                                         DRW_shgroup_uniform_int(shgrp, "screen_space", &screen_space[0], 1);
2856                                         break;
2857                                 case PART_DRAW_CIRC:
2858                                         shgrp = DRW_shgroup_instance_create(
2859                                                 sh_data->part_prim, psl->particle, DRW_cache_particles_get_prim(PART_DRAW_CIRC),
2860                                                 e_data.particle_format);
2861                                         DRW_shgroup_uniform_texture(shgrp, "ramp", G_draw.ramp);
2862                                         DRW_shgroup_uniform_vec3(shgrp, "color", ma ? &ma->r : def_prim_col, 1);
2863                                         DRW_shgroup_uniform_int(shgrp, "screen_space", &screen_space[1], 1);
2864                                         break;
2865                                 case PART_DRAW_AXIS:
2866                                         shgrp = DRW_shgroup_instance_create(
2867                                                 sh_data->part_axis, psl->particle, DRW_cache_particles_get_prim(PART_DRAW_AXIS),
2868                                                 e_data.particle_format);
2869                                         DRW_shgroup_uniform_int(shgrp, "screen_space", &screen_space[0], 1);
2870                                         break;
2871                                 default:
2872                                         break;
2873                         }
2874
2875                         if (shgrp) {
2876                                 if (draw_as != PART_DRAW_DOT) {
2877                                         DRW_shgroup_uniform_float(shgrp, "draw_size", &part->draw_size, 1);
2878                                         DRW_shgroup_instance_batch(shgrp, geom);
2879                                 }
2880                         }
2881                 }
2882         }
2883 }
2884
2885 static void OBJECT_cache_populate(void *vedata, Object *ob)
2886 {
2887         OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl;
2888         OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl;
2889         OBJECT_ShadingGroupList *sgl = (ob->dtx & OB_DRAWXRAY) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
2890         const DRWContextState *draw_ctx = DRW_context_state_get();
2891         const bool is_edit_mode = (ob == draw_ctx->object_edit) || BKE_object_is_in_editmode(ob);
2892         ViewLayer *view_layer = draw_ctx->view_layer;
2893         Scene *scene = draw_ctx->scene;
2894         View3D *v3d = draw_ctx->v3d;
2895         RegionView3D *rv3d = draw_ctx->rv3d;
2896         ModifierData *md = NULL;
2897         int theme_id = TH_UNDEFINED;
2898         const int ob_visibility = DRW_object_visibility_in_active_context(ob);
2899         OBJECT_Shaders *sh_data = &e_data.sh_data[draw_ctx->shader_slot];
2900
2901         /* Handle particles first in case the emitter itself shouldn't be rendered. */
2902         if (ob_visibility & OB_VISIBLE_PARTICLES) {
2903                 OBJECT_cache_populate_particles(sh_data, ob, psl);
2904         }
2905
2906         if ((ob_visibility & OB_VISIBLE_SELF) == 0) {
2907                 return;
2908         }
2909
2910         const bool do_outlines = (draw_ctx->v3d->flag & V3D_SELECT_OUTLINE) && ((ob->base_flag & BASE_SELECTED) != 0) &&
2911                                  ((DRW_object_is_renderable(ob) && (ob->dt > OB_WIRE)) || (ob->dt == OB_WIRE));
2912         const bool show_relations = ((draw_ctx->v3d->flag & V3D_HIDE_HELPLINES) == 0);
2913         const bool hide_object_extra = (v3d->overlay.flag & V3D_OVERLAY_HIDE_OBJECT_XTRAS) != 0;
2914
2915         if (do_outlines) {
2916                 if (!BKE_object_is_in_editmode(ob) &&
2917                     !((ob == draw_ctx->obact) && (draw_ctx->object_mode & OB_MODE_ALL_PAINT)))
2918                 {
2919                         struct GPUBatch *geom;
2920
2921                         /* This fixes only the biggest case which is a plane in ortho view. */
2922                         int flat_axis = 0;
2923                         bool is_flat_object_viewed_from_side = (
2924                                 (rv3d->persp == RV3D_ORTHO) &&
2925                                 DRW_object_is_flat(ob, &flat_axis) &&
2926                                 DRW_object_axis_orthogonal_to_view(ob, flat_axis));
2927
2928                         if (stl->g_data->xray_enabled || is_flat_object_viewed_from_side) {
2929                                 geom = DRW_cache_object_edge_detection_get(ob, NULL);
2930                         }
2931                         else {
2932                                 geom = DRW_cache_object_surface_get(ob);
2933                         }
2934
2935                         if (geom) {
2936                                 theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
2937                                 DRWShadingGroup *shgroup = shgroup_theme_id_to_outline_or_null(stl, theme_id, ob->base_flag);
2938                                 if (shgroup != NULL) {
2939                                         DRW_shgroup_call_object_add(shgroup, geom, ob);
2940                                 }
2941                         }
2942                 }
2943         }
2944
2945         switch (ob->type) {
2946                 case OB_MESH:
2947                 {
2948                         if (hide_object_extra) {
2949                                 break;
2950                         }
2951                         Mesh *me = ob->data;
2952                         if (me->totedge == 0) {
2953                                 if (!is_edit_mode) {
2954                                         struct GPUBatch *geom = DRW_cache_mesh_all_verts_get(ob);
2955                                         if (geom) {
2956                                                 if (theme_id == TH_UNDEFINED) {
2957                                                         theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
2958                                                 }
2959                                                 DRWShadingGroup *shgroup = shgroup_theme_id_to_point(sgl, theme_id, ob->base_flag);
2960                                                 DRW_shgroup_call_object_add(shgroup, geom, ob);
2961                                         }
2962                                 }
2963                         }
2964                         else {
2965                                 /* Kind of expensive in edit mode. Only show if in wireframe mode. */
2966                                 bool has_edit_mesh_cage = false;
2967                                 /* TODO: Should be its own function. */
2968                                 if (is_edit_mode) {
2969                                         BMEditMesh *embm = me->edit_btmesh;
2970                                         has_edit_mesh_cage = embm->mesh_eval_cage && (embm->mesh_eval_cage != embm->mesh_eval_final);
2971                                 }
2972                                 if (!is_edit_mode ||
2973                                     (((v3d->shading.type < OB_SOLID) || (ob->dt == OB_WIRE)) && has_edit_mesh_cage))
2974                                 {
2975                                         struct GPUBatch *geom = DRW_cache_mesh_loose_edges_get(ob);
2976                                         if (geom) {
2977                                                 if (theme_id == TH_UNDEFINED) {
2978                                                         theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
2979                                                 }
2980                                                 DRWShadingGroup *shgroup = shgroup_theme_id_to_wire(sgl, theme_id, ob->base_flag);
2981                                                 DRW_shgroup_call_object_add(shgroup, geom, ob);
2982                                         }
2983                                 }
2984                         }
2985                         break;
2986                 }
2987                 case OB_SURF:
2988                 {
2989                         if (hide_object_extra) {
2990                                 break;
2991                         }
2992                         struct GPUBatch *geom = DRW_cache_surf_edge_wire_get(ob);
2993                         if (geom == NULL) {
2994                                 break;
2995                         }
2996                         if (theme_id == TH_UNDEFINED) {
2997                                 theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
2998                         }
2999                         DRWShadingGroup *shgroup = shgroup_theme_id_to_wire(sgl, theme_id, ob->base_flag);
3000                         DRW_shgroup_call_object_add(shgroup, geom, ob);
3001                         break;
3002                 }
3003                 case OB_LATTICE:
3004                 {
3005                         if (!is_edit_mode) {
3006                                 if (hide_object_extra) {
3007                                         break;
3008                                 }
3009                                 struct GPUBatch *geom = DRW_cache_lattice_wire_get(ob, false);
3010                                 if (theme_id == TH_UNDEFINED) {
3011                                         theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
3012                                 }
3013
3014                                 DRWShadingGroup *shgro