diff options
Diffstat (limited to 'source/blender/draw/modes/object_mode.c')
-rw-r--r-- | source/blender/draw/modes/object_mode.c | 1377 |
1 files changed, 1377 insertions, 0 deletions
diff --git a/source/blender/draw/modes/object_mode.c b/source/blender/draw/modes/object_mode.c new file mode 100644 index 00000000000..2b42a82cf49 --- /dev/null +++ b/source/blender/draw/modes/object_mode.c @@ -0,0 +1,1377 @@ +/* + * Copyright 2016, Blender Foundation. + * + * 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. + * + * Contributor(s): Blender Institute + * + */ + +/** \file blender/draw/modes/object_mode.c + * \ingroup draw + */ + +#include "DRW_engine.h" +#include "DRW_render.h" + +#include "DNA_userdef_types.h" +#include "DNA_armature_types.h" +#include "DNA_camera_types.h" +#include "DNA_curve_types.h" +#include "DNA_object_force.h" +#include "DNA_view3d_types.h" +#include "DNA_world_types.h" + +#include "BKE_anim.h" +#include "BKE_camera.h" +#include "BKE_curve.h" +#include "BKE_global.h" + +#include "ED_view3d.h" +#include "ED_view3d.h" + +#include "GPU_shader.h" + +#include "UI_resources.h" + +#include "draw_mode_engines.h" +#include "draw_manager_text.h" +#include "draw_common.h" + +extern struct GPUUniformBuffer *globals_ubo; /* draw_common.c */ +extern GlobalsUboStorage ts; + +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_common_globals_lib_glsl[]; + +/* *********** LISTS *********** */ +typedef struct OBJECT_PassList { + struct DRWPass *non_meshes; + struct DRWPass *ob_center; + struct DRWPass *outlines; + struct DRWPass *outlines_search; + struct DRWPass *outlines_expand; + struct DRWPass *outlines_fade1; + struct DRWPass *outlines_fade2; + struct DRWPass *outlines_fade3; + struct DRWPass *outlines_fade4; + struct DRWPass *outlines_fade5; + struct DRWPass *outlines_resolve; + struct DRWPass *grid; + struct DRWPass *bone_solid; + struct DRWPass *bone_wire; +} OBJECT_PassList; + +typedef struct OBJECT_FramebufferList { + struct GPUFrameBuffer *outlines; + struct GPUFrameBuffer *blur; +} OBJECT_FramebufferList; + +typedef struct OBJECT_TextureList { + struct GPUTexture *outlines_depth_tx; + struct GPUTexture *outlines_color_tx; + struct GPUTexture *outlines_blur_tx; +} OBJECT_TextureList; + +typedef struct OBJECT_StorageList { + struct g_data *g_data; +} OBJECT_StorageList; + +typedef struct OBJECT_Data { + void *engine_type; + OBJECT_FramebufferList *fbl; + OBJECT_TextureList *txl; + OBJECT_PassList *psl; + OBJECT_StorageList *stl; +} OBJECT_Data; + +/* *********** STATIC *********** */ + +typedef struct g_data{ + /* Empties */ + DRWShadingGroup *plain_axes; + DRWShadingGroup *cube; + DRWShadingGroup *circle; + DRWShadingGroup *sphere; + DRWShadingGroup *cone; + DRWShadingGroup *single_arrow; + DRWShadingGroup *single_arrow_line; + DRWShadingGroup *arrows; + DRWShadingGroup *axis_names; + + /* 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; + + /* Speaker */ + DRWShadingGroup *speaker; + + /* Lamps */ + DRWShadingGroup *lamp_center; + DRWShadingGroup *lamp_center_group; + DRWShadingGroup *lamp_groundpoint; + DRWShadingGroup *lamp_groundline; + DRWShadingGroup *lamp_circle; + DRWShadingGroup *lamp_circle_shadow; + DRWShadingGroup *lamp_sunrays; + DRWShadingGroup *lamp_distance; + DRWShadingGroup *lamp_buflimit; + DRWShadingGroup *lamp_buflimit_points; + DRWShadingGroup *lamp_area; + DRWShadingGroup *lamp_hemi; + DRWShadingGroup *lamp_spot_cone; + DRWShadingGroup *lamp_spot_blend; + DRWShadingGroup *lamp_spot_pyramid; + DRWShadingGroup *lamp_spot_blend_rect; + + /* Helpers */ + DRWShadingGroup *relationship_lines; + + /* Objects Centers */ + DRWShadingGroup *center_active; + DRWShadingGroup *center_selected; + DRWShadingGroup *center_deselected; + DRWShadingGroup *center_selected_lib; + DRWShadingGroup *center_deselected_lib; + + /* Camera */ + DRWShadingGroup *camera; + DRWShadingGroup *camera_tria; + DRWShadingGroup *camera_focus; + DRWShadingGroup *camera_clip; + DRWShadingGroup *camera_clip_points; + DRWShadingGroup *camera_mist; + DRWShadingGroup *camera_mist_points; + + /* Outlines */ + DRWShadingGroup *outlines_active; + DRWShadingGroup *outlines_active_group; + DRWShadingGroup *outlines_select; + DRWShadingGroup *outlines_select_group; + DRWShadingGroup *outlines_transform; + + /* Wire */ + DRWShadingGroup *wire; + DRWShadingGroup *wire_active; + DRWShadingGroup *wire_active_group; + DRWShadingGroup *wire_select; + DRWShadingGroup *wire_select_group; + DRWShadingGroup *wire_transform; + +} g_data; /* Transient data */ + +static struct { + GPUShader *outline_resolve_sh; + GPUShader *outline_detect_sh; + GPUShader *outline_fade_sh; + GPUShader *grid_sh; + float camera_pos[3]; + float grid_settings[5]; + float grid_mat[4][4]; + int grid_flag; + int zpos_flag; + int zneg_flag; +} 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), +}; + +/* *********** FUNCTIONS *********** */ + +static void OBJECT_engine_init(void *vedata) +{ + OBJECT_TextureList *txl = ((OBJECT_Data *)vedata)->txl; + OBJECT_FramebufferList *fbl = ((OBJECT_Data *)vedata)->fbl; + + const float *viewport_size = DRW_viewport_size_get(); + + DRWFboTexture tex[2] = { + {&txl->outlines_depth_tx, DRW_BUF_DEPTH_24, 0}, + {&txl->outlines_color_tx, DRW_BUF_RGBA_8, DRW_TEX_FILTER}, + }; + + if (DRW_state_is_fbo()) { + DRW_framebuffer_init( + &fbl->outlines, + (int)viewport_size[0], (int)viewport_size[1], + tex, 2); + + DRWFboTexture blur_tex = {&txl->outlines_blur_tx, DRW_BUF_RGBA_8, DRW_TEX_FILTER}; + DRW_framebuffer_init( + &fbl->blur, + (int)viewport_size[0], (int)viewport_size[1], + &blur_tex, 1); + } + + if (!e_data.outline_resolve_sh) { + e_data.outline_resolve_sh = DRW_shader_create_fullscreen(datatoc_object_outline_resolve_frag_glsl, NULL); + } + + if (!e_data.outline_detect_sh) { + e_data.outline_detect_sh = DRW_shader_create_fullscreen(datatoc_object_outline_detect_frag_glsl, NULL); + } + + if (!e_data.outline_fade_sh) { + e_data.outline_fade_sh = DRW_shader_create_fullscreen(datatoc_object_outline_expand_frag_glsl, NULL); + } + + if (!e_data.grid_sh) { + e_data.grid_sh = DRW_shader_create_with_lib( + datatoc_object_grid_vert_glsl, NULL, + datatoc_object_grid_frag_glsl, + datatoc_common_globals_lib_glsl, NULL); + } + + { + /* Grid precompute */ + float viewinvmat[4][4], winmat[4][4], invwinmat[4][4], viewmat[4][4]; + const DRWContextState *draw_ctx = DRW_context_state_get(); + 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, offs; + + 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; + + DRW_viewport_matrix_get(winmat, DRW_MAT_WIN); + DRW_viewport_matrix_get(viewmat, DRW_MAT_VIEW); + DRW_viewport_matrix_get(viewinvmat, DRW_MAT_VIEWINV); + + /* Setup camera pos */ + copy_v3_v3(e_data.camera_pos, viewinvmat[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} + }; + /* invert the proj matrix */ + invert_m4_m4(invwinmat, winmat); + + /* 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]); /* normalize */ + } + + fov = angle_v3v3(viewvecs[0], viewvecs[1]) / 2.0f; + grid_res = fabsf(tanf(fov)) / grid_scale; + + /* Grid matrix polygon offset (fix depth fighting) */ + /* see ED_view3d_polygon_offset */ + offs = winmat[3][2] * -0.0025f; + + 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 { + float viewdist = 1.0f / max_ff(fabsf(winmat[0][0]), fabsf(winmat[1][1])); + grid_res = viewdist / grid_scale; + + /* Grid matrix polygon offset (fix depth fighting) */ + /* see ED_view3d_polygon_offset */ + offs = 0.00001f * viewdist; + if (ELEM(rv3d->view, RV3D_VIEW_RIGHT, RV3D_VIEW_LEFT)) { + e_data.grid_flag = PLANE_YZ; + e_data.grid_flag |= SHOW_AXIS_Y; + e_data.grid_flag |= SHOW_AXIS_Z; + e_data.grid_flag |= SHOW_GRID; + } + else if (ELEM(rv3d->view, RV3D_VIEW_TOP, RV3D_VIEW_BOTTOM)) { + e_data.grid_flag = PLANE_XY; + e_data.grid_flag |= SHOW_AXIS_X; + e_data.grid_flag |= SHOW_AXIS_Y; + e_data.grid_flag |= SHOW_GRID; + } + else if (ELEM(rv3d->view, RV3D_VIEW_FRONT, RV3D_VIEW_BACK)) { + e_data.grid_flag = PLANE_XZ; + e_data.grid_flag |= SHOW_AXIS_X; + e_data.grid_flag |= SHOW_AXIS_Z; + e_data.grid_flag |= SHOW_GRID; + } + 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; + } + } + + /* 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(viewinvmat, 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; + } + } + else { + e_data.zneg_flag = e_data.zpos_flag = CLIP_ZNEG | CLIP_ZPOS; + } + + winmat[3][2] -= offs; + mul_m4_m4m4(e_data.grid_mat, winmat, viewmat); + + e_data.grid_settings[0] = v3d->far / 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 / log(v3d->gridsubdiv) : 0.0; /* 1/log(gridSubdiv) */ + } +} + +static void OBJECT_engine_free(void) +{ + DRW_SHADER_FREE_SAFE(e_data.outline_resolve_sh); + DRW_SHADER_FREE_SAFE(e_data.outline_detect_sh); + DRW_SHADER_FREE_SAFE(e_data.outline_fade_sh); + DRW_SHADER_FREE_SAFE(e_data.grid_sh); +} + +static DRWShadingGroup *shgroup_outline(DRWPass *pass, const float col[4], GPUShader *sh) +{ + DRWShadingGroup *grp = DRW_shgroup_create(sh, pass); + DRW_shgroup_uniform_vec4(grp, "color", col, 1); + + return grp; +} + +/* currently same as 'shgroup_outline', new function to avoid confustion */ +static DRWShadingGroup *shgroup_wire(DRWPass *pass, const float col[4], GPUShader *sh) +{ + DRWShadingGroup *grp = DRW_shgroup_create(sh, pass); + DRW_shgroup_uniform_vec4(grp, "color", col, 1); + + return grp; +} + +static DRWShadingGroup *shgroup_theme_id_to_outline_or( + OBJECT_StorageList *stl, int theme_id, DRWShadingGroup *fallback) +{ + switch (theme_id) { + case TH_ACTIVE: + return stl->g_data->outlines_active; + case TH_SELECT: + return stl->g_data->outlines_select; + case TH_GROUP_ACTIVE: + return stl->g_data->outlines_select_group; + case TH_TRANSFORM: + return stl->g_data->outlines_transform; + default: + return fallback; + } +} + +static DRWShadingGroup *shgroup_theme_id_to_wire_or( + OBJECT_StorageList *stl, int theme_id, DRWShadingGroup *fallback) +{ + switch (theme_id) { + case TH_ACTIVE: + return stl->g_data->wire_active; + case TH_SELECT: + return stl->g_data->wire_select; + case TH_GROUP_ACTIVE: + return stl->g_data->wire_select_group; + case TH_TRANSFORM: + return stl->g_data->wire_transform; + default: + return fallback; + } +} + +static void OBJECT_cache_init(void *vedata) +{ + OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl; + OBJECT_TextureList *txl = ((OBJECT_Data *)vedata)->txl; + OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl; + DefaultTextureList *dtxl = DRW_viewport_texture_list_get(); + + if (!stl->g_data) { + /* Alloc transient pointers */ + stl->g_data = MEM_mallocN(sizeof(g_data), "g_data"); + } + + { + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_WIRE; + psl->outlines = DRW_pass_create("Outlines Pass", state); + + GPUShader *sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + + /* Select */ + stl->g_data->outlines_select = shgroup_outline(psl->outlines, ts.colorSelect, sh); + stl->g_data->outlines_select_group = shgroup_outline(psl->outlines, ts.colorGroupActive, sh); + + /* Transform */ + stl->g_data->outlines_transform = shgroup_outline(psl->outlines, ts.colorTransform, sh); + + /* Active */ + stl->g_data->outlines_active = shgroup_outline(psl->outlines, ts.colorActive, sh); + stl->g_data->outlines_active_group = shgroup_outline(psl->outlines, ts.colorGroupActive, sh); + } + + { + DRWState state = DRW_STATE_WRITE_COLOR; + struct Batch *quad = DRW_cache_fullscreen_quad_get(); + static float alphaOcclu = 0.35f; + static float one = 1.0f; + static float alpha1 = 5.0f / 6.0f; + static float alpha2 = 4.0f / 5.0f; + static float alpha3 = 3.0f / 4.0f; + static float alpha4 = 2.0f / 3.0f; + static float alpha5 = 1.0f / 2.0f; + static bool bTrue = true; + static bool bFalse = false; + + psl->outlines_search = DRW_pass_create("Outlines Expand Pass", state); + + DRWShadingGroup *grp = DRW_shgroup_create(e_data.outline_detect_sh, psl->outlines_search); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_buffer(grp, "sceneDepth", &dtxl->depth, 2); + DRW_shgroup_uniform_float(grp, "alphaOcclu", &alphaOcclu, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_expand = DRW_pass_create("Outlines Expand Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_expand); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &one, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bTrue, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade1 = DRW_pass_create("Outlines Fade 1 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade1); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha1, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade2 = DRW_pass_create("Outlines Fade 2 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade2); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha2, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade3 = DRW_pass_create("Outlines Fade 3 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade3); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha3, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade4 = DRW_pass_create("Outlines Fade 4 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade4); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha4, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + DRW_shgroup_call_add(grp, quad, NULL); + + psl->outlines_fade5 = DRW_pass_create("Outlines Fade 5 Pass", state); + + grp = DRW_shgroup_create(e_data.outline_fade_sh, psl->outlines_fade5); + DRW_shgroup_uniform_buffer(grp, "outlineColor", &txl->outlines_color_tx, 0); + DRW_shgroup_uniform_buffer(grp, "outlineDepth", &txl->outlines_depth_tx, 1); + DRW_shgroup_uniform_float(grp, "alpha", &alpha5, 1); + DRW_shgroup_uniform_bool(grp, "doExpand", &bFalse, 1); + 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 Batch *quad = DRW_cache_fullscreen_quad_get(); + + DRWShadingGroup *grp = DRW_shgroup_create(e_data.outline_resolve_sh, psl->outlines_resolve); + DRW_shgroup_uniform_buffer(grp, "outlineBluredColor", &txl->outlines_blur_tx, 0); + DRW_shgroup_call_add(grp, quad, NULL); + } + + { + /* Grid pass */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND; + psl->grid = DRW_pass_create("Infinite Grid Pass", state); + + struct Batch *quad = DRW_cache_fullscreen_quad_get(); + static float mat[4][4]; + unit_m4(mat); + + /* Create 3 quads to render ordered transparency Z axis */ + DRWShadingGroup *grp = DRW_shgroup_create(e_data.grid_sh, psl->grid); + DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zneg_flag, 1); + DRW_shgroup_uniform_mat4(grp, "ViewProjectionOffsetMatrix", (float *)e_data.grid_mat); + 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(grp, "gridOneOverLogSubdiv", &e_data.grid_settings[4], 1); + DRW_shgroup_uniform_block(grp, "globalsBlock", globals_ubo, 0); + DRW_shgroup_call_add(grp, quad, mat); + + grp = DRW_shgroup_create(e_data.grid_sh, psl->grid); + DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.grid_flag, 1); + DRW_shgroup_call_add(grp, quad, mat); + + grp = DRW_shgroup_create(e_data.grid_sh, psl->grid); + DRW_shgroup_uniform_int(grp, "gridFlag", &e_data.zpos_flag, 1); + DRW_shgroup_call_add(grp, quad, mat); + } + + { + /* Solid bones */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS; + psl->bone_solid = DRW_pass_create("Bone Solid Pass", state); + } + + { + /* Wire bones */ + DRWState state = DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND; + psl->bone_wire = DRW_pass_create("Bone Wire Pass", state); + } + + { + /* Non Meshes Pass (Camera, empties, lamps ...) */ + struct Batch *geom; + + DRWState state = + DRW_STATE_WRITE_COLOR | DRW_STATE_WRITE_DEPTH | + DRW_STATE_DEPTH_LESS | DRW_STATE_BLEND | DRW_STATE_POINT; + state |= DRW_STATE_WIRE; + psl->non_meshes = DRW_pass_create("Non Meshes Pass", state); + + /* Empties */ + geom = DRW_cache_plain_axes_get(); + stl->g_data->plain_axes = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_cube_get(); + stl->g_data->cube = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_circle_get(); + stl->g_data->circle = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_empty_sphere_get(); + stl->g_data->sphere = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_empty_cone_get(); + stl->g_data->cone = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_arrow_get(); + stl->g_data->single_arrow = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_get(); + stl->g_data->single_arrow_line = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_arrows_get(); + stl->g_data->arrows = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_axis_names_get(); + stl->g_data->axis_names = shgroup_instance_axis_names(psl->non_meshes, geom); + + /* Force Field */ + geom = DRW_cache_field_wind_get(); + stl->g_data->field_wind = shgroup_instance_scaled(psl->non_meshes, geom); + + geom = DRW_cache_field_force_get(); + stl->g_data->field_force = shgroup_instance_screen_aligned(psl->non_meshes, geom); + + geom = DRW_cache_field_vortex_get(); + stl->g_data->field_vortex = shgroup_instance_scaled(psl->non_meshes, geom); + + geom = DRW_cache_screenspace_circle_get(); + stl->g_data->field_curve_sta = shgroup_instance_screen_aligned(psl->non_meshes, geom); + + /* Speaker */ + geom = DRW_cache_speaker_get(); + stl->g_data->speaker = shgroup_instance(psl->non_meshes, geom); + + /* Camera */ + geom = DRW_cache_camera_get(); + stl->g_data->camera = shgroup_camera_instance(psl->non_meshes, geom); + + geom = DRW_cache_camera_tria_get(); + stl->g_data->camera_tria = shgroup_camera_instance(psl->non_meshes, geom); + + geom = DRW_cache_plain_axes_get(); + stl->g_data->camera_focus = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_get(); + stl->g_data->camera_clip = shgroup_distance_lines_instance(psl->non_meshes, geom); + stl->g_data->camera_mist = shgroup_distance_lines_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_endpoints_get(); + stl->g_data->camera_clip_points = shgroup_distance_lines_instance(psl->non_meshes, geom); + stl->g_data->camera_mist_points = shgroup_distance_lines_instance(psl->non_meshes, geom); + + } + + { + GPUShader *sh = GPU_shader_get_builtin_shader(GPU_SHADER_3D_UNIFORM_COLOR); + + /* Unselected */ + stl->g_data->wire = shgroup_wire(psl->non_meshes, ts.colorWire, sh); + + /* Select */ + stl->g_data->wire_select = shgroup_wire(psl->non_meshes, ts.colorSelect, sh); + stl->g_data->wire_select_group = shgroup_wire(psl->non_meshes, ts.colorGroupActive, sh); + + /* Transform */ + stl->g_data->wire_transform = shgroup_wire(psl->non_meshes, ts.colorTransform, sh); + + /* Active */ + stl->g_data->wire_active = shgroup_wire(psl->non_meshes, ts.colorActive, sh); + stl->g_data->wire_active_group = shgroup_wire(psl->non_meshes, ts.colorGroupActive, sh); + } + + { + /* Lamps */ + /* TODO + * for now we create multiple times the same VBO with only lamp center coordinates + * but ideally we would only create it once */ + struct Batch *geom; + + /* start with buflimit because we don't want stipples */ + geom = DRW_cache_single_line_get(); + stl->g_data->lamp_buflimit = shgroup_distance_lines_instance(psl->non_meshes, geom); + + stl->g_data->lamp_center = shgroup_dynpoints_uniform_color(psl->non_meshes, ts.colorLampNoAlpha, &ts.sizeLampCenter); + stl->g_data->lamp_center_group = shgroup_dynpoints_uniform_color(psl->non_meshes, ts.colorGroup, &ts.sizeLampCenter); + + geom = DRW_cache_lamp_get(); + stl->g_data->lamp_circle = shgroup_instance_screenspace(psl->non_meshes, geom, &ts.sizeLampCircle); + stl->g_data->lamp_circle_shadow = shgroup_instance_screenspace(psl->non_meshes, geom, &ts.sizeLampCircleShadow); + + geom = DRW_cache_lamp_sunrays_get(); + stl->g_data->lamp_sunrays = shgroup_instance_screenspace(psl->non_meshes, geom, &ts.sizeLampCircle); + + stl->g_data->lamp_groundline = shgroup_groundlines_uniform_color(psl->non_meshes, ts.colorLamp); + stl->g_data->lamp_groundpoint = shgroup_groundpoints_uniform_color(psl->non_meshes, ts.colorLamp); + + geom = DRW_cache_lamp_area_get(); + stl->g_data->lamp_area = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_lamp_hemi_get(); + stl->g_data->lamp_hemi = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_get(); + stl->g_data->lamp_distance = shgroup_distance_lines_instance(psl->non_meshes, geom); + + geom = DRW_cache_single_line_endpoints_get(); + stl->g_data->lamp_buflimit_points = shgroup_distance_lines_instance(psl->non_meshes, geom); + + geom = DRW_cache_lamp_spot_get(); + stl->g_data->lamp_spot_cone = shgroup_spot_instance(psl->non_meshes, geom); + + geom = DRW_cache_circle_get(); + stl->g_data->lamp_spot_blend = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_lamp_spot_square_get(); + stl->g_data->lamp_spot_pyramid = shgroup_instance(psl->non_meshes, geom); + + geom = DRW_cache_square_get(); + stl->g_data->lamp_spot_blend_rect = shgroup_instance(psl->non_meshes, geom); + } + + { + /* -------- STIPPLES ------- */ + /* TODO port to shader stipple */ + struct Batch *geom; + + /* Relationship Lines */ + stl->g_data->relationship_lines = shgroup_dynlines_uniform_color(psl->non_meshes, ts.colorWire); + DRW_shgroup_state_set(stl->g_data->relationship_lines, DRW_STATE_STIPPLE_3); + + /* Force Field Curve Guide End (here because of stipple) */ + geom = DRW_cache_screenspace_circle_get(); + stl->g_data->field_curve_end = shgroup_instance_screen_aligned(psl->non_meshes, geom); + + /* Force Field Limits */ + geom = DRW_cache_field_tube_limit_get(); + stl->g_data->field_tube_limit = shgroup_instance_scaled(psl->non_meshes, geom); + + geom = DRW_cache_field_cone_limit_get(); + stl->g_data->field_cone_limit = shgroup_instance_scaled(psl->non_meshes, geom); + } + + { + /* 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(GPU_SHADER_3D_POINT_UNIFORM_SIZE_UNIFORM_COLOR_OUTLINE_AA); + + /* 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", ts.colorActive, 1); + DRW_shgroup_uniform_vec4(grp, "outlineColor", ts.colorOutline, 1); + stl->g_data->center_active = grp; + + /* Select */ + grp = DRW_shgroup_point_batch_create(sh, psl->ob_center); + DRW_shgroup_uniform_vec4(grp, "color", ts.colorSelect, 1); + stl->g_data->center_selected = grp; + + /* Deselect */ + grp = DRW_shgroup_point_batch_create(sh, psl->ob_center); + DRW_shgroup_uniform_vec4(grp, "color", ts.colorDeselect, 1); + stl->g_data->center_deselected = grp; + + /* Select (library) */ + grp = DRW_shgroup_point_batch_create(sh, psl->ob_center); + DRW_shgroup_uniform_vec4(grp, "color", ts.colorLibrarySelect, 1); + 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", ts.colorLibrary, 1); + stl->g_data->center_deselected_lib = grp; + } +} + +static void DRW_shgroup_lamp(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + Lamp *la = ob->data; + float *color; + int theme_id = DRW_object_wire_theme_get(ob, sl, &color); + static float zero = 0.0f; + + float **la_mats = (float **)DRW_object_engine_data_get(ob, &draw_engine_object_type); + if (*la_mats == NULL) { + /* we need 2 matrices */ + *la_mats = MEM_mallocN(sizeof(float) * 16 * 2, "Lamp Object Mode Matrices"); + } + + float (*shapemat)[4], (*spotblendmat)[4]; + shapemat = (float (*)[4])(*la_mats); + spotblendmat = (float (*)[4])(*la_mats + 16); + + /* Don't draw the center if it's selected or active */ + if (theme_id == TH_GROUP) + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_center_group, ob->obmat[3]); + else if (theme_id == TH_LAMP) + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_center, ob->obmat[3]); + + /* First circle */ + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_circle, ob->obmat[3], color); + + /* draw dashed outer circle if shadow is on. remember some lamps can't have certain shadows! */ + if (la->type != LA_HEMI) { + if ((la->mode & LA_SHAD_RAY) || ((la->mode & LA_SHAD_BUF) && (la->type == LA_SPOT))) { + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_circle_shadow, ob->obmat[3], color); + } + } + + /* Distance */ + if (ELEM(la->type, LA_HEMI, LA_SUN, LA_AREA)) { + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_distance, color, &zero, &la->dist, ob->obmat); + } + + copy_m4_m4(shapemat, ob->obmat); + + if (la->type == LA_SUN) { + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_sunrays, ob->obmat[3], color); + } + else if (la->type == LA_SPOT) { + float size[3], sizemat[4][4]; + static float one = 1.0f; + 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', M_PI / 2.0f); + mul_m4_m4m4(spotblendmat, shapemat, sizemat); + + if (la->mode & LA_SQUARE) { + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_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(stl->g_data->lamp_spot_blend_rect, color, &one, spotblendmat); + } + } + else { + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_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(stl->g_data->lamp_spot_blend, color, &one, spotblendmat); + } + } + + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_buflimit, color, &la->clipsta, &la->clipend, ob->obmat); + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_buflimit_points, color, &la->clipsta, &la->clipend, ob->obmat); + } + else if (la->type == LA_HEMI) { + static float hemisize = 2.0f; + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_hemi, color, &hemisize, shapemat); + } + else if (la->type == LA_AREA) { + float size[3] = {1.0f, 1.0f, 1.0f}, sizemat[4][4]; + + if (la->area_shape == LA_AREA_RECT) { + size[1] = la->area_sizey / la->area_size; + size_to_mat4(sizemat, size); + mul_m4_m4m4(shapemat, shapemat, sizemat); + } + + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_area, color, &la->area_size, shapemat); + } + + /* Line and point going to the ground */ + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_groundline, ob->obmat[3]); + DRW_shgroup_call_dynamic_add(stl->g_data->lamp_groundpoint, ob->obmat[3]); +} + +static void DRW_shgroup_camera(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + const DRWContextState *draw_ctx = DRW_context_state_get(); + View3D *v3d = draw_ctx->v3d; + Scene *scene = draw_ctx->scene; + + Camera *cam = ob->data; + const bool is_active = (ob == v3d->camera); + float *color; + DRW_object_wire_theme_get(ob, sl, &color); + + float vec[4][3], asp[2], shift[2], scale[3], drawsize; + + 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->drwcorners[0], vec[0]); + copy_v2_v2(cam->drwcorners[1], vec[1]); + copy_v2_v2(cam->drwcorners[2], vec[2]); + copy_v2_v2(cam->drwcorners[3], vec[3]); + + /* depth */ + cam->drwdepth = vec[0][2]; + + /* tria */ + cam->drwtria[0][0] = shift[0] + ((0.7f * drawsize) * scale[0]); + cam->drwtria[0][1] = shift[1] + ((drawsize * (asp[1] + 0.1f)) * scale[1]); + cam->drwtria[1][0] = shift[0]; + cam->drwtria[1][1] = shift[1] + ((1.1f * drawsize * (asp[1] + 0.7f)) * scale[1]); + + DRW_shgroup_call_dynamic_add(stl->g_data->camera, color, cam->drwcorners, &cam->drwdepth, cam->drwtria, ob->obmat); + + /* Active cam */ + if (is_active) { + DRW_shgroup_call_dynamic_add( + stl->g_data->camera_tria, color, + cam->drwcorners, &cam->drwdepth, cam->drwtria, ob->obmat); + } + + /* draw the rest in normalize object space */ + copy_m4_m4(cam->drwnormalmat, ob->obmat); + normalize_m4(cam->drwnormalmat); + + if (cam->flag & CAM_SHOWLIMITS) { + static float col[3] = {0.5f, 0.5f, 0.25f}, col_hi[3] = {1.0f, 1.0f, 0.5f}; + float sizemat[4][4], size[3] = {1.0f, 1.0f, 0.0f}; + float focusdist = BKE_camera_object_dof_distance(ob); + + copy_m4_m4(cam->drwfocusmat, cam->drwnormalmat); + translate_m4(cam->drwfocusmat, 0.0f, 0.0f, -focusdist); + size_to_mat4(sizemat, size); + mul_m4_m4m4(cam->drwfocusmat, cam->drwfocusmat, sizemat); + + DRW_shgroup_call_dynamic_add( + stl->g_data->camera_focus, (is_active ? col_hi : col), + &cam->drawsize, cam->drwfocusmat); + + DRW_shgroup_call_dynamic_add( + stl->g_data->camera_clip, color, + &cam->clipsta, &cam->clipend, cam->drwnormalmat); + DRW_shgroup_call_dynamic_add( + stl->g_data->camera_clip_points, (is_active ? col_hi : col), + &cam->clipsta, &cam->clipend, cam->drwnormalmat); + } + + if (cam->flag & CAM_SHOWMIST) { + World *world = scene->world; + + if (world) { + static float col[3] = {0.5f, 0.5f, 0.5f}, col_hi[3] = {1.0f, 1.0f, 1.0f}; + world->mistend = world->miststa + world->mistdist; + DRW_shgroup_call_dynamic_add( + stl->g_data->camera_mist, color, + &world->miststa, &world->mistend, cam->drwnormalmat); + DRW_shgroup_call_dynamic_add( + stl->g_data->camera_mist_points, (is_active ? col_hi : col), + &world->miststa, &world->mistend, cam->drwnormalmat); + } + } +} + +static void DRW_shgroup_empty(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + float *color; + DRW_object_wire_theme_get(ob, sl, &color); + + switch (ob->empty_drawtype) { + case OB_PLAINAXES: + DRW_shgroup_call_dynamic_add(stl->g_data->plain_axes, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_SINGLE_ARROW: + DRW_shgroup_call_dynamic_add(stl->g_data->single_arrow, color, &ob->empty_drawsize, ob->obmat); + DRW_shgroup_call_dynamic_add(stl->g_data->single_arrow_line, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_CUBE: + DRW_shgroup_call_dynamic_add(stl->g_data->cube, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_CIRCLE: + DRW_shgroup_call_dynamic_add(stl->g_data->circle, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_EMPTY_SPHERE: + DRW_shgroup_call_dynamic_add(stl->g_data->sphere, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_EMPTY_CONE: + DRW_shgroup_call_dynamic_add(stl->g_data->cone, color, &ob->empty_drawsize, ob->obmat); + break; + case OB_ARROWS: + DRW_shgroup_call_dynamic_add(stl->g_data->arrows, color, &ob->empty_drawsize, ob->obmat); + DRW_shgroup_call_dynamic_add(stl->g_data->axis_names, color, &ob->empty_drawsize, ob->obmat); + break; + } +} + +static void DRW_shgroup_forcefield(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + int theme_id = DRW_object_wire_theme_get(ob, sl, 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->curve_cache->path && ob->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(stl->g_data->field_wind, color, &pd->drawvec1, ob->obmat); + break; + case PFIELD_FORCE: + DRW_shgroup_call_dynamic_add(stl->g_data->field_force, color, &pd->drawvec1, ob->obmat); + break; + case PFIELD_VORTEX: + DRW_shgroup_call_dynamic_add(stl->g_data->field_vortex, color, &pd->drawvec1, ob->obmat); + break; + case PFIELD_GUIDE: + if (cu && (cu->flag & CU_PATH) && ob->curve_cache->path && ob->curve_cache->path->data) { + DRW_shgroup_call_dynamic_add(stl->g_data->field_curve_sta, color, &pd->f_strength, ob->obmat); + DRW_shgroup_call_dynamic_add(stl->g_data->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(stl->g_data->field_curve_end, color, &pd->maxdist, ob->obmat); + } + + if ((pd->flag & PFIELD_USEMIN) != 0) { + DRW_shgroup_call_dynamic_add(stl->g_data->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(stl->g_data->field_tube_limit, color, &pd->drawvec_falloff_max, ob->obmat); + } + + if (pd->flag & (PFIELD_USEMIN | PFIELD_USEMINR)) { + DRW_shgroup_call_dynamic_add(stl->g_data->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(stl->g_data->field_cone_limit, color, &pd->drawvec_falloff_max, ob->obmat); + } + + if (pd->flag & (PFIELD_USEMIN | PFIELD_USEMINR)) { + DRW_shgroup_call_dynamic_add(stl->g_data->field_cone_limit, color, &pd->drawvec_falloff_min, ob->obmat); + } + } +} + +static void DRW_shgroup_speaker(OBJECT_StorageList *stl, Object *ob, SceneLayer *sl) +{ + float *color; + static float one = 1.0f; + DRW_object_wire_theme_get(ob, sl, &color); + + DRW_shgroup_call_dynamic_add(stl->g_data->speaker, color, &one, ob->obmat); +} + +static void DRW_shgroup_relationship_lines(OBJECT_StorageList *stl, Object *ob) +{ + if (ob->parent) { + DRW_shgroup_call_dynamic_add(stl->g_data->relationship_lines, ob->obmat[3]); + DRW_shgroup_call_dynamic_add(stl->g_data->relationship_lines, ob->parent->obmat[3]); + } +} + +static void DRW_shgroup_object_center(OBJECT_StorageList *stl, Object *ob) +{ + const bool is_library = ob->id.us > 1 || ID_IS_LINKED_DATABLOCK(ob); + DRWShadingGroup *shgroup; + + if ((ob->base_flag & BASE_SELECTED) != 0) { + if (is_library) { + shgroup = stl->g_data->center_selected_lib; + } + else { + shgroup = stl->g_data->center_selected; + } + } + else { + if (is_library) { + shgroup = stl->g_data->center_deselected_lib; + } + else { + shgroup = stl->g_data->center_deselected; + } + } + + DRW_shgroup_call_dynamic_add(shgroup, ob->obmat[3]); +} + +static void OBJECT_cache_populate(void *vedata, Object *ob) +{ + OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl; + OBJECT_StorageList *stl = ((OBJECT_Data *)vedata)->stl; + const DRWContextState *draw_ctx = DRW_context_state_get(); + Scene *scene = draw_ctx->scene; + SceneLayer *sl = draw_ctx->sl; + int theme_id = TH_UNDEFINED; + + //CollectionEngineSettings *ces_mode_ob = BKE_object_collection_engine_get(ob, COLLECTION_MODE_OBJECT, ""); + + //bool do_wire = BKE_collection_engine_property_value_get_bool(ces_mode_ob, "show_wire"); + bool do_outlines = ((ob->base_flag & BASE_SELECTED) != 0); + + if (do_outlines) { + Object *obedit = scene->obedit; + if (ob != obedit) { + struct Batch *geom = DRW_cache_object_surface_get(ob); + if (geom) { + theme_id = DRW_object_wire_theme_get(ob, sl, NULL); + DRWShadingGroup *shgroup = shgroup_theme_id_to_outline_or(stl, theme_id, NULL); + if (shgroup != NULL) { + DRW_shgroup_call_add(shgroup, geom, ob->obmat); + } + } + } + } + + switch (ob->type) { + case OB_MESH: + case OB_SURF: + break; + case OB_LATTICE: + { + Object *obedit = scene->obedit; + if (ob != obedit) { + struct Batch *geom = DRW_cache_lattice_wire_get(ob); + if (theme_id == TH_UNDEFINED) { + theme_id = DRW_object_wire_theme_get(ob, sl, NULL); + } + + DRWShadingGroup *shgroup = shgroup_theme_id_to_wire_or(stl, theme_id, stl->g_data->wire); + DRW_shgroup_call_add(shgroup, geom, ob->obmat); + } + break; + } + + case OB_CURVE: + { + Object *obedit = scene->obedit; + if (ob != obedit) { + struct Batch *geom = DRW_cache_curve_edge_wire_get(ob); + if (theme_id == TH_UNDEFINED) { + theme_id = DRW_object_wire_theme_get(ob, sl, NULL); + } + DRWShadingGroup *shgroup = shgroup_theme_id_to_wire_or(stl, theme_id, stl->g_data->wire); + DRW_shgroup_call_add(shgroup, geom, ob->obmat); + } + break; + } + case OB_LAMP: + DRW_shgroup_lamp(stl, ob, sl); + break; + case OB_CAMERA: + DRW_shgroup_camera(stl, ob, sl); + break; + case OB_EMPTY: + DRW_shgroup_empty(stl, ob, sl); + break; + case OB_SPEAKER: + DRW_shgroup_speaker(stl, ob, sl); + break; + case OB_ARMATURE: + { + bArmature *arm = ob->data; + if (arm->edbo == NULL) { + if ((ob->mode & OB_MODE_POSE) && (ob == OBACT_NEW)) { + DRW_shgroup_armature_pose( + ob, psl->bone_solid, psl->bone_wire, + stl->g_data->relationship_lines); + } + else { + DRW_shgroup_armature_object( + ob, sl, psl->bone_solid, psl->bone_wire, + stl->g_data->relationship_lines); + } + } + break; + } + default: + break; + } + + if (ob->pd && ob->pd->forcefield) { + DRW_shgroup_forcefield(stl, ob, sl); + } + + /* don't show object extras in set's */ + if ((ob->base_flag & BASE_FROM_SET) == 0) { + DRW_shgroup_object_center(stl, ob); + DRW_shgroup_relationship_lines(stl, ob); + + if ((ob->dtx & OB_DRAWNAME) && DRW_state_show_text()) { + struct DRWTextStore *dt = DRW_text_cache_ensure(); + if (theme_id == TH_UNDEFINED) { + theme_id = DRW_object_wire_theme_get(ob, sl, NULL); + } + + unsigned char 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, DRW_TEXT_CACHE_GLOBALSPACE | DRW_TEXT_CACHE_STRING_PTR, color); + } + } +} + +static void OBJECT_draw_scene(void *vedata) +{ + + OBJECT_PassList *psl = ((OBJECT_Data *)vedata)->psl; + OBJECT_FramebufferList *fbl = ((OBJECT_Data *)vedata)->fbl; + OBJECT_TextureList *txl = ((OBJECT_Data *)vedata)->txl; + DefaultFramebufferList *dfbl = DRW_viewport_framebuffer_list_get(); + float clearcol[4] = {0.0f, 0.0f, 0.0f, 0.0f}; + + if (DRW_state_is_fbo()) { + /* Render filled polygon on a separate framebuffer */ + DRW_framebuffer_bind(fbl->outlines); + DRW_framebuffer_clear(true, true, false, clearcol, 1.0f); + DRW_draw_pass(psl->outlines); + + /* detach textures */ + DRW_framebuffer_texture_detach(txl->outlines_depth_tx); + + /* Search outline pixels */ + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_search); + + /* Expand and fade gradually */ + DRW_framebuffer_bind(fbl->outlines); + DRW_draw_pass(psl->outlines_expand); + + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_fade1); + + DRW_framebuffer_bind(fbl->outlines); + DRW_draw_pass(psl->outlines_fade2); + + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_fade3); + + DRW_framebuffer_bind(fbl->outlines); + DRW_draw_pass(psl->outlines_fade4); + + DRW_framebuffer_bind(fbl->blur); + DRW_draw_pass(psl->outlines_fade5); + + /* reattach */ + DRW_framebuffer_texture_attach(fbl->outlines, txl->outlines_depth_tx, 0, 0); + DRW_framebuffer_bind(dfbl->default_fb); + } + + /* This needs to be drawn after the oultine */ + DRW_draw_pass(psl->bone_wire); + DRW_draw_pass(psl->bone_solid); + DRW_draw_pass(psl->non_meshes); + DRW_draw_pass(psl->ob_center); + + if (!DRW_state_is_select()) { + DRW_draw_pass(psl->grid); + + /* Combine with scene buffer last */ + DRW_draw_pass(psl->outlines_resolve); + } +} + +void OBJECT_collection_settings_create(IDProperty *props) +{ + BLI_assert(props && + props->type == IDP_GROUP && + props->subtype == IDP_GROUP_SUB_MODE_OBJECT); + BKE_collection_engine_property_add_int(props, "show_wire", false); + BKE_collection_engine_property_add_int(props, "show_backface_culling", false); +} + +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, + NULL, + NULL, + &OBJECT_draw_scene +}; |