Differential D5352 Diff 16633 source/blender/editors/sculpt_paint/sculpt.c

Changeset View

Standalone View

source/blender/editors/sculpt_paint/sculpt.c

	Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines

	#include "bmesh.h"			#include "bmesh.h"
	#include "bmesh_tools.h"			#include "bmesh_tools.h"

	#include <math.h>			#include <math.h>
	#include <stdlib.h>			#include <stdlib.h>
	#include <string.h>			#include <string.h>

				/* Sculpt PBVH abstraction API */

				int sculpt_active_vertex_get(SculptSession *ss)
				brechtUnsubmitted Done Inline Actions All these functions should be `static` since they are not exposed in any header file. brecht: All these functions should be `static` since they are not exposed in any header file.
				{
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				return ss->active_vertex_index;
				case PBVH_BMESH:
				return ss->active_vertex_index;
				default:
				return 0;
				}
				}

				int sculpt_vertex_count_get(SculptSession *ss)
				{
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				return ss->totvert;
				case PBVH_BMESH:
				return BM_mesh_elem_count(BKE_pbvh_get_bmesh(ss->pbvh), BM_VERT);
				default:
				return 0;
				}
				}

				void sculpt_vertex_normal_get(SculptSession *ss, int index, float no[3])
				{
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				normal_short_to_float_v3(no, ss->mvert[index].no);
				return;
				case PBVH_BMESH:
				copy_v3_v3(no, BM_vert_at_index(BKE_pbvh_get_bmesh(ss->pbvh), index)->no);
				default:
				return;
				}
				}

				float sculpt_vertex_co_get(SculptSession ss, int index)
				{
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				return ss->mvert[index].co;
				case PBVH_BMESH:
				return BM_vert_at_index(BKE_pbvh_get_bmesh(ss->pbvh), index)->co;
				default:
				return NULL;
				}
				}

				void sculpt_vertex_co_set(SculptSession *ss, int index, float co[3])
				{
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				copy_v3_v3(ss->mvert[index].co, co);
				return;
				case PBVH_BMESH:
				copy_v3_v3(BM_vert_at_index(BKE_pbvh_get_bmesh(ss->pbvh), index)->co, co);
				return;
				default:
				return;
				}
				}

				void sculpt_vertex_mask_set(SculptSession *ss, int index, float mask)
				{
				BMVert *v;
				float *mask_p;
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				ss->vmask[index] = mask;
				return;
				case PBVH_BMESH:
				v = BM_vert_at_index(BKE_pbvh_get_bmesh(ss->pbvh), index);
				mask_p = BM_ELEM_CD_GET_VOID_P(v, CustomData_get_offset(&ss->bm->vdata, CD_PAINT_MASK));
				*(mask_p) = mask;
				return;
				default:
				return;
				}
				}

				float sculpt_vertex_mask_get(SculptSession *ss, int index)
				{
				BMVert *v;
				float *mask;
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				return ss->vmask[index];
				case PBVH_BMESH:
				v = BM_vert_at_index(BKE_pbvh_get_bmesh(ss->pbvh), index);
				mask = BM_ELEM_CD_GET_VOID_P(v, CustomData_get_offset(&ss->bm->vdata, CD_PAINT_MASK));
				return *mask;
				default:
				return 0;
				}
				}

				void sculpt_vertex_tag_update(SculptSession *ss, int index)
				{
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				ss->mvert[index].flag \|= ME_VERT_PBVH_UPDATE;
				return;
				case PBVH_BMESH:
				return;
				default:
				return;
				}
				}

				typedef struct SculptVertexNeighbourIter {
				int *neighbours;
				int count;
				int index;
				int i;
				} SculptVertexNeighbourIter;

				void sculpt_vertex_neighbours_get_bmesh(SculptSession *ss,
				int index,
				SculptVertexNeighbourIter *iter)
				{
				BMVert *v = BM_vert_at_index(ss->bm, index);
				brechtUnsubmitted Not Done Inline Actions This will not reallocate when `iter->count` reaches `2 * SCULPT_VERTEX_NEIGHBOUR_MAX`. brecht: This will not reallocate when `iter->count` reaches `2 * SCULPT_VERTEX_NEIGHBOUR_MAX`.
				BMIter liter;
				BMLoop *l;
				GSet *n_set;
				n_set = BLI_gset_new(BLI_ghashutil_uinthash, BLI_ghashutil_intcmp, "neighbour set");
				brechtUnsubmitted Done Inline Actions Creating a gset and the associated memory allocations here is too slow. Since the typical number of neighbors is low, you can just store them in an array and loop over the array every time to check for duplicates. To avoid the memory allocation, `SculptVertexNeighbourIter` can contain a fixed size array of e.g. `256`. `int neighbours` would initially point to that. You can then use `MEM_malloc` to double the capacity when that number is exceeded, which would be almost never. The code to do that can also be shared between the bmesh and faces case, if you make a common `sculpt_vertex_neighbours_add` function for both to call. brecht:* Creating a gset and the associated memory allocations here is too slow. Since the typical…
				int i = 0;
				BM_ITER_ELEM (l, &liter, v, BM_LOOPS_OF_VERT) {
				const BMVert *adj_v[2] = {l->prev->v, l->next->v};
				for (i = 0; i < ARRAY_SIZE(adj_v); i++) {
				const BMVert *v_other = adj_v[i];
				if (BM_elem_index_get(v_other) != index) {
				BLI_gset_add(n_set, BM_elem_index_get(v_other));
				}
				}
				}

				iter->count = BLI_gset_len(n_set);
				iter->neighbours = MEM_mallocN(BLI_gset_len(n_set) * sizeof(int), "neighbour array");

				int c_index = 0;
				GSetIterator *gsi = BLI_gsetIterator_new(n_set);
				for (BLI_gsetIterator_init(gsi, n_set); !BLI_gsetIterator_done(gsi);
				BLI_gsetIterator_step(gsi)) {
				iter->neighbours[c_index] = BLI_gsetIterator_getKey(gsi);
				c_index++;
				}
				brechtUnsubmitted Not Done Inline Actions Doing one allocation per vertex is still relatively slow, these things tend to work poorly especially with multithreading. brecht: Doing one allocation per vertex is still relatively slow, these things tend to work poorly…
				BLI_gsetIterator_free(gsi);
				BLI_gset_free(n_set, NULL);
				}

				void sculpt_vertex_neighbours_get_faces(SculptSession *ss,
				int index,
				SculptVertexNeighbourIter *iter)
				{
				GSet *n_set;
				int i;
				MeshElemMap *vert_map = &ss->pmap[index];
				n_set = BLI_gset_new(BLI_ghashutil_uinthash, BLI_ghashutil_intcmp, "neighbour set");
				for (i = 0; i < ss->pmap[index].count; i++) {
				const MPoly *p = &ss->mpoly[vert_map->indices[i]];
				unsigned f_adj_v[2];
				if (poly_get_adj_loops_from_vert(p, ss->mloop, index, f_adj_v) != -1) {
				int j;
				for (j = 0; j < ARRAY_SIZE(f_adj_v); j += 1) {
				if (vert_map->count != 2 \|\| ss->pmap[f_adj_v[j]].count <= 2) {
				if (f_adj_v[j] != (int)index) {
				BLI_gset_add(n_set, f_adj_v[j]);
				}
				}
				}
				}
				}

				iter->count = BLI_gset_len(n_set);
				iter->neighbours = MEM_mallocN(BLI_gset_len(n_set) * sizeof(int), "neighbour array");

				int c_index = 0;
				GSetIterator *gsi = BLI_gsetIterator_new(n_set);
				for (BLI_gsetIterator_init(gsi, n_set); !BLI_gsetIterator_done(gsi);
				BLI_gsetIterator_step(gsi)) {
				iter->neighbours[c_index] = BLI_gsetIterator_getKey(gsi);
				c_index++;
				}
				BLI_gsetIterator_free(gsi);
				BLI_gset_free(n_set, NULL);
				}

				void sculpt_vertex_neighbours_get(SculptSession ss, int index, SculptVertexNeighbourIter iter)
				{
				switch (BKE_pbvh_type(ss->pbvh)) {
				case PBVH_FACES:
				sculpt_vertex_neighbours_get_faces(ss, index, iter);
				return;
				case PBVH_BMESH:
				sculpt_vertex_neighbours_get_bmesh(ss, index, iter);
				return;
				default:
				break;
				}
				}
				#define sculpt_vertex_neighbours_iter_begin(ss, v_index, neighbour_iterator) \
				sculpt_vertex_neighbours_get(ss, v_index, &neighbour_iterator); \
				for (neighbour_iterator.i = 0; neighbour_iterator.i < neighbour_iterator.count; \
				neighbour_iterator.i++) { \
				neighbour_iterator.index = ni.neighbours[ni.i];

				#define sculpt_vertex_neighbours_iter_end(neighbour_iterator) \
				} \
				MEM_freeN(neighbour_iterator.neighbours);

	/** \name Tool Capabilities			/** \name Tool Capabilities
	*			*
	* Avoid duplicate checks, internal logic only,			* Avoid duplicate checks, internal logic only,
	* share logic with #rna_def_sculpt_capabilities where possible.			* share logic with #rna_def_sculpt_capabilities where possible.
	*			*
	* \{ */			* \{ */

	/* Check if there are any active modifiers in stack			/* Check if there are any active modifiers in stack
	▲ Show 20 Lines • Show All 6,431 Lines • Show Last 20 Lines