source/blender/draw/modes/object_mode.c

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