Differential D5352 Diff 16695 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 */

				static 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;
				}
				}

				static 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;
				}
				}

				static 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;
				}
				}

				static 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;
				}
				}

				static 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;
				}
				}

				static 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;
				}
				}

				static 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;
				}
				}

				static 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;

				#define SCULPT_VERTEX_NEIGHBOUR_MAX 256

				static void sculpt_vertex_neighbour_add(SculptVertexNeighbourIter *iter, int neighbour_index)
				{
				if (iter->count >= SCULPT_VERTEX_NEIGHBOUR_MAX) {
				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`.
				iter->neighbours = MEM_reallocN_id(iter->neighbours,
				(iter->count + SCULPT_VERTEX_NEIGHBOUR_MAX) * sizeof(int),
				"neighbour array");
				}
				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…

				for (int i = 0; i < iter->count; i++) {
				if (iter->neighbours[i] == neighbour_index) {
				return;
				}
				}

				iter->neighbours[iter->count] = neighbour_index;
				iter->count++;
				return;
				}

				static void sculpt_vertex_neighbours_get_bmesh(SculptSession *ss,
				int index,
				SculptVertexNeighbourIter *iter)
				{
				BMVert *v = BM_vert_at_index(ss->bm, index);
				BMIter liter;
				BMLoop *l;
				iter->count = 0;
				iter->neighbours = MEM_mallocN(SCULPT_VERTEX_NEIGHBOUR_MAX * sizeof(int), "neighbour array");
				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…
				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) != (int)index) {
				sculpt_vertex_neighbour_add(iter, BM_elem_index_get(v_other));
				}
				}
				}
				}

				static void sculpt_vertex_neighbours_get_faces(SculptSession *ss,
				int index,
				SculptVertexNeighbourIter *iter)
				{
				int i;
				MeshElemMap *vert_map = &ss->pmap[(int)index];
				iter->count = 0;
				iter->neighbours = MEM_mallocN(SCULPT_VERTEX_NEIGHBOUR_MAX * sizeof(int), "neighbour array");
				for (i = 0; i < ss->pmap[(int)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, (int)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) {
				sculpt_vertex_neighbour_add(iter, f_adj_v[j]);
				}
				}
				}
				}
				}
				}

				static 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