[Bf-blender-cvs] [8ef8b64fc61] blender2.8: DRW: edit-mesh cage loose edge/vert support

Campbell Barton noreply at git.blender.org
Fri Oct 12 07:06:43 CEST 2018


Commit: 8ef8b64fc6135f6a32343999d1d6d5090bc0f1c4
Author: Campbell Barton
Date:   Fri Oct 12 16:05:31 2018 +1100
Branches: blender2.8
https://developer.blender.org/rB8ef8b64fc6135f6a32343999d1d6d5090bc0f1c4

DRW: edit-mesh cage loose edge/vert support

===================================================================

M	source/blender/draw/intern/draw_cache_impl_mesh.c

===================================================================

diff --git a/source/blender/draw/intern/draw_cache_impl_mesh.c b/source/blender/draw/intern/draw_cache_impl_mesh.c
index ab05874c5dc..2672e23bb7f 100644
--- a/source/blender/draw/intern/draw_cache_impl_mesh.c
+++ b/source/blender/draw/intern/draw_cache_impl_mesh.c
@@ -159,6 +159,12 @@ typedef struct MeshRenderData {
 		int loop_len;
 		int poly_len;
 
+		int *loose_verts;
+		int  loose_vert_len;
+
+		int *loose_edges;
+		int  loose_edge_len;
+
 		/* origindex layers */
 		int *v_origindex;
 		int *e_origindex;
@@ -525,10 +531,9 @@ static MeshRenderData *mesh_render_data_create_ex(
 		if (types & MR_DATATYPE_OVERLAY) {
 			rdata->loose_vert_len = rdata->loose_edge_len = 0;
 
-			int *lverts = rdata->loose_verts = MEM_mallocN(rdata->vert_len * sizeof(int), "Loose Vert");
-			int *ledges = rdata->loose_edges = MEM_mallocN(rdata->edge_len * sizeof(int), "Loose Edges");
-
 			{
+				rdata->loose_verts = MEM_mallocN(rdata->vert_len * sizeof(int), __func__);
+				int *lverts = rdata->loose_verts;
 				BLI_assert((bm->elem_table_dirty & BM_VERT) == 0);
 				BMVert **vtable = bm->vtable;
 				for (int i = 0; i < bm->totvert; i++) {
@@ -540,9 +545,12 @@ static MeshRenderData *mesh_render_data_create_ex(
 						}
 					}
 				}
+				rdata->loose_verts = MEM_reallocN(rdata->loose_verts, rdata->loose_vert_len * sizeof(int));
 			}
 
 			{
+				rdata->loose_edges = MEM_mallocN(rdata->edge_len * sizeof(int), __func__);
+				int *ledges = rdata->loose_edges;
 				BLI_assert((bm->elem_table_dirty & BM_EDGE) == 0);
 				BMEdge **etable = bm->etable;
 				for (int i = 0; i < bm->totedge; i++) {
@@ -554,10 +562,53 @@ static MeshRenderData *mesh_render_data_create_ex(
 						}
 					}
 				}
+				rdata->loose_edges = MEM_reallocN(rdata->loose_edges, rdata->loose_edge_len * sizeof(int));
 			}
 
-			rdata->loose_verts = MEM_reallocN(rdata->loose_verts, rdata->loose_vert_len * sizeof(int));
-			rdata->loose_edges = MEM_reallocN(rdata->loose_edges, rdata->loose_edge_len * sizeof(int));
+			if (rdata->mapped.supported) {
+				Mesh *me_cage = embm->mesh_eval_cage;
+				rdata->mapped.loose_vert_len = rdata->mapped.loose_edge_len = 0;
+
+				if (rdata->loose_vert_len) {
+					rdata->mapped.loose_verts = MEM_mallocN(me_cage->totvert * sizeof(int), __func__);
+					int *lverts = rdata->mapped.loose_verts;
+					const int *v_origindex = rdata->mapped.v_origindex;
+					for (int i = 0; i < me_cage->totvert; i++) {
+						const int v_orig = v_origindex[i];
+						if (v_orig != ORIGINDEX_NONE) {
+							BMVert *eve = BM_vert_at_index(bm, v_orig);
+							if (!BM_elem_flag_test(eve, BM_ELEM_HIDDEN)) {
+								/* Loose vert */
+								if (eve->e == NULL || !bm_vert_has_visible_edge(eve)) {
+									lverts[rdata->mapped.loose_vert_len++] = i;
+								}
+							}
+						}
+					}
+					rdata->mapped.loose_verts = MEM_reallocN(
+					        rdata->mapped.loose_verts, rdata->mapped.loose_vert_len * sizeof(int));
+				}
+
+				if (rdata->loose_edge_len) {
+					rdata->mapped.loose_edges = MEM_mallocN(me_cage->totedge * sizeof(int), __func__);
+					int *ledges = rdata->mapped.loose_edges;
+					const int *e_origindex = rdata->mapped.e_origindex;
+					for (int i = 0; i < me_cage->totedge; i++) {
+						const int e_orig = e_origindex[i];
+						if (e_orig != ORIGINDEX_NONE) {
+							BMEdge *eed = BM_edge_at_index(bm, e_orig);
+							if (!BM_elem_flag_test(eed, BM_ELEM_HIDDEN)) {
+								/* Loose edge */
+								if (eed->l == NULL || !bm_edge_has_visible_face(eed)) {
+									ledges[rdata->mapped.loose_edge_len++] = i;
+								}
+							}
+						}
+					}
+					rdata->mapped.loose_edges = MEM_reallocN(
+					        rdata->mapped.loose_edges, rdata->mapped.loose_edge_len * sizeof(int));
+				}
+			}
 		}
 	}
 	else {
@@ -915,6 +966,9 @@ static void mesh_render_data_free(MeshRenderData *rdata)
 	MEM_SAFE_FREE(rdata->edge_select_bool);
 	MEM_SAFE_FREE(rdata->vert_color);
 
+	MEM_SAFE_FREE(rdata->mapped.loose_verts);
+	MEM_SAFE_FREE(rdata->mapped.loose_edges);
+
 	CustomData_free(&rdata->cd.output.ldata, rdata->loop_len);
 
 	MEM_freeN(rdata);
@@ -974,11 +1028,16 @@ static int mesh_render_data_verts_len_get_maybe_mapped(const MeshRenderData *rda
 	return ((rdata->mapped.use == false) ? rdata->vert_len : rdata->mapped.vert_len);
 }
 
-static int mesh_render_data_loose_verts_len_get(const MeshRenderData *rdata)
+static int UNUSED_FUNCTION(mesh_render_data_loose_verts_len_get)(const MeshRenderData *rdata)
 {
 	BLI_assert(rdata->types & MR_DATATYPE_OVERLAY);
 	return rdata->loose_vert_len;
 }
+static int mesh_render_data_loose_verts_len_get_maybe_mapped(const MeshRenderData *rdata)
+{
+	BLI_assert(rdata->types & MR_DATATYPE_OVERLAY);
+	return ((rdata->mapped.use == false) ? rdata->loose_vert_len : rdata->mapped.loose_vert_len);
+}
 
 static int mesh_render_data_edges_len_get(const MeshRenderData *rdata)
 {
@@ -991,11 +1050,16 @@ static int mesh_render_data_edges_len_get_maybe_mapped(const MeshRenderData *rda
 	return ((rdata->mapped.use == false) ? rdata->edge_len : rdata->mapped.edge_len);
 }
 
-static int mesh_render_data_loose_edges_len_get(const MeshRenderData *rdata)
+static int UNUSED_FUNCTION(mesh_render_data_loose_edges_len_get)(const MeshRenderData *rdata)
 {
 	BLI_assert(rdata->types & MR_DATATYPE_OVERLAY);
 	return rdata->loose_edge_len;
 }
+static int mesh_render_data_loose_edges_len_get_maybe_mapped(const MeshRenderData *rdata)
+{
+	BLI_assert(rdata->types & MR_DATATYPE_OVERLAY);
+	return ((rdata->mapped.use == false) ? rdata->loose_edge_len : rdata->mapped.loose_edge_len);
+}
 
 static int mesh_render_data_looptri_len_get(const MeshRenderData *rdata)
 {
@@ -1718,6 +1782,36 @@ static void add_overlay_loose_edge(
 		}
 	}
 }
+static void add_overlay_loose_edge_mapped(
+        MeshRenderData *rdata, GPUVertBuf *vbo_pos, GPUVertBuf *vbo_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) {
+		/* 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, pos_id, base_vert_idx + i, pos);
+		}
+	}
+
+	if (vbo_nor) {
+		for (int i = 0; i < 2; ++i) {
+			GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mvert[*(&ed->v1 + i)].no);
+			GPU_vertbuf_attr_set(vbo_nor, vnor_id, base_vert_idx + i, &vnor);
+		}
+	}
+
+	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);
+		}
+	}
+}
 
 static void add_overlay_loose_vert(
         MeshRenderData *rdata, GPUVertBuf *vbo_pos, GPUVertBuf *vbo_nor, GPUVertBuf *vbo_data,
@@ -1748,6 +1842,27 @@ static void add_overlay_loose_vert(
 		GPU_vertbuf_attr_set(vbo_data, data_id, base_vert_idx, vflag);
 	}
 }
+static void add_overlay_loose_vert_mapped(
+        MeshRenderData *rdata, GPUVertBuf *vbo_pos, GPUVertBuf *vbo_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)
+{
+	if (vbo_pos) {
+		const float *pos = mv->co;
+		GPU_vertbuf_attr_set(vbo_pos, pos_id, base_vert_idx, pos);
+	}
+
+	if (vbo_nor) {
+		GPUPackedNormal vnor = GPU_normal_convert_i10_s3(mv->no);
+		GPU_vertbuf_attr_set(vbo_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);
+	}
+}
 
 /** \} */
 
@@ -3383,28 +3498,42 @@ static GPUVertBuf *mesh_batch_cache_get_vert_pos_and_nor_in_order(
 		}
 
 		GPUVertBuf *vbo = cache->pos_in_order = GPU_vertbuf_create_with_format(&format);
-		const int vbo_len_capacity = mesh_render_data_verts_len_get(rdata);
+		const int vbo_len_capacity = mesh_render_data_verts_len_get_maybe_mapped(rdata);
 		GPU_vertbuf_data_alloc(vbo, vbo_len_capacity);
 
-		if (rdata->edit_bmesh) {
-			BMesh *bm = rdata->edit_bmesh->bm;
-			BMIter iter;
-			BMVert *eve;
-			uint i;
+		if (rdata->mapped.use == false) {
+			if (rdata->edit_bmesh) {
+				BMesh *bm = rdata->edit_bmesh->bm;
+				BMIter iter;
+				BMVert *eve;
+				uint i;
 
-			BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
-				static short no_short[4];
-				normal_float_to_short_v3(no_short, eve->no);
+				BM_ITER_MESH_INDEX (eve, &iter, bm, BM_VERTS_OF_MESH, i) {
+					static short no_short[4];
+					normal_float_to_short_v3(no_short, eve->no);
 
-				GPU_vertbuf_attr_set(vbo, attr_id.pos, i, eve->co);
-				GPU_vertbuf_attr_set(vbo, attr_id.nor, i, no_short);
+					GPU_vertbuf_attr_set(vbo, attr_id.pos, i, eve->co);
+					GPU_vertbuf_attr_set(vbo, attr_id.nor, i, no_short);
+				}
+				BLI_assert(i == vbo_len_capacity);
+			}
+			else {
+				for (int i = 0; i < vbo_len_capacity; ++i) {
+					GPU_vertbuf_attr_set(vbo, attr_id.pos, i, rdata->mvert[i].co);
+					GPU_vertbuf_attr_set(vbo, attr_id.nor, i, rdata->mvert[i].no); /* XXX actually reading 4 shorts */
+				}
 			}
-			BLI_assert(i == vbo_len_capacity);
 		}
 		else {
-			for (int i = 0; i < vbo_len_capacity; ++i) {
-				GPU_vertbuf_attr_set(vbo, attr_id.pos, i, rdata->mvert[i].co);
-				GPU_vertbuf_attr_set(vbo, attr_id.nor, i, rdata->mvert[i].no); /* XXX actually reading 4 shorts */
+			const MVert *mvert = rdata->mapped.me_cage->mvert;
+			const int *v_origindex = rdata->mapped.v_origindex;
+			for (int i = 0; i < vbo_len_capacity; i++) {
+				const int v_orig = v_origindex[i];
+				if (v_orig != ORIGINDEX_NONE) {
+					const MVert *mv = &mvert[i];
+					GPU_vertbuf_attr_set(vbo, attr_id.pos, i, mv->co);
+					GPU_vertbuf_attr_set(vbo, attr_id.nor, i, mv->no); /* XXX actually reading 4 shorts */
+				}
 			}
 		}
 	}
@@ -3546,7 +3675,7 @@ static void mesh_batch_cache_create_overlay_ledge_buffers(
 {
 	BLI_assert(rdata->types & (MR_DATATYPE_VERT | MR_DATATYPE_LOOPTRI));
 
-	c

@@ Diff output truncated at 10240 characters. @@



More information about the Bf-blender-cvs mailing list