diff options
Diffstat (limited to 'source/blender/draw/intern')
| -rw-r--r-- | source/blender/draw/intern/draw_cache_impl.h | 35 | ||||
| -rw-r--r-- | source/blender/draw/intern/draw_cache_impl_curve.c | 8 | ||||
| -rw-r--r-- | source/blender/draw/intern/draw_cache_impl_lattice.c | 4 | ||||
| -rw-r--r-- | source/blender/draw/intern/draw_cache_impl_mesh.c | 1501 |
4 files changed, 611 insertions, 937 deletions
diff --git a/source/blender/draw/intern/draw_cache_impl.h b/source/blender/draw/intern/draw_cache_impl.h index d6d244c81d0..ee91245fb1a 100644 --- a/source/blender/draw/intern/draw_cache_impl.h +++ b/source/blender/draw/intern/draw_cache_impl.h @@ -114,12 +114,9 @@ struct GPUBatch *DRW_mesh_batch_cache_get_surface_vertpaint(struct Mesh *me); struct GPUBatch *DRW_mesh_batch_cache_get_surface_weights(struct Mesh *me); /* edit-mesh drawing */ struct GPUBatch *DRW_mesh_batch_cache_get_edit_triangles(struct Mesh *me); -struct GPUBatch *DRW_mesh_batch_cache_get_edit_triangles_nor(struct Mesh *me); -struct GPUBatch *DRW_mesh_batch_cache_get_edit_triangles_lnor(struct Mesh *me); struct GPUBatch *DRW_mesh_batch_cache_get_edit_vertices(struct Mesh *me); -struct GPUBatch *DRW_mesh_batch_cache_get_edit_loose_edges(struct Mesh *me); -struct GPUBatch *DRW_mesh_batch_cache_get_edit_loose_edges_nor(struct Mesh *me); -struct GPUBatch *DRW_mesh_batch_cache_get_edit_loose_verts(struct Mesh *me); +struct GPUBatch *DRW_mesh_batch_cache_get_edit_edges(struct Mesh *me); +struct GPUBatch *DRW_mesh_batch_cache_get_edit_lnors(struct Mesh *me); struct GPUBatch *DRW_mesh_batch_cache_get_edit_facedots(struct Mesh *me); /* edit-mesh selection */ struct GPUBatch *DRW_mesh_batch_cache_get_triangles_with_select_id(struct Mesh *me); @@ -142,25 +139,27 @@ struct GPUBatch *DRW_mesh_batch_cache_get_uv_edges(struct Mesh *me); void DRW_mesh_cache_sculpt_coords_ensure(struct Mesh *me); /* Edit mesh bitflags (is this the right place?) */ - enum { - VFLAG_VERTEX_ACTIVE = 1 << 0, - VFLAG_VERTEX_SELECTED = 1 << 1, - VFLAG_VERTEX_EXISTS = 1 << 2, - VFLAG_FACE_ACTIVE = 1 << 3, - VFLAG_FACE_SELECTED = 1 << 4, - VFLAG_FACE_FREESTYLE = 1 << 5, + VFLAG_VERT_ACTIVE = 1 << 0, + VFLAG_VERT_SELECTED = 1 << 1, + VFLAG_EDGE_ACTIVE = 1 << 2, + VFLAG_EDGE_SELECTED = 1 << 3, + VFLAG_EDGE_SEAM = 1 << 4, + VFLAG_EDGE_SHARP = 1 << 5, + VFLAG_EDGE_FREESTYLE = 1 << 6, /* Beware to not go over 1 << 7 (it's a byte flag) * (see gpu_shader_edit_mesh_overlay_geom.glsl) */ }; enum { - VFLAG_EDGE_EXISTS = 1 << 0, - VFLAG_EDGE_ACTIVE = 1 << 1, - VFLAG_EDGE_SELECTED = 1 << 2, - VFLAG_EDGE_SEAM = 1 << 3, - VFLAG_EDGE_SHARP = 1 << 4, - VFLAG_EDGE_FREESTYLE = 1 << 5, + VFLAG_FACE_ACTIVE = 1 << 0, + VFLAG_FACE_SELECTED = 1 << 1, + VFLAG_FACE_FREESTYLE = 1 << 2, + VFLAG_VERT_UV_SELECT = 1 << 3, + VFLAG_VERT_UV_PINNED = 1 << 4, + VFLAG_EDGE_UV_SELECT = 1 << 5, + VFLAG_FACE_UV_ACTIVE = 1 << 6, + VFLAG_FACE_UV_SELECT = 1 << 7, /* Beware to not go over 1 << 7 (it's a byte flag) * (see gpu_shader_edit_mesh_overlay_geom.glsl) */ }; diff --git a/source/blender/draw/intern/draw_cache_impl_curve.c b/source/blender/draw/intern/draw_cache_impl_curve.c index 510cc790be2..54c1c924f87 100644 --- a/source/blender/draw/intern/draw_cache_impl_curve.c +++ b/source/blender/draw/intern/draw_cache_impl_curve.c @@ -679,8 +679,8 @@ static void curve_create_edit_curves_nor(CurveRenderData *rdata, GPUVertBuf *vbo static char beztriple_vflag_get(CurveRenderData *rdata, char flag, char col_id, int v_idx, int nu_id) { char vflag = 0; - SET_FLAG_FROM_TEST(vflag, (flag & SELECT), VFLAG_VERTEX_SELECTED); - SET_FLAG_FROM_TEST(vflag, (v_idx == rdata->actvert), VFLAG_VERTEX_ACTIVE); + SET_FLAG_FROM_TEST(vflag, (flag & SELECT), VFLAG_VERT_SELECTED); + SET_FLAG_FROM_TEST(vflag, (v_idx == rdata->actvert), VFLAG_VERT_ACTIVE); SET_FLAG_FROM_TEST(vflag, (nu_id == rdata->actnu), ACTIVE_NURB); /* handle color id */ vflag |= col_id << 4; /* << 4 because of EVEN_U_BIT */ @@ -690,8 +690,8 @@ static char beztriple_vflag_get(CurveRenderData *rdata, char flag, char col_id, static char bpoint_vflag_get(CurveRenderData *rdata, char flag, int v_idx, int nu_id, int u) { char vflag = 0; - SET_FLAG_FROM_TEST(vflag, (flag & SELECT), VFLAG_VERTEX_SELECTED); - SET_FLAG_FROM_TEST(vflag, (v_idx == rdata->actvert), VFLAG_VERTEX_ACTIVE); + SET_FLAG_FROM_TEST(vflag, (flag & SELECT), VFLAG_VERT_SELECTED); + SET_FLAG_FROM_TEST(vflag, (v_idx == rdata->actvert), VFLAG_VERT_ACTIVE); SET_FLAG_FROM_TEST(vflag, (nu_id == rdata->actnu), ACTIVE_NURB); SET_FLAG_FROM_TEST(vflag, ((u % 2) == 0), EVEN_U_BIT); vflag |= COLOR_NURB_ULINE_ID << 4; /* << 4 because of EVEN_U_BIT */ diff --git a/source/blender/draw/intern/draw_cache_impl_lattice.c b/source/blender/draw/intern/draw_cache_impl_lattice.c index 53ce55bae71..d1abd19c2ff 100644 --- a/source/blender/draw/intern/draw_cache_impl_lattice.c +++ b/source/blender/draw/intern/draw_cache_impl_lattice.c @@ -513,10 +513,10 @@ static void lattice_batch_cache_create_overlay_batches(Lattice *lt) char vflag = 0; if (bp->f1 & SELECT) { if (i == rdata->actbp) { - vflag |= VFLAG_VERTEX_ACTIVE; + vflag |= VFLAG_VERT_ACTIVE; } else { - vflag |= VFLAG_VERTEX_SELECTED; + vflag |= VFLAG_VERT_SELECTED; } } diff --git a/source/blender/draw/intern/draw_cache_impl_mesh.c b/source/blender/draw/intern/draw_cache_impl_mesh.c index 0d79ce3025a..016631e84d0 100644 --- a/source/blender/draw/intern/draw_cache_impl_mesh.c +++ b/source/blender/draw/intern/draw_cache_impl_mesh.c @@ -181,6 +181,7 @@ typedef struct MeshRenderData { BMEditMesh *edit_bmesh; struct EditMeshData *edit_data; + const ToolSettings *toolsettings; Mesh *me; @@ -243,6 +244,7 @@ typedef struct MeshRenderData { BMVert *eve_act; BMEdge *eed_act; BMFace *efa_act; + BMFace *efa_act_uv; /* Data created on-demand (usually not for bmesh-based data). */ EdgeAdjacentPolys *edges_adjacent_polys; @@ -549,10 +551,12 @@ static void mesh_cd_extract_auto_layers_names_and_srgb( * Although this only impacts the data that's generated, not the materials that display. */ static MeshRenderData *mesh_render_data_create_ex( - Mesh *me, const int types, const uchar cd_vused[CD_NUMTYPES], const ushort cd_lused[CD_NUMTYPES]) + Mesh *me, const int types, const uchar cd_vused[CD_NUMTYPES], const ushort cd_lused[CD_NUMTYPES], + const ToolSettings *ts) { MeshRenderData *rdata = MEM_callocN(sizeof(*rdata), __func__); rdata->types = types; + rdata->toolsettings = ts; rdata->mat_len = mesh_render_mat_len_get(me); CustomData_reset(&rdata->cd.output.ldata); @@ -586,6 +590,9 @@ static MeshRenderData *mesh_render_data_create_ex( if (types & MR_DATATYPE_LOOPTRI) { rdata->mapped.tri_len = poly_to_tri_count(me_cage->totpoly, me_cage->totloop); } + if (types & MR_DATATYPE_LOOPUV) { + rdata->mloopuv = CustomData_get_layer(&me_cage->ldata, CD_MLOOPUV); + } rdata->mapped.v_origindex = CustomData_get_layer(&me_cage->vdata, CD_ORIGINDEX); rdata->mapped.e_origindex = CustomData_get_layer(&me_cage->edata, CD_ORIGINDEX); @@ -626,6 +633,7 @@ static MeshRenderData *mesh_render_data_create_ex( bm_ensure_types |= BM_FACE; } if (types & MR_DATATYPE_OVERLAY) { + rdata->efa_act_uv = EDBM_uv_active_face_get(embm, false, false); rdata->efa_act = BM_mesh_active_face_get(bm, false, true); rdata->eed_act = BM_mesh_active_edge_get(bm); rdata->eve_act = BM_mesh_active_vert_get(bm); @@ -1110,11 +1118,6 @@ static void mesh_render_data_free(MeshRenderData *rdata) MEM_freeN(rdata); } -static MeshRenderData *mesh_render_data_create(Mesh *me, const int types) -{ - return mesh_render_data_create_ex(me, types, NULL, NULL); -} - /** \} */ /* ---------------------------------------------------------------------- */ @@ -1241,7 +1244,7 @@ static int mesh_render_data_polys_len_get_maybe_mapped(const MeshRenderData *rda /* ---------------------------------------------------------------------- */ /* TODO remove prototype. */ -static void mesh_create_edit_facedots(MeshRenderData *rdata, GPUVertBuf *vbo_pos_nor_data_facedots); +static void mesh_create_edit_facedots(MeshRenderData *rdata, GPUVertBuf *vbo_facedots_pos_nor_data); /** \name Internal Cache (Lazy Initialization) * \{ */ @@ -1468,18 +1471,24 @@ fallback: /** \name Internal Cache Generation * \{ */ -static uchar mesh_render_data_looptri_flag(MeshRenderData *rdata, const BMFace *efa) +static uchar mesh_render_data_face_flag(MeshRenderData *rdata, const BMFace *efa, const int cd_ofs) { uchar fflag = 0; if (efa == rdata->efa_act) { fflag |= VFLAG_FACE_ACTIVE; } - if (BM_elem_flag_test(efa, BM_ELEM_SELECT)) { fflag |= VFLAG_FACE_SELECTED; } + if (efa == rdata->efa_act_uv) { + fflag |= VFLAG_FACE_UV_ACTIVE; + } + if ((cd_ofs != -1) && uvedit_face_select_test_ex(rdata->toolsettings, (BMFace *)efa, cd_ofs)) { + fflag |= VFLAG_FACE_UV_SELECT; + } + #ifdef WITH_FREESTYLE if (rdata->cd.offset.freestyle_face != -1) { const FreestyleFace *ffa = BM_ELEM_CD_GET_VOID_P(efa, rdata->cd.offset.freestyle_face); @@ -1496,24 +1505,29 @@ static void mesh_render_data_edge_flag( const MeshRenderData *rdata, const BMEdge *eed, EdgeDrawAttr *eattr) { - eattr->e_flag |= VFLAG_EDGE_EXISTS; + const ToolSettings *ts = rdata->toolsettings; + const bool is_vertex_select_mode = (ts != NULL) && (ts->selectmode & SCE_SELECT_VERTEX) != 0; if (eed == rdata->eed_act) { eattr->e_flag |= VFLAG_EDGE_ACTIVE; } - - if (BM_elem_flag_test(eed, BM_ELEM_SELECT)) { + if (!is_vertex_select_mode && + BM_elem_flag_test(eed, BM_ELEM_SELECT)) + { + eattr->e_flag |= VFLAG_EDGE_SELECTED; + } + if (is_vertex_select_mode && + BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) && + BM_elem_flag_test(eed->v2, BM_ELEM_SELECT)) + { eattr->e_flag |= VFLAG_EDGE_SELECTED; } - if (BM_elem_flag_test(eed, BM_ELEM_SEAM)) { eattr->e_flag |= VFLAG_EDGE_SEAM; } - if (!BM_elem_flag_test(eed, BM_ELEM_SMOOTH)) { eattr->e_flag |= VFLAG_EDGE_SHARP; } - /* Use a byte for value range */ if (rdata->cd.offset.crease != -1) { float crease = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.crease); @@ -1521,7 +1535,6 @@ static void mesh_render_data_edge_flag( eattr->crease = (uchar)(crease * 255.0f); } } - /* Use a byte for value range */ if (rdata->cd.offset.bweight != -1) { float bweight = BM_ELEM_CD_GET_FLOAT(eed, rdata->cd.offset.bweight); @@ -1529,7 +1542,6 @@ static void mesh_render_data_edge_flag( eattr->bweight = (uchar)(bweight * 255.0f); } } - #ifdef WITH_FREESTYLE if (rdata->cd.offset.freestyle_edge != -1) { const FreestyleEdge *fed = BM_ELEM_CD_GET_VOID_P(eed, rdata->cd.offset.freestyle_edge); @@ -1540,288 +1552,30 @@ static void mesh_render_data_edge_flag( #endif } -static uchar mesh_render_data_vertex_flag(MeshRenderData *rdata, const BMVert *eve) -{ - uchar vflag = VFLAG_VERTEX_EXISTS; - - /* Current vertex */ - if (eve == rdata->eve_act) { - vflag |= VFLAG_VERTEX_ACTIVE; - } - - if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { - vflag |= VFLAG_VERTEX_SELECTED; - } - - return vflag; -} - -static void add_edit_tri( - MeshRenderData *rdata, GPUVertBuf *vbo_pos_nor, GPUVertBuf *vbo_lnor, GPUVertBuf *vbo_data, GPUIndexBufBuilder *elb, - const uint pos_id, const uint vnor_id, const uint lnor_id, const uint data_id, - const BMLoop **bm_looptri, const int base_vert_idx) +static void mesh_render_data_loop_flag(MeshRenderData *rdata, BMLoop *loop, const int cd_ofs, EdgeDrawAttr *eattr) { - uchar fflag; - uchar vflag; - - /* Only draw vertices once. */ - if (elb) { - for (int i = 0; i < 3; ++i) { - if (!BM_elem_flag_test(bm_looptri[i]->v, BM_ELEM_TAG)) { - BM_elem_flag_enable(bm_looptri[i]->v, BM_ELEM_TAG); - GPU_indexbuf_add_generic_vert(elb, base_vert_idx + i); - } - } - } - - if (vbo_pos_nor) { - /* TODO(sybren): deduplicate this and all the other places it's pasted to in this file. */ - if (rdata->edit_data && rdata->edit_data->vertexCos) { - for (uint i = 0; i < 3; i++) { - int vidx = BM_elem_index_get(bm_looptri[i]->v); - const float *pos = rdata->edit_data->vertexCos[vidx]; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx + i, pos); - } - } - else { - for (uint i = 0; i < 3; i++) { - const float *pos = bm_looptri[i]->v->co; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx + i, pos); - } - } - - for (uint i = 0; i < 3; i++) { - GPUPackedNormal vnor = GPU_normal_convert_i10_v3(bm_looptri[i]->v->no); - GPU_vertbuf_attr_set(vbo_pos_nor, vnor_id, base_vert_idx + i, &vnor); - } - } - - if (vbo_lnor) { - float (*lnors)[3] = rdata->loop_normals; - for (uint i = 0; i < 3; i++) { - const float *nor = (lnors) ? lnors[BM_elem_index_get(bm_looptri[i])] : bm_looptri[0]->f->no; - GPUPackedNormal lnor = GPU_normal_convert_i10_v3(nor); - GPU_vertbuf_attr_set(vbo_lnor, lnor_id, base_vert_idx + i, &lnor); - } - } - - if (vbo_data) { - fflag = mesh_render_data_looptri_flag(rdata, bm_looptri[0]->f); - for (uint i = 0; i < 3; i++) { - const int i_next = (i + 1) % 3; - const int i_prev = (i + 2) % 3; - vflag = mesh_render_data_vertex_flag(rdata, bm_looptri[i]->v); - /* Opposite edge to the vertex at 'i'. */ - EdgeDrawAttr eattr = {0}; - const bool is_edge_real = (bm_looptri[i_next] == bm_looptri[i_prev]->prev); - if (is_edge_real) { - mesh_render_data_edge_flag(rdata, bm_looptri[i_next]->e, &eattr); - } - eattr.v_flag = fflag | vflag; - GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx + i, &eattr); - } - } -} -static bool add_edit_tri_mapped( - MeshRenderData *rdata, GPUVertBuf *vbo_pos_nor, GPUVertBuf *vbo_lnor, GPUVertBuf *vbo_data, GPUIndexBufBuilder *elb, - const uint pos_id, const uint vnor_id, const uint lnor_id, const uint data_id, - BMFace *efa, const MLoopTri *mlt, const float (*poly_normals)[3], const float (*loop_normals)[3], const int base_vert_idx) -{ - if (BM_elem_flag_test(efa, BM_ELEM_HIDDEN)) { - return false; - } - - BMEditMesh *embm = rdata->edit_bmesh; - BMesh *bm = embm->bm; - Mesh *me_cage = embm->mesh_eval_cage; - - const MVert *mvert = me_cage->mvert; - const MEdge *medge = me_cage->medge; - const MLoop *mloop = me_cage->mloop; - - const int *v_origindex = rdata->mapped.v_origindex; - const int *e_origindex = rdata->mapped.e_origindex; - - if (elb) { - for (int i = 0; i < 3; ++i) { - const int v_orig = v_origindex[mloop[mlt->tri[i]].v]; - if (v_orig == ORIGINDEX_NONE) { - continue; - } - BMVert *v = BM_vert_at_index(bm, v_orig); - if (!BM_elem_flag_test(v, BM_ELEM_TAG)) { - BM_elem_flag_enable(v, BM_ELEM_TAG); - GPU_indexbuf_add_generic_vert(elb, base_vert_idx + i); - } - } - } - - if (vbo_pos_nor) { - for (uint i = 0; i < 3; i++) { - const float *pos = mvert[mloop[mlt->tri[i]].v].co; - GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[mloop[mlt->tri[i]].v].no); - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx + i, pos); - GPU_vertbuf_attr_set(vbo_pos_nor, vnor_id, base_vert_idx + i, &vnor); - } - } - - if (vbo_lnor) { - for (uint i = 0; i < 3; i++) { - const float *nor = loop_normals ? loop_normals[mlt->tri[i]] : poly_normals[mlt->poly]; - GPUPackedNormal lnor = GPU_normal_convert_i10_v3(nor); - GPU_vertbuf_attr_set(vbo_lnor, lnor_id, base_vert_idx + i, &lnor); - } - } - - if (vbo_data) { - EdgeDrawAttr eattr[3] = {{0}}; /* Importantly VFLAG_VERTEX_EXISTS is not set. */ - uchar fflag = mesh_render_data_looptri_flag(rdata, efa); - for (uint i = 0; i < 3; i++) { - const int i_next = (i + 1) % 3; - const int i_prev = (i + 2) % 3; - const int v_orig = v_origindex[mloop[mlt->tri[i]].v]; - if (v_orig != ORIGINDEX_NONE) { - BMVert *v = BM_vert_at_index(bm, v_orig); - eattr[i].v_flag |= mesh_render_data_vertex_flag(rdata, v); - } - /* Opposite edge to the vertex at 'i'. */ - const int e_idx = mloop[mlt->tri[i_next]].e; - const int e_orig = e_origindex[e_idx]; - if (e_orig != ORIGINDEX_NONE) { - const MEdge *ed = &medge[e_idx]; - const uint tri_edge[2] = {mloop[mlt->tri[i_prev]].v, mloop[mlt->tri[i_next]].v}; - const bool is_edge_real = ( - ((ed->v1 == tri_edge[0]) && (ed->v2 == tri_edge[1])) || - ((ed->v1 == tri_edge[1]) && (ed->v2 == tri_edge[0]))); - if (is_edge_real) { - BMEdge *eed = BM_edge_at_index(bm, e_orig); - mesh_render_data_edge_flag(rdata, eed, &eattr[i]); - /* Set vertex selected if both original verts are selected. */ - if (BM_elem_flag_test(eed->v1, BM_ELEM_SELECT) && - BM_elem_flag_test(eed->v2, BM_ELEM_SELECT)) - { - eattr[i_next].v_flag |= VFLAG_VERTEX_SELECTED; - eattr[i_prev].v_flag |= VFLAG_VERTEX_SELECTED; - } - } - } - } - for (uint i = 0; i < 3; i++) { - eattr[i].v_flag |= fflag; - GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx + i, &eattr[i]); - } - } - - return true; -} - -static void add_edit_loose_edge( - MeshRenderData *rdata, GPUVertBuf *vbo_pos_nor, GPUVertBuf *vbo_data, - const uint pos_id, const uint vnor_id, const uint data_id, - const BMEdge *eed, const int base_vert_idx) -{ - if (vbo_pos_nor) { - /* TODO(sybren): deduplicate this and all the other places it's pasted to in this file. */ - if (rdata->edit_data && rdata->edit_data->vertexCos) { - for (uint i = 0; i < 2; i++) { - int vidx = BM_elem_index_get((&eed->v1)[i]); - const float *pos = rdata->edit_data->vertexCos[vidx]; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx + i, pos); - } - } - else { - for (int i = 0; i < 2; i++) { - const float *pos = (&eed->v1)[i]->co; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx + i, pos); - } - } - - for (int i = 0; i < 2; i++) { - GPUPackedNormal vnor = GPU_normal_convert_i10_v3((&eed->v1)[i]->no); - GPU_vertbuf_attr_set(vbo_pos_nor, vnor_id, base_vert_idx + i, &vnor); - } + if (cd_ofs == -1) { + return; } - - if (vbo_data) { - EdgeDrawAttr eattr = {0}; - mesh_render_data_edge_flag(rdata, eed, &eattr); - for (int i = 0; i < 2; i++) { - eattr.v_flag = mesh_render_data_vertex_flag(rdata, (&eed->v1)[i]); - GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx + i, &eattr); - } + MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_ofs); + if (luv != NULL && (luv->flag & MLOOPUV_PINNED)) { + eattr->v_flag |= VFLAG_VERT_UV_PINNED; } -} -static void add_edit_loose_edge_mapped( - MeshRenderData *rdata, GPUVertBuf *vbo_pos_nor, GPUVertBuf *vbo_data, - const uint pos_id, const uint vnor_id, const uint data_id, - BMEdge *eed, const MVert *mvert, const MEdge *ed, const int base_vert_idx) -{ - if (vbo_pos_nor) { - /* TODO(sybren): deduplicate this and all the other places it's pasted to in this file. */ - for (int i = 0; i < 2; i++) { - const float *pos = mvert[*(&ed->v1 + i)].co; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx + i, pos); - - GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[*(&ed->v1 + i)].no); - GPU_vertbuf_attr_set(vbo_pos_nor, vnor_id, base_vert_idx + i, &vnor); - } + if (uvedit_uv_select_test_ex(rdata->toolsettings, loop, cd_ofs)) { + eattr->v_flag |= VFLAG_VERT_UV_SELECT; } - - if (vbo_data) { - EdgeDrawAttr eattr = {0}; - mesh_render_data_edge_flag(rdata, eed, &eattr); - for (int i = 0; i < 2; i++) { - const int v_orig = rdata->mapped.v_origindex[*(&ed->v1 + i)]; - eattr.v_flag = (v_orig != ORIGINDEX_NONE) ? mesh_render_data_vertex_flag(rdata, (&eed->v1)[i]) : 0; - GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx + i, &eattr); - } + if (uvedit_edge_select_test_ex(rdata->toolsettings, loop, cd_ofs)) { + eattr->v_flag |= VFLAG_EDGE_UV_SELECT; } } -static void add_edit_loose_vert( - MeshRenderData *rdata, GPUVertBuf *vbo_pos_nor, GPUVertBuf *vbo_data, - const uint pos_id, const uint vnor_id, const uint data_id, - const BMVert *eve, const int base_vert_idx) -{ - if (vbo_pos_nor) { - /* TODO(sybren): deduplicate this and all the other places it's pasted to in this file. */ - if (rdata->edit_data && rdata->edit_data->vertexCos) { - int vidx = BM_elem_index_get(eve); - const float *pos = rdata->edit_data->vertexCos[vidx]; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx, pos); - } - else { - const float *pos = eve->co; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx, pos); - } - - GPUPackedNormal vnor = GPU_normal_convert_i10_v3(eve->no); - GPU_vertbuf_attr_set(vbo_pos_nor, vnor_id, base_vert_idx, &vnor); - } - - if (vbo_data) { - uchar vflag[4] = {0, 0, 0, 0}; - vflag[0] = mesh_render_data_vertex_flag(rdata, eve); - GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx, vflag); - } -} -static void add_edit_loose_vert_mapped( - MeshRenderData *rdata, GPUVertBuf *vbo_pos_nor, GPUVertBuf *vbo_data, - const uint pos_id, const uint vnor_id, const uint data_id, - const BMVert *eve, const MVert *mv, const int base_vert_idx) +static void mesh_render_data_vert_flag(MeshRenderData *rdata, const BMVert *eve, EdgeDrawAttr *eattr) { - if (vbo_pos_nor) { - const float *pos = mv->co; - GPU_vertbuf_attr_set(vbo_pos_nor, pos_id, base_vert_idx, pos); - - GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mv->no); - GPU_vertbuf_attr_set(vbo_pos_nor, vnor_id, base_vert_idx, &vnor); + if (eve == rdata->eve_act) { + eattr->e_flag |= VFLAG_VERT_ACTIVE; } - - if (vbo_data) { - uchar vflag[4] = {0, 0, 0, 0}; - vflag[0] = mesh_render_data_vertex_flag(rdata, eve); - GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx, vflag); + if (BM_elem_flag_test(eve, BM_ELEM_SELECT)) { + eattr->e_flag |= VFLAG_VERT_SELECTED; } } @@ -2005,35 +1759,30 @@ typedef struct MeshBatchCache { } tess; /* Edit Mesh Data: - * Data is also tesselated because of barycentric wireframe rendering. */ + * Edit cage can be different from final mesh so vertex count + * might differ. */ struct { - GPUVertBuf *pos_nor; - GPUVertBuf *pos_nor_ledges; - GPUVertBuf *pos_nor_lverts; - GPUVertBuf *pos_nor_data_facedots; - GPUVertBuf *data; - GPUVertBuf *data_ledges; - GPUVertBuf *data_lverts; - GPUVertBuf *lnor; + /* TODO(fclem): Reuse ordered.loop_pos_nor and maybe even + * ordered.loop_uv_tan when cage match final mesh. */ + GPUVertBuf *loop_pos_nor; + GPUVertBuf *loop_data; + GPUVertBuf *loop_lnor; + GPUVertBuf *facedots_pos_nor_data; + /* UV data without modifier applied. + * Vertex count is always the one of the cage. */ + GPUVertBuf *loop_uv; + GPUVertBuf *loop_uv_data; + GPUVertBuf *loop_stretch_angle; + GPUVertBuf *loop_stretch_area; + GPUVertBuf *facedots_uv; + GPUVertBuf *facedots_uv_data; /* Selection */ - GPUVertBuf *loop_pos; GPUVertBuf *loop_vert_idx; GPUVertBuf *loop_edge_idx; GPUVertBuf *loop_face_idx; GPUVertBuf *facedots_idx; } edit; - /* Edit UVs: - * We need different flags and vertex count form edit mesh. */ - struct { - GPUVertBuf *loop_stretch_angle; - GPUVertBuf *loop_stretch_area; - GPUVertBuf *loop_uv; - GPUVertBuf *loop_data; - GPUVertBuf *facedots_uv; - GPUVertBuf *facedots_data; - } edituv; - /* Index Buffers: * Only need to be updated when topology changes. */ struct { @@ -2045,15 +1794,14 @@ typedef struct MeshBatchCache { /* Indices to vloops. */ GPUIndexBuf *loops_tris; GPUIndexBuf *loops_lines; - /* Contains indices to unique edit vertices to not - * draw the same vert multiple times (because of tesselation). */ - GPUIndexBuf *edit_verts_points; - /* Edit mode selection. */ + /* Edit mode. */ GPUIndexBuf *edit_loops_points; /* verts */ GPUIndexBuf *edit_loops_lines; /* edges */ GPUIndexBuf *edit_loops_tris; /* faces */ /* Edit UVs */ - GPUIndexBuf *edituv_loops_lines; /* edges & faces */ + GPUIndexBuf *edituv_loops_points; /* verts */ + GPUIndexBuf *edituv_loops_lines; /* edges */ + GPUIndexBuf *edituv_loops_tri_fans; /* faces */ } ibo; struct { @@ -2063,11 +1811,8 @@ typedef struct MeshBatchCache { /* Edit mode */ GPUBatch *edit_triangles; GPUBatch *edit_vertices; - GPUBatch *edit_loose_edges; - GPUBatch *edit_loose_verts; - GPUBatch *edit_triangles_nor; - GPUBatch *edit_triangles_lnor; - GPUBatch *edit_loose_edges_nor; + GPUBatch *edit_edges; + GPUBatch *edit_lnor; GPUBatch *edit_facedots; /* Edit UVs */ GPUBatch *edituv_faces_strech_area; @@ -2245,12 +1990,15 @@ static void mesh_batch_cache_discard_shaded_tri(MeshBatchCache *cache) static void mesh_batch_cache_discard_uvedit(MeshBatchCache *cache) { - for (int i = 0; i < sizeof(cache->edituv) / sizeof(void *); ++i) { - GPUVertBuf **vbo = (GPUVertBuf **)&cache->edituv; - GPU_VERTBUF_DISCARD_SAFE(vbo[i]); - } - + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_angle); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_area); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv_data); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv_data); + GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_tri_fans); GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_lines); + GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_points); GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_area); GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_angle); GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces); @@ -2270,15 +2018,11 @@ void DRW_mesh_batch_cache_dirty_tag(Mesh *me, int mode) cache->is_maybe_dirty = true; break; case BKE_MESH_BATCH_DIRTY_SELECT: - GPU_VERTBUF_DISCARD_SAFE(cache->edit.data); - GPU_VERTBUF_DISCARD_SAFE(cache->edit.data_ledges); - GPU_VERTBUF_DISCARD_SAFE(cache->edit.data_lverts); - GPU_VERTBUF_DISCARD_SAFE(cache->edit.pos_nor_data_facedots); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_data); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_pos_nor_data); GPU_BATCH_DISCARD_SAFE(cache->batch.edit_triangles); GPU_BATCH_DISCARD_SAFE(cache->batch.edit_vertices); - GPU_BATCH_DISCARD_SAFE(cache->batch.edit_loose_verts); - GPU_BATCH_DISCARD_SAFE(cache->batch.edit_loose_edges); - GPU_BATCH_DISCARD_SAFE(cache->batch.edit_loose_edges_nor); + GPU_BATCH_DISCARD_SAFE(cache->batch.edit_edges); GPU_BATCH_DISCARD_SAFE(cache->batch.edit_facedots); /* Paint mode selection */ /* TODO only do that in paint mode. */ @@ -2307,8 +2051,8 @@ void DRW_mesh_batch_cache_dirty_tag(Mesh *me, int mode) mesh_batch_cache_discard_uvedit(cache); break; case BKE_MESH_BATCH_DIRTY_UVEDIT_SELECT: - GPU_VERTBUF_DISCARD_SAFE(cache->edituv.loop_data); - GPU_VERTBUF_DISCARD_SAFE(cache->edituv.facedots_data); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv_data); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv_data); GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_area); GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces_strech_angle); GPU_BATCH_DISCARD_SAFE(cache->batch.edituv_faces); @@ -2583,9 +2327,15 @@ BLI_INLINE void mesh_edit_add_select_index(GPUVertBufRaw *buf, GPUVertCompType c #define SELECT_COMP_FORMAT(el_len) (el_len > 0xFF ? (el_len > 0xFFFF ? GPU_COMP_U32 : GPU_COMP_U16) : GPU_COMP_U8) -static void mesh_create_edit_select_id( +static void mesh_create_edit_vertex_loops( MeshRenderData *rdata, - GPUVertBuf *vbo_pos, GPUVertBuf *vbo_verts, GPUVertBuf *vbo_edges, GPUVertBuf *vbo_faces) + GPUVertBuf *vbo_pos_nor, + GPUVertBuf *vbo_lnor, + GPUVertBuf *vbo_uv, + GPUVertBuf *vbo_data, + GPUVertBuf *vbo_verts, + GPUVertBuf *vbo_edges, + GPUVertBuf *vbo_faces) { const int vert_len = mesh_render_data_verts_len_get_maybe_mapped(rdata); const int edge_len = mesh_render_data_edges_len_get_maybe_mapped(rdata); @@ -2594,37 +2344,67 @@ static void mesh_create_edit_select_id( const int ledge_len = mesh_render_data_loose_edges_len_get_maybe_mapped(rdata); const int loop_len = mesh_render_data_loops_len_get_maybe_mapped(rdata); const int tot_loop_len = loop_len + ledge_len * 2 + lvert_len; + static struct { uint vert, edge, face, pos, nor, lnor, data, uvs; } attr_id; + float (*lnors)[3] = rdata->loop_normals; + uchar fflag; /* Choose the most compact vertex format. */ GPUVertCompType vert_comp = SELECT_COMP_FORMAT(vert_len); GPUVertCompType edge_comp = SELECT_COMP_FORMAT(edge_len); GPUVertCompType face_comp = SELECT_COMP_FORMAT(poly_len); - GPUVertFormat format_vert = { 0 }, format_edge = { 0 }, format_face = { 0 }, format_pos = { 0 }; - struct { uint vert, edge, face, pos; } attr_id; - attr_id.vert = GPU_vertformat_attr_add(&format_vert, "color", vert_comp, 1, GPU_FETCH_INT); - attr_id.edge = GPU_vertformat_attr_add(&format_edge, "color", edge_comp, 1, GPU_FETCH_INT); - attr_id.face = GPU_vertformat_attr_add(&format_face, "color", face_comp, 1, GPU_FETCH_INT); - attr_id.pos = GPU_vertformat_attr_add(&format_pos, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT); + GPUVertFormat format_vert_idx = { 0 }, format_edge_idx = { 0 }, format_face_idx = { 0 }; + attr_id.vert = GPU_vertformat_attr_add(&format_vert_idx, "color", vert_comp, 1, GPU_FETCH_INT); + attr_id.edge = GPU_vertformat_attr_add(&format_edge_idx, "color", edge_comp, 1, GPU_FETCH_INT); + attr_id.face = GPU_vertformat_attr_add(&format_face_idx, "color", face_comp, 1, GPU_FETCH_INT); + + /* Static formats */ + static GPUVertFormat format_pos_nor = { 0 }, format_lnor = { 0 }, format_flag = { 0 }, format_uv = { 0 }; + if (format_pos_nor.attr_len == 0) { + attr_id.pos = GPU_vertformat_attr_add(&format_pos_nor, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT); + attr_id.nor = GPU_vertformat_attr_add(&format_pos_nor, "vnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT); + attr_id.lnor = GPU_vertformat_attr_add(&format_lnor, "lnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT); + attr_id.data = GPU_vertformat_attr_add(&format_flag, "data", GPU_COMP_U8, 4, GPU_FETCH_INT); + attr_id.uvs = GPU_vertformat_attr_add(&format_uv, "u", GPU_COMP_F32, 2, GPU_FETCH_FLOAT); + GPU_vertformat_alias_add(&format_uv, "pos"); + GPU_vertformat_alias_add(&format_flag, "flag"); + } - GPUVertBufRaw raw_verts, raw_edges, raw_faces, raw_pos; - if (DRW_TEST_ASSIGN_VBO(vbo_pos)) { - GPU_vertbuf_init_with_format(vbo_pos, &format_pos); - GPU_vertbuf_data_alloc(vbo_pos, tot_loop_len); - GPU_vertbuf_attr_get_raw_data(vbo_pos, attr_id.pos, &raw_pos); + GPUVertBufRaw raw_verts, raw_edges, raw_faces, raw_pos, raw_nor, raw_lnor, raw_uv, raw_data; + if (DRW_TEST_ASSIGN_VBO(vbo_pos_nor)) { + GPU_vertbuf_init_with_format(vbo_pos_nor, &format_pos_nor); + GPU_vertbuf_data_alloc(vbo_pos_nor, tot_loop_len); + GPU_vertbuf_attr_get_raw_data(vbo_pos_nor, attr_id.pos, &raw_pos); + GPU_vertbuf_attr_get_raw_data(vbo_pos_nor, attr_id.nor, &raw_nor); + } + if (DRW_TEST_ASSIGN_VBO(vbo_lnor)) { + GPU_vertbuf_init_with_format(vbo_lnor, &format_lnor); + GPU_vertbuf_data_alloc(vbo_lnor, tot_loop_len); + GPU_vertbuf_attr_get_raw_data(vbo_lnor, attr_id.lnor, &raw_lnor); } + if (DRW_TEST_ASSIGN_VBO(vbo_data)) { + GPU_vertbuf_init_with_format(vbo_data, &format_flag); + GPU_vertbuf_data_alloc(vbo_data, tot_loop_len); + GPU_vertbuf_attr_get_raw_data(vbo_data, attr_id.data, &raw_data); + } + if (DRW_TEST_ASSIGN_VBO(vbo_uv)) { + GPU_vertbuf_init_with_format(vbo_uv, &format_uv); + GPU_vertbuf_data_alloc(vbo_uv, tot_loop_len); + GPU_vertbuf_attr_get_raw_data(vbo_uv, attr_id.uvs, &raw_uv); + } + /* Select Idx */ if (DRW_TEST_ASSIGN_VBO(vbo_verts)) { - GPU_vertbuf_init_with_format(vbo_verts, &format_vert); + GPU_vertbuf_init_with_format(vbo_verts, &format_vert_idx); GPU_vertbuf_data_alloc(vbo_verts, tot_loop_len); GPU_vertbuf_attr_get_raw_data(vbo_verts, attr_id.vert, &raw_verts); } if (DRW_TEST_ASSIGN_VBO(vbo_edges)) { - GPU_vertbuf_init_with_format(vbo_edges, &format_edge); + GPU_vertbuf_init_with_format(vbo_edges, &format_edge_idx); GPU_vertbuf_data_alloc(vbo_edges, tot_loop_len); GPU_vertbuf_attr_get_raw_data(vbo_edges, attr_id.edge, &raw_edges); } if (DRW_TEST_ASSIGN_VBO(vbo_faces)) { - GPU_vertbuf_init_with_format(vbo_faces, &format_face); + GPU_vertbuf_init_with_format(vbo_faces, &format_face_idx); GPU_vertbuf_data_alloc(vbo_faces, tot_loop_len); GPU_vertbuf_attr_get_raw_data(vbo_faces, attr_id.face, &raw_faces); } @@ -2636,14 +2416,37 @@ static void mesh_create_edit_select_id( BMEdge *eed; BMVert *eve; BMLoop *loop; + const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV); /* Face Loops */ BM_ITER_MESH (efa, &iter_efa, bm, BM_FACES_OF_MESH) { int fidx = BM_elem_index_get(efa); + if (vbo_data) { + fflag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset); + } BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) { - if (vbo_pos) { + if (vbo_pos_nor) { + GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor); + *vnor = GPU_normal_convert_i10_v3(loop->v->no); copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), loop->v->co); } + if (vbo_lnor) { + const float *nor = (lnors) ? lnors[BM_elem_index_get(loop)] : efa->no; + GPUPackedNormal *lnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor); + *lnor = GPU_normal_convert_i10_v3(nor); + } + if (vbo_data) { + EdgeDrawAttr eattr = { .v_flag = fflag }; + mesh_render_data_edge_flag(rdata, loop->e, &eattr); + mesh_render_data_vert_flag(rdata, loop->v, &eattr); + mesh_render_data_loop_flag(rdata, loop, cd_loop_uv_offset, &eattr); + memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr)); + } + if (vbo_uv) { + MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(loop, cd_loop_uv_offset); + copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv); + } + /* Select Idx */ if (vbo_verts) { int vidx = BM_elem_index_get(loop->v); mesh_edit_add_select_index(&raw_verts, vert_comp, vidx); @@ -2661,9 +2464,18 @@ static void mesh_create_edit_select_id( for (int e = 0; e < ledge_len; e++) { eed = BM_edge_at_index(bm, rdata->loose_edges[e]); BM_ITER_ELEM (eve, &iter_vert, eed, BM_VERTS_OF_EDGE) { - if (vbo_pos) { + if (vbo_pos_nor) { + GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor); + *vnor = GPU_normal_convert_i10_v3(eve->no); copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), eve->co); } + if (vbo_data) { + EdgeDrawAttr eattr = { 0 }; + mesh_render_data_edge_flag(rdata, eed, &eattr); + mesh_render_data_vert_flag(rdata, eve, &eattr); + memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr)); + } + /* Select Idx */ if (vbo_verts) { int vidx = BM_elem_index_get(eve); mesh_edit_add_select_index(&raw_verts, vert_comp, vidx); @@ -2677,9 +2489,17 @@ static void mesh_create_edit_select_id( /* Loose verts */ for (int e = 0; e < lvert_len; e++) { eve = BM_vert_at_index(bm, rdata->loose_verts[e]); - if (vbo_pos) { + if (vbo_pos_nor) { + GPUPackedNormal *vnor = (GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor); + *vnor = GPU_normal_convert_i10_v3(eve->no); copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), eve->co); } + if (vbo_data) { + EdgeDrawAttr eattr = { 0 }; + mesh_render_data_vert_flag(rdata, eve, &eattr); + memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr)); + } + /* Select Idx */ if (vbo_verts) { int vidx = BM_elem_index_get(eve); mesh_edit_add_select_index(&raw_verts, vert_comp, vidx); @@ -2687,6 +2507,9 @@ static void mesh_create_edit_select_id( } } else if (rdata->mapped.use == true) { + BMesh *bm = rdata->edit_bmesh->bm; + const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV); + const MPoly *mpoly = rdata->mapped.me_cage->mpoly; const MEdge *medge = rdata->mapped.me_cage->medge; const MVert *mvert = rdata->mapped.me_cage->mvert; @@ -2700,10 +2523,56 @@ static void mesh_create_edit_select_id( for (int poly = 0; poly < poly_len; poly++, mpoly++) { const MLoop *l = &mloop[mpoly->loopstart]; int fidx = p_origindex[poly]; + BMFace *efa = NULL; + if (vbo_data) { + fflag = 0; + if (fidx != ORIGINDEX_NONE) { + efa = BM_face_at_index(bm, fidx); + fflag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset); + } + } for (int i = 0; i < mpoly->totloop; i++, l++) { - if (vbo_pos) { + if (vbo_pos_nor) { copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[l->v].co); } + if (vbo_lnor || vbo_pos_nor) { + GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[l->v].no); + if (vbo_pos_nor) { + *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor; + } + if (vbo_lnor) { + /* Mapped does not support lnors yet. */ + *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor) = vnor; + } + } + if (vbo_data) { + EdgeDrawAttr eattr = { .v_flag = fflag }; + int vidx = v_origindex[l->v]; + int eidx = e_origindex[l->e]; + if (vidx != ORIGINDEX_NONE) { + BMVert *eve = BM_vert_at_index(bm, vidx); + mesh_render_data_vert_flag(rdata, eve, &eattr); + } + if (eidx != ORIGINDEX_NONE) { + BMEdge *eed = BM_edge_at_index(bm, eidx); + mesh_render_data_edge_flag(rdata, eed, &eattr); + /* TODO find a more efficient way to do that. */ + BMLoop *loop; + BMIter iter_loop; + BM_ITER_ELEM (loop, &iter_loop, efa, BM_LOOPS_OF_FACE) { + if (loop->e == eed) { + mesh_render_data_loop_flag(rdata, loop, cd_loop_uv_offset, &eattr); + break; + } + } + } + memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr)); + } + if (vbo_uv) { + MLoopUV *luv = &rdata->mloopuv[mpoly->loopstart + i]; + copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv); + } + /* Select Idx */ if (vbo_verts) { int vidx = v_origindex[l->v]; mesh_edit_add_select_index(&raw_verts, vert_comp, vidx); @@ -2722,9 +2591,26 @@ static void mesh_create_edit_select_id( const int e = rdata->mapped.loose_edges[j]; for (int i = 0; i < 2; ++i) { int v = (i == 0) ? medge[e].v1 : medge[e].v2; - if (vbo_pos) { + if (vbo_pos_nor) { + GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[v].no); + *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor; copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[v].co); } + if (vbo_data) { + EdgeDrawAttr eattr = { 0 }; + int vidx = v_origindex[v]; + int eidx = e_origindex[e]; + if (vidx != ORIGINDEX_NONE) { + BMVert *eve = BM_vert_at_index(bm, vidx); + mesh_render_data_vert_flag(rdata, eve, &eattr); + } + if (eidx != ORIGINDEX_NONE) { + BMEdge *eed = BM_edge_at_index(bm, eidx); + mesh_render_data_edge_flag(rdata, eed, &eattr); + } + memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr)); + } + /* Select Idx */ if (vbo_verts) { int vidx = v_origindex[v]; mesh_edit_add_select_index(&raw_verts, vert_comp, vidx); @@ -2738,9 +2624,21 @@ static void mesh_create_edit_select_id( /* Loose verts */ for (int i = 0; i < lvert_len; i++) { const int v = rdata->mapped.loose_verts[i]; - if (vbo_pos) { + if (vbo_pos_nor) { + GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[v].no); + *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor; copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[v].co); } + if (vbo_data) { + EdgeDrawAttr eattr = { 0 }; + int vidx = v_origindex[v]; + if (vidx != ORIGINDEX_NONE) { + BMVert *eve = BM_vert_at_index(bm, vidx); + mesh_render_data_vert_flag(rdata, eve, &eattr); + } + memcpy(GPU_vertbuf_raw_step(&raw_data), &eattr, sizeof(EdgeDrawAttr)); + } + /* Select Idx */ if (vbo_verts) { int vidx = v_origindex[v]; mesh_edit_add_select_index(&raw_verts, vert_comp, vidx); @@ -2761,9 +2659,24 @@ static void mesh_create_edit_select_id( const MLoop *l = &mloop[mpoly->loopstart]; int fidx = p_origindex ? p_origindex[poly] : poly; for (int i = 0; i < mpoly->totloop; i++, l++) { - if (vbo_pos) { + if (vbo_pos_nor) { copy_v3_v3(GPU_vertbuf_raw_step(&raw_pos), mvert[l->v].co); } + if (vbo_lnor || vbo_pos_nor) { + GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[l->v].no); + if (vbo_pos_nor) { + *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_nor) = vnor; + } + if (vbo_lnor) { + /* Mapped does not support lnors yet. */ + *(GPUPackedNormal *)GPU_vertbuf_raw_step(&raw_lnor) = vnor; + } + } + if (vbo_uv) { + MLoopUV *luv = &rdata->mloopuv[mpoly->loopstart + i]; + copy_v2_v2(GPU_vertbuf_raw_step(&raw_uv), luv->uv); + } + /* Select Idx */ if (vbo_verts) { int vidx = v_origindex ? v_origindex[l->v] : l->v; mesh_edit_add_select_index(&raw_verts, vert_comp, vidx); @@ -3270,268 +3183,24 @@ static void mesh_create_loop_vcol(MeshRenderData *rdata, GPUVertBuf *vbo) #undef USE_COMP_MESH_DATA } -static GPUVertFormat *edit_mesh_pos_nor_format(uint *r_pos_id, uint *r_nor_id) -{ - static GPUVertFormat format_pos_nor = { 0 }; - static uint pos_id, nor_id; - if (format_pos_nor.attr_len == 0) { - pos_id = GPU_vertformat_attr_add(&format_pos_nor, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT); - nor_id = GPU_vertformat_attr_add(&format_pos_nor, "vnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT); - } - *r_pos_id = pos_id; - *r_nor_id = nor_id; - return &format_pos_nor; -} - -static GPUVertFormat *edit_mesh_lnor_format(uint *r_lnor_id) -{ - static GPUVertFormat format_lnor = { 0 }; - static uint lnor_id; - if (format_lnor.attr_len == 0) { - lnor_id = GPU_vertformat_attr_add(&format_lnor, "lnor", GPU_COMP_I10, 3, GPU_FETCH_INT_TO_FLOAT_UNIT); - } - *r_lnor_id = lnor_id; - return &format_lnor; -} - -static GPUVertFormat *edit_mesh_data_format(uint *r_data_id) -{ - static GPUVertFormat format_flag = { 0 }; - static uint data_id; - if (format_flag.attr_len == 0) { - data_id = GPU_vertformat_attr_add(&format_flag, "data", GPU_COMP_U8, 4, GPU_FETCH_INT); - GPU_vertformat_triple_load(&format_flag); - } - *r_data_id = data_id; - return &format_flag; -} - -static GPUVertFormat *edit_mesh_facedot_format(uint *r_pos_id, uint *r_nor_flag_id) -{ - static GPUVertFormat format_facedots = { 0 }; - static uint pos_id, nor_flag_id; - if (format_facedots.attr_len == 0) { - pos_id = GPU_vertformat_attr_add(&format_facedots, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT); - nor_flag_id = GPU_vertformat_attr_add(&format_facedots, "norAndFlag", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT); - } - *r_pos_id = pos_id; - *r_nor_flag_id = nor_flag_id; - return &format_facedots; -} - -static void mesh_create_edit_tris_and_verts( - MeshRenderData *rdata, - GPUVertBuf *vbo_data, GPUVertBuf *vbo_pos_nor, GPUVertBuf *vbo_lnor, GPUIndexBuf *ibo_verts) -{ - BMesh *bm = rdata->edit_bmesh->bm; - BMIter iter; - BMVert *ev; - const int tri_len = mesh_render_data_looptri_len_get_maybe_mapped(rdata); - int tri_len_used = 0; - int points_len = bm->totvert; - int verts_tri_len = tri_len * 3; - struct { uint pos, vnor, lnor, data; } attr_id; - GPUVertFormat *pos_nor_format = edit_mesh_pos_nor_format(&attr_id.pos, &attr_id.vnor); - GPUVertFormat *data_format = edit_mesh_data_format(&attr_id.data); - GPUVertFormat *lnor_format = edit_mesh_lnor_format(&attr_id.lnor); - - /* Positions & Vert Normals */ - if (DRW_TEST_ASSIGN_VBO(vbo_pos_nor)) { - GPU_vertbuf_init_with_format(vbo_pos_nor, pos_nor_format); - GPU_vertbuf_data_alloc(vbo_pos_nor, verts_tri_len); - } - /* Overlay data */ - if (DRW_TEST_ASSIGN_VBO(vbo_data)) { - GPU_vertbuf_init_with_format(vbo_data, data_format); - GPU_vertbuf_data_alloc(vbo_data, verts_tri_len); - } - /* Loop Normals */ - if (DRW_TEST_ASSIGN_VBO(vbo_lnor)) { - GPU_vertbuf_init_with_format(vbo_lnor, lnor_format); - GPU_vertbuf_data_alloc(vbo_lnor, verts_tri_len); - } - /* Verts IBO */ - GPUIndexBufBuilder elb, *elbp = NULL; - if (DRW_TEST_ASSIGN_IBO(ibo_verts)) { - elbp = &elb; - GPU_indexbuf_init(elbp, GPU_PRIM_POINTS, points_len, verts_tri_len); - /* Clear tag */ - BM_ITER_MESH(ev, &iter, bm, BM_VERTS_OF_MESH) { - BM_elem_flag_disable(ev, BM_ELEM_TAG); - } - } - - if (rdata->mapped.use == false) { - for (int i = 0; i < tri_len; i++) { - const BMLoop **bm_looptri = (const BMLoop **)rdata->edit_bmesh->looptris[i]; - if (!BM_elem_flag_test(bm_looptri[0]->f, BM_ELEM_HIDDEN)) { - add_edit_tri(rdata, vbo_pos_nor, vbo_lnor, vbo_data, elbp, - attr_id.pos, attr_id.vnor, attr_id.lnor, attr_id.data, - bm_looptri, tri_len_used); - tri_len_used += 3; - } - } - } - else { - Mesh *me_cage = rdata->mapped.me_cage; - - /* TODO(fclem): Maybe move data generation to mesh_render_data_create() */ - const MLoopTri *mlooptri = BKE_mesh_runtime_looptri_ensure(me_cage); - if (vbo_lnor && !CustomData_has_layer(&me_cage->pdata, CD_NORMAL)) { - BKE_mesh_ensure_normals_for_display(me_cage); - } - const float (*polynors)[3] = CustomData_get_layer(&me_cage->pdata, CD_NORMAL); - const float (*loopnors)[3] = CustomData_get_layer(&me_cage->ldata, CD_NORMAL); - - for (int i = 0; i < tri_len; i++) { - const MLoopTri *mlt = &mlooptri[i]; - const int p_orig = rdata->mapped.p_origindex[mlt->poly]; - if (p_orig != ORIGINDEX_NONE) { - BMFace *efa = BM_face_at_index(bm, p_orig); - if (add_edit_tri_mapped(rdata, vbo_pos_nor, vbo_lnor, vbo_data, elbp, - attr_id.pos, attr_id.vnor, attr_id.lnor, attr_id.data, - efa, mlt, polynors, loopnors, tri_len_used)) - { - tri_len_used += 3; - } - } - } - } - - /* Resize & Finish */ - if (elbp != NULL) { - GPU_indexbuf_build_in_place(elbp, ibo_verts); - } - if (tri_len_used != verts_tri_len) { - if (vbo_pos_nor != NULL) { - GPU_vertbuf_data_resize(vbo_pos_nor, tri_len_used); - } - if (vbo_lnor != NULL) { - GPU_vertbuf_data_resize(vbo_lnor, tri_len_used); - } - if (vbo_data != NULL) { - GPU_vertbuf_data_resize(vbo_data, tri_len_used); - } - } -} - -static void mesh_create_edit_loose_edges( - MeshRenderData *rdata, - GPUVertBuf *vbo_data_ledges, GPUVertBuf *vbo_pos_nor_ledges) -{ - BMesh *bm = rdata->edit_bmesh->bm; - const int loose_edge_len = mesh_render_data_loose_edges_len_get_maybe_mapped(rdata); - const int verts_ledges_len = loose_edge_len * 2; - int ledges_len_used = 0; - - struct { uint pos, vnor, data; } attr_id; - GPUVertFormat *pos_nor_format = edit_mesh_pos_nor_format(&attr_id.pos, &attr_id.vnor); - GPUVertFormat *data_format = edit_mesh_data_format(&attr_id.data); - - /* Positions & Vert Normals */ - if (DRW_TEST_ASSIGN_VBO(vbo_pos_nor_ledges)) { - GPU_vertbuf_init_with_format(vbo_pos_nor_ledges, pos_nor_format); - GPU_vertbuf_data_alloc(vbo_pos_nor_ledges, verts_ledges_len); - } - /* Overlay data */ - if (DRW_TEST_ASSIGN_VBO(vbo_data_ledges)) { - GPU_vertbuf_init_with_format(vbo_data_ledges, data_format); - GPU_vertbuf_data_alloc(vbo_data_ledges, verts_ledges_len); - } - - if (rdata->mapped.use == false) { - for (uint i = 0; i < loose_edge_len; i++) { - const BMEdge *eed = BM_edge_at_index(bm, rdata->loose_edges[i]); - add_edit_loose_edge(rdata, vbo_pos_nor_ledges, vbo_data_ledges, - attr_id.pos, attr_id.vnor, attr_id.data, - eed, ledges_len_used); - ledges_len_used += 2; - } - } - else { - Mesh *me_cage = rdata->mapped.me_cage; - const MVert *mvert = me_cage->mvert; - const MEdge *medge = me_cage->medge; - const int *e_origindex = rdata->mapped.e_origindex; - - for (uint i_iter = 0; i_iter < loose_edge_len; i_iter++) { - const int i = rdata->mapped.loose_edges[i_iter]; - const int e_orig = e_origindex[i]; - BMEdge *eed = BM_edge_at_index(bm, e_orig); - add_edit_loose_edge_mapped(rdata, vbo_pos_nor_ledges, vbo_data_ledges, - attr_id.pos, attr_id.vnor, attr_id.data, - eed, mvert, &medge[i], ledges_len_used); - ledges_len_used += 2; - } - } - BLI_assert(ledges_len_used == verts_ledges_len); -} - -static void mesh_create_edit_loose_verts( - MeshRenderData *rdata, - GPUVertBuf *vbo_data_lverts, GPUVertBuf *vbo_pos_nor_lverts) -{ - BMesh *bm = rdata->edit_bmesh->bm; - const int loose_verts_len = mesh_render_data_loose_verts_len_get_maybe_mapped(rdata); - const int verts_lverts_len = loose_verts_len; - int lverts_len_used = 0; - - struct { uint pos, vnor, data; } attr_id; - GPUVertFormat *pos_nor_format = edit_mesh_pos_nor_format(&attr_id.pos, &attr_id.vnor); - GPUVertFormat *data_format = edit_mesh_data_format(&attr_id.data); - - /* Positions & Vert Normals */ - if (DRW_TEST_ASSIGN_VBO(vbo_pos_nor_lverts)) { - GPU_vertbuf_init_with_format(vbo_pos_nor_lverts, pos_nor_format); - GPU_vertbuf_data_alloc(vbo_pos_nor_lverts, verts_lverts_len); - } - /* Overlay data */ - if (DRW_TEST_ASSIGN_VBO(vbo_data_lverts)) { - GPU_vertbuf_init_with_format(vbo_data_lverts, data_format); - GPU_vertbuf_data_alloc(vbo_data_lverts, verts_lverts_len); - } - - if (rdata->mapped.use == false) { - for (uint i = 0; i < loose_verts_len; i++) { - BMVert *eve = BM_vert_at_index(bm, rdata->loose_verts[i]); - add_edit_loose_vert(rdata, vbo_pos_nor_lverts, vbo_data_lverts, - attr_id.pos, attr_id.vnor, attr_id.data, - eve, lverts_len_used); - lverts_len_used += 1; - } - } - else { - Mesh *me_cage = rdata->mapped.me_cage; - const MVert *mvert = me_cage->mvert; - const int *v_origindex = rdata->mapped.v_origindex; - - for (uint i_iter = 0; i_iter < loose_verts_len; i_iter++) { - const int i = rdata->mapped.loose_verts[i_iter]; - const int v_orig = v_origindex[i]; - BMVert *eve = BM_vert_at_index(bm, v_orig); - add_edit_loose_vert_mapped(rdata, vbo_pos_nor_lverts, vbo_data_lverts, - attr_id.pos, attr_id.vnor, attr_id.data, - eve, &mvert[i], lverts_len_used); - lverts_len_used += 1; - } - } - BLI_assert(lverts_len_used == verts_lverts_len); -} - static void mesh_create_edit_facedots( MeshRenderData *rdata, - GPUVertBuf *vbo_pos_nor_data_facedots) + GPUVertBuf *vbo_facedots_pos_nor_data) { const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata); const int verts_facedot_len = poly_len; int facedot_len_used = 0; - struct { uint fdot_pos, fdot_nor_flag; } attr_id; - GPUVertFormat *facedot_format = edit_mesh_facedot_format(&attr_id.fdot_pos, &attr_id.fdot_nor_flag); + static struct { uint fdot_pos, fdot_nor_flag; } attr_id; + static GPUVertFormat facedot_format = { 0 }; + if (facedot_format.attr_len == 0) { + attr_id.fdot_pos = GPU_vertformat_attr_add(&facedot_format, "pos", GPU_COMP_F32, 3, GPU_FETCH_FLOAT); + attr_id.fdot_nor_flag = GPU_vertformat_attr_add(&facedot_format, "norAndFlag", GPU_COMP_I10, 4, GPU_FETCH_INT_TO_FLOAT_UNIT); + } - if (DRW_TEST_ASSIGN_VBO(vbo_pos_nor_data_facedots)) { - GPU_vertbuf_init_with_format(vbo_pos_nor_data_facedots, facedot_format); - GPU_vertbuf_data_alloc(vbo_pos_nor_data_facedots, verts_facedot_len); + if (DRW_TEST_ASSIGN_VBO(vbo_facedots_pos_nor_data)) { + GPU_vertbuf_init_with_format(vbo_facedots_pos_nor_data, &facedot_format); + GPU_vertbuf_data_alloc(vbo_facedots_pos_nor_data, verts_facedot_len); /* TODO(fclem): Maybe move data generation to mesh_render_data_create() */ if (rdata->edit_bmesh) { if (rdata->edit_data && rdata->edit_data->vertexCos != NULL) { @@ -3543,7 +3212,7 @@ static void mesh_create_edit_facedots( if (rdata->mapped.use == false) { for (int i = 0; i < poly_len; i++) { - if (add_edit_facedot(rdata, vbo_pos_nor_data_facedots, + if (add_edit_facedot(rdata, vbo_facedots_pos_nor_data, attr_id.fdot_pos, attr_id.fdot_nor_flag, i, facedot_len_used)) { @@ -3560,7 +3229,7 @@ static void mesh_create_edit_facedots( const int *v_origindex = rdata->mapped.v_origindex; #endif for (int i = 0; i < poly_len; i++) { - if (add_edit_facedot_mapped(rdata, vbo_pos_nor_data_facedots, + if (add_edit_facedot_mapped(rdata, vbo_facedots_pos_nor_data, attr_id.fdot_pos, attr_id.fdot_nor_flag, i, facedot_len_used)) { @@ -3571,8 +3240,8 @@ static void mesh_create_edit_facedots( /* Resize & Finish */ if (facedot_len_used != verts_facedot_len) { - if (vbo_pos_nor_data_facedots != NULL) { - GPU_vertbuf_data_resize(vbo_pos_nor_data_facedots, facedot_len_used); + if (vbo_facedots_pos_nor_data != NULL) { + GPU_vertbuf_data_resize(vbo_facedots_pos_nor_data, facedot_len_used); } } } @@ -4446,54 +4115,6 @@ GPUBatch *DRW_mesh_batch_cache_get_wireframes_face(Mesh *me) return DRW_batch_request(&cache->batch.wire_triangles); } -GPUBatch *DRW_mesh_batch_cache_get_edit_triangles(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_triangles); -} - -GPUBatch *DRW_mesh_batch_cache_get_edit_vertices(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_vertices); -} - -GPUBatch *DRW_mesh_batch_cache_get_edit_loose_edges(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_loose_edges); -} - -GPUBatch *DRW_mesh_batch_cache_get_edit_loose_verts(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_loose_verts); -} - -GPUBatch *DRW_mesh_batch_cache_get_edit_triangles_nor(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_triangles_nor); -} - -GPUBatch *DRW_mesh_batch_cache_get_edit_triangles_lnor(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_triangles_lnor); -} - -GPUBatch *DRW_mesh_batch_cache_get_edit_loose_edges_nor(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_loose_edges_nor); -} - -GPUBatch *DRW_mesh_batch_cache_get_edit_facedots(Mesh *me) -{ - MeshBatchCache *cache = mesh_batch_cache_get(me); - return DRW_batch_request(&cache->batch.edit_facedots); -} - GPUBatch **DRW_mesh_batch_cache_get_surface_shaded( Mesh *me, struct GPUMaterial **gpumat_array, uint gpumat_array_len, char **auto_layer_names, int **auto_layer_is_srgb, int *auto_layer_count) @@ -4556,6 +4177,42 @@ GPUBatch *DRW_mesh_batch_cache_get_surface_vertpaint(Mesh *me) /** \} */ /* ---------------------------------------------------------------------- */ +/** \name Edit Mode API + * \{ */ + +GPUBatch *DRW_mesh_batch_cache_get_edit_triangles(Mesh *me) +{ + MeshBatchCache *cache = mesh_batch_cache_get(me); + return DRW_batch_request(&cache->batch.edit_triangles); +} + +GPUBatch *DRW_mesh_batch_cache_get_edit_edges(Mesh *me) +{ + MeshBatchCache *cache = mesh_batch_cache_get(me); + return DRW_batch_request(&cache->batch.edit_edges); +} + +GPUBatch *DRW_mesh_batch_cache_get_edit_vertices(Mesh *me) +{ + MeshBatchCache *cache = mesh_batch_cache_get(me); + return DRW_batch_request(&cache->batch.edit_vertices); +} + +GPUBatch *DRW_mesh_batch_cache_get_edit_lnors(Mesh *me) +{ + MeshBatchCache *cache = mesh_batch_cache_get(me); + return DRW_batch_request(&cache->batch.edit_lnor); +} + +GPUBatch *DRW_mesh_batch_cache_get_edit_facedots(Mesh *me) +{ + MeshBatchCache *cache = mesh_batch_cache_get(me); + return DRW_batch_request(&cache->batch.edit_facedots); +} + +/** \} */ + +/* ---------------------------------------------------------------------- */ /** \name Edit Mode selection API * \{ */ @@ -4712,53 +4369,26 @@ BLI_INLINE float edit_uv_get_loop_stretch_angle( } #endif -#define VERTEX_SELECT (1 << 0) -#define VERTEX_PINNED (1 << 1) -#define FACE_SELECT (1 << 2) -#define FACE_ACTIVE (1 << 3) -#define EDGE_SELECT (1 << 4) - -BLI_INLINE uchar edit_uv_get_face_flag(BMFace *efa, BMFace *efa_act, const int cd_loop_uv_offset, Scene *scene) -{ - uchar flag = 0; - flag |= uvedit_face_select_test(scene, efa, cd_loop_uv_offset) ? FACE_SELECT : 0; - flag |= (efa == efa_act) ? FACE_ACTIVE : 0; - return flag; -} - -BLI_INLINE uchar edit_uv_get_loop_flag(BMLoop *l, const int cd_loop_uv_offset, Scene *scene) -{ - MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset); - uchar flag = 0; - flag |= uvedit_uv_select_test(scene, l, cd_loop_uv_offset) ? VERTEX_SELECT : 0; - flag |= uvedit_edge_select_test(scene, l, cd_loop_uv_offset) ? EDGE_SELECT : 0; - flag |= (luv->flag & MLOOPUV_PINNED) ? VERTEX_PINNED : 0; - return flag; -} - static struct EditUVFormatIndex { - uint uvs, area, angle, uv_adj, flag, fdots_uvs, fdots_flag; + uint area, angle, uv_adj, flag, fdots_uvs, fdots_flag; } uv_attr_id = {0}; static void uvedit_fill_buffer_data( - Mesh *me, const ToolSettings *ts, - GPUVertBuf *vbo_pos, GPUVertBuf *vbo_data, GPUVertBuf *vbo_area, GPUVertBuf *vbo_angle, + MeshRenderData *rdata, + GPUVertBuf *vbo_area, GPUVertBuf *vbo_angle, GPUVertBuf *vbo_fdots_pos, GPUVertBuf *vbo_fdots_data, - GPUIndexBufBuilder *elb) + GPUIndexBufBuilder *elb_vert, + GPUIndexBufBuilder *elb_edge, + GPUIndexBufBuilder *elb_face) { - BMEditMesh *embm = me->edit_btmesh; - BMesh *bm = embm->bm; + BMesh *bm = rdata->edit_bmesh->bm; BMIter iter, liter; BMFace *efa; - BMLoop *l; - MLoopUV *luv; - uint vidx, fidx, i; + uint vidx, fidx, fdot_idx, i; + const int poly_len = mesh_render_data_polys_len_get_maybe_mapped(rdata); float (*faces_areas)[2] = NULL; float totarea = 0.0f, totuvarea = 0.0f; const int cd_loop_uv_offset = CustomData_get_offset(&bm->ldata, CD_MLOOPUV); - BMFace *efa_act = EDBM_uv_active_face_get(embm, false, false); /* will be set to NULL if hidden */ - /* Hack to avoid passing the scene here. */ - Scene scene = { .toolsettings = (ToolSettings *)ts }; BLI_buffer_declare_static(vec3f, vec3_buf, BLI_BUFFER_NOP, BM_DEFAULT_NGON_STACK_SIZE); BLI_buffer_declare_static(vec2f, vec2_buf, BLI_BUFFER_NOP, BM_DEFAULT_NGON_STACK_SIZE); @@ -4771,7 +4401,7 @@ static void uvedit_fill_buffer_data( fidx = 0; BM_ITER_MESH(efa, &iter, bm, BM_FACES_OF_MESH) { /* Tag hidden faces */ - BM_elem_flag_set(efa, BM_ELEM_TAG, uvedit_face_visible_nolocal(&scene, efa)); + BM_elem_flag_set(efa, BM_ELEM_TAG, uvedit_face_visible_nolocal_ex(rdata->toolsettings, efa)); if (vbo_area && BM_elem_flag_test(efa, BM_ELEM_TAG)) { edit_uv_preprocess_stretch_area(efa, cd_loop_uv_offset, fidx++, @@ -4781,72 +4411,124 @@ static void uvedit_fill_buffer_data( vidx = 0; fidx = 0; - BM_ITER_MESH(efa, &iter, bm, BM_FACES_OF_MESH) { - const int efa_len = efa->len; - float fdot[2] = {0.0f, 0.0f}; - float (*av)[3], (*auv)[2]; - ushort area_stretch; - /* Skip hidden faces. */ - if (!BM_elem_flag_test(efa, BM_ELEM_TAG)) { - continue; - } - - uchar face_flag = edit_uv_get_face_flag(efa, efa_act, cd_loop_uv_offset, &scene); - /* Face preprocess */ - if (vbo_area) { - area_stretch = edit_uv_get_stretch_area(faces_areas[fidx][0] / totarea, - faces_areas[fidx][1] / totuvarea) * 65534.0f; - } - if (vbo_angle) { - av = (float (*)[3])BLI_buffer_reinit_data(&vec3_buf, vec3f, efa_len); - auv = (float (*)[2])BLI_buffer_reinit_data(&vec2_buf, vec2f, efa_len); - edit_uv_preprocess_stretch_angle(auv, av, cd_loop_uv_offset, efa); - } - - BM_ITER_ELEM_INDEX(l, &liter, efa, BM_LOOPS_OF_FACE, i) { - luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset); + fdot_idx = 0; + if (rdata->mapped.use == false && rdata->edit_bmesh) { + BMLoop *l; + BM_ITER_MESH(efa, &iter, bm, BM_FACES_OF_MESH) { + const bool face_visible = BM_elem_flag_test(efa, BM_ELEM_TAG); + const int efa_len = efa->len; + float fdot[2] = {0.0f, 0.0f}; + float (*av)[3], (*auv)[2]; + ushort area_stretch; + + /* Face preprocess */ if (vbo_area) { - GPU_vertbuf_attr_set(vbo_area, uv_attr_id.area, vidx, &area_stretch); + area_stretch = edit_uv_get_stretch_area(faces_areas[fidx][0] / totarea, + faces_areas[fidx][1] / totuvarea) * 65534.0f; } if (vbo_angle) { - int i_next = (i + 1) % efa_len; - short suv[4]; - /* Send uvs to the shader and let it compute the aspect corrected angle. */ - normal_float_to_short_v2(&suv[0], auv[i]); - normal_float_to_short_v2(&suv[2], auv[i_next]); - GPU_vertbuf_attr_set(vbo_angle, uv_attr_id.uv_adj, vidx, suv); - /* Compute 3D angle here */ - short angle = 32767.0f * angle_normalized_v3v3(av[i], av[i_next]) / (float)M_PI; - GPU_vertbuf_attr_set(vbo_angle, uv_attr_id.angle, vidx, &angle); - } - if (vbo_pos) { - GPU_vertbuf_attr_set(vbo_pos, uv_attr_id.uvs, vidx, luv->uv); + av = (float (*)[3])BLI_buffer_reinit_data(&vec3_buf, vec3f, efa_len); + auv = (float (*)[2])BLI_buffer_reinit_data(&vec2_buf, vec2f, efa_len); + edit_uv_preprocess_stretch_angle(auv, av, cd_loop_uv_offset, efa); } - if (vbo_data) { - uchar flag = face_flag | edit_uv_get_loop_flag(l, cd_loop_uv_offset, &scene); - GPU_vertbuf_attr_set(vbo_data, uv_attr_id.flag, vidx, &flag); + + /* Skip hidden faces. */ + if (elb_face && face_visible) { + for (i = 0; i < efa->len; ++i) { + GPU_indexbuf_add_generic_vert(elb_face, vidx + i); + GPU_indexbuf_add_generic_vert(elb_vert, vidx + i); + GPU_indexbuf_add_line_verts(elb_edge, vidx + i, vidx + (i + 1) % efa->len); + } + } + + BM_ITER_ELEM_INDEX(l, &liter, efa, BM_LOOPS_OF_FACE, i) { + MLoopUV *luv = BM_ELEM_CD_GET_VOID_P(l, cd_loop_uv_offset); + if (vbo_area) { + GPU_vertbuf_attr_set(vbo_area, uv_attr_id.area, vidx, &area_stretch); + } + if (vbo_angle) { + int i_next = (i + 1) % efa_len; + short suv[4]; + /* Send uvs to the shader and let it compute the aspect corrected angle. */ + normal_float_to_short_v2(&suv[0], auv[i]); + normal_float_to_short_v2(&suv[2], auv[i_next]); + GPU_vertbuf_attr_set(vbo_angle, uv_attr_id.uv_adj, vidx, suv); + /* Compute 3D angle here */ + short angle = 32767.0f * angle_normalized_v3v3(av[i], av[i_next]) / (float)M_PI; + GPU_vertbuf_attr_set(vbo_angle, uv_attr_id.angle, vidx, &angle); + } + if (vbo_fdots_pos) { + add_v2_v2(fdot, luv->uv); + } + vidx++; } - if (elb) { - GPU_indexbuf_add_generic_vert(elb, vidx); + + if (elb_face && face_visible) { + GPU_indexbuf_add_generic_vert(elb_face, vidx - efa->len); + GPU_indexbuf_add_primitive_restart(elb_face); + } + if (vbo_fdots_pos && face_visible) { + mul_v2_fl(fdot, 1.0f / (float)efa->len); + GPU_vertbuf_attr_set(vbo_fdots_pos, uv_attr_id.fdots_uvs, fdot_idx, fdot); } - if (vbo_fdots_pos) { - add_v2_v2(fdot, luv->uv); + if (vbo_fdots_data && face_visible) { + uchar face_flag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset); + GPU_vertbuf_attr_set(vbo_fdots_data, uv_attr_id.fdots_flag, fdot_idx, &face_flag); } - vidx++; + fdot_idx += face_visible ? 1 : 0; + fidx++; } + } + else { + const MPoly *mpoly = rdata->mapped.me_cage->mpoly; + // const MEdge *medge = rdata->mapped.me_cage->medge; + // const MVert *mvert = rdata->mapped.me_cage->mvert; + const MLoop *mloop = rdata->mapped.me_cage->mloop; - if (elb) { - GPU_indexbuf_add_generic_vert(elb, vidx - efa->len); - GPU_indexbuf_add_primitive_restart(elb); - } - if (vbo_fdots_pos) { - mul_v2_fl(fdot, 1.0f / (float)efa->len); - GPU_vertbuf_attr_set(vbo_fdots_pos, uv_attr_id.fdots_uvs, fidx, fdot); - } - if (vbo_fdots_data) { - GPU_vertbuf_attr_set(vbo_fdots_data, uv_attr_id.fdots_flag, fidx, &face_flag); + const int *v_origindex = rdata->mapped.v_origindex; + const int *e_origindex = rdata->mapped.e_origindex; + const int *p_origindex = rdata->mapped.p_origindex; + + /* Face Loops */ + for (int poly = 0; poly < poly_len; poly++, mpoly++) { + float fdot[2] = {0.0f, 0.0f}; + const MLoop *l = &mloop[mpoly->loopstart]; + int fidx_ori = p_origindex[poly]; + efa = (fidx_ori != ORIGINDEX_NONE) ? BM_face_at_index(bm, fidx_ori) : NULL; + const bool face_visible = efa != NULL && BM_elem_flag_test(efa, BM_ELEM_TAG); + if (efa && vbo_fdots_data) { + uchar face_flag = mesh_render_data_face_flag(rdata, efa, cd_loop_uv_offset); + GPU_vertbuf_attr_set(vbo_fdots_data, uv_attr_id.fdots_flag, fdot_idx, &face_flag); + } + /* Skip hidden faces. */ + if (elb_face && face_visible) { + for (i = 0; i < mpoly->totloop; ++i) { + GPU_indexbuf_add_generic_vert(elb_face, vidx + i); + if (e_origindex[l[i].e] != ORIGINDEX_NONE) { + GPU_indexbuf_add_line_verts(elb_edge, vidx + i, vidx + (i + 1) % mpoly->totloop); + } + if (v_origindex[l[i].v] != ORIGINDEX_NONE) { + GPU_indexbuf_add_generic_vert(elb_vert, vidx + i); + } + } + GPU_indexbuf_add_generic_vert(elb_face, vidx); + GPU_indexbuf_add_primitive_restart(elb_face); + } + for (i = 0; i < mpoly->totloop; i++, l++) { + /* TODO support stretch. */ + if (vbo_fdots_pos) { + MLoopUV *luv = &rdata->mloopuv[mpoly->loopstart + i]; + add_v2_v2(fdot, luv->uv); + } + vidx++; + } + if (vbo_fdots_pos && face_visible) { + mul_v2_fl(fdot, 1.0f / mpoly->totloop); + GPU_vertbuf_attr_set(vbo_fdots_pos, uv_attr_id.fdots_uvs, fdot_idx, fdot); + } + fidx++; + fdot_idx += face_visible ? 1 : 0; } - fidx++; } if (faces_areas) { @@ -4856,76 +4538,48 @@ static void uvedit_fill_buffer_data( BLI_buffer_free(&vec3_buf); BLI_buffer_free(&vec2_buf); - if (vidx < bm->totloop) { - if (vbo_area) { - GPU_vertbuf_data_resize(vbo_area, vidx); - } - if (vbo_angle) { - GPU_vertbuf_data_resize(vbo_angle, vidx); - } - if (vbo_pos) { - GPU_vertbuf_data_resize(vbo_pos, vidx); - } - if (vbo_data) { - GPU_vertbuf_data_resize(vbo_data, vidx); - } - } - if (fidx < bm->totface) { + if (fdot_idx < poly_len) { if (vbo_fdots_pos) { - GPU_vertbuf_data_resize(vbo_fdots_pos, fidx); + GPU_vertbuf_data_resize(vbo_fdots_pos, fdot_idx); } if (vbo_fdots_data) { - GPU_vertbuf_data_resize(vbo_fdots_data, fidx); + GPU_vertbuf_data_resize(vbo_fdots_data, fdot_idx); } } } static void mesh_create_uvedit_buffers( - Mesh *me, const ToolSettings *ts, - GPUVertBuf *vbo_pos, GPUVertBuf *vbo_data, GPUVertBuf *vbo_area, GPUVertBuf *vbo_angle, - GPUVertBuf *vbo_fdots_pos, GPUVertBuf *vbo_fdots_data, GPUIndexBuf *ibo_face) + MeshRenderData *rdata, + GPUVertBuf *vbo_area, GPUVertBuf *vbo_angle, + GPUVertBuf *vbo_fdots_pos, GPUVertBuf *vbo_fdots_data, + GPUIndexBuf *ibo_vert, GPUIndexBuf *ibo_edge, GPUIndexBuf *ibo_face) { - BMesh *bm = me->edit_btmesh->bm; - - static GPUVertFormat format_pos = { 0 }; static GPUVertFormat format_area = { 0 }; static GPUVertFormat format_angle = { 0 }; - static GPUVertFormat format_flag = { 0 }; static GPUVertFormat format_fdots_pos = { 0 }; static GPUVertFormat format_fdots_flag = { 0 }; - if (format_pos.attr_len == 0) { + if (format_area.attr_len == 0) { uv_attr_id.area = GPU_vertformat_attr_add(&format_area, "stretch", GPU_COMP_U16, 1, GPU_FETCH_INT_TO_FLOAT_UNIT); uv_attr_id.angle = GPU_vertformat_attr_add(&format_angle, "angle", GPU_COMP_I16, 1, GPU_FETCH_INT_TO_FLOAT_UNIT); uv_attr_id.uv_adj = GPU_vertformat_attr_add(&format_angle, "uv_adj", GPU_COMP_I16, 4, GPU_FETCH_INT_TO_FLOAT_UNIT); - uv_attr_id.flag = GPU_vertformat_attr_add(&format_flag, "flag", GPU_COMP_U8, 1, GPU_FETCH_INT); - uv_attr_id.uvs = GPU_vertformat_attr_add(&format_pos, "u", GPU_COMP_F32, 2, GPU_FETCH_FLOAT); - GPU_vertformat_alias_add(&format_pos, "pos"); uv_attr_id.fdots_flag = GPU_vertformat_attr_add(&format_fdots_flag, "flag", GPU_COMP_U8, 1, GPU_FETCH_INT); uv_attr_id.fdots_uvs = GPU_vertformat_attr_add(&format_fdots_pos, "u", GPU_COMP_F32, 2, GPU_FETCH_FLOAT); GPU_vertformat_alias_add(&format_fdots_pos, "pos"); } - const uint vert_len = bm->totloop; - const uint idx_len = bm->totloop + bm->totface * 2; - const uint face_len = bm->totface; + const int loop_len = mesh_render_data_loops_len_get_maybe_mapped(rdata); + const int face_len = mesh_render_data_polys_len_get_maybe_mapped(rdata); + const int idx_len = loop_len + face_len * 2; - if (DRW_TEST_ASSIGN_VBO(vbo_pos)) { - GPU_vertbuf_init_with_format(vbo_pos, &format_pos); - GPU_vertbuf_data_alloc(vbo_pos, vert_len); - } - if (DRW_TEST_ASSIGN_VBO(vbo_data)) { - GPU_vertbuf_init_with_format(vbo_data, &format_flag); - GPU_vertbuf_data_alloc(vbo_data, vert_len); - } if (DRW_TEST_ASSIGN_VBO(vbo_area)) { GPU_vertbuf_init_with_format(vbo_area, &format_area); - GPU_vertbuf_data_alloc(vbo_area, vert_len); + GPU_vertbuf_data_alloc(vbo_area, loop_len); } if (DRW_TEST_ASSIGN_VBO(vbo_angle)) { GPU_vertbuf_init_with_format(vbo_angle, &format_angle); - GPU_vertbuf_data_alloc(vbo_angle, vert_len); + GPU_vertbuf_data_alloc(vbo_angle, loop_len); } if (DRW_TEST_ASSIGN_VBO(vbo_fdots_pos)) { GPU_vertbuf_init_with_format(vbo_fdots_pos, &format_fdots_pos); @@ -4936,17 +4590,33 @@ static void mesh_create_uvedit_buffers( GPU_vertbuf_data_alloc(vbo_fdots_data, face_len); } - GPUIndexBufBuilder elb; + GPUIndexBufBuilder elb_vert, elb_edge, elb_face; + if (DRW_TEST_ASSIGN_IBO(ibo_vert)) { + GPU_indexbuf_init_ex(&elb_vert, GPU_PRIM_POINTS, loop_len, loop_len, false); + } + if (DRW_TEST_ASSIGN_IBO(ibo_edge)) { + GPU_indexbuf_init_ex(&elb_edge, GPU_PRIM_LINES, loop_len * 2, loop_len, false); + } if (DRW_TEST_ASSIGN_IBO(ibo_face)) { - GPU_indexbuf_init_ex(&elb, GPU_PRIM_LINE_STRIP, idx_len, vert_len, true); + GPU_indexbuf_init_ex(&elb_face, GPU_PRIM_TRI_FAN, idx_len, loop_len, true); + } + + uvedit_fill_buffer_data(rdata, + vbo_area, vbo_angle, vbo_fdots_pos, vbo_fdots_data, + ibo_vert ? &elb_vert : NULL, + ibo_edge ? &elb_edge : NULL, + ibo_face ? &elb_face : NULL); + + if (ibo_vert) { + GPU_indexbuf_build_in_place(&elb_vert, ibo_vert); } - uvedit_fill_buffer_data(me, ts, - vbo_pos, vbo_data, vbo_area, vbo_angle, vbo_fdots_pos, vbo_fdots_data, - ibo_face ? &elb : NULL); + if (ibo_edge) { + GPU_indexbuf_build_in_place(&elb_edge, ibo_edge); + } if (ibo_face) { - GPU_indexbuf_build_in_place(&elb, ibo_face); + GPU_indexbuf_build_in_place(&elb_face, ibo_face); } } @@ -5016,11 +4686,14 @@ void DRW_mesh_batch_cache_create_requested( const bool is_uvsyncsel = (ts->uv_flag & UV_SYNC_SELECTION); if (cache->is_uvsyncsel != is_uvsyncsel) { cache->is_uvsyncsel = is_uvsyncsel; - for (int i = 0; i < sizeof(cache->edituv) / sizeof(void *); ++i) { - GPUVertBuf **vbo = (GPUVertBuf **)&cache->edituv; - GPU_VERTBUF_DISCARD_SAFE(vbo[i]); - } + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv_data); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_angle); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_stretch_area); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.loop_uv); + GPU_VERTBUF_DISCARD_SAFE(cache->edit.facedots_uv); + GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_tri_fans); GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_lines); + GPU_INDEXBUF_DISCARD_SAFE(cache->ibo.edituv_loops_points); /* We only clear the batches as they may already have been referenced. */ GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_faces_strech_area); GPU_BATCH_CLEAR_SAFE(cache->batch.edituv_faces_strech_angle); @@ -5081,93 +4754,82 @@ void DRW_mesh_batch_cache_create_requested( /* Edit Mesh */ if (DRW_batch_requested(cache->batch.edit_triangles, GPU_PRIM_TRIS)) { - DRW_vbo_request(cache->batch.edit_triangles, &cache->edit.pos_nor); - DRW_vbo_request(cache->batch.edit_triangles, &cache->edit.data); + DRW_ibo_request(cache->batch.edit_triangles, &cache->ibo.edit_loops_tris); + DRW_vbo_request(cache->batch.edit_triangles, &cache->edit.loop_pos_nor); + DRW_vbo_request(cache->batch.edit_triangles, &cache->edit.loop_data); } if (DRW_batch_requested(cache->batch.edit_vertices, GPU_PRIM_POINTS)) { - DRW_ibo_request(cache->batch.edit_vertices, &cache->ibo.edit_verts_points); - DRW_vbo_request(cache->batch.edit_vertices, &cache->edit.pos_nor); - DRW_vbo_request(cache->batch.edit_vertices, &cache->edit.data); - } - if (DRW_batch_requested(cache->batch.edit_loose_edges, GPU_PRIM_LINES)) { - DRW_vbo_request(cache->batch.edit_loose_edges, &cache->edit.pos_nor_ledges); - DRW_vbo_request(cache->batch.edit_loose_edges, &cache->edit.data_ledges); + DRW_ibo_request(cache->batch.edit_vertices, &cache->ibo.edit_loops_points); + DRW_vbo_request(cache->batch.edit_vertices, &cache->edit.loop_pos_nor); + DRW_vbo_request(cache->batch.edit_vertices, &cache->edit.loop_data); } - if (DRW_batch_requested(cache->batch.edit_loose_verts, GPU_PRIM_POINTS)) { - DRW_vbo_request(cache->batch.edit_loose_verts, &cache->edit.pos_nor_lverts); - DRW_vbo_request(cache->batch.edit_loose_verts, &cache->edit.data_lverts); + if (DRW_batch_requested(cache->batch.edit_edges, GPU_PRIM_LINES)) { + DRW_ibo_request(cache->batch.edit_edges, &cache->ibo.edit_loops_lines); + DRW_vbo_request(cache->batch.edit_edges, &cache->edit.loop_pos_nor); + DRW_vbo_request(cache->batch.edit_edges, &cache->edit.loop_data); } - if (DRW_batch_requested(cache->batch.edit_triangles_nor, GPU_PRIM_POINTS)) { - DRW_ibo_request(cache->batch.edit_triangles_nor, &cache->ibo.edit_verts_points); - DRW_vbo_request(cache->batch.edit_triangles_nor, &cache->edit.pos_nor); - } - if (DRW_batch_requested(cache->batch.edit_triangles_lnor, GPU_PRIM_POINTS)) { - DRW_vbo_request(cache->batch.edit_triangles_lnor, &cache->edit.pos_nor); - DRW_vbo_request(cache->batch.edit_triangles_lnor, &cache->edit.lnor); - } - if (DRW_batch_requested(cache->batch.edit_loose_edges_nor, GPU_PRIM_POINTS)) { - DRW_vbo_request(cache->batch.edit_loose_edges_nor, &cache->edit.pos_nor_ledges); - DRW_vbo_request(cache->batch.edit_loose_edges_nor, &cache->edit.data_ledges); + if (DRW_batch_requested(cache->batch.edit_lnor, GPU_PRIM_POINTS)) { + /* TODO use a range of loops line, before drawing the loose edges. */ + DRW_ibo_request(cache->batch.edit_lnor, &cache->ibo.edit_loops_lines); + DRW_vbo_request(cache->batch.edit_lnor, &cache->edit.loop_pos_nor); + DRW_vbo_request(cache->batch.edit_lnor, &cache->edit.loop_lnor); } if (DRW_batch_requested(cache->batch.edit_facedots, GPU_PRIM_POINTS)) { - DRW_vbo_request(cache->batch.edit_facedots, &cache->edit.pos_nor_data_facedots); - } - if (DRW_batch_requested(cache->batch.edit_triangles_nor, GPU_PRIM_POINTS)) { - DRW_ibo_request(cache->batch.edit_triangles_nor, &cache->ibo.edit_verts_points); - DRW_vbo_request(cache->batch.edit_triangles_nor, &cache->edit.pos_nor); + DRW_vbo_request(cache->batch.edit_facedots, &cache->edit.facedots_pos_nor_data); } /* Edit UV */ if (DRW_batch_requested(cache->batch.edituv_faces, GPU_PRIM_TRI_FAN)) { - DRW_ibo_request(cache->batch.edituv_faces, &cache->ibo.edituv_loops_lines); /* reuse linestrip as fan */ - DRW_vbo_request(cache->batch.edituv_faces, &cache->edituv.loop_uv); - DRW_vbo_request(cache->batch.edituv_faces, &cache->edituv.loop_data); + DRW_ibo_request(cache->batch.edituv_faces, &cache->ibo.edituv_loops_tri_fans); + DRW_vbo_request(cache->batch.edituv_faces, &cache->edit.loop_uv); + DRW_vbo_request(cache->batch.edituv_faces, &cache->edit.loop_uv_data); } if (DRW_batch_requested(cache->batch.edituv_faces_strech_area, GPU_PRIM_TRI_FAN)) { - DRW_ibo_request(cache->batch.edituv_faces_strech_area, &cache->ibo.edituv_loops_lines); /* reuse linestrip as fan */ - DRW_vbo_request(cache->batch.edituv_faces_strech_area, &cache->edituv.loop_uv); - DRW_vbo_request(cache->batch.edituv_faces_strech_area, &cache->edituv.loop_data); - DRW_vbo_request(cache->batch.edituv_faces_strech_area, &cache->edituv.loop_stretch_area); + DRW_ibo_request(cache->batch.edituv_faces_strech_area, &cache->ibo.edituv_loops_tri_fans); + DRW_vbo_request(cache->batch.edituv_faces_strech_area, &cache->edit.loop_uv); + DRW_vbo_request(cache->batch.edituv_faces_strech_area, &cache->edit.loop_uv_data); + DRW_vbo_request(cache->batch.edituv_faces_strech_area, &cache->edit.loop_stretch_area); } if (DRW_batch_requested(cache->batch.edituv_faces_strech_angle, GPU_PRIM_TRI_FAN)) { - DRW_ibo_request(cache->batch.edituv_faces_strech_angle, &cache->ibo.edituv_loops_lines); /* reuse linestrip as fan */ - DRW_vbo_request(cache->batch.edituv_faces_strech_angle, &cache->edituv.loop_uv); - DRW_vbo_request(cache->batch.edituv_faces_strech_angle, &cache->edituv.loop_data); - DRW_vbo_request(cache->batch.edituv_faces_strech_angle, &cache->edituv.loop_stretch_angle); + DRW_ibo_request(cache->batch.edituv_faces_strech_angle, &cache->ibo.edituv_loops_tri_fans); + DRW_vbo_request(cache->batch.edituv_faces_strech_angle, &cache->edit.loop_uv); + DRW_vbo_request(cache->batch.edituv_faces_strech_angle, &cache->edit.loop_uv_data); + DRW_vbo_request(cache->batch.edituv_faces_strech_angle, &cache->edit.loop_stretch_angle); } - if (DRW_batch_requested(cache->batch.edituv_edges, GPU_PRIM_LINE_STRIP)) { + if (DRW_batch_requested(cache->batch.edituv_edges, GPU_PRIM_LINES)) { DRW_ibo_request(cache->batch.edituv_edges, &cache->ibo.edituv_loops_lines); - DRW_vbo_request(cache->batch.edituv_edges, &cache->edituv.loop_uv); - DRW_vbo_request(cache->batch.edituv_edges, &cache->edituv.loop_data); + DRW_vbo_request(cache->batch.edituv_edges, &cache->edit.loop_uv); + DRW_vbo_request(cache->batch.edituv_edges, &cache->edit.loop_uv_data); } if (DRW_batch_requested(cache->batch.edituv_verts, GPU_PRIM_POINTS)) { - DRW_vbo_request(cache->batch.edituv_verts, &cache->edituv.loop_uv); - DRW_vbo_request(cache->batch.edituv_verts, &cache->edituv.loop_data); + DRW_ibo_request(cache->batch.edituv_verts, &cache->ibo.edituv_loops_points); + DRW_vbo_request(cache->batch.edituv_verts, &cache->edit.loop_uv); + DRW_vbo_request(cache->batch.edituv_verts, &cache->edit.loop_uv_data); } if (DRW_batch_requested(cache->batch.edituv_facedots, GPU_PRIM_POINTS)) { - DRW_vbo_request(cache->batch.edituv_facedots, &cache->edituv.facedots_uv); - DRW_vbo_request(cache->batch.edituv_facedots, &cache->edituv.facedots_data); + DRW_vbo_request(cache->batch.edituv_facedots, &cache->edit.facedots_uv); + DRW_vbo_request(cache->batch.edituv_facedots, &cache->edit.facedots_uv_data); } /* Selection */ /* TODO reuse ordered.loop_pos_nor if possible. */ if (DRW_batch_requested(cache->batch.edit_selection_verts, GPU_PRIM_POINTS)) { DRW_ibo_request(cache->batch.edit_selection_verts, &cache->ibo.edit_loops_points); - DRW_vbo_request(cache->batch.edit_selection_verts, &cache->edit.loop_pos); + DRW_vbo_request(cache->batch.edit_selection_verts, &cache->edit.loop_pos_nor); DRW_vbo_request(cache->batch.edit_selection_verts, &cache->edit.loop_vert_idx); } if (DRW_batch_requested(cache->batch.edit_selection_edges, GPU_PRIM_LINES)) { DRW_ibo_request(cache->batch.edit_selection_edges, &cache->ibo.edit_loops_lines); - DRW_vbo_request(cache->batch.edit_selection_edges, &cache->edit.loop_pos); + DRW_vbo_request(cache->batch.edit_selection_edges, &cache->edit.loop_pos_nor); DRW_vbo_request(cache->batch.edit_selection_edges, &cache->edit.loop_edge_idx); } if (DRW_batch_requested(cache->batch.edit_selection_faces, GPU_PRIM_TRIS)) { DRW_ibo_request(cache->batch.edit_selection_faces, &cache->ibo.edit_loops_tris); - DRW_vbo_request(cache->batch.edit_selection_faces, &cache->edit.loop_pos); + DRW_vbo_request(cache->batch.edit_selection_faces, &cache->edit.loop_pos_nor); DRW_vbo_request(cache->batch.edit_selection_faces, &cache->edit.loop_face_idx); } if (DRW_batch_requested(cache->batch.edit_selection_facedots, GPU_PRIM_POINTS)) { - DRW_vbo_request(cache->batch.edit_selection_facedots, &cache->edit.pos_nor_data_facedots); + DRW_vbo_request(cache->batch.edit_selection_facedots, &cache->edit.facedots_pos_nor_data); DRW_vbo_request(cache->batch.edit_selection_facedots, &cache->edit.facedots_idx); } @@ -5215,34 +4877,30 @@ void DRW_mesh_batch_cache_create_requested( DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_flag, cache->surf_per_mat_tris[i], MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_LOOPTRI); } - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.data, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI | MR_DATATYPE_POLY | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.data_ledges, MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.data_lverts, MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.pos_nor, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI | MR_DATATYPE_POLY | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.pos_nor_ledges, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.pos_nor_lverts, MR_DATATYPE_VERT | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.pos_nor_data_facedots, MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.lnor, MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI | MR_DATATYPE_OVERLAY); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_pos, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP); + int combined_edit_flag = MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | + MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_OVERLAY; + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_pos_nor, combined_edit_flag); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_lnor, combined_edit_flag); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_data, combined_edit_flag); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_uv_data, combined_edit_flag); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_uv, combined_edit_flag | MR_DATATYPE_LOOPUV); DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_vert_idx, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP); DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_edge_idx, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP); DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_face_idx, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP); DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.facedots_idx, MR_DATATYPE_POLY); - DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edit_verts_points, MR_DATATYPE_VERT | MR_DATATYPE_POLY | MR_DATATYPE_LOOPTRI); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.facedots_pos_nor_data, MR_DATATYPE_VERT | MR_DATATYPE_LOOP | MR_DATATYPE_POLY | MR_DATATYPE_OVERLAY); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_stretch_angle, combined_edit_flag); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.loop_stretch_area, combined_edit_flag); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.facedots_uv, combined_edit_flag | MR_DATATYPE_LOOPUV); + DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edit.facedots_uv_data, combined_edit_flag); + DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edituv_loops_points, combined_edit_flag); + DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edituv_loops_lines, combined_edit_flag); + DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edituv_loops_tri_fans, combined_edit_flag); /* TODO: Some of the flags here may not be needed. */ DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edit_loops_points, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI); DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edit_loops_lines, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI); DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edit_loops_tris, MR_DATATYPE_VERT | MR_DATATYPE_EDGE | MR_DATATYPE_LOOSE_VERT | MR_DATATYPE_LOOSE_EDGE | MR_DATATYPE_POLY | MR_DATATYPE_LOOP | MR_DATATYPE_LOOPTRI); - /* Thoses read bmesh directly. */ - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edituv.loop_stretch_angle, 0); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edituv.loop_stretch_area, 0); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edituv.loop_uv, 0); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edituv.loop_data, 0); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edituv.facedots_uv, 0); - DRW_ADD_FLAG_FROM_VBO_REQUEST(mr_edit_flag, cache->edituv.facedots_data, 0); - DRW_ADD_FLAG_FROM_IBO_REQUEST(mr_edit_flag, cache->ibo.edituv_loops_lines, 0); - Mesh *me_original = me; MBC_GET_FINAL_MESH(me); @@ -5253,7 +4911,7 @@ void DRW_mesh_batch_cache_create_requested( MeshRenderData *rdata = NULL; if (mr_flag != 0) { - rdata = mesh_render_data_create_ex(me, mr_flag, cache->cd_vused, cache->cd_lused); + rdata = mesh_render_data_create_ex(me, mr_flag, cache->cd_vused, cache->cd_lused, ts); } /* Generate VBOs */ @@ -5305,39 +4963,32 @@ void DRW_mesh_batch_cache_create_requested( if (rdata) { mesh_render_data_free(rdata); } - rdata = mesh_render_data_create(me_original, mr_edit_flag); + rdata = mesh_render_data_create_ex(me_original, mr_edit_flag, NULL, NULL, ts); } if (rdata && rdata->mapped.supported) { rdata->mapped.use = true; } - if (DRW_vbo_requested(cache->edit.data) || - DRW_vbo_requested(cache->edit.pos_nor) || - DRW_vbo_requested(cache->edit.lnor) || - DRW_ibo_requested(cache->ibo.edit_verts_points)) - { - mesh_create_edit_tris_and_verts( - rdata, - cache->edit.data, cache->edit.pos_nor, - cache->edit.lnor, cache->ibo.edit_verts_points); - } - if (DRW_vbo_requested(cache->edit.data_ledges) || DRW_vbo_requested(cache->edit.pos_nor_ledges)) { - mesh_create_edit_loose_edges(rdata, cache->edit.data_ledges, cache->edit.pos_nor_ledges); - } - if (DRW_vbo_requested(cache->edit.data_lverts) || DRW_vbo_requested(cache->edit.pos_nor_lverts)) { - mesh_create_edit_loose_verts(rdata, cache->edit.data_lverts, cache->edit.pos_nor_lverts); - } - if (DRW_vbo_requested(cache->edit.pos_nor_data_facedots)) { - mesh_create_edit_facedots(rdata, cache->edit.pos_nor_data_facedots); - } - if (DRW_vbo_requested(cache->edit.loop_pos) || + if (DRW_vbo_requested(cache->edit.loop_pos_nor) || + DRW_vbo_requested(cache->edit.loop_lnor) || + DRW_vbo_requested(cache->edit.loop_data) || DRW_vbo_requested(cache->edit.loop_vert_idx) || DRW_vbo_requested(cache->edit.loop_edge_idx) || DRW_vbo_requested(cache->edit.loop_face_idx)) { - mesh_create_edit_select_id(rdata, cache->edit.loop_pos, cache->edit.loop_vert_idx, - cache->edit.loop_edge_idx, cache->edit.loop_face_idx); + mesh_create_edit_vertex_loops( + rdata, + cache->edit.loop_pos_nor, + cache->edit.loop_lnor, + NULL, + cache->edit.loop_data, + cache->edit.loop_vert_idx, + cache->edit.loop_edge_idx, + cache->edit.loop_face_idx); + } + if (DRW_vbo_requested(cache->edit.facedots_pos_nor_data)) { + mesh_create_edit_facedots(rdata, cache->edit.facedots_pos_nor_data); } if (DRW_vbo_requested(cache->edit.facedots_idx)) { mesh_create_edit_facedots_select_id(rdata, cache->edit.facedots_idx); @@ -5351,19 +5002,43 @@ void DRW_mesh_batch_cache_create_requested( mesh_create_edit_loops_tris(rdata, cache->ibo.edit_loops_tris); } - if (DRW_vbo_requested(cache->edituv.loop_stretch_angle) || - DRW_vbo_requested(cache->edituv.loop_stretch_area) || - DRW_vbo_requested(cache->edituv.loop_uv) || - DRW_vbo_requested(cache->edituv.loop_data) || - DRW_vbo_requested(cache->edituv.facedots_uv) || - DRW_vbo_requested(cache->edituv.facedots_data) || - DRW_ibo_requested(cache->ibo.edituv_loops_lines)) + /* UV editor */ + /** + * TODO: The code and data structure is ready to support modified UV display + * but the selection code for UVs needs to support it first. So for now, only + * display the cage in all cases. + **/ + if (rdata && rdata->mapped.supported) { + rdata->mapped.use = false; + } + + if (DRW_vbo_requested(cache->edit.loop_uv_data) || + DRW_vbo_requested(cache->edit.loop_uv)) + { + mesh_create_edit_vertex_loops( + rdata, + NULL, + NULL, + cache->edit.loop_uv, + cache->edit.loop_uv_data, + NULL, + NULL, + NULL); + } + if (DRW_vbo_requested(cache->edit.loop_stretch_angle) || + DRW_vbo_requested(cache->edit.loop_stretch_area) || + DRW_vbo_requested(cache->edit.facedots_uv) || + DRW_vbo_requested(cache->edit.facedots_uv_data) || + DRW_ibo_requested(cache->ibo.edituv_loops_points) || + DRW_ibo_requested(cache->ibo.edituv_loops_lines) || + DRW_ibo_requested(cache->ibo.edituv_loops_tri_fans)) { - mesh_create_uvedit_buffers(me_original, ts, - cache->edituv.loop_uv, cache->edituv.loop_data, - cache->edituv.loop_stretch_area, cache->edituv.loop_stretch_angle, - cache->edituv.facedots_uv, cache->edituv.facedots_data, - cache->ibo.edituv_loops_lines); + mesh_create_uvedit_buffers(rdata, + cache->edit.loop_stretch_area, cache->edit.loop_stretch_angle, + cache->edit.facedots_uv, cache->edit.facedots_uv_data, + cache->ibo.edituv_loops_points, + cache->ibo.edituv_loops_lines, + cache->ibo.edituv_loops_tri_fans); } if (rdata) { |