Cr8-xyz/blender
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
3fc7d51ed3d3e42a67a07a7be686907358fcd872
blender/source/blender/draw/modes/object_mode.c
Dalai Felinto 3fc7d51ed3 Viewport: Fix stereoscopy volume "wires" not showing 
This is unreported. When using volume opacity 0.0, the wires were not visible
(nor were they in other cases, but this was the most obvious one).

The volume itself is still glitchy, and slightly worse than 2.79. I
still don't know how to fix this though. It seems a common problem
(see T62262).
2019-03-06 10:59:32 -03:00

3342 lines
115 KiB
C
Raw Blame History

/*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* Copyright 2016, Blender Foundation.
*/
/** \file
* \ingroup draw
*/
#include "DRW_engine.h"
#include "DRW_render.h"
#include "DNA_userdef_types.h"
#include "DNA_armature_types.h"
#include "DNA_constraint_types.h"
#include "DNA_camera_types.h"
#include "DNA_curve_types.h"
#include "DNA_mesh_types.h"
#include "DNA_meta_types.h"
#include "DNA_modifier_types.h"
#include "DNA_object_force_types.h"
#include "DNA_lightprobe_types.h"
#include "DNA_particle_types.h"
#include "DNA_rigidbody_types.h"
#include "DNA_smoke_types.h"
#include "DNA_view3d_types.h"
#include "DNA_world_types.h"
#include "BKE_anim.h"
#include "BKE_camera.h"
#include "BKE_constraint.h"
#include "BKE_curve.h"
#include "BKE_editmesh.h"
#include "BKE_mball.h"
#include "BKE_mesh.h"
#include "BKE_modifier.h"
#include "BKE_movieclip.h"
#include "BKE_object.h"
#include "BKE_particle.h"
#include "BKE_tracking.h"
#include "ED_view3d.h"
#include "GPU_batch.h"
#include "GPU_draw.h"
#include "GPU_shader.h"
#include "GPU_texture.h"
#include "MEM_guardedalloc.h"
#include "UI_resources.h"
#include "draw_mode_engines.h"
#include "draw_manager_text.h"
#include "draw_common.h"
#include "DEG_depsgraph_query.h"
extern char datatoc_object_outline_prepass_vert_glsl[];
extern char datatoc_object_outline_prepass_geom_glsl[];
extern char datatoc_object_outline_prepass_frag_glsl[];
extern char datatoc_object_outline_resolve_frag_glsl[];
extern char datatoc_object_outline_detect_frag_glsl[];
extern char datatoc_object_outline_expand_frag_glsl[];
extern char datatoc_object_grid_frag_glsl[];
extern char datatoc_object_grid_vert_glsl[];
extern char datatoc_object_empty_image_frag_glsl[];
extern char datatoc_object_empty_image_vert_glsl[];
extern char datatoc_object_lightprobe_grid_vert_glsl[];
extern char datatoc_object_loose_points_frag_glsl[];
extern char datatoc_object_particle_prim_vert_glsl[];
extern char datatoc_object_particle_dot_vert_glsl[];
extern char datatoc_object_particle_dot_frag_glsl[];
extern char datatoc_common_globals_lib_glsl[];
extern char datatoc_common_fxaa_lib_glsl[];
extern char datatoc_gpu_shader_flat_color_frag_glsl[];
extern char datatoc_gpu_shader_flat_id_frag_glsl[];
extern char datatoc_common_fullscreen_vert_glsl[];
extern char datatoc_gpu_shader_uniform_color_frag_glsl[];
extern char datatoc_gpu_shader_3D_vert_glsl[];
/* *********** LISTS *********** */
typedef struct OBJECT_PassList {
struct DRWPass *non_meshes[2];
struct DRWPass *image_empties[2];
struct DRWPass *spot_shapes[2];
struct DRWPass *ob_center;
struct DRWPass *outlines;
struct DRWPass *outlines_search;
struct DRWPass *outlines_expand;
struct DRWPass *outlines_bleed;
struct DRWPass *outlines_resolve;
struct DRWPass *grid;
struct DRWPass *bone_solid[2];
struct DRWPass *bone_outline[2];
struct DRWPass *bone_wire[2];
struct DRWPass *bone_envelope[2];
struct DRWPass *bone_axes[2];
struct DRWPass *particle;
struct DRWPass *lightprobes;
} OBJECT_PassList;
typedef struct OBJECT_FramebufferList {
struct GPUFrameBuffer *outlines_fb;
struct GPUFrameBuffer *blur_fb;
struct GPUFrameBuffer *expand_fb;
struct GPUFrameBuffer *ghost_fb;
} OBJECT_FramebufferList;
typedef struct OBJECT_StorageList {
struct OBJECT_PrivateData *g_data;
} OBJECT_StorageList;
typedef struct OBJECT_Data {
void *engine_type;
OBJECT_FramebufferList *fbl;
DRWViewportEmptyList *txl;
OBJECT_PassList *psl;
OBJECT_StorageList *stl;
} OBJECT_Data;
typedef struct OBJECT_Shaders {
/* fullscreen shaders */
GPUShader *outline_prepass;
GPUShader *outline_prepass_wire;
GPUShader *outline_resolve;
GPUShader *outline_resolve_aa;
GPUShader *outline_detect;
GPUShader *outline_detect_wire;
GPUShader *outline_fade;
GPUShader *outline_fade_large;
/* regular shaders */
GPUShader *object_empty_image;
GPUShader *object_empty_image_wire;
GPUShader *grid;
GPUShader *part_dot;
GPUShader *part_prim;
GPUShader *part_axis;
GPUShader *lightprobe_grid;
GPUShader *loose_points;
} OBJECT_Shaders;
/* *********** STATIC *********** */
typedef struct OBJECT_ShadingGroupList {
/* Reference only */
struct DRWPass *non_meshes;
struct DRWPass *image_empties;
struct DRWPass *spot_shapes;
struct DRWPass *bone_solid;
struct DRWPass *bone_outline;
struct DRWPass *bone_wire;
struct DRWPass *bone_envelope;
struct DRWPass *bone_axes;
/* Empties */
DRWShadingGroup *plain_axes;
DRWShadingGroup *cube;
DRWShadingGroup *circle;
DRWShadingGroup *sphere;
DRWShadingGroup *sphere_solid;
DRWShadingGroup *cylinder;
DRWShadingGroup *capsule_cap;
DRWShadingGroup *capsule_body;
DRWShadingGroup *cone;
DRWShadingGroup *single_arrow;
DRWShadingGroup *single_arrow_line;
DRWShadingGroup *empty_axes;
/* Force Field */
DRWShadingGroup *field_wind;
DRWShadingGroup *field_force;
DRWShadingGroup *field_vortex;
DRWShadingGroup *field_curve_sta;
DRWShadingGroup *field_curve_end;
DRWShadingGroup *field_tube_limit;
DRWShadingGroup *field_cone_limit;
/* Grease Pencil */
DRWShadingGroup *gpencil_axes;
/* Speaker */
DRWShadingGroup *speaker;
/* Probe */
DRWShadingGroup *probe_cube;
DRWShadingGroup *probe_planar;
DRWShadingGroup *probe_grid;
/* MetaBalls */
DRWShadingGroup *mball_handle;
/* Lights */
DRWShadingGroup *light_center;
DRWShadingGroup *light_groundpoint;
DRWShadingGroup *light_groundline;
DRWShadingGroup *light_circle;
DRWShadingGroup *light_circle_shadow;
DRWShadingGroup *light_sunrays;
DRWShadingGroup *light_distance;
DRWShadingGroup *light_buflimit;
DRWShadingGroup *light_buflimit_points;
DRWShadingGroup *light_area_sphere;
DRWShadingGroup *light_area_square;
DRWShadingGroup *light_area_disk;
DRWShadingGroup *light_hemi;
DRWShadingGroup *light_spot_cone;
DRWShadingGroup *light_spot_blend;
DRWShadingGroup *light_spot_pyramid;
DRWShadingGroup *light_spot_blend_rect;
DRWShadingGroup *light_spot_volume;
DRWShadingGroup *light_spot_volume_rect;
DRWShadingGroup *light_spot_volume_outside;
DRWShadingGroup *light_spot_volume_rect_outside;
/* Helpers */
DRWShadingGroup *relationship_lines;
DRWShadingGroup *constraint_lines;
/* Camera */
DRWShadingGroup *camera;
DRWShadingGroup *camera_frame;
DRWShadingGroup *camera_tria;
DRWShadingGroup *camera_focus;
DRWShadingGroup *camera_clip;
DRWShadingGroup *camera_clip_points;
DRWShadingGroup *camera_mist;
DRWShadingGroup *camera_mist_points;
DRWShadingGroup *camera_stereo_plane;
DRWShadingGroup *camera_stereo_volume;
DRWShadingGroup *camera_stereo_volume_wires;
ListBase camera_path;
/* Wire */
DRWShadingGroup *wire;
DRWShadingGroup *wire_active;
DRWShadingGroup *wire_select;
DRWShadingGroup *wire_transform;
/* Wire (duplicator) */
DRWShadingGroup *wire_dupli;
DRWShadingGroup *wire_dupli_select;
/* Points */
DRWShadingGroup *points;
DRWShadingGroup *points_active;
DRWShadingGroup *points_select;
DRWShadingGroup *points_transform;
/* Points (duplicator) */
DRWShadingGroup *points_dupli;
DRWShadingGroup *points_dupli_select;
/* Texture Space */
DRWShadingGroup *texspace;
} OBJECT_ShadingGroupList;
typedef struct OBJECT_PrivateData {
OBJECT_ShadingGroupList sgl;
OBJECT_ShadingGroupList sgl_ghost;
/* Outlines */
DRWShadingGroup *outlines_active;
DRWShadingGroup *outlines_select;
DRWShadingGroup *outlines_select_dupli;
DRWShadingGroup *outlines_transform;
/* Lightprobes */
DRWShadingGroup *lightprobes_cube_select;
DRWShadingGroup *lightprobes_cube_select_dupli;
DRWShadingGroup *lightprobes_cube_active;
DRWShadingGroup *lightprobes_cube_transform;
DRWShadingGroup *lightprobes_planar_select;
DRWShadingGroup *lightprobes_planar_select_dupli;
DRWShadingGroup *lightprobes_planar_active;
DRWShadingGroup *lightprobes_planar_transform;
/* Objects Centers */
DRWShadingGroup *center_active;
DRWShadingGroup *center_selected;
DRWShadingGroup *center_deselected;
DRWShadingGroup *center_selected_lib;
DRWShadingGroup *center_deselected_lib;
/* Outlines id offset (accessed as an array) */
int id_ofs_active;
int id_ofs_select;
int id_ofs_select_dupli;
int id_ofs_transform;
int id_ofs_prb_active;
int id_ofs_prb_select;
int id_ofs_prb_select_dupli;
int id_ofs_prb_transform;
bool xray_enabled;
bool xray_enabled_and_not_wire;
} OBJECT_PrivateData; /* Transient data */
static struct {
/* Instance Data format */
struct GPUVertFormat *particle_format;
struct GPUVertFormat *empty_image_format;
struct GPUVertFormat *empty_image_wire_format;
OBJECT_Shaders sh_data[GPU_SHADER_CFG_LEN];
float camera_pos[3];
float grid_settings[5];
float grid_mesh_size;
int grid_flag;
float grid_axes[3];
int zpos_flag;
int zneg_flag;
float zplane_axes[3];
float inv_viewport_size[2];
bool draw_grid;
/* Temp buffer textures */
struct GPUTexture *outlines_depth_tx;
struct GPUTexture *outlines_id_tx;
struct GPUTexture *outlines_color_tx;
struct GPUTexture *outlines_blur_tx;
ListBase smoke_domains;
} e_data = {NULL}; /* Engine data */
enum {
SHOW_AXIS_X = (1 << 0),
SHOW_AXIS_Y = (1 << 1),
SHOW_AXIS_Z = (1 << 2),
SHOW_GRID = (1 << 3),
PLANE_XY = (1 << 4),
PLANE_XZ = (1 << 5),
PLANE_YZ = (1 << 6),
CLIP_ZPOS = (1 << 7),
CLIP_ZNEG = (1 << 8),
GRID_BACK = (1 << 9),
};
/* Prototypes. */
static void DRW_shgroup_empty_ex(OBJECT_ShadingGroupList *sgl, float mat[4][4], float *draw_size, char draw_type, float *color);
/* *********** FUNCTIONS *********** */
static void OBJECT_engine_init(void *vedata)
{
OBJECT_FramebufferList *fbl = ((OBJECT_Data *)vedata)->fbl;
const float *viewport_size = DRW_viewport_size_get();
const int size[2] = {(int)viewport_size[0], (int)viewport_size[1]};
if (DRW_state_is_fbo()) {
e_data.outlines_depth_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_DEPTH_COMPONENT24,
&draw_engine_object_type);
/* XXX TODO GPU_R16UI can overflow, it would cause no harm
* (only bad colored or missing outlines) but we should
* use 32bits only if the scene have that many objects */
e_data.outlines_id_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_R16UI,
&draw_engine_object_type);
GPU_framebuffer_ensure_config(&fbl->outlines_fb, {
GPU_ATTACHMENT_TEXTURE(e_data.outlines_depth_tx),
GPU_ATTACHMENT_TEXTURE(e_data.outlines_id_tx)
});
e_data.outlines_color_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_RGBA8,
&draw_engine_object_type);
GPU_framebuffer_ensure_config(&fbl->expand_fb, {
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(e_data.outlines_color_tx)
});
e_data.outlines_blur_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_RGBA8,
&draw_engine_object_type);
GPU_framebuffer_ensure_config(&fbl->blur_fb, {
GPU_ATTACHMENT_NONE,
GPU_ATTACHMENT_TEXTURE(e_data.outlines_blur_tx)
});
}
/* Shaders */
const DRWContextState *draw_ctx = DRW_context_state_get();
OBJECT_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
const GPUShaderConfigData *sh_cfg_data = &GPU_shader_cfg_data[draw_ctx->sh_cfg];
if (!sh_data->outline_resolve) {
/* Outline */
sh_data->outline_prepass = GPU_shader_create_from_arrays({
.vert = (const char *[]){sh_cfg_data->lib, datatoc_gpu_shader_3D_vert_glsl, NULL},
.frag = (const char *[]){datatoc_object_outline_prepass_frag_glsl, NULL},
.defs = (const char *[]){sh_cfg_data->def, NULL},
});
sh_data->outline_prepass_wire = GPU_shader_create_from_arrays({
.vert = (const char *[]){sh_cfg_data->lib, datatoc_object_outline_prepass_vert_glsl, NULL},
.geom = (const char *[]){sh_cfg_data->lib, datatoc_object_outline_prepass_geom_glsl, NULL},
.frag = (const char *[]){datatoc_object_outline_prepass_frag_glsl, NULL},
.defs = (const char *[]){sh_cfg_data->def, NULL},
});
sh_data->outline_resolve = DRW_shader_create_fullscreen(datatoc_object_outline_resolve_frag_glsl, NULL);
sh_data->outline_resolve_aa = DRW_shader_create_with_lib(
datatoc_common_fullscreen_vert_glsl, NULL,
datatoc_object_outline_resolve_frag_glsl,
datatoc_common_fxaa_lib_glsl,
"#define FXAA_ALPHA\n"
"#define USE_FXAA\n");
sh_data->outline_detect = DRW_shader_create_with_lib(
datatoc_common_fullscreen_vert_glsl, NULL,
datatoc_object_outline_detect_frag_glsl,
datatoc_common_globals_lib_glsl,
NULL);
sh_data->outline_detect_wire = DRW_shader_create_with_lib(
datatoc_common_fullscreen_vert_glsl, NULL,
datatoc_object_outline_detect_frag_glsl,
datatoc_common_globals_lib_glsl,
"#define WIRE\n");
sh_data->outline_fade = DRW_shader_create_fullscreen(datatoc_object_outline_expand_frag_glsl, NULL);
sh_data->outline_fade_large = DRW_shader_create_fullscreen(datatoc_object_outline_expand_frag_glsl, "#define LARGE_OUTLINE\n");
/* Empty images */
{
const char *empty_image_defs = (
"#define DEPTH_UNCHANGED " STRINGIFY(OB_EMPTY_IMAGE_DEPTH_DEFAULT) "\n"
"#define DEPTH_FRONT " STRINGIFY(OB_EMPTY_IMAGE_DEPTH_FRONT) "\n"
"#define DEPTH_BACK " STRINGIFY(OB_EMPTY_IMAGE_DEPTH_BACK) "\n");
sh_data->object_empty_image = GPU_shader_create_from_arrays({
.vert = (const char *[]){sh_cfg_data->lib, datatoc_object_empty_image_vert_glsl, NULL},
.frag = (const char *[]){datatoc_object_empty_image_frag_glsl, NULL},
.defs = (const char *[]){sh_cfg_data->def, empty_image_defs, NULL},
});
sh_data->object_empty_image_wire = GPU_shader_create_from_arrays({
.vert = (const char *[]){sh_cfg_data->lib, datatoc_object_empty_image_vert_glsl, NULL},
.frag = (const char *[]){datatoc_object_empty_image_frag_glsl, NULL},
.defs = (const char *[]){sh_cfg_data->def, "#define USE_WIRE\n", empty_image_defs, NULL},
});
}
/* Grid */
sh_data->grid = DRW_shader_create_with_lib(
datatoc_object_grid_vert_glsl, NULL,
datatoc_object_grid_frag_glsl,
datatoc_common_globals_lib_glsl, NULL);
/* Particles */
sh_data->part_prim = DRW_shader_create(
datatoc_object_particle_prim_vert_glsl, NULL, datatoc_gpu_shader_flat_color_frag_glsl, NULL);
sh_data->part_axis = DRW_shader_create(
datatoc_object_particle_prim_vert_glsl, NULL, datatoc_gpu_shader_flat_color_frag_glsl,
"#define USE_AXIS\n");
sh_data->part_dot = DRW_shader_create(
datatoc_object_particle_dot_vert_glsl, NULL, datatoc_object_particle_dot_frag_glsl, NULL);
/* Lightprobes */
sh_data->lightprobe_grid = DRW_shader_create(
datatoc_object_lightprobe_grid_vert_glsl, NULL, datatoc_gpu_shader_flat_id_frag_glsl, NULL);
/* Loose Points */
sh_data->loose_points = GPU_shader_create_from_arrays({
.vert = (const char *[]){sh_cfg_data->lib, datatoc_gpu_shader_3D_vert_glsl, NULL},
.frag = (const char *[]){datatoc_object_loose_points_frag_glsl, NULL},
.defs = (const char *[]){sh_cfg_data->def, NULL},
});
}
{
/* Grid precompute */
float invviewmat[4][4], invwinmat[4][4];
float viewmat[4][4], winmat[4][4];
View3D *v3d = draw_ctx->v3d;
Scene *scene = draw_ctx->scene;
RegionView3D *rv3d = draw_ctx->rv3d;
float grid_scale = ED_view3d_grid_scale(scene, v3d, NULL);
float grid_res;
const bool show_axis_x = (v3d->gridflag & V3D_SHOW_X) != 0;
const bool show_axis_y = (v3d->gridflag & V3D_SHOW_Y) != 0;
const bool show_axis_z = (v3d->gridflag & V3D_SHOW_Z) != 0;
const bool show_floor = (v3d->gridflag & V3D_SHOW_FLOOR) != 0;
e_data.draw_grid = show_axis_x || show_axis_y || show_axis_z || show_floor;
DRW_viewport_matrix_get(winmat, DRW_MAT_WIN);
DRW_viewport_matrix_get(viewmat, DRW_MAT_VIEW);
DRW_viewport_matrix_get(invwinmat, DRW_MAT_WININV);
DRW_viewport_matrix_get(invviewmat, DRW_MAT_VIEWINV);
/* Setup camera pos */
copy_v3_v3(e_data.camera_pos, invviewmat[3]);
/* if perps */
if (winmat[3][3] == 0.0f) {
float fov;
float viewvecs[2][4] = {
{1.0f, -1.0f, -1.0f, 1.0f},
{-1.0f, 1.0f, -1.0f, 1.0f},
};
/* convert the view vectors to view space */
for (int i = 0; i < 2; i++) {
mul_m4_v4(invwinmat, viewvecs[i]);
mul_v3_fl(viewvecs[i], 1.0f / viewvecs[i][2]); /* perspective divide */
}
fov = angle_v3v3(viewvecs[0], viewvecs[1]) / 2.0f;
grid_res = fabsf(tanf(fov)) / grid_scale;
e_data.grid_flag = (1 << 4); /* XY plane */
if (show_axis_x) {
e_data.grid_flag |= SHOW_AXIS_X;
}
if (show_axis_y) {
e_data.grid_flag |= SHOW_AXIS_Y;
}
if (show_floor) {
e_data.grid_flag |= SHOW_GRID;
}
}
else {
if (rv3d->view != RV3D_VIEW_USER) {
/* Allow 3 more subdivisions. */
grid_scale /= powf(v3d->gridsubdiv, 3);
}
float viewdist = 1.0f / max_ff(fabsf(winmat[0][0]), fabsf(winmat[1][1]));
grid_res = viewdist / grid_scale;
if (ELEM(rv3d->view, RV3D_VIEW_RIGHT, RV3D_VIEW_LEFT)) {
e_data.draw_grid = true;
e_data.grid_flag = PLANE_YZ | SHOW_AXIS_Y | SHOW_AXIS_Z | SHOW_GRID | GRID_BACK;
}
else if (ELEM(rv3d->view, RV3D_VIEW_TOP, RV3D_VIEW_BOTTOM)) {
e_data.draw_grid = true;
e_data.grid_flag = PLANE_XY | SHOW_AXIS_X | SHOW_AXIS_Y | SHOW_GRID | GRID_BACK;
}
else if (ELEM(rv3d->view, RV3D_VIEW_FRONT, RV3D_VIEW_BACK)) {
e_data.draw_grid = true;
e_data.grid_flag = PLANE_XZ | SHOW_AXIS_X | SHOW_AXIS_Z | SHOW_GRID | GRID_BACK;
}
else { /* RV3D_VIEW_USER */
e_data.grid_flag = PLANE_XY;
if (show_axis_x) {
e_data.grid_flag |= SHOW_AXIS_X;
}
if (show_axis_y) {
e_data.grid_flag |= SHOW_AXIS_Y;
}
if (show_floor) {
e_data.grid_flag |= SHOW_GRID;
}
}
}
e_data.grid_axes[0] = (float)((e_data.grid_flag & (PLANE_XZ | PLANE_XY)) != 0);
e_data.grid_axes[1] = (float)((e_data.grid_flag & (PLANE_YZ | PLANE_XY)) != 0);
e_data.grid_axes[2] = (float)((e_data.grid_flag & (PLANE_YZ | PLANE_XZ)) != 0);
/* Z axis if needed */
if (((rv3d->view == RV3D_VIEW_USER) || (rv3d->persp != RV3D_ORTHO)) && show_axis_z) {
e_data.zpos_flag = SHOW_AXIS_Z;
float zvec[4] = {0.0f, 0.0f, -1.0f, 0.0f};
mul_m4_v4(invviewmat, zvec);
/* z axis : chose the most facing plane */
if (fabsf(zvec[0]) < fabsf(zvec[1])) {
e_data.zpos_flag |= PLANE_XZ;
}
else {
e_data.zpos_flag |= PLANE_YZ;
}
e_data.zneg_flag = e_data.zpos_flag;
/* Persp : If camera is below floor plane, we switch clipping
* Ortho : If eye vector is looking up, we switch clipping */
if (((winmat[3][3] == 0.0f) && (e_data.camera_pos[2] > 0.0f)) ||
((winmat[3][3] != 0.0f) && (zvec[2] < 0.0f)))
{
e_data.zpos_flag |= CLIP_ZPOS;
e_data.zneg_flag |= CLIP_ZNEG;
}
else {
e_data.zpos_flag |= CLIP_ZNEG;
e_data.zneg_flag |= CLIP_ZPOS;
}
e_data.zplane_axes[0] = (float)((e_data.zpos_flag & (PLANE_XZ | PLANE_XY)) != 0);
e_data.zplane_axes[1] = (float)((e_data.zpos_flag & (PLANE_YZ | PLANE_XY)) != 0);
e_data.zplane_axes[2] = (float)((e_data.zpos_flag & (PLANE_YZ | PLANE_XZ)) != 0);
}
else {
e_data.zneg_flag = e_data.zpos_flag = CLIP_ZNEG | CLIP_ZPOS;
}
float dist;
if (rv3d->persp == RV3D_CAMOB && v3d->camera && v3d->camera->type == OB_CAMERA) {
Object *camera_object = DEG_get_evaluated_object(draw_ctx->depsgraph, v3d->camera);
dist = ((Camera *)(camera_object->data))->clip_end;
}
else {
dist = v3d->clip_end;
}
e_data.grid_settings[0] = dist / 2.0f; /* gridDistance */
e_data.grid_settings[1] = grid_res; /* gridResolution */
e_data.grid_settings[2] = grid_scale; /* gridScale */
e_data.grid_settings[3] = v3d->gridsubdiv; /* gridSubdiv */
e_data.grid_settings[4] = (v3d->gridsubdiv > 1) ? 1.0f / logf(v3d->gridsubdiv) : 0.0f; /* 1/log(gridSubdiv) */
if (winmat[3][3] == 0.0f) {
e_data.grid_mesh_size = dist;
}
else {
float viewdist = 1.0f / min_ff(fabsf(winmat[0][0]), fabsf(winmat[1][1]));
e_data.grid_mesh_size = viewdist * dist;
}
}
copy_v2_v2(e_data.inv_viewport_size, DRW_viewport_size_get());
invert_v2(e_data.inv_viewport_size);
}
static void OBJECT_engine_free(void)
{
MEM_SAFE_FREE(e_data.particle_format);
MEM_SAFE_FREE(e_data.empty_image_format);
MEM_SAFE_FREE(e_data.empty_image_wire_format);
for (int sh_data_index = 0; sh_data_index < ARRAY_SIZE(e_data.sh_data); sh_data_index++) {
OBJECT_Shaders *sh_data = &e_data.sh_data[sh_data_index];
GPUShader **sh_data_as_array = (GPUShader **)sh_data;
for (int i = 0; i < (sizeof(OBJECT_Shaders) / sizeof(GPUShader *)); i++) {
DRW_SHADER_FREE_SAFE(sh_data_as_array[i]);
}
}
}
static DRWShadingGroup *shgroup_outline(DRWPass *pass, const int *ofs, GPUShader *sh, eGPUShaderConfig sh_cfg)
{
DRWShadingGroup *grp = DRW_shgroup_create(sh, pass);
DRW_shgroup_uniform_int(grp, "baseId", ofs, 1);
if (sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
}
return grp;
}
/* currently same as 'shgroup_outline', new function to avoid confustion */
static DRWShadingGroup *shgroup_wire(DRWPass *pass, const float col[4], GPUShader *sh, eGPUShaderConfig sh_cfg)
{
DRWShadingGroup *grp = DRW_shgroup_create(sh, pass);
DRW_shgroup_uniform_vec4(grp, "color", col, 1);
if (sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
}
return grp;
}
/* currently same as 'shgroup_outline', new function to avoid confustion */
static DRWShadingGroup *shgroup_points(DRWPass *pass, const float col[4], GPUShader *sh, eGPUShaderConfig sh_cfg)
{
DRWShadingGroup *grp = DRW_shgroup_create(sh, pass);
DRW_shgroup_uniform_vec4(grp, "color", col, 1);
DRW_shgroup_uniform_vec4(grp, "innerColor", G_draw.block.colorEditMeshMiddle, 1);
if (sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
}
return grp;
}
static int *shgroup_theme_id_to_probe_outline_counter(
OBJECT_StorageList *stl, int theme_id, const int base_flag)
{
if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
switch (theme_id) {
case TH_ACTIVE:
case TH_SELECT:
return &stl->g_data->id_ofs_prb_select_dupli;
case TH_TRANSFORM:
default:
return &stl->g_data->id_ofs_prb_transform;
}
}
switch (theme_id) {
case TH_ACTIVE:
return &stl->g_data->id_ofs_prb_active;
case TH_SELECT:
return &stl->g_data->id_ofs_prb_select;
case TH_TRANSFORM:
default:
return &stl->g_data->id_ofs_prb_transform;
}
}
static int *shgroup_theme_id_to_outline_counter(
OBJECT_StorageList *stl, int theme_id, const int base_flag)
{
if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
switch (theme_id) {
case TH_ACTIVE:
case TH_SELECT:
return &stl->g_data->id_ofs_select_dupli;
case TH_TRANSFORM:
default:
return &stl->g_data->id_ofs_transform;
}
}
switch (theme_id) {
case TH_ACTIVE:
return &stl->g_data->id_ofs_active;
case TH_SELECT:
return &stl->g_data->id_ofs_select;
case TH_TRANSFORM:
default:
return &stl->g_data->id_ofs_transform;
}
}
static DRWShadingGroup *shgroup_theme_id_to_probe_planar_outline_shgrp(
OBJECT_StorageList *stl, int theme_id)
{
/* does not increment counter */
switch (theme_id) {
case TH_ACTIVE:
return stl->g_data->lightprobes_planar_active;
case TH_SELECT:
return stl->g_data->lightprobes_planar_select;
case TH_TRANSFORM:
default:
return stl->g_data->lightprobes_planar_transform;
}
}
static DRWShadingGroup *shgroup_theme_id_to_probe_cube_outline_shgrp(
OBJECT_StorageList *stl, int theme_id, const int base_flag)
{
/* does not increment counter */
if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
switch (theme_id) {
case TH_ACTIVE:
case TH_SELECT:
return stl->g_data->lightprobes_cube_select_dupli;
case TH_TRANSFORM:
default:
return stl->g_data->lightprobes_cube_transform;
}
}
switch (theme_id) {
case TH_ACTIVE:
return stl->g_data->lightprobes_cube_active;
case TH_SELECT:
return stl->g_data->lightprobes_cube_select;
case TH_TRANSFORM:
default:
return stl->g_data->lightprobes_cube_transform;
}
}
static DRWShadingGroup *shgroup_theme_id_to_outline_or_null(
OBJECT_StorageList *stl, int theme_id, const int base_flag)
{
int *counter = shgroup_theme_id_to_outline_counter(stl, theme_id, base_flag);
*counter += 1;
if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
switch (theme_id) {
case TH_ACTIVE:
case TH_SELECT:
return stl->g_data->outlines_select_dupli;
case TH_TRANSFORM:
return stl->g_data->outlines_transform;
default:
return NULL;
}
}
switch (theme_id) {
case TH_ACTIVE:
return stl->g_data->outlines_active;
case TH_SELECT:
return stl->g_data->outlines_select;
case TH_TRANSFORM:
return stl->g_data->outlines_transform;
default:
return NULL;
}
}
static DRWShadingGroup *shgroup_theme_id_to_wire(
OBJECT_ShadingGroupList *sgl, int theme_id, const short base_flag)
{
if (UNLIKELY(base_flag & BASE_FROM_SET)) {
return sgl->wire_dupli;
}
else if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
switch (theme_id) {
case TH_ACTIVE:
case TH_SELECT:
return sgl->wire_dupli_select;
case TH_TRANSFORM:
return sgl->wire_transform;
default:
return sgl->wire_dupli;
}
}
switch (theme_id) {
case TH_ACTIVE:
return sgl->wire_active;
case TH_SELECT:
return sgl->wire_select;
case TH_TRANSFORM:
return sgl->wire_transform;
default:
return sgl->wire;
}
}
static DRWShadingGroup *shgroup_theme_id_to_point(
OBJECT_ShadingGroupList *sgl, int theme_id, const short base_flag)
{
if (UNLIKELY(base_flag & BASE_FROM_SET)) {
return sgl->points_dupli;
}
else if (UNLIKELY(base_flag & BASE_FROM_DUPLI)) {
switch (theme_id) {
case TH_ACTIVE:
case TH_SELECT:
return sgl->points_dupli_select;
case TH_TRANSFORM:
return sgl->points_transform;
default:
return sgl->points_dupli;
}
}
switch (theme_id) {
case TH_ACTIVE:
return sgl->points_active;
case TH_SELECT:
return sgl->points_select;
case TH_TRANSFORM:
return sgl->points_transform;
default:
return sgl->points;
}
}
static void image_calc_aspect(Image *ima, const int size[2], float r_image_aspect[2])
{
float ima_x, ima_y;
if (ima) {
ima_x = size[0];
ima_y = size[1];
}
else {
/* if no image, make it a 1x1 empty square, honor scale & offset */
ima_x = ima_y = 1.0f;
}
/* Get the image aspect even if the buffer is invalid */
float sca_x = 1.0f, sca_y = 1.0f;
if (ima) {
if (ima->aspx > ima->aspy) {
sca_y = ima->aspy / ima->aspx;
}
else if (ima->aspx < ima->aspy) {
sca_x = ima->aspx / ima->aspy;
}
}
const float scale_x_inv = ima_x * sca_x;
const float scale_y_inv = ima_y * sca_y;
if (scale_x_inv > scale_y_inv) {
r_image_aspect[0] = 1.0f;
r_image_aspect[1] = scale_y_inv / scale_x_inv;
}
else {
r_image_aspect[0] = scale_x_inv / scale_y_inv;
r_image_aspect[1] = 1.0f;
}
}
static void DRW_shgroup_empty_image(
OBJECT_Shaders *sh_data, OBJECT_ShadingGroupList *sgl,
Object *ob, const float color[3], RegionView3D *rv3d, eGPUShaderConfig sh_cfg)
{
/* TODO: 'StereoViews', see draw_empty_image. */
if (!BKE_object_empty_image_is_visible_in_view3d(ob, rv3d)) {
return;
}
/* Calling 'BKE_image_get_size' may free the texture. Get the size from 'tex' instead, see: T59347 */
int size[2] = {0};
GPUTexture *tex = NULL;
if (ob->data != NULL) {
tex = GPU_texture_from_blender(ob->data, ob->iuser, GL_TEXTURE_2D, false);
if (tex) {
size[0] = GPU_texture_width(tex);
size[1] = GPU_texture_height(tex);
}
}
CLAMP_MIN(size[0], 1);
CLAMP_MIN(size[1], 1);
float image_aspect[2];
image_calc_aspect(ob->data, size, image_aspect);
/* OPTI(fclem) We need sorting only for transparent images. If an image as no alpha channel and
* ob->col[3] == 1.0f, we could remove it from the sorting pass. */
if (tex && (ob->color[3] > 0.0f)) {
DRWShadingGroup *grp = DRW_shgroup_create(sh_data->object_empty_image, sgl->image_empties);
DRW_shgroup_uniform_texture(grp, "image", tex);
/* TODO(fclem) implement DRW_shgroup_uniform_vec2_copy */
DRW_shgroup_uniform_float_copy(grp, "aspectX", image_aspect[0]);
DRW_shgroup_uniform_float_copy(grp, "aspectY", image_aspect[1]);
DRW_shgroup_uniform_int_copy(grp, "depthMode", ob->empty_image_depth);
DRW_shgroup_uniform_float(grp, "size", &ob->empty_drawsize, 1);
DRW_shgroup_uniform_vec2(grp, "offset", ob->ima_ofs, 1);
DRW_shgroup_uniform_vec4(grp, "objectColor", ob->color, 1);
if (sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
}
DRW_shgroup_call_add(grp, DRW_cache_image_plane_get(), ob->obmat);
}
{
DRWShadingGroup *grp = DRW_shgroup_create(sh_data->object_empty_image_wire, sgl->non_meshes);
/* TODO(fclem) implement DRW_shgroup_uniform_vec2_copy */
DRW_shgroup_uniform_float_copy(grp, "aspectX", image_aspect[0]);
DRW_shgroup_uniform_float_copy(grp, "aspectY", image_aspect[1]);
DRW_shgroup_uniform_int_copy(grp, "depthMode", ob->empty_image_depth);
DRW_shgroup_uniform_float(grp, "size", &ob->empty_drawsize, 1);
DRW_shgroup_uniform_vec2(grp, "offset", ob->ima_ofs, 1);
DRW_shgroup_uniform_vec3(grp, "color", color, 1);
if (sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, DRW_context_state_get()->rv3d);
}
DRW_shgroup_call_add(grp, DRW_cache_image_plane_wire_get(), ob->obmat);
}
}
static void OBJECT_cache_init(void *vedata)
{
const GlobalsUboStorage *gb = &G_draw.block;
OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl;
OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl;
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
OBJECT_PrivateData *g_data;
const DRWContextState *draw_ctx = DRW_context_state_get();
OBJECT_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
const float outline_width = UI_GetThemeValuef(TH_OUTLINE_WIDTH);
const bool do_outline_expand = (U.pixelsize > 1.0) || (outline_width > 2.0f);
const bool do_large_expand = ((U.pixelsize > 1.0) && (outline_width > 2.0f)) || (outline_width > 4.0f);
if (!stl->g_data) {
/* Alloc transient pointers */
stl->g_data = MEM_mallocN(sizeof(*stl->g_data), __func__);
}
g_data = stl->g_data;
g_data->xray_enabled = XRAY_ENABLED(draw_ctx->v3d) &&
(draw_ctx->v3d->shading.type < OB_MATERIAL);
g_data->xray_enabled_and_not_wire = g_data->xray_enabled && draw_ctx->v3d->shading.type > OB_WIRE;
{
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_WIRE;
psl->outlines = DRW_pass_create("Outlines Depth Pass", state);
GPUShader *sh = sh_data->outline_prepass;
if (g_data->xray_enabled_and_not_wire) {
sh = sh_data->outline_prepass_wire;
}
g_data->outlines_select = shgroup_outline(psl->outlines, &g_data->id_ofs_select, sh, draw_ctx->sh_cfg);
g_data->outlines_select_dupli = shgroup_outline(psl->outlines, &g_data->id_ofs_select_dupli, sh, draw_ctx->sh_cfg);
g_data->outlines_transform = shgroup_outline(psl->outlines, &g_data->id_ofs_transform, sh, draw_ctx->sh_cfg);
g_data->outlines_active = shgroup_outline(psl->outlines, &g_data->id_ofs_active, sh, draw_ctx->sh_cfg);
g_data->id_ofs_select = 0;
g_data->id_ofs_select_dupli = 0;
g_data->id_ofs_active = 0;
g_data->id_ofs_transform = 0;
}
{
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_POINT;
DRWPass *pass = psl->lightprobes = DRW_pass_create("Object Probe Pass", state);
struct GPUBatch *sphere = DRW_cache_sphere_get();
struct GPUBatch *quad = DRW_cache_quad_get();
/* Cubemap */
g_data->lightprobes_cube_select = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_select);
g_data->lightprobes_cube_select_dupli = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_select_dupli);
g_data->lightprobes_cube_active = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_active);
g_data->lightprobes_cube_transform = shgroup_instance_outline(pass, sphere, &g_data->id_ofs_prb_transform);
/* Planar */
g_data->lightprobes_planar_select = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_select);
g_data->lightprobes_planar_select_dupli = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_select_dupli);
g_data->lightprobes_planar_active = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_active);
g_data->lightprobes_planar_transform = shgroup_instance_outline(pass, quad, &g_data->id_ofs_prb_transform);
g_data->id_ofs_prb_select = 0;
g_data->id_ofs_prb_select_dupli = 0;
g_data->id_ofs_prb_active = 0;
g_data->id_ofs_prb_transform = 0;
}
{
DRWState state = DRW_STATE_WRITE_COLOR;
struct GPUBatch *quad = DRW_cache_fullscreen_quad_get();
/* Don't occlude the "outline" detection pass if in xray mode (too much flickering). */
float alphaOcclu = (g_data->xray_enabled) ? 1.0f : 0.35f;
psl->outlines_search = DRW_pass_create("Outlines Detect Pass", state);
GPUShader *sh = (g_data->xray_enabled_and_not_wire) ? sh_data->outline_detect_wire : sh_data->outline_detect;
DRWShadingGroup *grp = DRW_shgroup_create(sh, psl->outlines_search);
DRW_shgroup_uniform_texture_ref(grp, "outlineId", &e_data.outlines_id_tx);
DRW_shgroup_uniform_texture_ref(grp, "outlineDepth", &e_data.outlines_depth_tx);
DRW_shgroup_uniform_texture_ref(grp, "sceneDepth", &dtxl->depth);
DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
DRW_shgroup_uniform_float_copy(grp, "alphaOcclu", alphaOcclu);
DRW_shgroup_uniform_int(grp, "idOffsets", &stl->g_data->id_ofs_active, 4);
DRW_shgroup_call_add(grp, quad, NULL);
/* This is the bleed pass if do_outline_expand is false. */
GPUShader *fade_sh = (do_large_expand) ? sh_data->outline_fade_large : sh_data->outline_fade;
psl->outlines_expand = DRW_pass_create("Outlines Expand Pass", state);
grp = DRW_shgroup_create(fade_sh, psl->outlines_expand);
DRW_shgroup_uniform_texture_ref(grp, "outlineColor", &e_data.outlines_blur_tx);
DRW_shgroup_uniform_bool_copy(grp, "doExpand", do_outline_expand);
DRW_shgroup_call_add(grp, quad, NULL);
psl->outlines_bleed = DRW_pass_create("Outlines Bleed Pass", state);
if (do_outline_expand) {
grp = DRW_shgroup_create(sh_data->outline_fade, psl->outlines_bleed);
DRW_shgroup_uniform_texture_ref(grp, "outlineColor", &e_data.outlines_color_tx);
DRW_shgroup_uniform_bool_copy(grp, "doExpand", false);
DRW_shgroup_call_add(grp, quad, NULL);
}
}
{
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND;
psl->outlines_resolve = DRW_pass_create("Outlines Resolve Pass", state);
struct GPUBatch *quad = DRW_cache_fullscreen_quad_get();
GPUTexture **outline_tx = (do_outline_expand) ? &e_data.outlines_blur_tx : &e_data.outlines_color_tx;
DRWShadingGroup *grp = DRW_shgroup_create(sh_data->outline_resolve_aa, psl->outlines_resolve);
DRW_shgroup_uniform_texture_ref(grp, "outlineBluredColor", outline_tx);
DRW_shgroup_uniform_vec2(grp, "rcpDimensions", e_data.inv_viewport_size, 1);
DRW_shgroup_call_add(grp, quad, NULL);
}
{
/* Grid pass */
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND;
psl->grid = DRW_pass_create("Infinite Grid Pass", state);
struct GPUBatch *geom = DRW_cache_grid_get();
float grid_line_size = max_ff(0.0f, U.pixelsize - 1.0f) * 0.5f;
static float mat[4][4];
unit_m4(mat);
/* Create 3 quads to render ordered transparency Z axis */
DRWShadingGroup *grp = DRW_shgroup_create(sh_data->grid, psl->grid);
DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zneg_flag, 1);
DRW_shgroup_uniform_vec3(grp, "planeAxes", e_data.zplane_axes, 1);
DRW_shgroup_uniform_vec3(grp, "cameraPos", e_data.camera_pos, 1);
DRW_shgroup_uniform_vec4(grp, "gridSettings", e_data.grid_settings, 1);
DRW_shgroup_uniform_float_copy(grp, "lineKernel", grid_line_size);
DRW_shgroup_uniform_float_copy(grp, "meshSize", e_data.grid_mesh_size);
DRW_shgroup_uniform_float(grp, "gridOneOverLogSubdiv", &e_data.grid_settings[4], 1);
DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_call_add(grp, geom, mat);
grp = DRW_shgroup_create(sh_data->grid, psl->grid);
DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.grid_flag, 1);
DRW_shgroup_uniform_vec3(grp, "planeAxes", e_data.grid_axes, 1);
DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_call_add(grp, geom, mat);
grp = DRW_shgroup_create(sh_data->grid, psl->grid);
DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zpos_flag, 1);
DRW_shgroup_uniform_vec3(grp, "planeAxes", e_data.zplane_axes, 1);
DRW_shgroup_uniform_block(grp, "globalsBlock", G_draw.block_ubo);
DRW_shgroup_uniform_texture_ref(grp, "depthBuffer", &dtxl->depth);
DRW_shgroup_call_add(grp, geom, mat);
}
for (int i = 0; i < 2; ++i) {
OBJECT_ShadingGroupList *sgl = (i == 1) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
/* Solid bones */
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL;
sgl->bone_solid = psl->bone_solid[i] = DRW_pass_create("Bone Solid Pass", state);
sgl->bone_outline = psl->bone_outline[i] = DRW_pass_create("Bone Outline Pass", state);
/* Wire bones */
state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND;
sgl->bone_wire = psl->bone_wire[i] = DRW_pass_create("Bone Wire Pass", state);
/* distance outline around envelope bones */
state = DRW_STATE_ADDITIVE | DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_CULL_FRONT;
sgl->bone_envelope = psl->bone_envelope[i] = DRW_pass_create("Bone Envelope Outline Pass", state);
state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_WIRE;
sgl->bone_axes = psl->bone_axes[i] = DRW_pass_create("Bone Axes Pass", state);
}
for (int i = 0; i < 2; ++i) {
OBJECT_ShadingGroupList *sgl = (i == 1) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
/* Non Meshes Pass (Camera, empties, lights ...) */
struct GPUBatch *geom;
struct GPUShader *sh;
DRWState state =
DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH |
DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND | DRW_STATE_POINT | DRW_STATE_WIRE;
sgl->non_meshes = psl->non_meshes[i] = DRW_pass_create("Non Meshes Pass", state);
state = DRW_STATE_WRITE_COLOR |
DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND | DRW_STATE_WIRE;
sgl->image_empties = psl->image_empties[i] = DRW_pass_create("Image Empties", state);
/* Empties */
geom = DRW_cache_plain_axes_get();
sgl->plain_axes = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_empty_cube_get();
sgl->cube = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_circle_get();
sgl->circle = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_empty_sphere_get();
sgl->sphere = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_sphere_get();
sgl->sphere_solid = shgroup_instance_solid(sgl->non_meshes, geom);
geom = DRW_cache_empty_cylinder_get();
sgl->cylinder = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_empty_capsule_cap_get();
sgl->capsule_cap = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_empty_capsule_body_get();
sgl->capsule_body = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_empty_cone_get();
sgl->cone = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_single_arrow_get();
sgl->single_arrow = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_single_line_get();
sgl->single_arrow_line = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_bone_arrows_get();
sgl->empty_axes = shgroup_instance_empty_axes(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* Force Field */
geom = DRW_cache_field_wind_get();
sgl->field_wind = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_field_force_get();
sgl->field_force = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_field_vortex_get();
sgl->field_vortex = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_screenspace_circle_get();
sgl->field_curve_sta = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* Grease Pencil */
geom = DRW_cache_gpencil_axes_get();
sgl->gpencil_axes = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* Speaker */
geom = DRW_cache_speaker_get();
sgl->speaker = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* Probe */
static float probeSize = 14.0f;
geom = DRW_cache_lightprobe_cube_get();
sgl->probe_cube = shgroup_instance_screenspace(sgl->non_meshes, geom, &probeSize, draw_ctx->sh_cfg);
geom = DRW_cache_lightprobe_grid_get();
sgl->probe_grid = shgroup_instance_screenspace(sgl->non_meshes, geom, &probeSize, draw_ctx->sh_cfg);
static float probePlanarSize = 20.0f;
geom = DRW_cache_lightprobe_planar_get();
sgl->probe_planar = shgroup_instance_screenspace(sgl->non_meshes, geom, &probePlanarSize, draw_ctx->sh_cfg);
/* Camera */
geom = DRW_cache_camera_get();
sgl->camera = shgroup_camera_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_camera_frame_get();
sgl->camera_frame = shgroup_camera_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_camera_tria_get();
sgl->camera_tria = shgroup_camera_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_plain_axes_get();
sgl->camera_focus = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_single_line_get();
sgl->camera_clip = shgroup_distance_lines_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
sgl->camera_mist = shgroup_distance_lines_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_single_line_endpoints_get();
sgl->camera_clip_points = shgroup_distance_lines_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
sgl->camera_mist_points = shgroup_distance_lines_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_quad_get();
sgl->camera_stereo_plane = shgroup_instance_alpha(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_cube_get();
sgl->camera_stereo_volume = shgroup_instance_alpha(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_empty_cube_get();
sgl->camera_stereo_volume_wires = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
BLI_listbase_clear(&sgl->camera_path);
/* Texture Space */
geom = DRW_cache_empty_cube_get();
sgl->texspace = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* Wires (for loose edges) */
sh = GPU_shader_get_builtin_shader_with_config(GPU_SHADER_3D_UNIFORM_COLOR, draw_ctx->sh_cfg);
sgl->wire = shgroup_wire(sgl->non_meshes, gb->colorWire, sh, draw_ctx->sh_cfg);
sgl->wire_select = shgroup_wire(sgl->non_meshes, gb->colorSelect, sh, draw_ctx->sh_cfg);
sgl->wire_transform = shgroup_wire(sgl->non_meshes, gb->colorTransform, sh, draw_ctx->sh_cfg);
sgl->wire_active = shgroup_wire(sgl->non_meshes, gb->colorActive, sh, draw_ctx->sh_cfg);
/* Wire (duplicator) */
sgl->wire_dupli = shgroup_wire(sgl->non_meshes, gb->colorDupli, sh, draw_ctx->sh_cfg);
sgl->wire_dupli_select = shgroup_wire(sgl->non_meshes, gb->colorDupliSelect, sh, draw_ctx->sh_cfg);
/* Points (loose points) */
sh = sh_data->loose_points;
sgl->points = shgroup_points(sgl->non_meshes, gb->colorWire, sh, draw_ctx->sh_cfg);
sgl->points_select = shgroup_points(sgl->non_meshes, gb->colorSelect, sh, draw_ctx->sh_cfg);
sgl->points_transform = shgroup_points(sgl->non_meshes, gb->colorTransform, sh, draw_ctx->sh_cfg);
sgl->points_active = shgroup_points(sgl->non_meshes, gb->colorActive, sh, draw_ctx->sh_cfg);
/* Points (duplicator) */
sgl->points_dupli = shgroup_points(sgl->non_meshes, gb->colorDupli, sh, draw_ctx->sh_cfg);
sgl->points_dupli_select = shgroup_points(sgl->non_meshes, gb->colorDupliSelect, sh, draw_ctx->sh_cfg);
DRW_shgroup_state_disable(sgl->points, DRW_STATE_BLEND);
DRW_shgroup_state_disable(sgl->points_select, DRW_STATE_BLEND);
DRW_shgroup_state_disable(sgl->points_transform, DRW_STATE_BLEND);
DRW_shgroup_state_disable(sgl->points_active, DRW_STATE_BLEND);
DRW_shgroup_state_disable(sgl->points_dupli, DRW_STATE_BLEND);
DRW_shgroup_state_disable(sgl->points_dupli_select, DRW_STATE_BLEND);
/* Metaballs Handles */
sgl->mball_handle = shgroup_instance_mball_handles(sgl->non_meshes, draw_ctx->sh_cfg);
/* Lights */
/* TODO
* for now we create multiple times the same VBO with only light center coordinates
* but ideally we would only create it once */
/* start with buflimit because we don't want stipples */
geom = DRW_cache_single_line_get();
sgl->light_buflimit = shgroup_distance_lines_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
sgl->light_center = shgroup_dynpoints_uniform_color(sgl->non_meshes, gb->colorLightNoAlpha, &gb->sizeLightCenter, draw_ctx->sh_cfg);
geom = DRW_cache_light_get();
sgl->light_circle = shgroup_instance_screenspace(sgl->non_meshes, geom, &gb->sizeLightCircle, draw_ctx->sh_cfg);
geom = DRW_cache_light_shadows_get();
sgl->light_circle_shadow = shgroup_instance_screenspace(sgl->non_meshes, geom, &gb->sizeLightCircleShadow, draw_ctx->sh_cfg);
geom = DRW_cache_light_sunrays_get();
sgl->light_sunrays = shgroup_instance_screenspace(sgl->non_meshes, geom, &gb->sizeLightCircle, draw_ctx->sh_cfg);
sgl->light_groundline = shgroup_groundlines_uniform_color(sgl->non_meshes, gb->colorLight, draw_ctx->sh_cfg);
sgl->light_groundpoint = shgroup_groundpoints_uniform_color(sgl->non_meshes, gb->colorLight, draw_ctx->sh_cfg);
geom = DRW_cache_screenspace_circle_get();
sgl->light_area_sphere = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_light_area_square_get();
sgl->light_area_square = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_light_area_disk_get();
sgl->light_area_disk = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_light_hemi_get();
sgl->light_hemi = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_single_line_get();
sgl->light_distance = shgroup_distance_lines_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_single_line_endpoints_get();
sgl->light_buflimit_points = shgroup_distance_lines_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_light_spot_get();
sgl->light_spot_cone = shgroup_spot_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_circle_get();
sgl->light_spot_blend = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_light_spot_square_get();
sgl->light_spot_pyramid = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_square_get();
sgl->light_spot_blend_rect = shgroup_instance(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* -------- STIPPLES ------- */
/* Relationship Lines */
sgl->relationship_lines = shgroup_dynlines_dashed_uniform_color(sgl->non_meshes, gb->colorWire);
sgl->constraint_lines = shgroup_dynlines_dashed_uniform_color(sgl->non_meshes, gb->colorGridAxisZ);
/* Force Field Curve Guide End (here because of stipple) */
/* TODO port to shader stipple */
geom = DRW_cache_screenspace_circle_get();
sgl->field_curve_end = shgroup_instance_screen_aligned(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* Force Field Limits */
/* TODO port to shader stipple */
geom = DRW_cache_field_tube_limit_get();
sgl->field_tube_limit = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* TODO port to shader stipple */
geom = DRW_cache_field_cone_limit_get();
sgl->field_cone_limit = shgroup_instance_scaled(sgl->non_meshes, geom, draw_ctx->sh_cfg);
/* Spot shapes */
state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS_EQUAL | DRW_STATE_BLEND | DRW_STATE_CULL_FRONT;
sgl->spot_shapes = psl->spot_shapes[i] = DRW_pass_create("Spot Shape Pass", state);
geom = DRW_cache_light_spot_volume_get();
sgl->light_spot_volume = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_light_spot_square_volume_get();
sgl->light_spot_volume_rect = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->sh_cfg);
geom = DRW_cache_light_spot_volume_get();
sgl->light_spot_volume_outside = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->sh_cfg);
DRW_shgroup_state_disable(sgl->light_spot_volume_outside, DRW_STATE_CULL_FRONT);
DRW_shgroup_state_enable(sgl->light_spot_volume_outside, DRW_STATE_CULL_BACK);
geom = DRW_cache_light_spot_square_volume_get();
sgl->light_spot_volume_rect_outside = shgroup_instance_alpha(sgl->spot_shapes, geom, draw_ctx->sh_cfg);
DRW_shgroup_state_disable(sgl->light_spot_volume_rect_outside, DRW_STATE_CULL_FRONT);
DRW_shgroup_state_enable(sgl->light_spot_volume_rect_outside, DRW_STATE_CULL_BACK);
}
{
/* Object Center pass grouped by State */
DRWShadingGroup *grp;
static float outlineWidth, size;
DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_BLEND | DRW_STATE_POINT;
psl->ob_center = DRW_pass_create("Obj Center Pass", state);
outlineWidth = 1.0f * U.pixelsize;
size = U.obcenter_dia * U.pixelsize + outlineWidth;
GPUShader *sh = GPU_shader_get_builtin_shader_with_config(
GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA, draw_ctx->sh_cfg);
/* Active */
grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
DRW_shgroup_uniform_float(grp, "size", &size, 1);
DRW_shgroup_uniform_float(grp, "outlineWidth", &outlineWidth, 1);
DRW_shgroup_uniform_vec4(grp, "color", gb->colorActive, 1);
DRW_shgroup_uniform_vec4(grp, "outlineColor", gb->colorOutline, 1);
if (draw_ctx->sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
}
stl->g_data->center_active = grp;
/* Select */
grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
DRW_shgroup_uniform_vec4(grp, "color", gb->colorSelect, 1);
if (draw_ctx->sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
}
stl->g_data->center_selected = grp;
/* Deselect */
grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
DRW_shgroup_uniform_vec4(grp, "color", gb->colorDeselect, 1);
if (draw_ctx->sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
}
stl->g_data->center_deselected = grp;
/* Select (library) */
grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
DRW_shgroup_uniform_vec4(grp, "color", gb->colorLibrarySelect, 1);
if (draw_ctx->sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
}
stl->g_data->center_selected_lib = grp;
/* Deselect (library) */
grp = DRW_shgroup_point_batch_create(sh, psl->ob_center);
DRW_shgroup_uniform_vec4(grp, "color", gb->colorLibrary, 1);
if (draw_ctx->sh_cfg == GPU_SHADER_CFG_CLIPPED) {
DRW_shgroup_world_clip_planes_from_rv3d(grp, draw_ctx->rv3d);
}
stl->g_data->center_deselected_lib = grp;
}
{
/* Particle Pass */
psl->particle = DRW_pass_create(
"Particle Pass",
DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS_EQUAL |
DRW_STATE_POINT | DRW_STATE_BLEND);
}
}
static void DRW_shgroup_mball_handles(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
{
MetaBall *mb = ob->data;
float *color;
DRW_object_wire_theme_get(ob, view_layer, &color);
float draw_scale_xform[3][4]; /* Matrix of Scale and Translation */
{
float scamat[3][3];
copy_m3_m4(scamat, ob->obmat);
/* Get the normalized inverse matrix to extract only
* the scale of Scamat */
float iscamat[3][3];
invert_m3_m3(iscamat, scamat);
normalize_m3(iscamat);
mul_m3_m3_post(scamat, iscamat);
copy_v3_v3(draw_scale_xform[0], scamat[0]);
copy_v3_v3(draw_scale_xform[1], scamat[1]);
copy_v3_v3(draw_scale_xform[2], scamat[2]);
}
for (MetaElem *ml = mb->elems.first; ml != NULL; ml = ml->next) {
/* draw radius */
float world_pos[3];
mul_v3_m4v3(world_pos, ob->obmat, &ml->x);
draw_scale_xform[0][3] = world_pos[0];
draw_scale_xform[1][3] = world_pos[1];
draw_scale_xform[2][3] = world_pos[2];
DRW_shgroup_call_dynamic_add(sgl->mball_handle, draw_scale_xform, &ml->rad, color);
}
}
static void DRW_shgroup_light(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
{
Light *la = ob->data;
float *color;
int theme_id = DRW_object_wire_theme_get(ob, view_layer, &color);
static float zero = 0.0f;
typedef struct LightEngineData {
DrawData dd;
float shape_mat[4][4];
float spot_blend_mat[4][4];
} LightEngineData;
LightEngineData *light_engine_data =
(LightEngineData *)DRW_drawdata_ensure(
&ob->id,
&draw_engine_object_type,
sizeof(LightEngineData),
NULL,
NULL);
float (*shapemat)[4] = light_engine_data->shape_mat;
float (*spotblendmat)[4] = light_engine_data->spot_blend_mat;
if ((ob->base_flag & (BASE_FROM_SET | BASE_FROM_DUPLI)) == 0) {
/* Don't draw the center if it's selected or active */
if (theme_id == TH_LIGHT) {
DRW_shgroup_call_dynamic_add(sgl->light_center, ob->obmat[3]);
}
}
/* First circle */
DRW_shgroup_call_dynamic_add(sgl->light_circle, ob->obmat[3], color);
/* draw dashed outer circle for shadow */
DRW_shgroup_call_dynamic_add(sgl->light_circle_shadow, ob->obmat[3], color);
/* Distance */
if (ELEM(la->type, LA_SUN, LA_AREA)) {
DRW_shgroup_call_dynamic_add(sgl->light_distance, color, &zero, &la->dist, ob->obmat);
}
copy_m4_m4(shapemat, ob->obmat);
if (la->type == LA_SUN) {
DRW_shgroup_call_dynamic_add(sgl->light_sunrays, ob->obmat[3], color);
}
else if (la->type == LA_SPOT) {
float size[3], sizemat[4][4];
static float one = 1.0f;
float cone_inside[4] = {0.0f, 0.0f, 0.0f, 0.5f};
float cone_outside[4] = {1.0f, 1.0f, 1.0f, 0.3f};
float blend = 1.0f - pow2f(la->spotblend);
size[0] = size[1] = sinf(la->spotsize * 0.5f) * la->dist;
size[2] = cosf(la->spotsize * 0.5f) * la->dist;
size_to_mat4(sizemat, size);
mul_m4_m4m4(shapemat, ob->obmat, sizemat);
size[0] = size[1] = blend; size[2] = 1.0f;
size_to_mat4(sizemat, size);
translate_m4(sizemat, 0.0f, 0.0f, -1.0f);
rotate_m4(sizemat, 'X', (float)(M_PI / 2));
mul_m4_m4m4(spotblendmat, shapemat, sizemat);
if (la->mode & LA_SQUARE) {
DRW_shgroup_call_dynamic_add(sgl->light_spot_pyramid, color, &one, shapemat);
/* hide line if it is zero size or overlaps with outer border,
* previously it adjusted to always to show it but that seems
* confusing because it doesn't show the actual blend size */
if (blend != 0.0f && blend != 1.0f) {
DRW_shgroup_call_dynamic_add(sgl->light_spot_blend_rect, color, &one, spotblendmat);
}
if (la->mode & LA_SHOW_CONE) {
DRW_shgroup_call_dynamic_add(sgl->light_spot_volume_rect, cone_inside, &one, shapemat);
DRW_shgroup_call_dynamic_add(sgl->light_spot_volume_rect_outside, cone_outside, &one, shapemat);
}
}
else {
DRW_shgroup_call_dynamic_add(sgl->light_spot_cone, color, shapemat);
/* hide line if it is zero size or overlaps with outer border,
* previously it adjusted to always to show it but that seems
* confusing because it doesn't show the actual blend size */
if (blend != 0.0f && blend != 1.0f) {
DRW_shgroup_call_dynamic_add(sgl->light_spot_blend, color, &one, spotblendmat);
}
if (la->mode & LA_SHOW_CONE) {
DRW_shgroup_call_dynamic_add(sgl->light_spot_volume, cone_inside, &one, shapemat);
DRW_shgroup_call_dynamic_add(sgl->light_spot_volume_outside, cone_outside, &one, shapemat);
}
}
DRW_shgroup_call_dynamic_add(sgl->light_buflimit, color, &la->clipsta, &la->clipend, ob->obmat);
DRW_shgroup_call_dynamic_add(sgl->light_buflimit_points, color, &la->clipsta, &la->clipend, ob->obmat);
}
else if (la->type == LA_AREA) {
float size[3] = {1.0f, 1.0f, 1.0f}, sizemat[4][4];
if (ELEM(la->area_shape, LA_AREA_RECT, LA_AREA_ELLIPSE)) {
size[1] = la->area_sizey / la->area_size;
size_to_mat4(sizemat, size);
mul_m4_m4m4(shapemat, shapemat, sizemat);
}
if (ELEM(la->area_shape, LA_AREA_DISK, LA_AREA_ELLIPSE)) {
DRW_shgroup_call_dynamic_add(sgl->light_area_disk, color, &la->area_size, shapemat);
}
else {
DRW_shgroup_call_dynamic_add(sgl->light_area_square, color, &la->area_size, shapemat);
}
}
if (ELEM(la->type, LA_LOCAL, LA_SPOT)) {
/* We only want position not scale. */
shapemat[0][0] = shapemat[1][1] = shapemat[2][2] = 1.0f;
shapemat[0][1] = shapemat[0][2] = 0.0f;
shapemat[1][0] = shapemat[1][2] = 0.0f;
shapemat[2][0] = shapemat[2][1] = 0.0f;
DRW_shgroup_call_dynamic_add(sgl->light_area_sphere, color, &la->area_size, shapemat);
}
/* Line and point going to the ground */
DRW_shgroup_call_dynamic_add(sgl->light_groundline, ob->obmat[3]);
DRW_shgroup_call_dynamic_add(sgl->light_groundpoint, ob->obmat[3]);
}
static GPUBatch *batch_camera_path_get(
ListBase *camera_paths, const MovieTrackingReconstruction *reconstruction)
{
GPUBatch *geom;
static GPUVertFormat format = { 0 };
static struct { uint pos; } attr_id;
if (format.attr_len == 0) {
attr_id.pos = GPU_vertformat_attr_add(&format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT);
}
GPUVertBuf *vbo = GPU_vertbuf_create_with_format(&format);
GPU_vertbuf_data_alloc(vbo, reconstruction->camnr);
MovieReconstructedCamera *camera = reconstruction->cameras;
for (int a = 0; a < reconstruction->camnr; a++, camera++) {
GPU_vertbuf_attr_set(vbo, attr_id.pos, a, camera->mat[3]);
}
geom = GPU_batch_create_ex(GPU_PRIM_LINE_STRIP, vbo, NULL, GPU_BATCH_OWNS_VBO);
/* Store the batch to do cleanup after drawing. */
BLI_addtail(camera_paths, BLI_genericNodeN(geom));
return geom;
}
static void batch_camera_path_free(ListBase *camera_paths)
{
LinkData *link;
while ((link = BLI_pophead(camera_paths))) {
GPUBatch *camera_path = link->data;
GPU_batch_discard(camera_path);
MEM_freeN(link);
}
}
static bool camera_view3d_is_stereo3d(Scene *scene, View3D *v3d)
{
return (scene->r.scemode & R_MULTIVIEW) != 0 &&
(v3d->stereo3d_flag);
}
static void camera_stereo3d(
OBJECT_ShadingGroupList *sgl,
Scene *scene, ViewLayer *view_layer, View3D *v3d,
Object *ob, Camera *cam,
const float vec[4][3], float drawsize, const float scale[3])
{
const bool is_select = DRW_state_is_select();
static float drw_tria_dummy[2][2][2] = {{{0}}};
const float fac = (cam->stereo.pivot == CAM_S3D_PIVOT_CENTER) ? 2.0f : 1.0f;
float origin[2][3] = {{0}};
const char *viewnames[2] = {STEREO_LEFT_NAME, STEREO_RIGHT_NAME};
const bool is_stereo3d_cameras = (v3d->stereo3d_flag & V3D_S3D_DISPCAMERAS) && (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D);
const bool is_stereo3d_plane = (v3d->stereo3d_flag & V3D_S3D_DISPPLANE) && (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D);
const bool is_stereo3d_volume = (v3d->stereo3d_flag & V3D_S3D_DISPVOLUME);
float *color;
DRW_object_wire_theme_get(ob, view_layer, &color);
for (int eye = 0; eye < 2; eye++) {
float obmat[4][4];
ob = BKE_camera_multiview_render(scene, ob, viewnames[eye]);
BKE_camera_multiview_model_matrix_scaled(&scene->r, ob, viewnames[eye], obmat);
copy_v2_v2(cam->runtime.drw_corners[eye][0], vec[0]);
copy_v2_v2(cam->runtime.drw_corners[eye][1], vec[1]);
copy_v2_v2(cam->runtime.drw_corners[eye][2], vec[2]);
copy_v2_v2(cam->runtime.drw_corners[eye][3], vec[3]);
cam->runtime.drw_depth[eye] = vec[0][2];
if (cam->stereo.convergence_mode == CAM_S3D_OFFAXIS) {
const float shift_x =
((BKE_camera_multiview_shift_x(&scene->r, ob, viewnames[eye]) - cam->shiftx) *
(drawsize * scale[0] * fac));
for (int i = 0; i < 4; i++) {
cam->runtime.drw_corners[eye][i][0] += shift_x;
}
}
/* Dummy triangle, draw on top of existent lines so it is invisible. */
copy_v2_v2(drw_tria_dummy[eye][0], cam->runtime.drw_corners[eye][0]);
copy_v2_v2(drw_tria_dummy[eye][1], cam->runtime.drw_corners[eye][0]);
if (is_stereo3d_cameras) {
DRW_shgroup_call_dynamic_add(
sgl->camera_frame, color, cam->runtime.drw_corners[eye],
&cam->runtime.drw_depth[eye], cam->runtime.drw_tria, obmat);
DRW_shgroup_call_dynamic_add(
sgl->camera, color, cam->runtime.drw_corners[eye],
&cam->runtime.drw_depth[eye], drw_tria_dummy[eye], obmat);
}
/* Connecting line. */
mul_m4_v3(obmat, origin[eye]);
}
/* Draw connecting lines. */
if (is_stereo3d_cameras) {
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, origin[0]);
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, origin[1]);
}
/* Draw convergence plane. */
if (is_stereo3d_plane && !is_select) {
static float convergence_distance_neg;
float axis_center[3];
float convergence_plane[4][2];
float offset;
mid_v3_v3v3(axis_center, origin[0], origin[1]);
for (int i = 0; i < 4; i++) {
mid_v2_v2v2(convergence_plane[i], cam->runtime.drw_corners[0][i], cam->runtime.drw_corners[1][i]);
}
offset = cam->stereo.convergence_distance / cam->runtime.drw_depth[0];
for (int i = 0; i < 4; i++) {
convergence_plane[i][0] -= 2.0f * cam->shiftx;
convergence_plane[i][1] -= 2.0f * cam->shifty;
mul_v2_fl(convergence_plane[i], offset);
}
convergence_distance_neg = -cam->stereo.convergence_distance;
DRW_shgroup_call_dynamic_add(
sgl->camera_frame, color, convergence_plane,
&convergence_distance_neg, cam->runtime.drw_tria, cam->runtime.drw_normalmat);
if (v3d->stereo3d_convergence_alpha > 0.0f) {
/* We are using a -1,1 quad for this shading group, so we need to
* scale and transform it to match the convergence plane border. */
static float one = 1.0f;
float plane_mat[4][4], scale_mat[4][4];
float scale_factor[3] = {1.0f, 1.0f, 1.0f};
float color_plane[4] = {0.0f, 0.0f, 0.0f, v3d->stereo3d_convergence_alpha};
const float height = convergence_plane[1][1] - convergence_plane[0][1];
const float width = convergence_plane[2][0] - convergence_plane[0][0];
scale_factor[0] = width * 0.5f;
scale_factor[1] = height * 0.5f;
copy_m4_m4(plane_mat, cam->runtime.drw_normalmat);
translate_m4(plane_mat, 0.0f, 0.0f, -cam->stereo.convergence_distance);
size_to_mat4(scale_mat, scale_factor);
mul_m4_m4_post(plane_mat, scale_mat);
DRW_shgroup_call_dynamic_add(sgl->camera_stereo_plane, color_plane, &one, plane_mat);
}
}
/* Draw convergence volume. */
if (is_stereo3d_volume && !is_select) {
static float one = 1.0f;
float color_volume[3][4] = {{0.0f, 1.0f, 1.0f, v3d->stereo3d_volume_alpha},
{1.0f, 0.0f, 0.0f, v3d->stereo3d_volume_alpha},
{0.0f, 0.0f, 0.0f, 1.0f}};
for (int eye = 0; eye < 2; eye++) {
float winmat[4][4], viewinv[4][4], viewmat[4][4], persmat[4][4], persinv[4][4];
ob = BKE_camera_multiview_render(scene, ob, viewnames[eye]);
BKE_camera_multiview_window_matrix(&scene->r, ob, viewnames[eye], winmat);
BKE_camera_multiview_model_matrix(&scene->r, ob, viewnames[eye], viewinv);
invert_m4_m4(viewmat, viewinv);
mul_m4_m4m4(persmat, winmat, viewmat);
invert_m4_m4(persinv, persmat);
if (v3d->stereo3d_volume_alpha > 0.0f) {
DRW_shgroup_call_dynamic_add(sgl->camera_stereo_volume, color_volume[eye], &one, persinv);
}
DRW_shgroup_call_dynamic_add(sgl->camera_stereo_volume_wires, color_volume[2], &one, persinv);
}
}
}
static void DRW_shgroup_camera(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
{
const DRWContextState *draw_ctx = DRW_context_state_get();
View3D *v3d = draw_ctx->v3d;
Scene *scene = draw_ctx->scene;
RegionView3D *rv3d = draw_ctx->rv3d;
Camera *cam = ob->data;
const Object *camera_object = DEG_get_evaluated_object(draw_ctx->depsgraph, v3d->camera);
const bool is_select = DRW_state_is_select();
const bool is_active = (ob == camera_object);
const bool look_through = (is_active && (rv3d->persp == RV3D_CAMOB));
const bool is_multiview = (scene->r.scemode & R_MULTIVIEW) != 0;
const bool is_stereo3d = is_active && camera_view3d_is_stereo3d(scene, v3d);
const bool is_stereo3d_view = (scene->r.views_format == SCE_VIEWS_FORMAT_STEREO_3D);
const bool is_stereo3d_cameras = (ob == scene->camera) &&
is_multiview &&
is_stereo3d_view &&
(v3d->stereo3d_flag & V3D_S3D_DISPCAMERAS);
const bool is_selection_camera_stereo = is_select &&
look_through && is_multiview &&
is_stereo3d_view;
float *color;
DRW_object_wire_theme_get(ob, view_layer, &color);
float vec[4][3], asp[2], shift[2], scale[3], drawsize;
/* BKE_camera_multiview_model_matrix already accounts for scale, don't do it here. */
if (is_selection_camera_stereo) {
scale[0] = 1.0f;
scale[1] = 1.0f;
scale[2] = 1.0f;
}
else {
scale[0] = 1.0f / len_v3(ob->obmat[0]);
scale[1] = 1.0f / len_v3(ob->obmat[1]);
scale[2] = 1.0f / len_v3(ob->obmat[2]);
}
BKE_camera_view_frame_ex(scene, cam, cam->drawsize, false, scale,
asp, shift, &drawsize, vec);
/* Frame coords */
copy_v2_v2(cam->runtime.drw_corners[0][0], vec[0]);
copy_v2_v2(cam->runtime.drw_corners[0][1], vec[1]);
copy_v2_v2(cam->runtime.drw_corners[0][2], vec[2]);
copy_v2_v2(cam->runtime.drw_corners[0][3], vec[3]);
/* depth */
cam->runtime.drw_depth[0] = vec[0][2];
/* tria */
cam->runtime.drw_tria[0][0] = shift[0] + ((0.7f * drawsize) * scale[0]);
cam->runtime.drw_tria[0][1] = shift[1] + ((drawsize * (asp[1] + 0.1f)) * scale[1]);
cam->runtime.drw_tria[1][0] = shift[0];
cam->runtime.drw_tria[1][1] = shift[1] + ((1.1f * drawsize * (asp[1] + 0.7f)) * scale[1]);
if (look_through) {
/* Only draw the frame. */
float mat[4][4];
if (is_stereo3d_view) {
const bool is_left = v3d->multiview_eye == STEREO_LEFT_ID;
const char *view_name = is_left ? STEREO_LEFT_NAME : STEREO_RIGHT_NAME;
BKE_camera_multiview_model_matrix(&scene->r, ob, view_name, mat);
const float shiftx = BKE_camera_multiview_shift_x(&scene->r, ob, view_name);
cam->runtime.drw_corners[0][0][0] += shiftx;
cam->runtime.drw_corners[0][1][0] += shiftx;
cam->runtime.drw_corners[0][2][0] += shiftx;
cam->runtime.drw_corners[0][3][0] += shiftx;
}
else {
copy_m4_m4(mat, ob->obmat);
}
DRW_shgroup_call_dynamic_add(
sgl->camera_frame, color, cam->runtime.drw_corners[0],
&cam->runtime.drw_depth[0], cam->runtime.drw_tria, mat);
}
else {
if (!is_stereo3d_cameras) {
DRW_shgroup_call_dynamic_add(
sgl->camera, color, cam->runtime.drw_corners[0],
&cam->runtime.drw_depth[0], cam->runtime.drw_tria, ob->obmat);
}
/* Active cam */
if (is_active) {
DRW_shgroup_call_dynamic_add(
sgl->camera_tria, color,
cam->runtime.drw_corners[0], &cam->runtime.drw_depth[0], cam->runtime.drw_tria, ob->obmat);
}
}
/* draw the rest in normalize object space */
normalize_m4_m4(cam->runtime.drw_normalmat, ob->obmat);
if (cam->flag & CAM_SHOWLIMITS) {
static float col[4] = {0.5f, 0.5f, 0.25f, 1.0f}, col_hi[4] = {1.0f, 1.0f, 0.5f, 1.0f};
float sizemat[4][4], size[3] = {1.0f, 1.0f, 0.0f};
float focusdist = BKE_camera_object_dof_distance(ob);
copy_m4_m4(cam->runtime.drw_focusmat, cam->runtime.drw_normalmat);
translate_m4(cam->runtime.drw_focusmat, 0.0f, 0.0f, -focusdist);
size_to_mat4(sizemat, size);
mul_m4_m4m4(cam->runtime.drw_focusmat, cam->runtime.drw_focusmat, sizemat);
DRW_shgroup_call_dynamic_add(
sgl->camera_focus, (is_active ? col_hi : col),
&cam->drawsize, cam->runtime.drw_focusmat);
DRW_shgroup_call_dynamic_add(
sgl->camera_clip, color,
&cam->clip_start, &cam->clip_end, cam->runtime.drw_normalmat);
DRW_shgroup_call_dynamic_add(
sgl->camera_clip_points, (is_active ? col_hi : col),
&cam->clip_start, &cam->clip_end, cam->runtime.drw_normalmat);
}
if (cam->flag & CAM_SHOWMIST) {
World *world = scene->world;
if (world) {
static float col[4] = {0.5f, 0.5f, 0.5f, 1.0f}, col_hi[4] = {1.0f, 1.0f, 1.0f, 1.0f};
world->mistend = world->miststa + world->mistdist;
DRW_shgroup_call_dynamic_add(
sgl->camera_mist, color,
&world->miststa, &world->mistend, cam->runtime.drw_normalmat);
DRW_shgroup_call_dynamic_add(
sgl->camera_mist_points, (is_active ? col_hi : col),
&world->miststa, &world->mistend, cam->runtime.drw_normalmat);
}
}
/* Stereo cameras drawing. */
if (is_stereo3d && !look_through) {
camera_stereo3d(sgl, scene, view_layer, v3d, ob, cam, vec, drawsize, scale);
}
/* Motion Tracking. */
MovieClip *clip = BKE_object_movieclip_get(scene, ob, false);
if ((v3d->flag2 & V3D_SHOW_RECONSTRUCTION) && (clip != NULL)) {
BLI_assert(BLI_listbase_is_empty(&sgl->camera_path));
const bool is_solid_bundle = (v3d->bundle_drawtype == OB_EMPTY_SPHERE) &&
((v3d->shading.type != OB_SOLID) ||
((v3d->shading.flag & XRAY_FLAG(v3d)) == 0));
MovieTracking *tracking = &clip->tracking;
/* Index must start in 1, to mimic BKE_tracking_track_get_indexed. */
int track_index = 1;
uchar text_color_selected[4], text_color_unselected[4];
float bundle_color_unselected[4], bundle_color_solid[4];
UI_GetThemeColor4ubv(TH_SELECT, text_color_selected);
UI_GetThemeColor4ubv(TH_TEXT, text_color_unselected);
UI_GetThemeColor4fv(TH_WIRE, bundle_color_unselected);
UI_GetThemeColor4fv(TH_BUNDLE_SOLID, bundle_color_solid);
float camera_mat[4][4];
BKE_tracking_get_camera_object_matrix(scene, ob, camera_mat);
float bundle_scale_mat[4][4];
if (is_solid_bundle) {
scale_m4_fl(bundle_scale_mat, v3d->bundle_size);
}
for (MovieTrackingObject *tracking_object = tracking->objects.first;
tracking_object != NULL;
tracking_object = tracking_object->next)
{
float tracking_object_mat[4][4];
if (tracking_object->flag & TRACKING_OBJECT_CAMERA) {
copy_m4_m4(tracking_object_mat, camera_mat);
}
else {
const int framenr = BKE_movieclip_remap_scene_to_clip_frame(clip, DEG_get_ctime(draw_ctx->depsgraph));
float object_mat[4][4];
BKE_tracking_camera_get_reconstructed_interpolate(tracking, tracking_object, framenr, object_mat);
invert_m4(object_mat);
mul_m4_m4m4(tracking_object_mat, cam->runtime.drw_normalmat, object_mat);
}
ListBase *tracksbase = BKE_tracking_object_get_tracks(tracking, tracking_object);
for (MovieTrackingTrack *track = tracksbase->first; track; track = track->next) {
if ((track->flag & TRACK_HAS_BUNDLE) == 0) {
continue;
}
bool is_selected = TRACK_SELECTED(track);
float bundle_mat[4][4];
copy_m4_m4(bundle_mat, tracking_object_mat);
translate_m4(bundle_mat, track->bundle_pos[0], track->bundle_pos[1], track->bundle_pos[2]);
float *bundle_color;
if (track->flag & TRACK_CUSTOMCOLOR) {
bundle_color = track->color;
}
else if (is_solid_bundle) {
bundle_color = bundle_color_solid;
}
else if (is_selected) {
bundle_color = color;
}
else {
bundle_color = bundle_color_unselected;
}
if (is_select) {
DRW_select_load_id(camera_object->select_id | (track_index << 16));
track_index++;
}
if (is_solid_bundle) {
if (is_selected) {
DRW_shgroup_empty_ex(sgl,
bundle_mat,
&v3d->bundle_size,
v3d->bundle_drawtype,
color);
}
float bundle_color_v4[4] = {
bundle_color[0],
bundle_color[1],
bundle_color[2],
1.0f,
};
mul_m4_m4m4(bundle_mat, bundle_mat, bundle_scale_mat);
DRW_shgroup_call_dynamic_add(sgl->sphere_solid,
bundle_mat,
bundle_color_v4);
}
else {
DRW_shgroup_empty_ex(sgl,
bundle_mat,
&v3d->bundle_size,
v3d->bundle_drawtype,
bundle_color);
}
if ((v3d->flag2 & V3D_SHOW_BUNDLENAME) && !is_select) {
struct DRWTextStore *dt = DRW_text_cache_ensure();
DRW_text_cache_add(dt,
bundle_mat[3],
track->name,
strlen(track->name),
10, 0,
DRW_TEXT_CACHE_GLOBALSPACE | DRW_TEXT_CACHE_STRING_PTR,
is_selected ? text_color_selected : text_color_unselected);
}
}
if ((v3d->flag2 & V3D_SHOW_CAMERAPATH) && (tracking_object->flag & TRACKING_OBJECT_CAMERA) && !is_select) {
MovieTrackingReconstruction *reconstruction;
reconstruction = BKE_tracking_object_get_reconstruction(tracking, tracking_object);
if (reconstruction->camnr) {
static float camera_path_color[4];
UI_GetThemeColor4fv(TH_CAMERA_PATH, camera_path_color);
GPUBatch *geom = batch_camera_path_get(&sgl->camera_path, reconstruction);
GPUShader *shader = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR);
DRWShadingGroup *shading_group = DRW_shgroup_create(shader, sgl->non_meshes);
DRW_shgroup_uniform_vec4(shading_group, "color", camera_path_color, 1);
DRW_shgroup_call_add(shading_group, geom, camera_mat);
}
}
}
}
}
static void DRW_shgroup_empty_ex(
OBJECT_ShadingGroupList *sgl, float mat[4][4], float *draw_size, char draw_type, float *color)
{
switch (draw_type) {
case OB_PLAINAXES:
DRW_shgroup_call_dynamic_add(sgl->plain_axes, color, draw_size, mat);
break;
case OB_SINGLE_ARROW:
DRW_shgroup_call_dynamic_add(sgl->single_arrow, color, draw_size, mat);
DRW_shgroup_call_dynamic_add(sgl->single_arrow_line, color, draw_size, mat);
break;
case OB_CUBE:
DRW_shgroup_call_dynamic_add(sgl->cube, color, draw_size, mat);
break;
case OB_CIRCLE:
DRW_shgroup_call_dynamic_add(sgl->circle, color, draw_size, mat);
break;
case OB_EMPTY_SPHERE:
DRW_shgroup_call_dynamic_add(sgl->sphere, color, draw_size, mat);
break;
case OB_EMPTY_CONE:
DRW_shgroup_call_dynamic_add(sgl->cone, color, draw_size, mat);
break;
case OB_ARROWS:
DRW_shgroup_call_dynamic_add(sgl->empty_axes, color, draw_size, mat);
break;
case OB_EMPTY_IMAGE:
BLI_assert(!"Should never happen, use DRW_shgroup_empty instead.");
break;
}
}
static void DRW_shgroup_empty(
OBJECT_Shaders *sh_data, OBJECT_ShadingGroupList *sgl,
Object *ob, ViewLayer *view_layer, RegionView3D *rv3d, eGPUShaderConfig sh_cfg)
{
float *color;
DRW_object_wire_theme_get(ob, view_layer, &color);
switch (ob->empty_drawtype) {
case OB_PLAINAXES:
case OB_SINGLE_ARROW:
case OB_CUBE:
case OB_CIRCLE:
case OB_EMPTY_SPHERE:
case OB_EMPTY_CONE:
case OB_ARROWS:
DRW_shgroup_empty_ex(sgl, ob->obmat, &ob->empty_drawsize, ob->empty_drawtype, color);
break;
case OB_EMPTY_IMAGE:
DRW_shgroup_empty_image(sh_data, sgl, ob, color, rv3d, sh_cfg);
break;
}
}
static void DRW_shgroup_forcefield(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
{
int theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
float *color = DRW_color_background_blend_get(theme_id);
PartDeflect *pd = ob->pd;
Curve *cu = (ob->type == OB_CURVE) ? ob->data : NULL;
/* TODO Move this to depsgraph */
float tmp[3];
copy_v3_fl(pd->drawvec1, ob->empty_drawsize);
switch (pd->forcefield) {
case PFIELD_WIND:
pd->drawvec1[2] = pd->f_strength;
break;
case PFIELD_VORTEX:
if (pd->f_strength < 0.0f) {
pd->drawvec1[1] = -pd->drawvec1[1];
}
break;
case PFIELD_GUIDE:
if (cu && (cu->flag & CU_PATH) && ob->runtime.curve_cache->path && ob->runtime.curve_cache->path->data) {
where_on_path(ob, 0.0f, pd->drawvec1, tmp, NULL, NULL, NULL);
where_on_path(ob, 1.0f, pd->drawvec2, tmp, NULL, NULL, NULL);
}
break;
}
if (pd->falloff == PFIELD_FALL_TUBE) {
pd->drawvec_falloff_max[0] = pd->drawvec_falloff_max[1] = (pd->flag & PFIELD_USEMAXR) ? pd->maxrad : 1.0f;
pd->drawvec_falloff_max[2] = (pd->flag & PFIELD_USEMAX) ? pd->maxdist : 0.0f;
pd->drawvec_falloff_min[0] = pd->drawvec_falloff_min[1] = (pd->flag & PFIELD_USEMINR) ? pd->minrad : 1.0f;
pd->drawvec_falloff_min[2] = (pd->flag & PFIELD_USEMIN) ? pd->mindist : 0.0f;
}
else if (pd->falloff == PFIELD_FALL_CONE) {
float radius, distance;
radius = DEG2RADF((pd->flag & PFIELD_USEMAXR) ? pd->maxrad : 1.0f);
distance = (pd->flag & PFIELD_USEMAX) ? pd->maxdist : 0.0f;
pd->drawvec_falloff_max[0] = pd->drawvec_falloff_max[1] = distance * sinf(radius);
pd->drawvec_falloff_max[2] = distance * cosf(radius);
radius = DEG2RADF((pd->flag & PFIELD_USEMINR) ? pd->minrad : 1.0f);
distance = (pd->flag & PFIELD_USEMIN) ? pd->mindist : 0.0f;
pd->drawvec_falloff_min[0] = pd->drawvec_falloff_min[1] = distance * sinf(radius);
pd->drawvec_falloff_min[2] = distance * cosf(radius);
}
/* End of things that should go to depthgraph */
switch (pd->forcefield) {
case PFIELD_WIND:
DRW_shgroup_call_dynamic_add(sgl->field_wind, color, &pd->drawvec1, ob->obmat);
break;
case PFIELD_FORCE:
DRW_shgroup_call_dynamic_add(sgl->field_force, color, &pd->drawvec1, ob->obmat);
break;
case PFIELD_VORTEX:
DRW_shgroup_call_dynamic_add(sgl->field_vortex, color, &pd->drawvec1, ob->obmat);
break;
case PFIELD_GUIDE:
if (cu && (cu->flag & CU_PATH) && ob->runtime.curve_cache->path && ob->runtime.curve_cache->path->data) {
DRW_shgroup_call_dynamic_add(sgl->field_curve_sta, color, &pd->f_strength, ob->obmat);
DRW_shgroup_call_dynamic_add(sgl->field_curve_end, color, &pd->f_strength, ob->obmat);
}
break;
}
if (pd->falloff == PFIELD_FALL_SPHERE) {
/* as last, guide curve alters it */
if ((pd->flag & PFIELD_USEMAX) != 0) {
DRW_shgroup_call_dynamic_add(sgl->field_curve_end, color, &pd->maxdist, ob->obmat);
}
if ((pd->flag & PFIELD_USEMIN) != 0) {
DRW_shgroup_call_dynamic_add(sgl->field_curve_end, color, &pd->mindist, ob->obmat);
}
}
else if (pd->falloff == PFIELD_FALL_TUBE) {
if (pd->flag & (PFIELD_USEMAX | PFIELD_USEMAXR)) {
DRW_shgroup_call_dynamic_add(sgl->field_tube_limit, color, &pd->drawvec_falloff_max, ob->obmat);
}
if (pd->flag & (PFIELD_USEMIN | PFIELD_USEMINR)) {
DRW_shgroup_call_dynamic_add(sgl->field_tube_limit, color, &pd->drawvec_falloff_min, ob->obmat);
}
}
else if (pd->falloff == PFIELD_FALL_CONE) {
if (pd->flag & (PFIELD_USEMAX | PFIELD_USEMAXR)) {
DRW_shgroup_call_dynamic_add(sgl->field_cone_limit, color, &pd->drawvec_falloff_max, ob->obmat);
}
if (pd->flag & (PFIELD_USEMIN | PFIELD_USEMINR)) {
DRW_shgroup_call_dynamic_add(sgl->field_cone_limit, color, &pd->drawvec_falloff_min, ob->obmat);
}
}
}
static void DRW_shgroup_volume_extra(
OBJECT_ShadingGroupList *sgl,
Object *ob, ViewLayer *view_layer, Scene *scene, ModifierData *md)
{
SmokeModifierData *smd = (SmokeModifierData *)md;
SmokeDomainSettings *sds = smd->domain;
float *color;
float one = 1.0f;
if (sds == NULL) {
return;
}
DRW_object_wire_theme_get(ob, view_layer, &color);
/* Small cube showing voxel size. */
float voxel_cubemat[4][4] = {{0.0f}};
voxel_cubemat[0][0] = 1.0f / (float)sds->res[0];
voxel_cubemat[1][1] = 1.0f / (float)sds->res[1];
voxel_cubemat[2][2] = 1.0f / (float)sds->res[2];
voxel_cubemat[3][0] = voxel_cubemat[3][1] = voxel_cubemat[3][2] = -1.0f;
voxel_cubemat[3][3] = 1.0f;
translate_m4(voxel_cubemat, 1.0f, 1.0f, 1.0f);
mul_m4_m4m4(voxel_cubemat, ob->obmat, voxel_cubemat);
DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, voxel_cubemat);
/* Don't show smoke before simulation starts, this could be made an option in the future. */
if (!sds->draw_velocity || !sds->fluid || CFRA < sds->point_cache[0]->startframe) {
return;
}
const bool use_needle = (sds->vector_draw_type == VECTOR_DRAW_NEEDLE);
int line_count = (use_needle) ? 6 : 1;
int slice_axis = -1;
line_count *= sds->res[0] * sds->res[1] * sds->res[2];
if (sds->slice_method == MOD_SMOKE_SLICE_AXIS_ALIGNED &&
sds->axis_slice_method == AXIS_SLICE_SINGLE)
{
float invviewmat[4][4];
DRW_viewport_matrix_get(invviewmat, DRW_MAT_VIEWINV);
const int axis = (sds->slice_axis == SLICE_AXIS_AUTO)
? axis_dominant_v3_single(invviewmat[2])
: sds->slice_axis - 1;
slice_axis = axis;
line_count /= sds->res[axis];
}
GPU_create_smoke_velocity(smd);
DRWShadingGroup *grp = DRW_shgroup_create(volume_velocity_shader_get(use_needle), sgl->non_meshes);
DRW_shgroup_uniform_texture(grp, "velocityX", sds->tex_velocity_x);
DRW_shgroup_uniform_texture(grp, "velocityY", sds->tex_velocity_y);
DRW_shgroup_uniform_texture(grp, "velocityZ", sds->tex_velocity_z);
DRW_shgroup_uniform_float_copy(grp, "displaySize", sds->vector_scale);
DRW_shgroup_uniform_float_copy(grp, "slicePosition", sds->slice_depth);
DRW_shgroup_uniform_int_copy(grp, "sliceAxis", slice_axis);
DRW_shgroup_call_procedural_lines_add(grp, line_count, ob->obmat);
BLI_addtail(&e_data.smoke_domains, BLI_genericNodeN(smd));
}
static void volumes_free_smoke_textures(void)
{
/* Free Smoke Textures after rendering */
/* XXX This is a waste of processing and GPU bandwidth if nothing
* is updated. But the problem is since Textures are stored in the
* modifier we don't want them to take precious VRAM if the
* modifier is not used for display. We should share them for
* all viewport in a redraw at least. */
for (LinkData *link = e_data.smoke_domains.first; link; link = link->next) {
SmokeModifierData *smd = (SmokeModifierData *)link->data;
GPU_free_smoke_velocity(smd);
}
BLI_freelistN(&e_data.smoke_domains);
}
static void DRW_shgroup_speaker(OBJECT_ShadingGroupList *sgl, Object *ob, ViewLayer *view_layer)
{
float *color;
static float one = 1.0f;
DRW_object_wire_theme_get(ob, view_layer, &color);
DRW_shgroup_call_dynamic_add(sgl->speaker, color, &one, ob->obmat);
}
typedef struct OBJECT_LightProbeEngineData {
DrawData dd;
float increment_x[3];
float increment_y[3];
float increment_z[3];
float corner[3];
} OBJECT_LightProbeEngineData;
static void DRW_shgroup_lightprobe(
OBJECT_Shaders *sh_data, OBJECT_StorageList *stl, OBJECT_PassList *psl,
Object *ob, ViewLayer *view_layer)
{
float *color;
static float one = 1.0f;
LightProbe *prb = (LightProbe *)ob->data;
bool do_outlines = ((ob->base_flag & BASE_SELECTED) != 0);
int theme_id = DRW_object_wire_theme_get(ob, view_layer, &color);
OBJECT_ShadingGroupList *sgl = (ob->dtx & OB_DRAWXRAY) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
OBJECT_LightProbeEngineData *prb_data = (OBJECT_LightProbeEngineData *)DRW_drawdata_ensure(
&ob->id,
&draw_engine_object_type,
sizeof(OBJECT_LightProbeEngineData),
NULL,
NULL);
if ((DRW_state_is_select() || do_outlines) && ((prb->flag & LIGHTPROBE_FLAG_SHOW_DATA) != 0)) {
int *call_id = shgroup_theme_id_to_probe_outline_counter(stl, theme_id, ob->base_flag);
if (prb->type == LIGHTPROBE_TYPE_GRID) {
/* Update transforms */
float cell_dim[3], half_cell_dim[3];
cell_dim[0] = 2.0f / (float)(prb->grid_resolution_x);
cell_dim[1] = 2.0f / (float)(prb->grid_resolution_y);
cell_dim[2] = 2.0f / (float)(prb->grid_resolution_z);
mul_v3_v3fl(half_cell_dim, cell_dim, 0.5f);
/* First cell. */
copy_v3_fl(prb_data->corner, -1.0f);
add_v3_v3(prb_data->corner, half_cell_dim);
mul_m4_v3(ob->obmat, prb_data->corner);
/* Opposite neighbor cell. */
copy_v3_fl3(prb_data->increment_x, cell_dim[0], 0.0f, 0.0f);
add_v3_v3(prb_data->increment_x, half_cell_dim);
add_v3_fl(prb_data->increment_x, -1.0f);
mul_m4_v3(ob->obmat, prb_data->increment_x);
sub_v3_v3(prb_data->increment_x, prb_data->corner);
copy_v3_fl3(prb_data->increment_y, 0.0f, cell_dim[1], 0.0f);
add_v3_v3(prb_data->increment_y, half_cell_dim);
add_v3_fl(prb_data->increment_y, -1.0f);
mul_m4_v3(ob->obmat, prb_data->increment_y);
sub_v3_v3(prb_data->increment_y, prb_data->corner);
copy_v3_fl3(prb_data->increment_z, 0.0f, 0.0f, cell_dim[2]);
add_v3_v3(prb_data->increment_z, half_cell_dim);
add_v3_fl(prb_data->increment_z, -1.0f);
mul_m4_v3(ob->obmat, prb_data->increment_z);
sub_v3_v3(prb_data->increment_z, prb_data->corner);
uint cell_count = prb->grid_resolution_x * prb->grid_resolution_y * prb->grid_resolution_z;
DRWShadingGroup *grp = DRW_shgroup_create(sh_data->lightprobe_grid, psl->lightprobes);
DRW_shgroup_uniform_int_copy(grp, "call_id", *call_id);
DRW_shgroup_uniform_int(grp, "baseId", call_id, 1); /* that's correct */
DRW_shgroup_uniform_vec3(grp, "corner", prb_data->corner, 1);
DRW_shgroup_uniform_vec3(grp, "increment_x", prb_data->increment_x, 1);
DRW_shgroup_uniform_vec3(grp, "increment_y", prb_data->increment_y, 1);
DRW_shgroup_uniform_vec3(grp, "increment_z", prb_data->increment_z, 1);
DRW_shgroup_uniform_ivec3(grp, "grid_resolution", &prb->grid_resolution_x, 1);
DRW_shgroup_call_procedural_points_add(grp, cell_count, NULL);
}
else if (prb->type == LIGHTPROBE_TYPE_CUBE) {
float draw_size = 1.0f;
float probe_cube_mat[4][4];
// prb_data->draw_size = prb->data_draw_size * 0.1f;
// unit_m4(prb_data->probe_cube_mat);
// copy_v3_v3(prb_data->probe_cube_mat[3], ob->obmat[3]);
DRWShadingGroup *grp = shgroup_theme_id_to_probe_cube_outline_shgrp(stl, theme_id, ob->base_flag);
/* TODO remove or change the drawing of the cube probes. Theses line draws nothing on purpose
* to keep the call ids correct. */
zero_m4(probe_cube_mat);
DRW_shgroup_call_dynamic_add(grp, call_id, &draw_size, probe_cube_mat);
}
else {
float draw_size = 1.0f;
DRWShadingGroup *grp = shgroup_theme_id_to_probe_planar_outline_shgrp(stl, theme_id);
DRW_shgroup_call_dynamic_add(grp, call_id, &draw_size, ob->obmat);
}
*call_id += 1;
}
switch (prb->type) {
case LIGHTPROBE_TYPE_PLANAR:
DRW_shgroup_call_dynamic_add(sgl->probe_planar, ob->obmat[3], color);
break;
case LIGHTPROBE_TYPE_GRID:
DRW_shgroup_call_dynamic_add(sgl->probe_grid, ob->obmat[3], color);
break;
case LIGHTPROBE_TYPE_CUBE:
default:
DRW_shgroup_call_dynamic_add(sgl->probe_cube, ob->obmat[3], color);
break;
}
if (prb->type == LIGHTPROBE_TYPE_PLANAR) {
float mat[4][4];
copy_m4_m4(mat, ob->obmat);
normalize_m4(mat);
DRW_shgroup_call_dynamic_add(sgl->single_arrow, color, &ob->empty_drawsize, mat);
DRW_shgroup_call_dynamic_add(sgl->single_arrow_line, color, &ob->empty_drawsize, mat);
copy_m4_m4(mat, ob->obmat);
zero_v3(mat[2]);
DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, mat);
}
if ((prb->flag & LIGHTPROBE_FLAG_SHOW_INFLUENCE) != 0) {
prb->distfalloff = (1.0f - prb->falloff) * prb->distinf;
prb->distgridinf = prb->distinf;
if (prb->type == LIGHTPROBE_TYPE_GRID) {
prb->distfalloff += 1.0f;
prb->distgridinf += 1.0f;
}
if (prb->type == LIGHTPROBE_TYPE_GRID ||
prb->attenuation_type == LIGHTPROBE_SHAPE_BOX)
{
DRW_shgroup_call_dynamic_add(sgl->cube, color, &prb->distgridinf, ob->obmat);
DRW_shgroup_call_dynamic_add(sgl->cube, color, &prb->distfalloff, ob->obmat);
}
else if (prb->type == LIGHTPROBE_TYPE_PLANAR) {
float rangemat[4][4];
copy_m4_m4(rangemat, ob->obmat);
normalize_v3(rangemat[2]);
mul_v3_fl(rangemat[2], prb->distinf);
DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, rangemat);
copy_m4_m4(rangemat, ob->obmat);
normalize_v3(rangemat[2]);
mul_v3_fl(rangemat[2], prb->distfalloff);
DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, rangemat);
}
else {
DRW_shgroup_call_dynamic_add(sgl->sphere, color, &prb->distgridinf, ob->obmat);
DRW_shgroup_call_dynamic_add(sgl->sphere, color, &prb->distfalloff, ob->obmat);
}
}
if ((prb->flag & LIGHTPROBE_FLAG_SHOW_PARALLAX) != 0) {
if (prb->type != LIGHTPROBE_TYPE_PLANAR) {
float (*obmat)[4], *dist;
if ((prb->flag & LIGHTPROBE_FLAG_CUSTOM_PARALLAX) != 0) {
dist = &prb->distpar;
/* TODO object parallax */
obmat = ob->obmat;
}
else {
dist = &prb->distinf;
obmat = ob->obmat;
}
if (prb->parallax_type == LIGHTPROBE_SHAPE_BOX) {
DRW_shgroup_call_dynamic_add(sgl->cube, color, dist, obmat);
}
else {
DRW_shgroup_call_dynamic_add(sgl->sphere, color, dist, obmat);
}
}
}
if ((prb->flag & LIGHTPROBE_FLAG_SHOW_CLIP_DIST) != 0) {
if (prb->type != LIGHTPROBE_TYPE_PLANAR) {
static const float cubefacemat[6][4][4] = {
{{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}},
{{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}},
{{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}},
{{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}},
{{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}},
{{-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}},
};
for (int i = 0; i < 6; ++i) {
float clipmat[4][4];
normalize_m4_m4(clipmat, ob->obmat);
mul_m4_m4m4(clipmat, clipmat, cubefacemat[i]);
DRW_shgroup_call_dynamic_add(sgl->light_buflimit, color, &prb->clipsta, &prb->clipend, clipmat);
DRW_shgroup_call_dynamic_add(sgl->light_buflimit_points, color, &prb->clipsta, &prb->clipend, clipmat);
}
}
}
/* Line and point going to the ground */
if (prb->type == LIGHTPROBE_TYPE_CUBE) {
DRW_shgroup_call_dynamic_add(sgl->light_groundline, ob->obmat[3]);
DRW_shgroup_call_dynamic_add(sgl->light_groundpoint, ob->obmat[3]);
}
}
static void DRW_shgroup_relationship_lines(
OBJECT_ShadingGroupList *sgl,
Depsgraph *depsgraph,
Scene *scene,
Object *ob)
{
if (ob->parent && (DRW_object_visibility_in_active_context(ob->parent) & OB_VISIBLE_SELF)) {
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->runtime.parent_display_origin);
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->obmat[3]);
}
if (ob->rigidbody_constraint) {
Object *rbc_ob1 = ob->rigidbody_constraint->ob1;
Object *rbc_ob2 = ob->rigidbody_constraint->ob2;
if (rbc_ob1 && (DRW_object_visibility_in_active_context(rbc_ob1) & OB_VISIBLE_SELF)) {
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, rbc_ob1->obmat[3]);
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->obmat[3]);
}
if (rbc_ob2 && (DRW_object_visibility_in_active_context(rbc_ob2) & OB_VISIBLE_SELF)) {
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, rbc_ob2->obmat[3]);
DRW_shgroup_call_dynamic_add(sgl->relationship_lines, ob->obmat[3]);
}
}
/* Drawing the constraint lines */
if (!BLI_listbase_is_empty(&ob->constraints)) {
bConstraint *curcon;
bConstraintOb *cob;
ListBase *list = &ob->constraints;
cob = BKE_constraints_make_evalob(depsgraph, scene, ob, NULL, CONSTRAINT_OBTYPE_OBJECT);
for (curcon = list->first; curcon; curcon = curcon->next) {
if (ELEM(curcon->type, CONSTRAINT_TYPE_FOLLOWTRACK, CONSTRAINT_TYPE_OBJECTSOLVER)) {
/* special case for object solver and follow track constraints because they don't fill
* constraint targets properly (design limitation -- scene is needed for their target
* but it can't be accessed from get_targets callback) */
Object *camob = NULL;
if (curcon->type == CONSTRAINT_TYPE_FOLLOWTRACK) {
bFollowTrackConstraint *data = (bFollowTrackConstraint *)curcon->data;
camob = data->camera ? data->camera : scene->camera;
}
else if (curcon->type == CONSTRAINT_TYPE_OBJECTSOLVER) {
bObjectSolverConstraint *data = (bObjectSolverConstraint *)curcon->data;
camob = data->camera ? data->camera : scene->camera;
}
if (camob) {
DRW_shgroup_call_dynamic_add(sgl->constraint_lines, camob->obmat[3]);
DRW_shgroup_call_dynamic_add(sgl->constraint_lines, ob->obmat[3]);
}
}
else {
const bConstraintTypeInfo *cti = BKE_constraint_typeinfo_get(curcon);
if ((cti && cti->get_constraint_targets) && (curcon->flag & CONSTRAINT_EXPAND)) {
ListBase targets = {NULL, NULL};
bConstraintTarget *ct;
cti->get_constraint_targets(curcon, &targets);
for (ct = targets.first; ct; ct = ct->next) {
/* calculate target's matrix */
if (cti->get_target_matrix) {
cti->get_target_matrix(depsgraph,
curcon,
cob,
ct,
DEG_get_ctime(depsgraph));
}
else {
unit_m4(ct->matrix);
}
DRW_shgroup_call_dynamic_add(sgl->constraint_lines, ct->matrix[3]);
DRW_shgroup_call_dynamic_add(sgl->constraint_lines, ob->obmat[3]);
}
if (cti->flush_constraint_targets) {
cti->flush_constraint_targets(curcon, &targets, 1);
}
}
}
}
BKE_constraints_clear_evalob(cob);
}
}
static void DRW_shgroup_object_center(OBJECT_StorageList *stl, Object *ob, ViewLayer *view_layer, View3D *v3d)
{
if (v3d->overlay.flag & V3D_OVERLAY_HIDE_OBJECT_ORIGINS) {
return;
}
const bool is_library = ob->id.us > 1 || ID_IS_LINKED(ob);
DRWShadingGroup *shgroup;
if (ob == OBACT(view_layer)) {
shgroup = stl->g_data->center_active;
}
else if (ob->base_flag & BASE_SELECTED) {
if (is_library) {
shgroup = stl->g_data->center_selected_lib;
}
else {
shgroup = stl->g_data->center_selected;
}
}
else if (v3d->flag & V3D_DRAW_CENTERS) {
if (is_library) {
shgroup = stl->g_data->center_deselected_lib;
}
else {
shgroup = stl->g_data->center_deselected;
}
}
else {
return;
}
DRW_shgroup_call_dynamic_add(shgroup, ob->obmat[3]);
}
static void DRW_shgroup_texture_space(OBJECT_ShadingGroupList *sgl, Object *ob, int theme_id)
{
if (ob->data == NULL) {
return;
}
ID *ob_data = ob->data;
float *texcoloc = NULL;
float *texcosize = NULL;
switch (GS(ob_data->name)) {
case ID_ME:
BKE_mesh_texspace_get_reference((Mesh *)ob_data, NULL, &texcoloc, NULL, &texcosize);
break;
case ID_CU:
{
Curve *cu = (Curve *)ob_data;
if (cu->bb == NULL || (cu->bb->flag & BOUNDBOX_DIRTY)) {
BKE_curve_texspace_calc(cu);
}
texcoloc = cu->loc;
texcosize = cu->size;
break;
}
case ID_MB:
{
MetaBall *mb = (MetaBall *)ob_data;
texcoloc = mb->loc;
texcosize = mb->size;
break;
}
default:
BLI_assert(0);
}
float tmp[4][4] = {{0.0f}}, one = 1.0f;
tmp[0][0] = texcosize[0];
tmp[1][1] = texcosize[1];
tmp[2][2] = texcosize[2];
tmp[3][0] = texcoloc[0];
tmp[3][1] = texcoloc[1];
tmp[3][2] = texcoloc[2];
tmp[3][3] = 1.0f;
mul_m4_m4m4(tmp, ob->obmat, tmp);
float color[4];
UI_GetThemeColor4fv(theme_id, color);
DRW_shgroup_call_dynamic_add(sgl->texspace, color, &one, tmp);
}
static void DRW_shgroup_bounds(OBJECT_ShadingGroupList *sgl, Object *ob, int theme_id)
{
float color[4], center[3], size[3], tmp[4][4], final_mat[4][4], one = 1.0f;
BoundBox bb_local;
if (ob->type == OB_MBALL && !BKE_mball_is_basis(ob)) {
return;
}
BoundBox *bb = BKE_object_boundbox_get(ob);
if (!ELEM(ob->type, OB_MESH, OB_CURVE, OB_SURF, OB_FONT,
OB_MBALL, OB_ARMATURE, OB_LATTICE))
{
const float min[3] = {-1.0f, -1.0f, -1.0f}, max[3] = {1.0f, 1.0f, 1.0f};
bb = &bb_local;
BKE_boundbox_init_from_minmax(bb, min, max);
}
UI_GetThemeColor4fv(theme_id, color);
BKE_boundbox_calc_center_aabb(bb, center);
BKE_boundbox_calc_size_aabb(bb, size);
switch (ob->boundtype) {
case OB_BOUND_BOX:
size_to_mat4(tmp, size);
copy_v3_v3(tmp[3], center);
mul_m4_m4m4(tmp, ob->obmat, tmp);
DRW_shgroup_call_dynamic_add(sgl->cube, color, &one, tmp);
break;
case OB_BOUND_SPHERE:
size[0] = max_fff(size[0], size[1], size[2]);
size[1] = size[2] = size[0];
size_to_mat4(tmp, size);
copy_v3_v3(tmp[3], center);
mul_m4_m4m4(tmp, ob->obmat, tmp);
DRW_shgroup_call_dynamic_add(sgl->sphere, color, &one, tmp);
break;
case OB_BOUND_CYLINDER:
size[0] = max_ff(size[0], size[1]);
size[1] = size[0];
size_to_mat4(tmp, size);
copy_v3_v3(tmp[3], center);
mul_m4_m4m4(tmp, ob->obmat, tmp);
DRW_shgroup_call_dynamic_add(sgl->cylinder, color, &one, tmp);
break;
case OB_BOUND_CONE:
size[0] = max_ff(size[0], size[1]);
size[1] = size[0];
size_to_mat4(tmp, size);
copy_v3_v3(tmp[3], center);
/* Cone batch has base at 0 and is pointing towards +Y. */
swap_v3_v3(tmp[1], tmp[2]);
tmp[3][2] -= size[2];
mul_m4_m4m4(tmp, ob->obmat, tmp);
DRW_shgroup_call_dynamic_add(sgl->cone, color, &one, tmp);
break;
case OB_BOUND_CAPSULE:
size[0] = max_ff(size[0], size[1]);
size[1] = size[0];
scale_m4_fl(tmp, size[0]);
copy_v2_v2(tmp[3], center);
tmp[3][2] = center[2] + max_ff(0.0f, size[2] - size[0]);
mul_m4_m4m4(final_mat, ob->obmat, tmp);
DRW_shgroup_call_dynamic_add(sgl->capsule_cap, color, &one, final_mat);
negate_v3(tmp[2]);
tmp[3][2] = center[2] - max_ff(0.0f, size[2] - size[0]);
mul_m4_m4m4(final_mat, ob->obmat, tmp);
DRW_shgroup_call_dynamic_add(sgl->capsule_cap, color, &one, final_mat);
tmp[2][2] = max_ff(0.0f, size[2] * 2.0f - size[0] * 2.0f);
mul_m4_m4m4(final_mat, ob->obmat, tmp);
DRW_shgroup_call_dynamic_add(sgl->capsule_body, color, &one, final_mat);
break;
}
}
static void OBJECT_cache_populate_particles(
OBJECT_Shaders *sh_data,
Object *ob,
OBJECT_PassList *psl)
{
for (ParticleSystem *psys = ob->particlesystem.first; psys; psys = psys->next) {
if (!psys_check_enabled(ob, psys, false)) {
continue;
}
if (!DRW_object_is_visible_psys_in_active_context(ob, psys)) {
continue;
}
ParticleSettings *part = psys->part;
int draw_as = (part->draw_as == PART_DRAW_REND) ? part->ren_as : part->draw_as;
static float mat[4][4];
unit_m4(mat);
if (draw_as != PART_DRAW_PATH) {
struct GPUBatch *geom = DRW_cache_particles_get_dots(ob, psys);
DRWShadingGroup *shgrp = NULL;
static int screen_space[2] = {0, 1};
static float def_prim_col[3] = {0.5f, 0.5f, 0.5f};
static float def_sec_col[3] = {1.0f, 1.0f, 1.0f};
/* Dummy particle format for instancing to work. */
DRW_shgroup_instance_format(e_data.particle_format, {{"dummy", DRW_ATTR_FLOAT, 1}});
Material *ma = give_current_material(ob, part->omat);
switch (draw_as) {
case PART_DRAW_DOT:
shgrp = DRW_shgroup_create(sh_data->part_dot, psl->particle);
DRW_shgroup_uniform_vec3(shgrp, "color", ma ? &ma->r : def_prim_col, 1);
DRW_shgroup_uniform_vec3(shgrp, "outlineColor", ma ? &ma->specr : def_sec_col, 1);
DRW_shgroup_uniform_float(shgrp, "pixel_size", DRW_viewport_pixelsize_get(), 1);
DRW_shgroup_uniform_float(shgrp, "size", &part->draw_size, 1);
DRW_shgroup_uniform_texture(shgrp, "ramp", G_draw.ramp);
DRW_shgroup_call_add(shgrp, geom, mat);
break;
case PART_DRAW_CROSS:
shgrp = DRW_shgroup_instance_create(
sh_data->part_prim, psl->particle, DRW_cache_particles_get_prim(PART_DRAW_CROSS),
e_data.particle_format);
DRW_shgroup_uniform_texture(shgrp, "ramp", G_draw.ramp);
DRW_shgroup_uniform_vec3(shgrp, "color", ma ? &ma->r : def_prim_col, 1);
DRW_shgroup_uniform_int(shgrp, "screen_space", &screen_space[0], 1);
break;
case PART_DRAW_CIRC:
shgrp = DRW_shgroup_instance_create(
sh_data->part_prim, psl->particle, DRW_cache_particles_get_prim(PART_DRAW_CIRC),
e_data.particle_format);
DRW_shgroup_uniform_texture(shgrp, "ramp", G_draw.ramp);
DRW_shgroup_uniform_vec3(shgrp, "color", ma ? &ma->r : def_prim_col, 1);
DRW_shgroup_uniform_int(shgrp, "screen_space", &screen_space[1], 1);
break;
case PART_DRAW_AXIS:
shgrp = DRW_shgroup_instance_create(
sh_data->part_axis, psl->particle, DRW_cache_particles_get_prim(PART_DRAW_AXIS),
e_data.particle_format);
DRW_shgroup_uniform_int(shgrp, "screen_space", &screen_space[0], 1);
break;
default:
break;
}
if (shgrp) {
if (draw_as != PART_DRAW_DOT) {
DRW_shgroup_uniform_float(shgrp, "draw_size", &part->draw_size, 1);
DRW_shgroup_instance_batch(shgrp, geom);
}
}
}
}
}
static void OBJECT_cache_populate(void *vedata, Object *ob)
{
OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl;
OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl;
OBJECT_ShadingGroupList *sgl = (ob->dtx & OB_DRAWXRAY) ? &stl->g_data->sgl_ghost : &stl->g_data->sgl;
const DRWContextState *draw_ctx = DRW_context_state_get();
const bool is_edit_mode = (ob == draw_ctx->object_edit) || BKE_object_is_in_editmode(ob);
ViewLayer *view_layer = draw_ctx->view_layer;
Scene *scene = draw_ctx->scene;
View3D *v3d = draw_ctx->v3d;
RegionView3D *rv3d = draw_ctx->rv3d;
ModifierData *md = NULL;
int theme_id = TH_UNDEFINED;
const int ob_visibility = DRW_object_visibility_in_active_context(ob);
OBJECT_Shaders *sh_data = &e_data.sh_data[draw_ctx->sh_cfg];
/* Handle particles first in case the emitter itself shouldn't be rendered. */
if (ob_visibility & OB_VISIBLE_PARTICLES) {
OBJECT_cache_populate_particles(sh_data, ob, psl);
}
if ((ob_visibility & OB_VISIBLE_SELF) == 0) {
return;
}
const bool do_outlines = (
(draw_ctx->v3d->flag & V3D_SELECT_OUTLINE) && ((ob->base_flag & BASE_SELECTED) != 0) &&
((DRW_object_is_renderable(ob) && (ob->dt > OB_WIRE)) || (ob->dt == OB_WIRE)));
const bool show_relations = ((draw_ctx->v3d->flag & V3D_HIDE_HELPLINES) == 0);
const bool hide_object_extra = (v3d->overlay.flag & V3D_OVERLAY_HIDE_OBJECT_XTRAS) != 0;
if (do_outlines) {
if (!BKE_object_is_in_editmode(ob) &&
!((ob == draw_ctx->obact) && (draw_ctx->object_mode & OB_MODE_ALL_PAINT)))
{
struct GPUBatch *geom;
/* This fixes only the biggest case which is a plane in ortho view. */
int flat_axis = 0;
bool is_flat_object_viewed_from_side = (
(rv3d->persp == RV3D_ORTHO) &&
DRW_object_is_flat(ob, &flat_axis) &&
DRW_object_axis_orthogonal_to_view(ob, flat_axis));
if (stl->g_data->xray_enabled_and_not_wire || is_flat_object_viewed_from_side) {
geom = DRW_cache_object_edge_detection_get(ob, NULL);
}
else {
geom = DRW_cache_object_surface_get(ob);
}
if (geom) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
DRWShadingGroup *shgroup = shgroup_theme_id_to_outline_or_null(stl, theme_id, ob->base_flag);
if (shgroup != NULL) {
DRW_shgroup_call_object_add(shgroup, geom, ob);
}
}
}
}
switch (ob->type) {
case OB_MESH:
{
if (hide_object_extra) {
break;
}
Mesh *me = ob->data;
if (me->totedge == 0) {
if (!is_edit_mode) {
struct GPUBatch *geom = DRW_cache_mesh_all_verts_get(ob);
if (geom) {
if (theme_id == TH_UNDEFINED) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
DRWShadingGroup *shgroup = shgroup_theme_id_to_point(sgl, theme_id, ob->base_flag);
DRW_shgroup_call_object_add(shgroup, geom, ob);
}
}
}
else {
bool has_edit_mesh_cage = false;
/* TODO: Should be its own function. */
if (is_edit_mode) {
BMEditMesh *embm = me->edit_mesh;
has_edit_mesh_cage = embm->mesh_eval_cage && (embm->mesh_eval_cage != embm->mesh_eval_final);
}
if (!is_edit_mode || has_edit_mesh_cage) {
struct GPUBatch *geom = DRW_cache_mesh_loose_edges_get(ob);
if (geom) {
if (theme_id == TH_UNDEFINED) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
DRWShadingGroup *shgroup = shgroup_theme_id_to_wire(sgl, theme_id, ob->base_flag);
DRW_shgroup_call_object_add(shgroup, geom, ob);
}
}
}
break;
}
case OB_SURF:
{
if (hide_object_extra) {
break;
}
struct GPUBatch *geom = DRW_cache_surf_edge_wire_get(ob);
if (geom == NULL) {
break;
}
if (theme_id == TH_UNDEFINED) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
DRWShadingGroup *shgroup = shgroup_theme_id_to_wire(sgl, theme_id, ob->base_flag);
DRW_shgroup_call_object_add(shgroup, geom, ob);
break;
}
case OB_LATTICE:
{
if (!is_edit_mode) {
if (hide_object_extra) {
break;
}
struct GPUBatch *geom = DRW_cache_lattice_wire_get(ob, false);
if (theme_id == TH_UNDEFINED) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
DRWShadingGroup *shgroup = shgroup_theme_id_to_wire(sgl, theme_id, ob->base_flag);
DRW_shgroup_call_object_add(shgroup, geom, ob);
}
break;
}
case OB_CURVE:
{
if (!is_edit_mode) {
if (hide_object_extra) {
break;
}
struct GPUBatch *geom = DRW_cache_curve_edge_wire_get(ob);
if (theme_id == TH_UNDEFINED) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
DRWShadingGroup *shgroup = shgroup_theme_id_to_wire(sgl, theme_id, ob->base_flag);
DRW_shgroup_call_object_add(shgroup, geom, ob);
}
break;
}
case OB_MBALL:
{
if (!is_edit_mode) {
DRW_shgroup_mball_handles(sgl, ob, view_layer);
}
break;
}
case OB_LAMP:
if (hide_object_extra) {
break;
}
DRW_shgroup_light(sgl, ob, view_layer);
break;
case OB_CAMERA:
if (hide_object_extra) {
break;
}
DRW_shgroup_camera(sgl, ob, view_layer);
break;
case OB_EMPTY:
if (hide_object_extra) {
break;
}
DRW_shgroup_empty(sh_data, sgl, ob, view_layer, rv3d, draw_ctx->sh_cfg);
break;
case OB_SPEAKER:
if (hide_object_extra) {
break;
}
DRW_shgroup_speaker(sgl, ob, view_layer);
break;
case OB_LIGHTPROBE:
if (hide_object_extra) {
break;
}
DRW_shgroup_lightprobe(sh_data, stl, psl, ob, view_layer);
break;
case OB_ARMATURE:
{
if ((v3d->flag2 & V3D_HIDE_OVERLAYS) ||
(v3d->overlay.flag & V3D_OVERLAY_HIDE_BONES) ||
((ob->dt < OB_WIRE) && !DRW_state_is_select()))
{
break;
}
bArmature *arm = ob->data;
if (arm->edbo == NULL) {
if (DRW_state_is_select() || !DRW_pose_mode_armature(ob, draw_ctx->obact)) {
bool is_wire = (v3d->shading.type == OB_WIRE) || (ob->dt <= OB_WIRE);
DRWArmaturePasses passes = {
.bone_solid = (is_wire) ? NULL : sgl->bone_solid,
.bone_outline = sgl->bone_outline,
.bone_wire = sgl->bone_wire,
.bone_envelope = sgl->bone_envelope,
.bone_axes = sgl->bone_axes,
.relationship_lines = NULL, /* Don't draw relationship lines */
};
DRW_shgroup_armature_object(ob, view_layer, passes, is_wire);
}
}
break;
}
case OB_FONT:
{
if (hide_object_extra) {
break;
}
Curve *cu = (Curve *)ob->data;
bool has_surface = (cu->flag & (CU_FRONT | CU_BACK)) || cu->ext1 != 0.0f || cu->ext2 != 0.0f;
if (!has_surface) {
struct GPUBatch *geom = DRW_cache_text_edge_wire_get(ob);
if (geom) {
if (theme_id == TH_UNDEFINED) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
DRWShadingGroup *shgroup = shgroup_theme_id_to_wire(sgl, theme_id, ob->base_flag);
DRW_shgroup_call_object_add(shgroup, geom, ob);
}
}
break;
}
default:
break;
}
if (ob->pd && ob->pd->forcefield) {
DRW_shgroup_forcefield(sgl, ob, view_layer);
}
if (ob->dt == OB_BOUNDBOX) {
if (theme_id == TH_UNDEFINED) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
DRW_shgroup_bounds(sgl, ob, theme_id);
}
/* don't show object extras in set's */
if ((ob->base_flag & (BASE_FROM_SET | BASE_FROM_DUPLI)) == 0) {
if ((draw_ctx->object_mode & (OB_MODE_ALL_PAINT | OB_MODE_ALL_PAINT_GPENCIL)) == 0) {
DRW_shgroup_object_center(stl, ob, view_layer, v3d);
}
if (show_relations && !DRW_state_is_select()) {
DRW_shgroup_relationship_lines(sgl, draw_ctx->depsgraph, scene, ob);
}
const bool draw_extra = (ob->dtx != 0);
if (draw_extra && (theme_id == TH_UNDEFINED)) {
theme_id = DRW_object_wire_theme_get(ob, view_layer, NULL);
}
if ((ob->dtx & OB_DRAWNAME) && DRW_state_show_text()) {
struct DRWTextStore *dt = DRW_text_cache_ensure();
uchar color[4];
UI_GetThemeColor4ubv(theme_id, color);
DRW_text_cache_add(
dt, ob->obmat[3],
ob->id.name + 2, strlen(ob->id.name + 2),
10, 0, DRW_TEXT_CACHE_GLOBALSPACE | DRW_TEXT_CACHE_STRING_PTR, color);
}
if ((ob->dtx & OB_TEXSPACE) && ELEM(ob->type, OB_MESH, OB_CURVE, OB_MBALL)) {
DRW_shgroup_texture_space(sgl, ob, theme_id);
}
/* Don't draw bounding box again if draw type is bound box. */
if (ob->dtx & OB_DRAWBOUNDOX && ob->dt != OB_BOUNDBOX) {
DRW_shgroup_bounds(sgl, ob, theme_id);
}
if (ob->dtx & OB_AXIS) {
float *color, axes_size = 1.0f;
DRW_object_wire_theme_get(ob, view_layer, &color);
DRW_shgroup_call_dynamic_add(sgl->empty_axes, color, &axes_size, ob->obmat);
}
if ((md = modifiers_findByType(ob, eModifierType_Smoke)) &&
(modifier_isEnabled(scene, md, eModifierMode_Realtime)) &&
(((SmokeModifierData *)md)->domain != NULL))
{
DRW_shgroup_volume_extra(sgl, ob, view_layer, scene, md);
}
}
}
static void OBJECT_cache_finish(void *vedata)
{
OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl;
DRW_pass_sort_shgroup_z(stl->g_data->sgl.image_empties);
DRW_pass_sort_shgroup_z(stl->g_data->sgl_ghost.image_empties);
}
static void OBJECT_draw_scene(void *vedata)
{
OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl;
OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl;
OBJECT_FramebufferList *fbl = ((OBJECT_Data *)vedata)->fbl;
OBJECT_PrivateData *g_data = stl->g_data;
DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
int id_len_select = g_data->id_ofs_select;
int id_len_select_dupli = g_data->id_ofs_select_dupli;
int id_len_active = g_data->id_ofs_active;
int id_len_transform = g_data->id_ofs_transform;
int id_len_prb_select = g_data->id_ofs_prb_select;
int id_len_prb_select_dupli = g_data->id_ofs_prb_select_dupli;
int id_len_prb_active = g_data->id_ofs_prb_active;
int id_len_prb_transform = g_data->id_ofs_prb_transform;
int outline_calls = id_len_select + id_len_select_dupli + id_len_active + id_len_transform;
outline_calls += id_len_prb_select + id_len_prb_select_dupli + id_len_prb_active + id_len_prb_transform;
float clearcol[4] = {0.0f, 0.0f, 0.0f, 0.0f};
// DRW_draw_pass(psl->bone_envelope); /* Never drawn in Object mode currently. */
MULTISAMPLE_SYNC_ENABLE(dfbl, dtxl);
DRW_draw_pass(stl->g_data->sgl.spot_shapes);
DRW_draw_pass(stl->g_data->sgl.bone_solid);
DRW_draw_pass(stl->g_data->sgl.bone_wire);
DRW_draw_pass(stl->g_data->sgl.bone_outline);
DRW_draw_pass(stl->g_data->sgl.non_meshes);
DRW_draw_pass(psl->particle);
DRW_draw_pass(stl->g_data->sgl.bone_axes);
MULTISAMPLE_SYNC_DISABLE(dfbl, dtxl)
DRW_draw_pass(stl->g_data->sgl.image_empties);
if (DRW_state_is_fbo() && outline_calls > 0) {
DRW_stats_group_start("Outlines");
g_data->id_ofs_active = 1;
g_data->id_ofs_select = g_data->id_ofs_active + id_len_active + id_len_prb_active + 1;
g_data->id_ofs_select_dupli = g_data->id_ofs_select + id_len_select + id_len_prb_select + 1;
g_data->id_ofs_transform = g_data->id_ofs_select_dupli + id_len_select_dupli + id_len_prb_select_dupli + 1;
g_data->id_ofs_prb_active = g_data->id_ofs_active + id_len_active;
g_data->id_ofs_prb_select = g_data->id_ofs_select + id_len_select;
g_data->id_ofs_prb_select_dupli = g_data->id_ofs_select_dupli + id_len_select_dupli;
g_data->id_ofs_prb_transform = g_data->id_ofs_transform + id_len_transform;
/* Render filled polygon on a separate framebuffer */
GPU_framebuffer_bind(fbl->outlines_fb);
GPU_framebuffer_clear_color_depth(fbl->outlines_fb, clearcol, 1.0f);
DRW_draw_pass(psl->outlines);
DRW_draw_pass(psl->lightprobes);
/* Search outline pixels */
GPU_framebuffer_bind(fbl->blur_fb);
DRW_draw_pass(psl->outlines_search);
/* Expand outline to form a 3px wide line */
GPU_framebuffer_bind(fbl->expand_fb);
DRW_draw_pass(psl->outlines_expand);
/* Bleed color so the AA can do it's stuff */
GPU_framebuffer_bind(fbl->blur_fb);
DRW_draw_pass(psl->outlines_bleed);
/* restore main framebuffer */
GPU_framebuffer_bind(dfbl->default_fb);
DRW_stats_group_end();
}
else if (DRW_state_is_select()) {
/* Render probes spheres/planes so we can select them. */
DRW_draw_pass(psl->lightprobes);
}
if (DRW_state_is_fbo()) {
if (e_data.draw_grid) {
GPU_framebuffer_bind(dfbl->color_only_fb);
DRW_draw_pass(psl->grid);
}
/* Combine with scene buffer last */
if (outline_calls > 0) {
DRW_draw_pass(psl->outlines_resolve);
}
}
volumes_free_smoke_textures();
batch_camera_path_free(&stl->g_data->sgl.camera_path);
if (!DRW_pass_is_empty(stl->g_data->sgl_ghost.bone_solid) ||
!DRW_pass_is_empty(stl->g_data->sgl_ghost.bone_wire) ||
!DRW_pass_is_empty(stl->g_data->sgl_ghost.bone_outline) ||
!DRW_pass_is_empty(stl->g_data->sgl_ghost.non_meshes) ||
!DRW_pass_is_empty(stl->g_data->sgl_ghost.image_empties) ||
!DRW_pass_is_empty(stl->g_data->sgl_ghost.bone_axes))
{
if (DRW_state_is_fbo()) {
/* meh, late init to not request a depth buffer we won't use. */
const float *viewport_size = DRW_viewport_size_get();
const int size[2] = {(int)viewport_size[0], (int)viewport_size[1]};
GPUTexture *ghost_depth_tx = DRW_texture_pool_query_2D(size[0], size[1], GPU_DEPTH_COMPONENT24, &draw_engine_object_type);
GPU_framebuffer_ensure_config(&fbl->ghost_fb, {
GPU_ATTACHMENT_TEXTURE(ghost_depth_tx),
GPU_ATTACHMENT_TEXTURE(dtxl->color),
});
GPU_framebuffer_bind(fbl->ghost_fb);
GPU_framebuffer_clear_depth(fbl->ghost_fb, 1.0f);
}
else if (DRW_state_is_select()) {
/* XXX `GPU_depth_range` is not a perfect solution
* since very distant geometries can still be occluded.
* Also the depth test precision of these geometries is impaired.
* However solves the selection for the vast majority of cases. */
GPU_depth_range(0.0f, 0.01f);
}
DRW_draw_pass(stl->g_data->sgl_ghost.spot_shapes);
DRW_draw_pass(stl->g_data->sgl_ghost.bone_solid);
DRW_draw_pass(stl->g_data->sgl_ghost.bone_wire);
DRW_draw_pass(stl->g_data->sgl_ghost.bone_outline);
DRW_draw_pass(stl->g_data->sgl_ghost.non_meshes);
DRW_draw_pass(stl->g_data->sgl_ghost.image_empties);
DRW_draw_pass(stl->g_data->sgl_ghost.bone_axes);
if (DRW_state_is_select()) {
GPU_depth_range(0.0f, 1.0f);
}
}
batch_camera_path_free(&stl->g_data->sgl_ghost.camera_path);
DRW_draw_pass(psl->ob_center);
}
static const DrawEngineDataSize OBJECT_data_size = DRW_VIEWPORT_DATA_SIZE(OBJECT_Data);
DrawEngineType draw_engine_object_type = {
NULL, NULL,
N_("ObjectMode"),
&OBJECT_data_size,
&OBJECT_engine_init,
&OBJECT_engine_free,
&OBJECT_cache_init,
&OBJECT_cache_populate,
&OBJECT_cache_finish,
NULL,
&OBJECT_draw_scene,
NULL,
NULL,
};
Reference in New Issue View Git Blame Copy Permalink