Page MenuHome
Differential D16010 Diff 55848 source/blender/draw/engines/overlay/overlay_engine.cc

Changeset View

Standalone View

View Options

source/blender/draw/engines/overlay/overlay_engine.cc

  • This file was moved from source/blender/draw/engines/overlay/overlay_engine.c.
Show All 16 Lines
#include "UI_interface.h" #include "UI_interface.h"
#include "BKE_object.h" #include "BKE_object.h"
#include "BKE_paint.h" #include "BKE_paint.h"
#include "DNA_space_types.h" #include "DNA_space_types.h"
#include "overlay_engine.h" #include "overlay_engine.h"
#include "overlay_private.h" #include "overlay_private.hh"
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name Engine Callbacks /** \name Engine Callbacks
* \{ */ * \{ */
static void OVERLAY_engine_init(void *vedata) static void OVERLAY_engine_init(void *vedata)
{ {
OVERLAY_Data *data = vedata; OVERLAY_Data *data = static_cast<OVERLAY_Data *>(vedata);
OVERLAY_StorageList *stl = data->stl; OVERLAY_StorageList *stl = data->stl;
const DRWContextState *draw_ctx = DRW_context_state_get(); const DRWContextState *draw_ctx = DRW_context_state_get();
const RegionView3D *rv3d = draw_ctx->rv3d; const RegionView3D *rv3d = draw_ctx->rv3d;
const View3D *v3d = draw_ctx->v3d; const View3D *v3d = draw_ctx->v3d;
const Scene *scene = draw_ctx->scene; const Scene *scene = draw_ctx->scene;
const ToolSettings *ts = scene->toolsettings; const ToolSettings *ts = scene->toolsettings;
if (!stl->pd) { if (!stl->pd) {
/* Allocate transient pointers. */ /* Allocate transient pointers. */
stl->pd = MEM_callocN(sizeof(*stl->pd), __func__); stl->pd = static_cast<OVERLAY_PrivateData *>(MEM_callocN(sizeof(*stl->pd), __func__));
} }
/* Allocate instance. */ /* Allocate instance. */
if (data->instance == NULL) { if (data->instance == nullptr) {
data->instance = MEM_callocN(sizeof(*data->instance), __func__); data->instance = static_cast<OVERLAY_Instance *>(
MEM_callocN(sizeof(*data->instance), __func__));
} }
OVERLAY_PrivateData *pd = stl->pd; OVERLAY_PrivateData *pd = stl->pd;
pd->space_type = v3d != NULL ? SPACE_VIEW3D : draw_ctx->space_data->spacetype; pd->space_type = v3d != nullptr ? SPACE_VIEW3D : draw_ctx->space_data->spacetype;
if (pd->space_type == SPACE_IMAGE) { if (pd->space_type == SPACE_IMAGE) {
const SpaceImage *sima = (SpaceImage *)draw_ctx->space_data; const SpaceImage *sima = (SpaceImage *)draw_ctx->space_data;
pd->hide_overlays = (sima->overlay.flag & SI_OVERLAY_SHOW_OVERLAYS) == 0; pd->hide_overlays = (sima->overlay.flag & SI_OVERLAY_SHOW_OVERLAYS) == 0;
pd->clipping_state = 0; pd->clipping_state = DRWState(0);
OVERLAY_grid_init(data); OVERLAY_grid_init(data);
OVERLAY_edit_uv_init(data); OVERLAY_edit_uv_init(data);
return; return;
} }
if (pd->space_type == SPACE_NODE) { if (pd->space_type == SPACE_NODE) {
pd->hide_overlays = true; pd->hide_overlays = true;
pd->clipping_state = 0; pd->clipping_state = DRWState(0);
return; return;
} }
pd->hide_overlays = (v3d->flag2 & V3D_HIDE_OVERLAYS) != 0; pd->hide_overlays = (v3d->flag2 & V3D_HIDE_OVERLAYS) != 0;
pd->ctx_mode = CTX_data_mode_enum_ex( pd->ctx_mode = CTX_data_mode_enum_ex(
draw_ctx->object_edit, draw_ctx->obact, draw_ctx->object_mode); draw_ctx->object_edit, draw_ctx->obact, draw_ctx->object_mode);
if (!pd->hide_overlays) { if (!pd->hide_overlays) {
Show All 23 Lines if (ts->sculpt) {
if (ts->sculpt->flags & SCULPT_HIDE_MASK) { if (ts->sculpt->flags & SCULPT_HIDE_MASK) {
pd->overlay.sculpt_mode_mask_opacity = 0.0f; pd->overlay.sculpt_mode_mask_opacity = 0.0f;
} }
} }
pd->use_in_front = (v3d->shading.type <= OB_SOLID) || pd->use_in_front = (v3d->shading.type <= OB_SOLID) ||
BKE_scene_uses_blender_workbench(draw_ctx->scene); BKE_scene_uses_blender_workbench(draw_ctx->scene);
pd->wireframe_mode = (v3d->shading.type == OB_WIRE); pd->wireframe_mode = (v3d->shading.type == OB_WIRE);
pd->clipping_state = RV3D_CLIPPING_ENABLED(v3d, rv3d) ? DRW_STATE_CLIP_PLANES : 0; pd->clipping_state = RV3D_CLIPPING_ENABLED(v3d, rv3d) ? DRW_STATE_CLIP_PLANES : DRWState(0);
pd->xray_opacity = XRAY_ALPHA(v3d); pd->xray_opacity = XRAY_ALPHA(v3d);
pd->xray_enabled = XRAY_ACTIVE(v3d); pd->xray_enabled = XRAY_ACTIVE(v3d);
pd->xray_enabled_and_not_wire = pd->xray_enabled && v3d->shading.type > OB_WIRE; pd->xray_enabled_and_not_wire = pd->xray_enabled && v3d->shading.type > OB_WIRE;
pd->clear_in_front = (v3d->shading.type != OB_SOLID); pd->clear_in_front = (v3d->shading.type != OB_SOLID);
pd->cfra = DEG_get_ctime(draw_ctx->depsgraph); pd->cfra = DEG_get_ctime(draw_ctx->depsgraph);
OVERLAY_antialiasing_init(vedata); OVERLAY_antialiasing_init(data);
switch (stl->pd->ctx_mode) { switch (stl->pd->ctx_mode) {
case CTX_MODE_EDIT_MESH: case CTX_MODE_EDIT_MESH:
OVERLAY_edit_mesh_init(vedata); OVERLAY_edit_mesh_init(data);
break; break;
case CTX_MODE_EDIT_CURVES: case CTX_MODE_EDIT_CURVES:
OVERLAY_edit_curves_init(vedata); OVERLAY_edit_curves_init(data);
break; break;
default: default:
/* Nothing to do. */ /* Nothing to do. */
break; break;
} }
OVERLAY_facing_init(vedata); OVERLAY_facing_init(data);
OVERLAY_grid_init(vedata); OVERLAY_grid_init(data);
OVERLAY_image_init(vedata); OVERLAY_image_init(data);
OVERLAY_outline_init(vedata); OVERLAY_outline_init(data);
OVERLAY_wireframe_init(vedata); OVERLAY_wireframe_init(data);
OVERLAY_paint_init(vedata); OVERLAY_paint_init(data);
} }
static void OVERLAY_cache_init(void *vedata) static void OVERLAY_cache_init(void *vedata)
{ {
OVERLAY_Data *data = vedata; OVERLAY_Data *data = static_cast<OVERLAY_Data *>(vedata);
OVERLAY_StorageList *stl = data->stl; OVERLAY_StorageList *stl = data->stl;
OVERLAY_PrivateData *pd = stl->pd; OVERLAY_PrivateData *pd = stl->pd;
if (pd->space_type == SPACE_IMAGE) { if (pd->space_type == SPACE_IMAGE) {
OVERLAY_background_cache_init(vedata); OVERLAY_background_cache_init(data);
OVERLAY_grid_cache_init(vedata); OVERLAY_grid_cache_init(data);
OVERLAY_edit_uv_cache_init(vedata); OVERLAY_edit_uv_cache_init(data);
return; return;
} }
if (pd->space_type == SPACE_NODE) { if (pd->space_type == SPACE_NODE) {
OVERLAY_background_cache_init(vedata); OVERLAY_background_cache_init(data);
return; return;
} }
switch (pd->ctx_mode) { switch (pd->ctx_mode) {
case CTX_MODE_EDIT_MESH: case CTX_MODE_EDIT_MESH: {
OVERLAY_edit_mesh_cache_init(vedata); OVERLAY_edit_mesh_cache_init(data);
/* `pd->edit_mesh.flag` is valid after calling `OVERLAY_edit_mesh_cache_init`. */ /* `pd->edit_mesh.flag` is valid after calling `OVERLAY_edit_mesh_cache_init`. */
const bool draw_edit_weights = (pd->edit_mesh.flag & V3D_OVERLAY_EDIT_WEIGHT); const bool draw_edit_weights = (pd->edit_mesh.flag & V3D_OVERLAY_EDIT_WEIGHT);
if (draw_edit_weights) { if (draw_edit_weights) {
OVERLAY_paint_cache_init(vedata); OVERLAY_paint_cache_init(data);
} }
break; break;
}
case CTX_MODE_EDIT_SURFACE: case CTX_MODE_EDIT_SURFACE:
case CTX_MODE_EDIT_CURVE: case CTX_MODE_EDIT_CURVE:
OVERLAY_edit_curve_cache_init(vedata); OVERLAY_edit_curve_cache_init(data);
break; break;
case CTX_MODE_EDIT_TEXT: case CTX_MODE_EDIT_TEXT:
OVERLAY_edit_text_cache_init(vedata); OVERLAY_edit_text_cache_init(data);
break; break;
case CTX_MODE_EDIT_ARMATURE: case CTX_MODE_EDIT_ARMATURE:
break; break;
case CTX_MODE_EDIT_METABALL: case CTX_MODE_EDIT_METABALL:
break; break;
case CTX_MODE_EDIT_LATTICE: case CTX_MODE_EDIT_LATTICE:
OVERLAY_edit_lattice_cache_init(vedata); OVERLAY_edit_lattice_cache_init(data);
break; break;
case CTX_MODE_PARTICLE: case CTX_MODE_PARTICLE:
OVERLAY_edit_particle_cache_init(vedata); OVERLAY_edit_particle_cache_init(data);
break; break;
case CTX_MODE_POSE: case CTX_MODE_POSE:
case CTX_MODE_PAINT_WEIGHT: case CTX_MODE_PAINT_WEIGHT:
case CTX_MODE_PAINT_VERTEX: case CTX_MODE_PAINT_VERTEX:
case CTX_MODE_PAINT_TEXTURE: case CTX_MODE_PAINT_TEXTURE:
OVERLAY_paint_cache_init(vedata); OVERLAY_paint_cache_init(data);
break; break;
case CTX_MODE_SCULPT: case CTX_MODE_SCULPT:
OVERLAY_sculpt_cache_init(vedata); OVERLAY_sculpt_cache_init(data);
break; break;
case CTX_MODE_EDIT_GPENCIL: case CTX_MODE_EDIT_GPENCIL:
case CTX_MODE_PAINT_GPENCIL: case CTX_MODE_PAINT_GPENCIL:
case CTX_MODE_SCULPT_GPENCIL: case CTX_MODE_SCULPT_GPENCIL:
case CTX_MODE_VERTEX_GPENCIL: case CTX_MODE_VERTEX_GPENCIL:
case CTX_MODE_WEIGHT_GPENCIL: case CTX_MODE_WEIGHT_GPENCIL:
OVERLAY_edit_gpencil_cache_init(vedata); OVERLAY_edit_gpencil_cache_init(data);
break; break;
case CTX_MODE_EDIT_CURVES: case CTX_MODE_EDIT_CURVES:
OVERLAY_edit_curves_cache_init(vedata); OVERLAY_edit_curves_cache_init(data);
break; break;
case CTX_MODE_SCULPT_CURVES: case CTX_MODE_SCULPT_CURVES:
OVERLAY_sculpt_curves_cache_init(vedata); OVERLAY_sculpt_curves_cache_init(data);
break; break;
case CTX_MODE_OBJECT: case CTX_MODE_OBJECT:
break; break;
default: default:
BLI_assert_msg(0, "Draw mode invalid"); BLI_assert_msg(0, "Draw mode invalid");
break; break;
} }
OVERLAY_antialiasing_cache_init(vedata); OVERLAY_antialiasing_cache_init(data);
OVERLAY_armature_cache_init(vedata); OVERLAY_armature_cache_init(data);
OVERLAY_background_cache_init(vedata); OVERLAY_background_cache_init(data);
OVERLAY_fade_cache_init(vedata); OVERLAY_fade_cache_init(data);
OVERLAY_mode_transfer_cache_init(vedata); OVERLAY_mode_transfer_cache_init(data);
OVERLAY_extra_cache_init(vedata); OVERLAY_extra_cache_init(data);
OVERLAY_facing_cache_init(vedata); OVERLAY_facing_cache_init(data);
OVERLAY_gpencil_cache_init(vedata); OVERLAY_gpencil_cache_init(data);
OVERLAY_grid_cache_init(vedata); OVERLAY_grid_cache_init(data);
OVERLAY_image_cache_init(vedata); OVERLAY_image_cache_init(data);
OVERLAY_metaball_cache_init(vedata); OVERLAY_metaball_cache_init(data);
OVERLAY_motion_path_cache_init(vedata); OVERLAY_motion_path_cache_init(data);
OVERLAY_outline_cache_init(vedata); OVERLAY_outline_cache_init(data);
OVERLAY_particle_cache_init(vedata); OVERLAY_particle_cache_init(data);
OVERLAY_wireframe_cache_init(vedata); OVERLAY_wireframe_cache_init(data);
OVERLAY_volume_cache_init(vedata); OVERLAY_volume_cache_init(data);
} }
BLI_INLINE OVERLAY_DupliData *OVERLAY_duplidata_get(Object *ob, void *vedata, bool *do_init) BLI_INLINE OVERLAY_DupliData *OVERLAY_duplidata_get(Object *ob, void *vedata, bool *do_init)
{ {
OVERLAY_DupliData **dupli_data = (OVERLAY_DupliData **)DRW_duplidata_get(vedata); OVERLAY_DupliData **dupli_data = (OVERLAY_DupliData **)DRW_duplidata_get(vedata);
*do_init = false; *do_init = false;
if (!ELEM(ob->type, OB_MESH, OB_SURF, OB_LATTICE, OB_CURVES_LEGACY, OB_FONT)) { if (!ELEM(ob->type, OB_MESH, OB_SURF, OB_LATTICE, OB_CURVES_LEGACY, OB_FONT)) {
return NULL; return nullptr;
} }
if (dupli_data) { if (dupli_data) {
if (*dupli_data == NULL) { if (*dupli_data == nullptr) {
*dupli_data = MEM_callocN(sizeof(OVERLAY_DupliData), __func__); *dupli_data = static_cast<OVERLAY_DupliData *>(
MEM_callocN(sizeof(OVERLAY_DupliData), __func__));
*do_init = true; *do_init = true;
} }
else if ((*dupli_data)->base_flag != ob->base_flag) { else if ((*dupli_data)->base_flag != ob->base_flag) {
/* Select state might have change, reinitialize. */ /* Select state might have change, reinitialize. */
*do_init = true; *do_init = true;
} }
return *dupli_data; return *dupli_data;
} }
return NULL; return nullptr;
} }
static bool overlay_object_is_edit_mode(const OVERLAY_PrivateData *pd, const Object *ob) static bool overlay_object_is_edit_mode(const OVERLAY_PrivateData *pd, const Object *ob)
{ {
if (DRW_object_is_in_edit_mode(ob)) { if (DRW_object_is_in_edit_mode(ob)) {
/* Also check for context mode as the object mode is not 100% reliable. (see T72490) */ /* Also check for context mode as the object mode is not 100% reliable. (see T72490) */
switch (ob->type) { switch (ob->type) {
case OB_MESH: case OB_MESH:
Show All 35 Lines if ((active_object->mode & ob->mode) != 0) {
return false; return false;
} }
return true; return true;
} }
static void OVERLAY_cache_populate(void *vedata, Object *ob) static void OVERLAY_cache_populate(void *vedata, Object *ob)
{ {
OVERLAY_Data *data = vedata; OVERLAY_Data *data = static_cast<OVERLAY_Data *>(vedata);
OVERLAY_PrivateData *pd = data->stl->pd; OVERLAY_PrivateData *pd = data->stl->pd;
if (pd->space_type == SPACE_IMAGE) { if (pd->space_type == SPACE_IMAGE) {
return; return;
} }
const DRWContextState *draw_ctx = DRW_context_state_get(); const DRWContextState *draw_ctx = DRW_context_state_get();
const bool is_select = DRW_state_is_select(); const bool is_select = DRW_state_is_select();
const bool renderable = DRW_object_is_renderable(ob); const bool renderable = DRW_object_is_renderable(ob);
const bool in_pose_mode = ob->type == OB_ARMATURE && OVERLAY_armature_is_pose_mode(ob, draw_ctx); const bool in_pose_mode = ob->type == OB_ARMATURE && OVERLAY_armature_is_pose_mode(ob, draw_ctx);
const bool in_edit_mode = overlay_object_is_edit_mode(pd, ob); const bool in_edit_mode = overlay_object_is_edit_mode(pd, ob);
const bool is_instance = (ob->base_flag & BASE_FROM_DUPLI); const bool is_instance = (ob->base_flag & BASE_FROM_DUPLI);
const bool instance_parent_in_edit_mode = is_instance ? const bool instance_parent_in_edit_mode = is_instance ?
overlay_object_is_edit_mode( overlay_object_is_edit_mode(
pd, DRW_object_get_dupli_parent(ob)) : pd, DRW_object_get_dupli_parent(ob)) :
false; false;
const bool in_particle_edit_mode = (ob->mode == OB_MODE_PARTICLE_EDIT) && const bool in_particle_edit_mode = (ob->mode == OB_MODE_PARTICLE_EDIT) &&
(pd->ctx_mode == CTX_MODE_PARTICLE); (pd->ctx_mode == CTX_MODE_PARTICLE);
const bool in_paint_mode = (ob == draw_ctx->obact) && const bool in_paint_mode = (ob == draw_ctx->obact) &&
(draw_ctx->object_mode & OB_MODE_ALL_PAINT); (draw_ctx->object_mode & OB_MODE_ALL_PAINT);
const bool in_sculpt_curve_mode = (ob == draw_ctx->obact) && const bool in_sculpt_curve_mode = (ob == draw_ctx->obact) &&
(draw_ctx->object_mode & OB_MODE_SCULPT_CURVES); (draw_ctx->object_mode & OB_MODE_SCULPT_CURVES);
const bool in_sculpt_mode = (ob == draw_ctx->obact) && (ob->sculpt != NULL) && const bool in_sculpt_mode = (ob == draw_ctx->obact) && (ob->sculpt != nullptr) &&
(ob->sculpt->mode_type == OB_MODE_SCULPT); (ob->sculpt->mode_type == OB_MODE_SCULPT);
const bool in_curves_sculpt_mode = (ob == draw_ctx->obact) && const bool in_curves_sculpt_mode = (ob == draw_ctx->obact) &&
(ob->mode == OB_MODE_SCULPT_CURVES); (ob->mode == OB_MODE_SCULPT_CURVES);
const bool has_surface = ELEM(ob->type, const bool has_surface = ELEM(ob->type,
OB_MESH, OB_MESH,
OB_CURVES_LEGACY, OB_CURVES_LEGACY,
OB_SURF, OB_SURF,
OB_FONT, OB_FONT,
Show All 24 Lines const bool draw_extras =
((draw_ctx->rv3d->persp == RV3D_CAMOB) && ((ID *)draw_ctx->v3d->camera == ob->id.orig_id))); ((draw_ctx->rv3d->persp == RV3D_CAMOB) && ((ID *)draw_ctx->v3d->camera == ob->id.orig_id)));
const bool draw_motion_paths = (pd->overlay.flag & V3D_OVERLAY_HIDE_MOTION_PATHS) == 0; const bool draw_motion_paths = (pd->overlay.flag & V3D_OVERLAY_HIDE_MOTION_PATHS) == 0;
bool do_init; bool do_init;
OVERLAY_DupliData *dupli = OVERLAY_duplidata_get(ob, vedata, &do_init); OVERLAY_DupliData *dupli = OVERLAY_duplidata_get(ob, vedata, &do_init);
if (draw_fade) { if (draw_fade) {
OVERLAY_fade_cache_populate(vedata, ob); OVERLAY_fade_cache_populate(data, ob);
} }
if (draw_facing) { if (draw_facing) {
OVERLAY_facing_cache_populate(vedata, ob); OVERLAY_facing_cache_populate(data, ob);
} }
if (draw_mode_transfer) { if (draw_mode_transfer) {
OVERLAY_mode_transfer_cache_populate(vedata, ob); OVERLAY_mode_transfer_cache_populate(data, ob);
} }
if (draw_wires) { if (draw_wires) {
OVERLAY_wireframe_cache_populate(vedata, ob, dupli, do_init); OVERLAY_wireframe_cache_populate(data, ob, dupli, do_init);
} }
if (draw_outlines) { if (draw_outlines) {
OVERLAY_outline_cache_populate(vedata, ob, dupli, do_init); OVERLAY_outline_cache_populate(data, ob, dupli, do_init);
} }
if (draw_bone_selection) { if (draw_bone_selection) {
OVERLAY_pose_cache_populate(vedata, ob); OVERLAY_pose_cache_populate(data, ob);
} }
if (ob->type == OB_VOLUME) { if (ob->type == OB_VOLUME) {
OVERLAY_volume_cache_populate(vedata, ob); OVERLAY_volume_cache_populate(data, ob);
} }
if (in_edit_mode && !pd->hide_overlays) { if (in_edit_mode && !pd->hide_overlays) {
switch (ob->type) { switch (ob->type) {
case OB_MESH: case OB_MESH:
OVERLAY_edit_mesh_cache_populate(vedata, ob); OVERLAY_edit_mesh_cache_populate(data, ob);
if (draw_edit_weights) { if (draw_edit_weights) {
OVERLAY_paint_weight_cache_populate(vedata, ob); OVERLAY_paint_weight_cache_populate(data, ob);
} }
break; break;
case OB_ARMATURE: case OB_ARMATURE:
if (draw_bones) { if (draw_bones) {
OVERLAY_edit_armature_cache_populate(vedata, ob); OVERLAY_edit_armature_cache_populate(data, ob);
} }
break; break;
case OB_CURVES_LEGACY: case OB_CURVES_LEGACY:
OVERLAY_edit_curve_cache_populate(vedata, ob); OVERLAY_edit_curve_cache_populate(data, ob);
break; break;
case OB_SURF: case OB_SURF:
OVERLAY_edit_surf_cache_populate(vedata, ob); OVERLAY_edit_surf_cache_populate(data, ob);
break; break;
case OB_LATTICE: case OB_LATTICE:
OVERLAY_edit_lattice_cache_populate(vedata, ob); OVERLAY_edit_lattice_cache_populate(data, ob);
break; break;
case OB_MBALL: case OB_MBALL:
OVERLAY_edit_metaball_cache_populate(vedata, ob); OVERLAY_edit_metaball_cache_populate(data, ob);
break; break;
case OB_FONT: case OB_FONT:
OVERLAY_edit_text_cache_populate(vedata, ob); OVERLAY_edit_text_cache_populate(data, ob);
break; break;
case OB_CURVES: case OB_CURVES:
OVERLAY_edit_curves_cache_populate(vedata, ob); OVERLAY_edit_curves_cache_populate(data, ob);
break; break;
} }
} }
else if (in_pose_mode && draw_bones) { else if (in_pose_mode && draw_bones) {
OVERLAY_pose_armature_cache_populate(vedata, ob); OVERLAY_pose_armature_cache_populate(data, ob);
} }
else if (in_paint_mode && !pd->hide_overlays) { else if (in_paint_mode && !pd->hide_overlays) {
switch (draw_ctx->object_mode) { switch (draw_ctx->object_mode) {
case OB_MODE_VERTEX_PAINT: case OB_MODE_VERTEX_PAINT:
OVERLAY_paint_vertex_cache_populate(vedata, ob); OVERLAY_paint_vertex_cache_populate(data, ob);
break; break;
case OB_MODE_WEIGHT_PAINT: case OB_MODE_WEIGHT_PAINT:
OVERLAY_paint_weight_cache_populate(vedata, ob); OVERLAY_paint_weight_cache_populate(data, ob);
break; break;
case OB_MODE_TEXTURE_PAINT: case OB_MODE_TEXTURE_PAINT:
OVERLAY_paint_texture_cache_populate(vedata, ob); OVERLAY_paint_texture_cache_populate(data, ob);
break; break;
default: default:
break; break;
} }
} }
else if (in_particle_edit_mode) { else if (in_particle_edit_mode) {
OVERLAY_edit_particle_cache_populate(vedata, ob); OVERLAY_edit_particle_cache_populate(data, ob);
} }
if (in_sculpt_mode) { if (in_sculpt_mode) {
OVERLAY_sculpt_cache_populate(vedata, ob); OVERLAY_sculpt_cache_populate(data, ob);
} }
else if (in_curves_sculpt_mode) { else if (in_curves_sculpt_mode) {
OVERLAY_sculpt_curves_cache_populate(vedata, ob); OVERLAY_sculpt_curves_cache_populate(data, ob);
} }
if (draw_motion_paths) { if (draw_motion_paths) {
OVERLAY_motion_path_cache_populate(vedata, ob); OVERLAY_motion_path_cache_populate(data, ob);
} }
if (!pd->hide_overlays) { if (!pd->hide_overlays) {
switch (ob->type) { switch (ob->type) {
case OB_ARMATURE: case OB_ARMATURE:
if (draw_bones && (is_select || (!in_edit_mode && !in_pose_mode))) { if (draw_bones && (is_select || (!in_edit_mode && !in_pose_mode))) {
OVERLAY_armature_cache_populate(vedata, ob); OVERLAY_armature_cache_populate(data, ob);
} }
break; break;
case OB_MBALL: case OB_MBALL:
if (!in_edit_mode) { if (!in_edit_mode) {
OVERLAY_metaball_cache_populate(vedata, ob); OVERLAY_metaball_cache_populate(data, ob);
} }
break; break;
case OB_GPENCIL: case OB_GPENCIL:
OVERLAY_gpencil_cache_populate(vedata, ob); OVERLAY_gpencil_cache_populate(data, ob);
break; break;
} }
} }
/* Non-Meshes */ /* Non-Meshes */
if (draw_extras) { if (draw_extras) {
switch (ob->type) { switch (ob->type) {
case OB_EMPTY: case OB_EMPTY:
OVERLAY_empty_cache_populate(vedata, ob); OVERLAY_empty_cache_populate(data, ob);
break; break;
case OB_LAMP: case OB_LAMP:
OVERLAY_light_cache_populate(vedata, ob); OVERLAY_light_cache_populate(data, ob);
break; break;
case OB_CAMERA: case OB_CAMERA:
OVERLAY_camera_cache_populate(vedata, ob); OVERLAY_camera_cache_populate(data, ob);
break; break;
case OB_SPEAKER: case OB_SPEAKER:
OVERLAY_speaker_cache_populate(vedata, ob); OVERLAY_speaker_cache_populate(data, ob);
break; break;
case OB_LIGHTPROBE: case OB_LIGHTPROBE:
OVERLAY_lightprobe_cache_populate(vedata, ob); OVERLAY_lightprobe_cache_populate(data, ob);
break; break;
case OB_LATTICE: { case OB_LATTICE: {
/* Unlike the other types above, lattices actually have a bounding box defined, so hide the /* Unlike the other types above, lattices actually have a bounding box defined, so hide the
* lattice wires if only the bounding-box is requested. */ * lattice wires if only the bounding-box is requested. */
if (ob->dt > OB_BOUNDBOX) { if (ob->dt > OB_BOUNDBOX) {
OVERLAY_lattice_cache_populate(vedata, ob); OVERLAY_lattice_cache_populate(data, ob);
} }
break; break;
} }
} }
} }
if (!BLI_listbase_is_empty(&ob->particlesystem)) { if (!BLI_listbase_is_empty(&ob->particlesystem)) {
OVERLAY_particle_cache_populate(vedata, ob); OVERLAY_particle_cache_populate(data, ob);
} }
/* Relationship, object center, bounding-box... etc. */ /* Relationship, object center, bounding-box... etc. */
if (!pd->hide_overlays) { if (!pd->hide_overlays) {
OVERLAY_extra_cache_populate(vedata, ob); OVERLAY_extra_cache_populate(data, ob);
} }
if (dupli) { if (dupli) {
dupli->base_flag = ob->base_flag; dupli->base_flag = ob->base_flag;
} }
} }
static void OVERLAY_cache_finish(void *vedata) static void OVERLAY_cache_finish(void *vedata)
{ {
OVERLAY_Data *data = vedata; OVERLAY_Data *data = static_cast<OVERLAY_Data *>(vedata);
OVERLAY_PrivateData *pd = data->stl->pd; OVERLAY_PrivateData *pd = data->stl->pd;
if (ELEM(pd->space_type, SPACE_IMAGE)) { if (ELEM(pd->space_type, SPACE_IMAGE)) {
OVERLAY_edit_uv_cache_finish(vedata); OVERLAY_edit_uv_cache_finish(data);
return; return;
} }
if (ELEM(pd->space_type, SPACE_NODE)) { if (ELEM(pd->space_type, SPACE_NODE)) {
return; return;
} }
/* TODO(fclem): Only do this when really needed. */ /* TODO(fclem): Only do this when really needed. */
{ {
/* HACK we allocate the in front depth here to avoid the overhead when if is not needed. */ /* HACK we allocate the in front depth here to avoid the overhead when if is not needed. */
DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); DefaultTextureList *dtxl = DRW_viewport_texture_list_get();
DRW_texture_ensure_fullscreen_2d(&dtxl->depth_in_front, GPU_DEPTH24_STENCIL8, 0); DRW_texture_ensure_fullscreen_2d(
&dtxl->depth_in_front, GPU_DEPTH24_STENCIL8, DRWTextureFlag(0));
GPU_framebuffer_ensure_config( GPU_framebuffer_ensure_config(
&dfbl->in_front_fb, &dfbl->in_front_fb,
{GPU_ATTACHMENT_TEXTURE(dtxl->depth_in_front), GPU_ATTACHMENT_TEXTURE(dtxl->color)}); {GPU_ATTACHMENT_TEXTURE(dtxl->depth_in_front), GPU_ATTACHMENT_TEXTURE(dtxl->color)});
} }
OVERLAY_mode_transfer_cache_finish(vedata); OVERLAY_mode_transfer_cache_finish(data);
OVERLAY_antialiasing_cache_finish(vedata); OVERLAY_antialiasing_cache_finish(data);
OVERLAY_armature_cache_finish(vedata); OVERLAY_armature_cache_finish(data);
OVERLAY_image_cache_finish(vedata); OVERLAY_image_cache_finish(data);
} }
static void OVERLAY_draw_scene(void *vedata) static void OVERLAY_draw_scene(void *vedata)
{ {
OVERLAY_Data *data = vedata; OVERLAY_Data *data = static_cast<OVERLAY_Data *>(vedata);
OVERLAY_PrivateData *pd = data->stl->pd; OVERLAY_PrivateData *pd = data->stl->pd;
OVERLAY_FramebufferList *fbl = data->fbl; OVERLAY_FramebufferList *fbl = data->fbl;
DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get();
/* Needs to be done first as it modifies the scene color and depth buffer. */ /* Needs to be done first as it modifies the scene color and depth buffer. */
if (pd->space_type == SPACE_VIEW3D) { if (pd->space_type == SPACE_VIEW3D) {
OVERLAY_image_scene_background_draw(vedata); OVERLAY_image_scene_background_draw(data);
} }
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(dfbl->overlay_only_fb); GPU_framebuffer_bind(dfbl->overlay_only_fb);
/* Don't clear background for the node editor. The node editor draws the background and we /* Don't clear background for the node editor. The node editor draws the background and we
* need to mask out the image from the already drawn overlay color buffer. */ * need to mask out the image from the already drawn overlay color buffer. */
if (pd->space_type != SPACE_NODE) { if (pd->space_type != SPACE_NODE) {
const float clear_col[4] = {0.0f, 0.0f, 0.0f, 0.0f}; const float clear_col[4] = {0.0f, 0.0f, 0.0f, 0.0f};
Show All 10 Lines if (pd->space_type == SPACE_IMAGE) {
OVERLAY_edit_uv_draw(data); OVERLAY_edit_uv_draw(data);
return; return;
} }
if (pd->space_type == SPACE_NODE) { if (pd->space_type == SPACE_NODE) {
OVERLAY_background_draw(data); OVERLAY_background_draw(data);
return; return;
} }
OVERLAY_image_background_draw(vedata); OVERLAY_image_background_draw(data);
OVERLAY_background_draw(vedata); OVERLAY_background_draw(data);
OVERLAY_antialiasing_start(vedata); OVERLAY_antialiasing_start(data);
DRW_view_set_active(NULL); DRW_view_set_active(nullptr);
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(fbl->overlay_color_only_fb); GPU_framebuffer_bind(fbl->overlay_color_only_fb);
} }
OVERLAY_outline_draw(vedata); OVERLAY_outline_draw(data);
OVERLAY_xray_depth_copy(vedata); OVERLAY_xray_depth_copy(data);
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(fbl->overlay_default_fb); GPU_framebuffer_bind(fbl->overlay_default_fb);
} }
OVERLAY_image_draw(vedata); OVERLAY_image_draw(data);
OVERLAY_fade_draw(vedata); OVERLAY_fade_draw(data);
OVERLAY_facing_draw(vedata); OVERLAY_facing_draw(data);
OVERLAY_mode_transfer_draw(vedata); OVERLAY_mode_transfer_draw(data);
OVERLAY_extra_blend_draw(vedata); OVERLAY_extra_blend_draw(data);
OVERLAY_volume_draw(vedata); OVERLAY_volume_draw(data);
/* These overlays are drawn here to avoid artifacts with wire-frame opacity. */ /* These overlays are drawn here to avoid artifacts with wire-frame opacity. */
switch (pd->ctx_mode) { switch (pd->ctx_mode) {
case CTX_MODE_SCULPT: case CTX_MODE_SCULPT:
OVERLAY_sculpt_draw(vedata); OVERLAY_sculpt_draw(data);
break; break;
case CTX_MODE_SCULPT_CURVES: case CTX_MODE_SCULPT_CURVES:
OVERLAY_sculpt_curves_draw(vedata); OVERLAY_sculpt_curves_draw(data);
break; break;
case CTX_MODE_EDIT_MESH: case CTX_MODE_EDIT_MESH:
case CTX_MODE_POSE: case CTX_MODE_POSE:
case CTX_MODE_PAINT_WEIGHT: case CTX_MODE_PAINT_WEIGHT:
case CTX_MODE_PAINT_VERTEX: case CTX_MODE_PAINT_VERTEX:
case CTX_MODE_PAINT_TEXTURE: case CTX_MODE_PAINT_TEXTURE:
OVERLAY_paint_draw(vedata); OVERLAY_paint_draw(data);
break; break;
default: default:
break; break;
} }
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(fbl->overlay_line_fb); GPU_framebuffer_bind(fbl->overlay_line_fb);
} }
OVERLAY_wireframe_draw(vedata); OVERLAY_wireframe_draw(data);
OVERLAY_armature_draw(vedata); OVERLAY_armature_draw(data);
OVERLAY_particle_draw(vedata); OVERLAY_particle_draw(data);
OVERLAY_metaball_draw(vedata); OVERLAY_metaball_draw(data);
OVERLAY_gpencil_draw(vedata); OVERLAY_gpencil_draw(data);
OVERLAY_extra_draw(vedata); OVERLAY_extra_draw(data);
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(fbl->overlay_color_only_fb); GPU_framebuffer_bind(fbl->overlay_color_only_fb);
} }
OVERLAY_xray_fade_draw(vedata); OVERLAY_xray_fade_draw(data);
OVERLAY_grid_draw(vedata); OVERLAY_grid_draw(data);
OVERLAY_xray_depth_infront_copy(vedata); OVERLAY_xray_depth_infront_copy(data);
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(fbl->overlay_in_front_fb); GPU_framebuffer_bind(fbl->overlay_in_front_fb);
} }
OVERLAY_fade_infront_draw(vedata); OVERLAY_fade_infront_draw(data);
OVERLAY_facing_infront_draw(vedata); OVERLAY_facing_infront_draw(data);
OVERLAY_mode_transfer_infront_draw(vedata); OVERLAY_mode_transfer_infront_draw(data);
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(fbl->overlay_line_in_front_fb); GPU_framebuffer_bind(fbl->overlay_line_in_front_fb);
} }
OVERLAY_wireframe_in_front_draw(vedata); OVERLAY_wireframe_in_front_draw(data);
OVERLAY_armature_in_front_draw(vedata); OVERLAY_armature_in_front_draw(data);
OVERLAY_extra_in_front_draw(vedata); OVERLAY_extra_in_front_draw(data);
OVERLAY_metaball_in_front_draw(vedata); OVERLAY_metaball_in_front_draw(data);
if (DRW_state_is_fbo()) { if (DRW_state_is_fbo()) {
GPU_framebuffer_bind(fbl->overlay_color_only_fb); GPU_framebuffer_bind(fbl->overlay_color_only_fb);
} }
OVERLAY_image_in_front_draw(vedata); OVERLAY_image_in_front_draw(data);
OVERLAY_motion_path_draw(vedata); OVERLAY_motion_path_draw(data);
OVERLAY_extra_centers_draw(vedata); OVERLAY_extra_centers_draw(data);
if (DRW_state_is_select() || DRW_state_is_depth()) { if (DRW_state_is_select() || DRW_state_is_depth()) {
/* Edit modes have their own selection code. */ /* Edit modes have their own selection code. */
return; return;
} }
/* Functions after this point can change FBO freely. */ /* Functions after this point can change FBO freely. */
switch (pd->ctx_mode) { switch (pd->ctx_mode) {
case CTX_MODE_EDIT_MESH: case CTX_MODE_EDIT_MESH:
OVERLAY_edit_mesh_draw(vedata); OVERLAY_edit_mesh_draw(data);
break; break;
case CTX_MODE_EDIT_SURFACE: case CTX_MODE_EDIT_SURFACE:
case CTX_MODE_EDIT_CURVE: case CTX_MODE_EDIT_CURVE:
OVERLAY_edit_curve_draw(vedata); OVERLAY_edit_curve_draw(data);
break; break;
case CTX_MODE_EDIT_TEXT: case CTX_MODE_EDIT_TEXT:
OVERLAY_edit_text_draw(vedata); OVERLAY_edit_text_draw(data);
break; break;
case CTX_MODE_EDIT_LATTICE: case CTX_MODE_EDIT_LATTICE:
OVERLAY_edit_lattice_draw(vedata); OVERLAY_edit_lattice_draw(data);
break; break;
case CTX_MODE_POSE: case CTX_MODE_POSE:
OVERLAY_pose_draw(vedata); OVERLAY_pose_draw(data);
break; break;
case CTX_MODE_PARTICLE: case CTX_MODE_PARTICLE:
OVERLAY_edit_particle_draw(vedata); OVERLAY_edit_particle_draw(data);
break; break;
case CTX_MODE_EDIT_GPENCIL: case CTX_MODE_EDIT_GPENCIL:
case CTX_MODE_PAINT_GPENCIL: case CTX_MODE_PAINT_GPENCIL:
case CTX_MODE_SCULPT_GPENCIL: case CTX_MODE_SCULPT_GPENCIL:
case CTX_MODE_VERTEX_GPENCIL: case CTX_MODE_VERTEX_GPENCIL:
case CTX_MODE_WEIGHT_GPENCIL: case CTX_MODE_WEIGHT_GPENCIL:
OVERLAY_edit_gpencil_draw(vedata); OVERLAY_edit_gpencil_draw(data);
break; break;
case CTX_MODE_SCULPT_CURVES: case CTX_MODE_SCULPT_CURVES:
break; break;
case CTX_MODE_EDIT_CURVES: case CTX_MODE_EDIT_CURVES:
OVERLAY_edit_curves_draw(vedata); OVERLAY_edit_curves_draw(data);
break; break;
default: default:
break; break;
} }
OVERLAY_antialiasing_end(vedata); OVERLAY_antialiasing_end(data);
} }
static void OVERLAY_engine_free(void) static void OVERLAY_engine_free(void)
{ {
OVERLAY_shader_free(); OVERLAY_shader_free();
} }
static void OVERLAY_instance_free(void *instance_) static void OVERLAY_instance_free(void *instance_)
{ {
OVERLAY_Instance *instance = (OVERLAY_Instance *)instance_; OVERLAY_Instance *instance = (OVERLAY_Instance *)instance_;
DRW_UBO_FREE_SAFE(instance->grid_ubo); DRW_UBO_FREE_SAFE(instance->grid_ubo);
MEM_freeN(instance); MEM_freeN(instance);
} }
/** \} */ /** \} */
/* -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- */
/** \name Engine Type /** \name Engine Type
* \{ */ * \{ */
static const DrawEngineDataSize overlay_data_size = DRW_VIEWPORT_DATA_SIZE(OVERLAY_Data); static const DrawEngineDataSize overlay_data_size = DRW_VIEWPORT_DATA_SIZE(OVERLAY_Data);
DrawEngineType draw_engine_overlay_type = { DrawEngineType draw_engine_overlay_type = {
NULL, nullptr,
NULL, nullptr,
N_("Overlay"), N_("Overlay"),
&overlay_data_size, &overlay_data_size,
&OVERLAY_engine_init, &OVERLAY_engine_init,
&OVERLAY_engine_free, &OVERLAY_engine_free,
&OVERLAY_instance_free, &OVERLAY_instance_free,
&OVERLAY_cache_init, &OVERLAY_cache_init,
&OVERLAY_cache_populate, &OVERLAY_cache_populate,
&OVERLAY_cache_finish, &OVERLAY_cache_finish,
&OVERLAY_draw_scene, &OVERLAY_draw_scene,
NULL, nullptr,
NULL, nullptr,
NULL, nullptr,
NULL, nullptr,
}; };
/** \} */ /** \} */
#undef SELECT_ENGINE #undef SELECT_ENGINE